xref: /illumos-gate/usr/src/cmd/zdb/zdb.c (revision 17f11284b49b98353b5119463254074fd9bc0a28)
1fa9e4066Sahrens /*
2fa9e4066Sahrens  * CDDL HEADER START
3fa9e4066Sahrens  *
4fa9e4066Sahrens  * The contents of this file are subject to the terms of the
5ea8dc4b6Seschrock  * Common Development and Distribution License (the "License").
6ea8dc4b6Seschrock  * You may not use this file except in compliance with the License.
7fa9e4066Sahrens  *
8fa9e4066Sahrens  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9fa9e4066Sahrens  * or http://www.opensolaris.org/os/licensing.
10fa9e4066Sahrens  * See the License for the specific language governing permissions
11fa9e4066Sahrens  * and limitations under the License.
12fa9e4066Sahrens  *
13fa9e4066Sahrens  * When distributing Covered Code, include this CDDL HEADER in each
14fa9e4066Sahrens  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15fa9e4066Sahrens  * If applicable, add the following below this CDDL HEADER, with the
16fa9e4066Sahrens  * fields enclosed by brackets "[]" replaced with your own identifying
17fa9e4066Sahrens  * information: Portions Copyright [yyyy] [name of copyright owner]
18fa9e4066Sahrens  *
19fa9e4066Sahrens  * CDDL HEADER END
20fa9e4066Sahrens  */
21ad135b5dSChristopher Siden 
22fa9e4066Sahrens /*
238f2529deSMark Shellenbaum  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
245cabbc6bSPrashanth Sreenivasa  * Copyright (c) 2011, 2017 by Delphix. All rights reserved.
25c3d26abcSMatthew Ahrens  * Copyright (c) 2014 Integros [integros.com]
26ed61ec1dSYuri Pankov  * Copyright 2017 Nexenta Systems, Inc.
27f06dce2cSAndrew Stormont  * Copyright 2017 RackTop Systems.
28fa9e4066Sahrens  */
29fa9e4066Sahrens 
30fa9e4066Sahrens #include <stdio.h>
31490d05b9SMatthew Ahrens #include <unistd.h>
32004388ebScasper #include <stdio_ext.h>
33fa9e4066Sahrens #include <stdlib.h>
3444cd46caSbillm #include <ctype.h>
35fa9e4066Sahrens #include <sys/zfs_context.h>
36fa9e4066Sahrens #include <sys/spa.h>
37fa9e4066Sahrens #include <sys/spa_impl.h>
38fa9e4066Sahrens #include <sys/dmu.h>
39fa9e4066Sahrens #include <sys/zap.h>
40fa9e4066Sahrens #include <sys/fs/zfs.h>
41fa9e4066Sahrens #include <sys/zfs_znode.h>
420a586ceaSMark Shellenbaum #include <sys/zfs_sa.h>
430a586ceaSMark Shellenbaum #include <sys/sa.h>
440a586ceaSMark Shellenbaum #include <sys/sa_impl.h>
45fa9e4066Sahrens #include <sys/vdev.h>
46fa9e4066Sahrens #include <sys/vdev_impl.h>
47fa9e4066Sahrens #include <sys/metaslab_impl.h>
48fa9e4066Sahrens #include <sys/dmu_objset.h>
49fa9e4066Sahrens #include <sys/dsl_dir.h>
50fa9e4066Sahrens #include <sys/dsl_dataset.h>
51fa9e4066Sahrens #include <sys/dsl_pool.h>
52fa9e4066Sahrens #include <sys/dbuf.h>
53fa9e4066Sahrens #include <sys/zil.h>
54fa9e4066Sahrens #include <sys/zil_impl.h>
55fa9e4066Sahrens #include <sys/stat.h>
56fa9e4066Sahrens #include <sys/resource.h>
57fa9e4066Sahrens #include <sys/dmu_traverse.h>
58fa9e4066Sahrens #include <sys/zio_checksum.h>
59fa9e4066Sahrens #include <sys/zio_compress.h>
60e0d35c44Smarks #include <sys/zfs_fuid.h>
6188b7b0f2SMatthew Ahrens #include <sys/arc.h>
62b24ab676SJeff Bonwick #include <sys/ddt.h>
63ad135b5dSChristopher Siden #include <sys/zfeature.h>
64770499e1SDan Kimmel #include <sys/abd.h>
654923c69fSMatthew Ahrens #include <sys/blkptr.h>
664445fffbSMatthew Ahrens #include <zfs_comutil.h>
670a055120SJason King #include <libcmdutils.h>
68de6628f0Sck #undef verify
69de6628f0Sck #include <libzfs.h>
70fa9e4066Sahrens 
713f7978d0SAlan Somers #include "zdb.h"
723f7978d0SAlan Somers 
73e690fb27SChristopher Siden #define	ZDB_COMPRESS_NAME(idx) ((idx) < ZIO_COMPRESS_FUNCTIONS ?	\
74e690fb27SChristopher Siden 	zio_compress_table[(idx)].ci_name : "UNKNOWN")
75e690fb27SChristopher Siden #define	ZDB_CHECKSUM_NAME(idx) ((idx) < ZIO_CHECKSUM_FUNCTIONS ?	\
76e690fb27SChristopher Siden 	zio_checksum_table[(idx)].ci_name : "UNKNOWN")
77e690fb27SChristopher Siden #define	ZDB_OT_NAME(idx) ((idx) < DMU_OT_NUMTYPES ?	\
78e690fb27SChristopher Siden 	dmu_ot[(idx)].ot_name : DMU_OT_IS_VALID(idx) ?	\
79e690fb27SChristopher Siden 	dmu_ot_byteswap[DMU_OT_BYTESWAP(idx)].ob_name : "UNKNOWN")
80e690fb27SChristopher Siden #define	ZDB_OT_TYPE(idx) ((idx) < DMU_OT_NUMTYPES ? (idx) :		\
815cabbc6bSPrashanth Sreenivasa 	(idx) == DMU_OTN_ZAP_DATA || (idx) == DMU_OTN_ZAP_METADATA ?	\
825cabbc6bSPrashanth Sreenivasa 	DMU_OT_ZAP_OTHER : \
835cabbc6bSPrashanth Sreenivasa 	(idx) == DMU_OTN_UINT64_DATA || (idx) == DMU_OTN_UINT64_METADATA ? \
845cabbc6bSPrashanth Sreenivasa 	DMU_OT_UINT64_OTHER : DMU_OT_NUMTYPES)
856de8f417SVictor Latushkin 
86feef89cfSVictor Latushkin #ifndef lint
874dd77f9eSMatthew Ahrens extern int reference_tracking_enable;
887fd05ac4SMatthew Ahrens extern boolean_t zfs_recover;
8906be9802SMatthew Ahrens extern uint64_t zfs_arc_max, zfs_arc_meta_limit;
90f7950bf1SMatthew Ahrens extern int zfs_vdev_async_read_max_active;
91f06dce2cSAndrew Stormont extern int aok;
92e144c4e6SPavel Zakharov extern boolean_t spa_load_verify_dryrun;
93feef89cfSVictor Latushkin #else
944dd77f9eSMatthew Ahrens int reference_tracking_enable;
957fd05ac4SMatthew Ahrens boolean_t zfs_recover;
9606be9802SMatthew Ahrens uint64_t zfs_arc_max, zfs_arc_meta_limit;
97f7950bf1SMatthew Ahrens int zfs_vdev_async_read_max_active;
98f06dce2cSAndrew Stormont int aok;
99e144c4e6SPavel Zakharov boolean_t spa_load_verify_dryrun;
100feef89cfSVictor Latushkin #endif
101feef89cfSVictor Latushkin 
1023f7978d0SAlan Somers static const char cmdname[] = "zdb";
103fa9e4066Sahrens uint8_t dump_opt[256];
104fa9e4066Sahrens 
105fa9e4066Sahrens typedef void object_viewer_t(objset_t *, uint64_t, void *data, size_t size);
106fa9e4066Sahrens 
107fa9e4066Sahrens uint64_t *zopt_object = NULL;
1083f7978d0SAlan Somers static unsigned zopt_objects = 0;
109de6628f0Sck libzfs_handle_t *g_zfs;
11006be9802SMatthew Ahrens uint64_t max_inflight = 1000;
111fa9e4066Sahrens 
112732885fcSMatthew Ahrens static void snprintf_blkptr_compact(char *, size_t, const blkptr_t *);
113732885fcSMatthew Ahrens 
114fa9e4066Sahrens /*
115fa9e4066Sahrens  * These libumem hooks provide a reasonable set of defaults for the allocator's
116fa9e4066Sahrens  * debugging facilities.
117fa9e4066Sahrens  */
118fa9e4066Sahrens const char *
119fa9e4066Sahrens _umem_debug_init()
120fa9e4066Sahrens {
121fa9e4066Sahrens 	return ("default,verbose"); /* $UMEM_DEBUG setting */
122fa9e4066Sahrens }
123fa9e4066Sahrens 
124fa9e4066Sahrens const char *
125fa9e4066Sahrens _umem_logging_init(void)
126fa9e4066Sahrens {
127fa9e4066Sahrens 	return ("fail,contents"); /* $UMEM_LOGGING setting */
128fa9e4066Sahrens }
129fa9e4066Sahrens 
130fa9e4066Sahrens static void
131fa9e4066Sahrens usage(void)
132fa9e4066Sahrens {
133fa9e4066Sahrens 	(void) fprintf(stderr,
13486714001SSerapheim Dimitropoulos 	    "Usage:\t%s [-AbcdDFGhikLMPsvX] [-e [-V] [-p <path> ...]] "
135ed61ec1dSYuri Pankov 	    "[-I <inflight I/Os>]\n"
136ed61ec1dSYuri Pankov 	    "\t\t[-o <var>=<value>]... [-t <txg>] [-U <cache>] [-x <dumpdir>]\n"
137ed61ec1dSYuri Pankov 	    "\t\t[<poolname> [<object> ...]]\n"
138dfd5965fSRichard Yao 	    "\t%s [-AdiPv] [-e [-V] [-p <path> ...]] [-U <cache>] <dataset> "
139ed61ec1dSYuri Pankov 	    "[<object> ...]\n"
140ed61ec1dSYuri Pankov 	    "\t%s -C [-A] [-U <cache>]\n"
141ed61ec1dSYuri Pankov 	    "\t%s -l [-Aqu] <device>\n"
142dfd5965fSRichard Yao 	    "\t%s -m [-AFLPX] [-e [-V] [-p <path> ...]] [-t <txg>] "
143dfd5965fSRichard Yao 	    "[-U <cache>]\n\t\t<poolname> [<vdev> [<metaslab> ...]]\n"
144ed61ec1dSYuri Pankov 	    "\t%s -O <dataset> <path>\n"
145dfd5965fSRichard Yao 	    "\t%s -R [-A] [-e [-V] [-p <path> ...]] [-U <cache>]\n"
146ed61ec1dSYuri Pankov 	    "\t\t<poolname> <vdev>:<offset>:<size>[:<flags>]\n"
1474923c69fSMatthew Ahrens 	    "\t%s -E [-A] word0:word1:...:word15\n"
148dfd5965fSRichard Yao 	    "\t%s -S [-AP] [-e [-V] [-p <path> ...]] [-U <cache>] "
149dfd5965fSRichard Yao 	    "<poolname>\n\n",
150ed61ec1dSYuri Pankov 	    cmdname, cmdname, cmdname, cmdname, cmdname, cmdname, cmdname,
1514923c69fSMatthew Ahrens 	    cmdname, cmdname);
1523ad6c7f9SVictor Latushkin 
1533ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    Dataset name must include at least one "
1543ad6c7f9SVictor Latushkin 	    "separator character '/' or '@'\n");
1553ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    If dataset name is specified, only that "
1563ad6c7f9SVictor Latushkin 	    "dataset is dumped\n");
1573ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    If object numbers are specified, only "
1583ad6c7f9SVictor Latushkin 	    "those objects are dumped\n\n");
1593ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    Options to control amount of output:\n");
1603ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -b block statistics\n");
1613ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -c checksum all metadata (twice for "
1626365109dSVictor Latushkin 	    "all data) blocks\n");
163ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -C config (or cachefile if alone)\n");
164ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -d dataset(s)\n");
165f0ba89beSJeff Bonwick 	(void) fprintf(stderr, "        -D dedup statistics\n");
1664923c69fSMatthew Ahrens 	(void) fprintf(stderr, "        -E decode and display block from an "
1674923c69fSMatthew Ahrens 	    "embedded block pointer\n");
168ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -h pool history\n");
169ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -i intent logs\n");
17064723e36SYuri Pankov 	(void) fprintf(stderr, "        -l read label contents\n");
17186714001SSerapheim Dimitropoulos 	(void) fprintf(stderr, "        -k examine the checkpointed state "
17286714001SSerapheim Dimitropoulos 	    "of the pool\n");
17382a0a985SVictor Latushkin 	(void) fprintf(stderr, "        -L disable leak tracking (do not "
17482a0a985SVictor Latushkin 	    "load spacemaps)\n");
175ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -m metaslabs\n");
176ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -M metaslab groups\n");
177ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -O perform object lookups by path\n");
178d41e7643Sek 	(void) fprintf(stderr, "        -R read and display block from a "
179ed61ec1dSYuri Pankov 	    "device\n");
180ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -s report stats on zdb's I/O\n");
181ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -S simulate dedup to measure effect\n");
182ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -v verbose (applies to all "
183ed61ec1dSYuri Pankov 	    "others)\n\n");
1843ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    Below options are intended for use "
185df15e419SMatthew Ahrens 	    "with other options:\n");
186feef89cfSVictor Latushkin 	(void) fprintf(stderr, "        -A ignore assertions (-A), enable "
187feef89cfSVictor Latushkin 	    "panic recovery (-AA) or both (-AAA)\n");
1883ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -e pool is exported/destroyed/"
1893ad6c7f9SVictor Latushkin 	    "has altroot/not in a cachefile\n");
190ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -F attempt automatic rewind within "
191ed61ec1dSYuri Pankov 	    "safe range of transaction groups\n");
192ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -G dump zfs_dbgmsg buffer before "
193ed61ec1dSYuri Pankov 	    "exiting\n");
1942e4c9986SGeorge Wilson 	(void) fprintf(stderr, "        -I <number of inflight I/Os> -- "
195df15e419SMatthew Ahrens 	    "specify the maximum number of "
196df15e419SMatthew Ahrens 	    "checksumming I/Os [default is 200]\n");
1970e60744cSPavel Zakharov 	(void) fprintf(stderr, "        -o <variable>=<value> set global "
1980e60744cSPavel Zakharov 	    "variable to an unsigned 32-bit integer value\n");
199ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -p <path> -- use one or more with "
200ed61ec1dSYuri Pankov 	    "-e to specify path to vdev dir\n");
201ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -P print numbers in parseable form\n");
20264723e36SYuri Pankov 	(void) fprintf(stderr, "        -q don't print label contents\n");
203ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -t <txg> -- highest txg to use when "
204ed61ec1dSYuri Pankov 	    "searching for uberblocks\n");
20564723e36SYuri Pankov 	(void) fprintf(stderr, "        -u uberblock\n");
206ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -U <cachefile_path> -- use alternate "
207ed61ec1dSYuri Pankov 	    "cachefile\n");
208dfd5965fSRichard Yao 	(void) fprintf(stderr, "        -V do verbatim import\n");
209ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -x <dumpdir> -- "
210ed61ec1dSYuri Pankov 	    "dump all read blocks into specified directory\n");
211ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -X attempt extreme rewind (does not "
212ed61ec1dSYuri Pankov 	    "work with dataset)\n\n");
213fa9e4066Sahrens 	(void) fprintf(stderr, "Specify an option more than once (e.g. -bb) "
214fa9e4066Sahrens 	    "to make only that option verbose\n");
215fa9e4066Sahrens 	(void) fprintf(stderr, "Default is to dump everything non-verbosely\n");
216fa9e4066Sahrens 	exit(1);
217fa9e4066Sahrens }
218fa9e4066Sahrens 
21929bdd2f9SPavel Zakharov static void
22029bdd2f9SPavel Zakharov dump_debug_buffer()
22129bdd2f9SPavel Zakharov {
22229bdd2f9SPavel Zakharov 	if (dump_opt['G']) {
22329bdd2f9SPavel Zakharov 		(void) printf("\n");
22429bdd2f9SPavel Zakharov 		zfs_dbgmsg_print("zdb");
22529bdd2f9SPavel Zakharov 	}
22629bdd2f9SPavel Zakharov }
22729bdd2f9SPavel Zakharov 
228ccba0801SRich Morris /*
229ccba0801SRich Morris  * Called for usage errors that are discovered after a call to spa_open(),
230ccba0801SRich Morris  * dmu_bonus_hold(), or pool_match().  abort() is called for other errors.
231ccba0801SRich Morris  */
232ccba0801SRich Morris 
233fa9e4066Sahrens static void
234fa9e4066Sahrens fatal(const char *fmt, ...)
235fa9e4066Sahrens {
236fa9e4066Sahrens 	va_list ap;
237fa9e4066Sahrens 
238fa9e4066Sahrens 	va_start(ap, fmt);
239fa9e4066Sahrens 	(void) fprintf(stderr, "%s: ", cmdname);
240fa9e4066Sahrens 	(void) vfprintf(stderr, fmt, ap);
241fa9e4066Sahrens 	va_end(ap);
242fa9e4066Sahrens 	(void) fprintf(stderr, "\n");
243fa9e4066Sahrens 
24429bdd2f9SPavel Zakharov 	dump_debug_buffer();
24529bdd2f9SPavel Zakharov 
246ccba0801SRich Morris 	exit(1);
247fa9e4066Sahrens }
248fa9e4066Sahrens 
249fa9e4066Sahrens /* ARGSUSED */
250fa9e4066Sahrens static void
251fa9e4066Sahrens dump_packed_nvlist(objset_t *os, uint64_t object, void *data, size_t size)
252fa9e4066Sahrens {
253fa9e4066Sahrens 	nvlist_t *nv;
254fa9e4066Sahrens 	size_t nvsize = *(uint64_t *)data;
255fa9e4066Sahrens 	char *packed = umem_alloc(nvsize, UMEM_NOFAIL);
256fa9e4066Sahrens 
2577bfdf011SNeil Perrin 	VERIFY(0 == dmu_read(os, object, 0, nvsize, packed, DMU_READ_PREFETCH));
258fa9e4066Sahrens 
259fa9e4066Sahrens 	VERIFY(nvlist_unpack(packed, nvsize, &nv, 0) == 0);
260fa9e4066Sahrens 
261fa9e4066Sahrens 	umem_free(packed, nvsize);
262fa9e4066Sahrens 
263fa9e4066Sahrens 	dump_nvlist(nv, 8);
264fa9e4066Sahrens 
265fa9e4066Sahrens 	nvlist_free(nv);
266fa9e4066Sahrens }
267fa9e4066Sahrens 
2684445fffbSMatthew Ahrens /* ARGSUSED */
2694445fffbSMatthew Ahrens static void
2704445fffbSMatthew Ahrens dump_history_offsets(objset_t *os, uint64_t object, void *data, size_t size)
2714445fffbSMatthew Ahrens {
2724445fffbSMatthew Ahrens 	spa_history_phys_t *shp = data;
2734445fffbSMatthew Ahrens 
2744445fffbSMatthew Ahrens 	if (shp == NULL)
2754445fffbSMatthew Ahrens 		return;
2764445fffbSMatthew Ahrens 
2774445fffbSMatthew Ahrens 	(void) printf("\t\tpool_create_len = %llu\n",
2784445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_pool_create_len);
2794445fffbSMatthew Ahrens 	(void) printf("\t\tphys_max_off = %llu\n",
2804445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_phys_max_off);
2814445fffbSMatthew Ahrens 	(void) printf("\t\tbof = %llu\n",
2824445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_bof);
2834445fffbSMatthew Ahrens 	(void) printf("\t\teof = %llu\n",
2844445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_eof);
2854445fffbSMatthew Ahrens 	(void) printf("\t\trecords_lost = %llu\n",
2864445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_records_lost);
2874445fffbSMatthew Ahrens }
2884445fffbSMatthew Ahrens 
2893f9d6ad7SLin Ling static void
2900a055120SJason King zdb_nicenum(uint64_t num, char *buf, size_t buflen)
2913f9d6ad7SLin Ling {
2923f9d6ad7SLin Ling 	if (dump_opt['P'])
2930a055120SJason King 		(void) snprintf(buf, buflen, "%llu", (longlong_t)num);
2943f9d6ad7SLin Ling 	else
2950a055120SJason King 		nicenum(num, buf, sizeof (buf));
2963f9d6ad7SLin Ling }
2973f9d6ad7SLin Ling 
2983f7978d0SAlan Somers static const char histo_stars[] = "****************************************";
2993f7978d0SAlan Somers static const uint64_t histo_width = sizeof (histo_stars) - 1;
300fa9e4066Sahrens 
301fa9e4066Sahrens static void
3020713e232SGeorge Wilson dump_histogram(const uint64_t *histo, int size, int offset)
303fa9e4066Sahrens {
304fa9e4066Sahrens 	int i;
305490d05b9SMatthew Ahrens 	int minidx = size - 1;
306fa9e4066Sahrens 	int maxidx = 0;
307fa9e4066Sahrens 	uint64_t max = 0;
308fa9e4066Sahrens 
309490d05b9SMatthew Ahrens 	for (i = 0; i < size; i++) {
310fa9e4066Sahrens 		if (histo[i] > max)
311fa9e4066Sahrens 			max = histo[i];
312fa9e4066Sahrens 		if (histo[i] > 0 && i > maxidx)
313fa9e4066Sahrens 			maxidx = i;
314fa9e4066Sahrens 		if (histo[i] > 0 && i < minidx)
315fa9e4066Sahrens 			minidx = i;
316fa9e4066Sahrens 	}
317fa9e4066Sahrens 
318490d05b9SMatthew Ahrens 	if (max < histo_width)
319490d05b9SMatthew Ahrens 		max = histo_width;
320fa9e4066Sahrens 
321490d05b9SMatthew Ahrens 	for (i = minidx; i <= maxidx; i++) {
322490d05b9SMatthew Ahrens 		(void) printf("\t\t\t%3u: %6llu %s\n",
3230713e232SGeorge Wilson 		    i + offset, (u_longlong_t)histo[i],
324490d05b9SMatthew Ahrens 		    &histo_stars[(max - histo[i]) * histo_width / max]);
325490d05b9SMatthew Ahrens 	}
326fa9e4066Sahrens }
327fa9e4066Sahrens 
328fa9e4066Sahrens static void
329fa9e4066Sahrens dump_zap_stats(objset_t *os, uint64_t object)
330fa9e4066Sahrens {
331fa9e4066Sahrens 	int error;
332fa9e4066Sahrens 	zap_stats_t zs;
333fa9e4066Sahrens 
334fa9e4066Sahrens 	error = zap_get_stats(os, object, &zs);
335fa9e4066Sahrens 	if (error)
336fa9e4066Sahrens 		return;
337fa9e4066Sahrens 
338fa9e4066Sahrens 	if (zs.zs_ptrtbl_len == 0) {
339fa9e4066Sahrens 		ASSERT(zs.zs_num_blocks == 1);
340fa9e4066Sahrens 		(void) printf("\tmicrozap: %llu bytes, %llu entries\n",
341fa9e4066Sahrens 		    (u_longlong_t)zs.zs_blocksize,
342fa9e4066Sahrens 		    (u_longlong_t)zs.zs_num_entries);
343fa9e4066Sahrens 		return;
344fa9e4066Sahrens 	}
345fa9e4066Sahrens 
346fa9e4066Sahrens 	(void) printf("\tFat ZAP stats:\n");
3478248818dSnd 
3488248818dSnd 	(void) printf("\t\tPointer table:\n");
3498248818dSnd 	(void) printf("\t\t\t%llu elements\n",
350fa9e4066Sahrens 	    (u_longlong_t)zs.zs_ptrtbl_len);
3518248818dSnd 	(void) printf("\t\t\tzt_blk: %llu\n",
3528248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_zt_blk);
3538248818dSnd 	(void) printf("\t\t\tzt_numblks: %llu\n",
3548248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_zt_numblks);
3558248818dSnd 	(void) printf("\t\t\tzt_shift: %llu\n",
3568248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_zt_shift);
3578248818dSnd 	(void) printf("\t\t\tzt_blks_copied: %llu\n",
3588248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_blks_copied);
3598248818dSnd 	(void) printf("\t\t\tzt_nextblk: %llu\n",
3608248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_nextblk);
3618248818dSnd 
362fa9e4066Sahrens 	(void) printf("\t\tZAP entries: %llu\n",
363fa9e4066Sahrens 	    (u_longlong_t)zs.zs_num_entries);
364fa9e4066Sahrens 	(void) printf("\t\tLeaf blocks: %llu\n",
365fa9e4066Sahrens 	    (u_longlong_t)zs.zs_num_leafs);
366fa9e4066Sahrens 	(void) printf("\t\tTotal blocks: %llu\n",
367fa9e4066Sahrens 	    (u_longlong_t)zs.zs_num_blocks);
3688248818dSnd 	(void) printf("\t\tzap_block_type: 0x%llx\n",
3698248818dSnd 	    (u_longlong_t)zs.zs_block_type);
3708248818dSnd 	(void) printf("\t\tzap_magic: 0x%llx\n",
3718248818dSnd 	    (u_longlong_t)zs.zs_magic);
3728248818dSnd 	(void) printf("\t\tzap_salt: 0x%llx\n",
3738248818dSnd 	    (u_longlong_t)zs.zs_salt);
374fa9e4066Sahrens 
375fa9e4066Sahrens 	(void) printf("\t\tLeafs with 2^n pointers:\n");
3760713e232SGeorge Wilson 	dump_histogram(zs.zs_leafs_with_2n_pointers, ZAP_HISTOGRAM_SIZE, 0);
377fa9e4066Sahrens 
378fa9e4066Sahrens 	(void) printf("\t\tBlocks with n*5 entries:\n");
3790713e232SGeorge Wilson 	dump_histogram(zs.zs_blocks_with_n5_entries, ZAP_HISTOGRAM_SIZE, 0);
380fa9e4066Sahrens 
381fa9e4066Sahrens 	(void) printf("\t\tBlocks n/10 full:\n");
3820713e232SGeorge Wilson 	dump_histogram(zs.zs_blocks_n_tenths_full, ZAP_HISTOGRAM_SIZE, 0);
383fa9e4066Sahrens 
384fa9e4066Sahrens 	(void) printf("\t\tEntries with n chunks:\n");
3850713e232SGeorge Wilson 	dump_histogram(zs.zs_entries_using_n_chunks, ZAP_HISTOGRAM_SIZE, 0);
386fa9e4066Sahrens 
387fa9e4066Sahrens 	(void) printf("\t\tBuckets with n entries:\n");
3880713e232SGeorge Wilson 	dump_histogram(zs.zs_buckets_with_n_entries, ZAP_HISTOGRAM_SIZE, 0);
389fa9e4066Sahrens }
390fa9e4066Sahrens 
391fa9e4066Sahrens /*ARGSUSED*/
392fa9e4066Sahrens static void
393fa9e4066Sahrens dump_none(objset_t *os, uint64_t object, void *data, size_t size)
394fa9e4066Sahrens {
395fa9e4066Sahrens }
396fa9e4066Sahrens 
3976de8f417SVictor Latushkin /*ARGSUSED*/
3986de8f417SVictor Latushkin static void
3996de8f417SVictor Latushkin dump_unknown(objset_t *os, uint64_t object, void *data, size_t size)
4006de8f417SVictor Latushkin {
4016de8f417SVictor Latushkin 	(void) printf("\tUNKNOWN OBJECT TYPE\n");
4026de8f417SVictor Latushkin }
4036de8f417SVictor Latushkin 
404fa9e4066Sahrens /*ARGSUSED*/
4053f7978d0SAlan Somers static void
406fa9e4066Sahrens dump_uint8(objset_t *os, uint64_t object, void *data, size_t size)
407fa9e4066Sahrens {
408fa9e4066Sahrens }
409fa9e4066Sahrens 
410fa9e4066Sahrens /*ARGSUSED*/
411fa9e4066Sahrens static void
412fa9e4066Sahrens dump_uint64(objset_t *os, uint64_t object, void *data, size_t size)
413fa9e4066Sahrens {
414fa9e4066Sahrens }
415fa9e4066Sahrens 
416fa9e4066Sahrens /*ARGSUSED*/
417fa9e4066Sahrens static void
418fa9e4066Sahrens dump_zap(objset_t *os, uint64_t object, void *data, size_t size)
419fa9e4066Sahrens {
420fa9e4066Sahrens 	zap_cursor_t zc;
421fa9e4066Sahrens 	zap_attribute_t attr;
422fa9e4066Sahrens 	void *prop;
4233f7978d0SAlan Somers 	unsigned i;
424fa9e4066Sahrens 
425fa9e4066Sahrens 	dump_zap_stats(os, object);
426fa9e4066Sahrens 	(void) printf("\n");
427fa9e4066Sahrens 
428fa9e4066Sahrens 	for (zap_cursor_init(&zc, os, object);
429fa9e4066Sahrens 	    zap_cursor_retrieve(&zc, &attr) == 0;
430fa9e4066Sahrens 	    zap_cursor_advance(&zc)) {
431fa9e4066Sahrens 		(void) printf("\t\t%s = ", attr.za_name);
432fa9e4066Sahrens 		if (attr.za_num_integers == 0) {
433fa9e4066Sahrens 			(void) printf("\n");
434fa9e4066Sahrens 			continue;
435fa9e4066Sahrens 		}
436fa9e4066Sahrens 		prop = umem_zalloc(attr.za_num_integers *
437fa9e4066Sahrens 		    attr.za_integer_length, UMEM_NOFAIL);
438fa9e4066Sahrens 		(void) zap_lookup(os, object, attr.za_name,
439fa9e4066Sahrens 		    attr.za_integer_length, attr.za_num_integers, prop);
440fa9e4066Sahrens 		if (attr.za_integer_length == 1) {
441fa9e4066Sahrens 			(void) printf("%s", (char *)prop);
442fa9e4066Sahrens 		} else {
443fa9e4066Sahrens 			for (i = 0; i < attr.za_num_integers; i++) {
444fa9e4066Sahrens 				switch (attr.za_integer_length) {
445fa9e4066Sahrens 				case 2:
446fa9e4066Sahrens 					(void) printf("%u ",
447fa9e4066Sahrens 					    ((uint16_t *)prop)[i]);
448fa9e4066Sahrens 					break;
449fa9e4066Sahrens 				case 4:
450fa9e4066Sahrens 					(void) printf("%u ",
451fa9e4066Sahrens 					    ((uint32_t *)prop)[i]);
452fa9e4066Sahrens 					break;
453fa9e4066Sahrens 				case 8:
454fa9e4066Sahrens 					(void) printf("%lld ",
455fa9e4066Sahrens 					    (u_longlong_t)((int64_t *)prop)[i]);
456fa9e4066Sahrens 					break;
457fa9e4066Sahrens 				}
458fa9e4066Sahrens 			}
459fa9e4066Sahrens 		}
460fa9e4066Sahrens 		(void) printf("\n");
461fa9e4066Sahrens 		umem_free(prop, attr.za_num_integers * attr.za_integer_length);
462fa9e4066Sahrens 	}
46387e5029aSahrens 	zap_cursor_fini(&zc);
464fa9e4066Sahrens }
465fa9e4066Sahrens 
466732885fcSMatthew Ahrens static void
467732885fcSMatthew Ahrens dump_bpobj(objset_t *os, uint64_t object, void *data, size_t size)
468732885fcSMatthew Ahrens {
469732885fcSMatthew Ahrens 	bpobj_phys_t *bpop = data;
470732885fcSMatthew Ahrens 	char bytes[32], comp[32], uncomp[32];
471732885fcSMatthew Ahrens 
4720a055120SJason King 	/* make sure the output won't get truncated */
4730a055120SJason King 	CTASSERT(sizeof (bytes) >= NN_NUMBUF_SZ);
4740a055120SJason King 	CTASSERT(sizeof (comp) >= NN_NUMBUF_SZ);
4750a055120SJason King 	CTASSERT(sizeof (uncomp) >= NN_NUMBUF_SZ);
4760a055120SJason King 
477732885fcSMatthew Ahrens 	if (bpop == NULL)
478732885fcSMatthew Ahrens 		return;
479732885fcSMatthew Ahrens 
4800a055120SJason King 	zdb_nicenum(bpop->bpo_bytes, bytes, sizeof (bytes));
4810a055120SJason King 	zdb_nicenum(bpop->bpo_comp, comp, sizeof (comp));
4820a055120SJason King 	zdb_nicenum(bpop->bpo_uncomp, uncomp, sizeof (uncomp));
483732885fcSMatthew Ahrens 
484732885fcSMatthew Ahrens 	(void) printf("\t\tnum_blkptrs = %llu\n",
485732885fcSMatthew Ahrens 	    (u_longlong_t)bpop->bpo_num_blkptrs);
486732885fcSMatthew Ahrens 	(void) printf("\t\tbytes = %s\n", bytes);
487732885fcSMatthew Ahrens 	if (size >= BPOBJ_SIZE_V1) {
488732885fcSMatthew Ahrens 		(void) printf("\t\tcomp = %s\n", comp);
489732885fcSMatthew Ahrens 		(void) printf("\t\tuncomp = %s\n", uncomp);
490732885fcSMatthew Ahrens 	}
491732885fcSMatthew Ahrens 	if (size >= sizeof (*bpop)) {
492732885fcSMatthew Ahrens 		(void) printf("\t\tsubobjs = %llu\n",
493732885fcSMatthew Ahrens 		    (u_longlong_t)bpop->bpo_subobjs);
494732885fcSMatthew Ahrens 		(void) printf("\t\tnum_subobjs = %llu\n",
495732885fcSMatthew Ahrens 		    (u_longlong_t)bpop->bpo_num_subobjs);
496732885fcSMatthew Ahrens 	}
497732885fcSMatthew Ahrens 
498732885fcSMatthew Ahrens 	if (dump_opt['d'] < 5)
499732885fcSMatthew Ahrens 		return;
500732885fcSMatthew Ahrens 
501732885fcSMatthew Ahrens 	for (uint64_t i = 0; i < bpop->bpo_num_blkptrs; i++) {
502732885fcSMatthew Ahrens 		char blkbuf[BP_SPRINTF_LEN];
503732885fcSMatthew Ahrens 		blkptr_t bp;
504732885fcSMatthew Ahrens 
505732885fcSMatthew Ahrens 		int err = dmu_read(os, object,
506732885fcSMatthew Ahrens 		    i * sizeof (bp), sizeof (bp), &bp, 0);
507732885fcSMatthew Ahrens 		if (err != 0) {
508732885fcSMatthew Ahrens 			(void) printf("got error %u from dmu_read\n", err);
509732885fcSMatthew Ahrens 			break;
510732885fcSMatthew Ahrens 		}
511732885fcSMatthew Ahrens 		snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), &bp);
512732885fcSMatthew Ahrens 		(void) printf("\t%s\n", blkbuf);
513732885fcSMatthew Ahrens 	}
514732885fcSMatthew Ahrens }
515732885fcSMatthew Ahrens 
516732885fcSMatthew Ahrens /* ARGSUSED */
517732885fcSMatthew Ahrens static void
518732885fcSMatthew Ahrens dump_bpobj_subobjs(objset_t *os, uint64_t object, void *data, size_t size)
519732885fcSMatthew Ahrens {
520732885fcSMatthew Ahrens 	dmu_object_info_t doi;
521732885fcSMatthew Ahrens 
522732885fcSMatthew Ahrens 	VERIFY0(dmu_object_info(os, object, &doi));
523732885fcSMatthew Ahrens 	uint64_t *subobjs = kmem_alloc(doi.doi_max_offset, KM_SLEEP);
524732885fcSMatthew Ahrens 
525732885fcSMatthew Ahrens 	int err = dmu_read(os, object, 0, doi.doi_max_offset, subobjs, 0);
526732885fcSMatthew Ahrens 	if (err != 0) {
527732885fcSMatthew Ahrens 		(void) printf("got error %u from dmu_read\n", err);
528732885fcSMatthew Ahrens 		kmem_free(subobjs, doi.doi_max_offset);
529732885fcSMatthew Ahrens 		return;
530732885fcSMatthew Ahrens 	}
531732885fcSMatthew Ahrens 
532732885fcSMatthew Ahrens 	int64_t last_nonzero = -1;
533732885fcSMatthew Ahrens 	for (uint64_t i = 0; i < doi.doi_max_offset / 8; i++) {
534732885fcSMatthew Ahrens 		if (subobjs[i] != 0)
535732885fcSMatthew Ahrens 			last_nonzero = i;
536732885fcSMatthew Ahrens 	}
537732885fcSMatthew Ahrens 
538732885fcSMatthew Ahrens 	for (int64_t i = 0; i <= last_nonzero; i++) {
539732885fcSMatthew Ahrens 		(void) printf("\t%llu\n", (longlong_t)subobjs[i]);
540732885fcSMatthew Ahrens 	}
541732885fcSMatthew Ahrens 	kmem_free(subobjs, doi.doi_max_offset);
542732885fcSMatthew Ahrens }
543732885fcSMatthew Ahrens 
544486ae710SMatthew Ahrens /*ARGSUSED*/
545486ae710SMatthew Ahrens static void
546486ae710SMatthew Ahrens dump_ddt_zap(objset_t *os, uint64_t object, void *data, size_t size)
547486ae710SMatthew Ahrens {
548486ae710SMatthew Ahrens 	dump_zap_stats(os, object);
549486ae710SMatthew Ahrens 	/* contents are printed elsewhere, properly decoded */
550486ae710SMatthew Ahrens }
551486ae710SMatthew Ahrens 
5520a586ceaSMark Shellenbaum /*ARGSUSED*/
5530a586ceaSMark Shellenbaum static void
5540a586ceaSMark Shellenbaum dump_sa_attrs(objset_t *os, uint64_t object, void *data, size_t size)
5550a586ceaSMark Shellenbaum {
5560a586ceaSMark Shellenbaum 	zap_cursor_t zc;
5570a586ceaSMark Shellenbaum 	zap_attribute_t attr;
5580a586ceaSMark Shellenbaum 
5590a586ceaSMark Shellenbaum 	dump_zap_stats(os, object);
5600a586ceaSMark Shellenbaum 	(void) printf("\n");
5610a586ceaSMark Shellenbaum 
5620a586ceaSMark Shellenbaum 	for (zap_cursor_init(&zc, os, object);
5630a586ceaSMark Shellenbaum 	    zap_cursor_retrieve(&zc, &attr) == 0;
5640a586ceaSMark Shellenbaum 	    zap_cursor_advance(&zc)) {
5650a586ceaSMark Shellenbaum 		(void) printf("\t\t%s = ", attr.za_name);
5660a586ceaSMark Shellenbaum 		if (attr.za_num_integers == 0) {
5670a586ceaSMark Shellenbaum 			(void) printf("\n");
5680a586ceaSMark Shellenbaum 			continue;
5690a586ceaSMark Shellenbaum 		}
5700a586ceaSMark Shellenbaum 		(void) printf(" %llx : [%d:%d:%d]\n",
5710a586ceaSMark Shellenbaum 		    (u_longlong_t)attr.za_first_integer,
5720a586ceaSMark Shellenbaum 		    (int)ATTR_LENGTH(attr.za_first_integer),
5730a586ceaSMark Shellenbaum 		    (int)ATTR_BSWAP(attr.za_first_integer),
5740a586ceaSMark Shellenbaum 		    (int)ATTR_NUM(attr.za_first_integer));
5750a586ceaSMark Shellenbaum 	}
5760a586ceaSMark Shellenbaum 	zap_cursor_fini(&zc);
5770a586ceaSMark Shellenbaum }
5780a586ceaSMark Shellenbaum 
5790a586ceaSMark Shellenbaum /*ARGSUSED*/
5800a586ceaSMark Shellenbaum static void
5810a586ceaSMark Shellenbaum dump_sa_layouts(objset_t *os, uint64_t object, void *data, size_t size)
5820a586ceaSMark Shellenbaum {
5830a586ceaSMark Shellenbaum 	zap_cursor_t zc;
5840a586ceaSMark Shellenbaum 	zap_attribute_t attr;
5850a586ceaSMark Shellenbaum 	uint16_t *layout_attrs;
5863f7978d0SAlan Somers 	unsigned i;
5870a586ceaSMark Shellenbaum 
5880a586ceaSMark Shellenbaum 	dump_zap_stats(os, object);
5890a586ceaSMark Shellenbaum 	(void) printf("\n");
5900a586ceaSMark Shellenbaum 
5910a586ceaSMark Shellenbaum 	for (zap_cursor_init(&zc, os, object);
5920a586ceaSMark Shellenbaum 	    zap_cursor_retrieve(&zc, &attr) == 0;
5930a586ceaSMark Shellenbaum 	    zap_cursor_advance(&zc)) {
5940a586ceaSMark Shellenbaum 		(void) printf("\t\t%s = [", attr.za_name);
5950a586ceaSMark Shellenbaum 		if (attr.za_num_integers == 0) {
5960a586ceaSMark Shellenbaum 			(void) printf("\n");
5970a586ceaSMark Shellenbaum 			continue;
5980a586ceaSMark Shellenbaum 		}
5990a586ceaSMark Shellenbaum 
6000a586ceaSMark Shellenbaum 		VERIFY(attr.za_integer_length == 2);
6010a586ceaSMark Shellenbaum 		layout_attrs = umem_zalloc(attr.za_num_integers *
6020a586ceaSMark Shellenbaum 		    attr.za_integer_length, UMEM_NOFAIL);
6030a586ceaSMark Shellenbaum 
6040a586ceaSMark Shellenbaum 		VERIFY(zap_lookup(os, object, attr.za_name,
6050a586ceaSMark Shellenbaum 		    attr.za_integer_length,
6060a586ceaSMark Shellenbaum 		    attr.za_num_integers, layout_attrs) == 0);
6070a586ceaSMark Shellenbaum 
6080a586ceaSMark Shellenbaum 		for (i = 0; i != attr.za_num_integers; i++)
6090a586ceaSMark Shellenbaum 			(void) printf(" %d ", (int)layout_attrs[i]);
6100a586ceaSMark Shellenbaum 		(void) printf("]\n");
6110a586ceaSMark Shellenbaum 		umem_free(layout_attrs,
6120a586ceaSMark Shellenbaum 		    attr.za_num_integers * attr.za_integer_length);
6130a586ceaSMark Shellenbaum 	}
6140a586ceaSMark Shellenbaum 	zap_cursor_fini(&zc);
6150a586ceaSMark Shellenbaum }
6160a586ceaSMark Shellenbaum 
617e7437265Sahrens /*ARGSUSED*/
618e7437265Sahrens static void
619e7437265Sahrens dump_zpldir(objset_t *os, uint64_t object, void *data, size_t size)
620e7437265Sahrens {
621e7437265Sahrens 	zap_cursor_t zc;
622e7437265Sahrens 	zap_attribute_t attr;
623e7437265Sahrens 	const char *typenames[] = {
624e7437265Sahrens 		/* 0 */ "not specified",
625e7437265Sahrens 		/* 1 */ "FIFO",
626e7437265Sahrens 		/* 2 */ "Character Device",
627e7437265Sahrens 		/* 3 */ "3 (invalid)",
628e7437265Sahrens 		/* 4 */ "Directory",
629e7437265Sahrens 		/* 5 */ "5 (invalid)",
630e7437265Sahrens 		/* 6 */ "Block Device",
631e7437265Sahrens 		/* 7 */ "7 (invalid)",
632e7437265Sahrens 		/* 8 */ "Regular File",
633e7437265Sahrens 		/* 9 */ "9 (invalid)",
634e7437265Sahrens 		/* 10 */ "Symbolic Link",
635e7437265Sahrens 		/* 11 */ "11 (invalid)",
636e7437265Sahrens 		/* 12 */ "Socket",
637e7437265Sahrens 		/* 13 */ "Door",
638e7437265Sahrens 		/* 14 */ "Event Port",
639e7437265Sahrens 		/* 15 */ "15 (invalid)",
640e7437265Sahrens 	};
641e7437265Sahrens 
642e7437265Sahrens 	dump_zap_stats(os, object);
643e7437265Sahrens 	(void) printf("\n");
644e7437265Sahrens 
645e7437265Sahrens 	for (zap_cursor_init(&zc, os, object);
646e7437265Sahrens 	    zap_cursor_retrieve(&zc, &attr) == 0;
647e7437265Sahrens 	    zap_cursor_advance(&zc)) {
648e7437265Sahrens 		(void) printf("\t\t%s = %lld (type: %s)\n",
649e7437265Sahrens 		    attr.za_name, ZFS_DIRENT_OBJ(attr.za_first_integer),
650e7437265Sahrens 		    typenames[ZFS_DIRENT_TYPE(attr.za_first_integer)]);
651e7437265Sahrens 	}
652e7437265Sahrens 	zap_cursor_fini(&zc);
653e7437265Sahrens }
654e7437265Sahrens 
6553f7978d0SAlan Somers static int
6560713e232SGeorge Wilson get_dtl_refcount(vdev_t *vd)
6570713e232SGeorge Wilson {
6580713e232SGeorge Wilson 	int refcount = 0;
6590713e232SGeorge Wilson 
6600713e232SGeorge Wilson 	if (vd->vdev_ops->vdev_op_leaf) {
6610713e232SGeorge Wilson 		space_map_t *sm = vd->vdev_dtl_sm;
6620713e232SGeorge Wilson 
6630713e232SGeorge Wilson 		if (sm != NULL &&
6640713e232SGeorge Wilson 		    sm->sm_dbuf->db_size == sizeof (space_map_phys_t))
6650713e232SGeorge Wilson 			return (1);
6660713e232SGeorge Wilson 		return (0);
6670713e232SGeorge Wilson 	}
6680713e232SGeorge Wilson 
6693f7978d0SAlan Somers 	for (unsigned c = 0; c < vd->vdev_children; c++)
6700713e232SGeorge Wilson 		refcount += get_dtl_refcount(vd->vdev_child[c]);
6710713e232SGeorge Wilson 	return (refcount);
6720713e232SGeorge Wilson }
6730713e232SGeorge Wilson 
6743f7978d0SAlan Somers static int
6750713e232SGeorge Wilson get_metaslab_refcount(vdev_t *vd)
6760713e232SGeorge Wilson {
6770713e232SGeorge Wilson 	int refcount = 0;
6780713e232SGeorge Wilson 
6795cabbc6bSPrashanth Sreenivasa 	if (vd->vdev_top == vd) {
6805cabbc6bSPrashanth Sreenivasa 		for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
6810713e232SGeorge Wilson 			space_map_t *sm = vd->vdev_ms[m]->ms_sm;
6820713e232SGeorge Wilson 
6830713e232SGeorge Wilson 			if (sm != NULL &&
6840713e232SGeorge Wilson 			    sm->sm_dbuf->db_size == sizeof (space_map_phys_t))
6850713e232SGeorge Wilson 				refcount++;
6860713e232SGeorge Wilson 		}
6870713e232SGeorge Wilson 	}
6883f7978d0SAlan Somers 	for (unsigned c = 0; c < vd->vdev_children; c++)
6890713e232SGeorge Wilson 		refcount += get_metaslab_refcount(vd->vdev_child[c]);
6900713e232SGeorge Wilson 
6910713e232SGeorge Wilson 	return (refcount);
6920713e232SGeorge Wilson }
6930713e232SGeorge Wilson 
6945cabbc6bSPrashanth Sreenivasa static int
6955cabbc6bSPrashanth Sreenivasa get_obsolete_refcount(vdev_t *vd)
6965cabbc6bSPrashanth Sreenivasa {
6975cabbc6bSPrashanth Sreenivasa 	int refcount = 0;
6985cabbc6bSPrashanth Sreenivasa 
6995cabbc6bSPrashanth Sreenivasa 	uint64_t obsolete_sm_obj = vdev_obsolete_sm_object(vd);
7005cabbc6bSPrashanth Sreenivasa 	if (vd->vdev_top == vd && obsolete_sm_obj != 0) {
7015cabbc6bSPrashanth Sreenivasa 		dmu_object_info_t doi;
7025cabbc6bSPrashanth Sreenivasa 		VERIFY0(dmu_object_info(vd->vdev_spa->spa_meta_objset,
7035cabbc6bSPrashanth Sreenivasa 		    obsolete_sm_obj, &doi));
7045cabbc6bSPrashanth Sreenivasa 		if (doi.doi_bonus_size == sizeof (space_map_phys_t)) {
7055cabbc6bSPrashanth Sreenivasa 			refcount++;
7065cabbc6bSPrashanth Sreenivasa 		}
7075cabbc6bSPrashanth Sreenivasa 	} else {
7085cabbc6bSPrashanth Sreenivasa 		ASSERT3P(vd->vdev_obsolete_sm, ==, NULL);
7095cabbc6bSPrashanth Sreenivasa 		ASSERT3U(obsolete_sm_obj, ==, 0);
7105cabbc6bSPrashanth Sreenivasa 	}
7115cabbc6bSPrashanth Sreenivasa 	for (unsigned c = 0; c < vd->vdev_children; c++) {
7125cabbc6bSPrashanth Sreenivasa 		refcount += get_obsolete_refcount(vd->vdev_child[c]);
7135cabbc6bSPrashanth Sreenivasa 	}
7145cabbc6bSPrashanth Sreenivasa 
7155cabbc6bSPrashanth Sreenivasa 	return (refcount);
7165cabbc6bSPrashanth Sreenivasa }
7175cabbc6bSPrashanth Sreenivasa 
7185cabbc6bSPrashanth Sreenivasa static int
7195cabbc6bSPrashanth Sreenivasa get_prev_obsolete_spacemap_refcount(spa_t *spa)
7205cabbc6bSPrashanth Sreenivasa {
7215cabbc6bSPrashanth Sreenivasa 	uint64_t prev_obj =
7225cabbc6bSPrashanth Sreenivasa 	    spa->spa_condensing_indirect_phys.scip_prev_obsolete_sm_object;
7235cabbc6bSPrashanth Sreenivasa 	if (prev_obj != 0) {
7245cabbc6bSPrashanth Sreenivasa 		dmu_object_info_t doi;
7255cabbc6bSPrashanth Sreenivasa 		VERIFY0(dmu_object_info(spa->spa_meta_objset, prev_obj, &doi));
7265cabbc6bSPrashanth Sreenivasa 		if (doi.doi_bonus_size == sizeof (space_map_phys_t)) {
7275cabbc6bSPrashanth Sreenivasa 			return (1);
7285cabbc6bSPrashanth Sreenivasa 		}
7295cabbc6bSPrashanth Sreenivasa 	}
7305cabbc6bSPrashanth Sreenivasa 	return (0);
7315cabbc6bSPrashanth Sreenivasa }
7325cabbc6bSPrashanth Sreenivasa 
73386714001SSerapheim Dimitropoulos static int
73486714001SSerapheim Dimitropoulos get_checkpoint_refcount(vdev_t *vd)
73586714001SSerapheim Dimitropoulos {
73686714001SSerapheim Dimitropoulos 	int refcount = 0;
73786714001SSerapheim Dimitropoulos 
73886714001SSerapheim Dimitropoulos 	if (vd->vdev_top == vd && vd->vdev_top_zap != 0 &&
73986714001SSerapheim Dimitropoulos 	    zap_contains(spa_meta_objset(vd->vdev_spa),
74086714001SSerapheim Dimitropoulos 	    vd->vdev_top_zap, VDEV_TOP_ZAP_POOL_CHECKPOINT_SM) == 0)
74186714001SSerapheim Dimitropoulos 		refcount++;
74286714001SSerapheim Dimitropoulos 
74386714001SSerapheim Dimitropoulos 	for (uint64_t c = 0; c < vd->vdev_children; c++)
74486714001SSerapheim Dimitropoulos 		refcount += get_checkpoint_refcount(vd->vdev_child[c]);
74586714001SSerapheim Dimitropoulos 
74686714001SSerapheim Dimitropoulos 	return (refcount);
74786714001SSerapheim Dimitropoulos }
74886714001SSerapheim Dimitropoulos 
7490713e232SGeorge Wilson static int
7500713e232SGeorge Wilson verify_spacemap_refcounts(spa_t *spa)
7510713e232SGeorge Wilson {
7522acef22dSMatthew Ahrens 	uint64_t expected_refcount = 0;
7532acef22dSMatthew Ahrens 	uint64_t actual_refcount;
7540713e232SGeorge Wilson 
7552acef22dSMatthew Ahrens 	(void) feature_get_refcount(spa,
7562acef22dSMatthew Ahrens 	    &spa_feature_table[SPA_FEATURE_SPACEMAP_HISTOGRAM],
7572acef22dSMatthew Ahrens 	    &expected_refcount);
7580713e232SGeorge Wilson 	actual_refcount = get_dtl_refcount(spa->spa_root_vdev);
7590713e232SGeorge Wilson 	actual_refcount += get_metaslab_refcount(spa->spa_root_vdev);
7605cabbc6bSPrashanth Sreenivasa 	actual_refcount += get_obsolete_refcount(spa->spa_root_vdev);
7615cabbc6bSPrashanth Sreenivasa 	actual_refcount += get_prev_obsolete_spacemap_refcount(spa);
76286714001SSerapheim Dimitropoulos 	actual_refcount += get_checkpoint_refcount(spa->spa_root_vdev);
7630713e232SGeorge Wilson 
7640713e232SGeorge Wilson 	if (expected_refcount != actual_refcount) {
7652acef22dSMatthew Ahrens 		(void) printf("space map refcount mismatch: expected %lld != "
7662acef22dSMatthew Ahrens 		    "actual %lld\n",
7672acef22dSMatthew Ahrens 		    (longlong_t)expected_refcount,
7682acef22dSMatthew Ahrens 		    (longlong_t)actual_refcount);
7690713e232SGeorge Wilson 		return (2);
7700713e232SGeorge Wilson 	}
7710713e232SGeorge Wilson 	return (0);
7720713e232SGeorge Wilson }
7730713e232SGeorge Wilson 
774fa9e4066Sahrens static void
7750713e232SGeorge Wilson dump_spacemap(objset_t *os, space_map_t *sm)
776fa9e4066Sahrens {
7775cabbc6bSPrashanth Sreenivasa 	char *ddata[] = { "ALLOC", "FREE", "CONDENSE", "INVALID",
7785cabbc6bSPrashanth Sreenivasa 	    "INVALID", "INVALID", "INVALID", "INVALID" };
779fa9e4066Sahrens 
7800713e232SGeorge Wilson 	if (sm == NULL)
781fa9e4066Sahrens 		return;
782fa9e4066Sahrens 
7835cabbc6bSPrashanth Sreenivasa 	(void) printf("space map object %llu:\n",
7845cabbc6bSPrashanth Sreenivasa 	    (longlong_t)sm->sm_phys->smp_object);
7855cabbc6bSPrashanth Sreenivasa 	(void) printf("  smp_objsize = 0x%llx\n",
7865cabbc6bSPrashanth Sreenivasa 	    (longlong_t)sm->sm_phys->smp_objsize);
7875cabbc6bSPrashanth Sreenivasa 	(void) printf("  smp_alloc = 0x%llx\n",
7885cabbc6bSPrashanth Sreenivasa 	    (longlong_t)sm->sm_phys->smp_alloc);
7895cabbc6bSPrashanth Sreenivasa 
790fa9e4066Sahrens 	/*
791fa9e4066Sahrens 	 * Print out the freelist entries in both encoded and decoded form.
792fa9e4066Sahrens 	 */
793*17f11284SSerapheim Dimitropoulos 	uint8_t mapshift = sm->sm_shift;
794*17f11284SSerapheim Dimitropoulos 	int64_t alloc = 0;
795*17f11284SSerapheim Dimitropoulos 	uint64_t word;
796*17f11284SSerapheim Dimitropoulos 	for (uint64_t offset = 0; offset < space_map_length(sm);
797*17f11284SSerapheim Dimitropoulos 	    offset += sizeof (word)) {
7980713e232SGeorge Wilson 
7990713e232SGeorge Wilson 		VERIFY0(dmu_read(os, space_map_object(sm), offset,
800*17f11284SSerapheim Dimitropoulos 		    sizeof (word), &word, DMU_READ_PREFETCH));
8010713e232SGeorge Wilson 
802*17f11284SSerapheim Dimitropoulos 		if (sm_entry_is_debug(word)) {
80387219db7SVictor Latushkin 			(void) printf("\t    [%6llu] %s: txg %llu, pass %llu\n",
804*17f11284SSerapheim Dimitropoulos 			    (u_longlong_t)(offset / sizeof (word)),
805*17f11284SSerapheim Dimitropoulos 			    ddata[SM_DEBUG_ACTION_DECODE(word)],
806*17f11284SSerapheim Dimitropoulos 			    (u_longlong_t)SM_DEBUG_TXG_DECODE(word),
807*17f11284SSerapheim Dimitropoulos 			    (u_longlong_t)SM_DEBUG_SYNCPASS_DECODE(word));
808*17f11284SSerapheim Dimitropoulos 			continue;
809*17f11284SSerapheim Dimitropoulos 		}
810*17f11284SSerapheim Dimitropoulos 
811*17f11284SSerapheim Dimitropoulos 		uint8_t words;
812*17f11284SSerapheim Dimitropoulos 		char entry_type;
813*17f11284SSerapheim Dimitropoulos 		uint64_t entry_off, entry_run, entry_vdev = SM_NO_VDEVID;
814*17f11284SSerapheim Dimitropoulos 
815*17f11284SSerapheim Dimitropoulos 		if (sm_entry_is_single_word(word)) {
816*17f11284SSerapheim Dimitropoulos 			entry_type = (SM_TYPE_DECODE(word) == SM_ALLOC) ?
817*17f11284SSerapheim Dimitropoulos 			    'A' : 'F';
818*17f11284SSerapheim Dimitropoulos 			entry_off = (SM_OFFSET_DECODE(word) << mapshift) +
819*17f11284SSerapheim Dimitropoulos 			    sm->sm_start;
820*17f11284SSerapheim Dimitropoulos 			entry_run = SM_RUN_DECODE(word) << mapshift;
821*17f11284SSerapheim Dimitropoulos 			words = 1;
822fa9e4066Sahrens 		} else {
823*17f11284SSerapheim Dimitropoulos 			/* it is a two-word entry so we read another word */
824*17f11284SSerapheim Dimitropoulos 			ASSERT(sm_entry_is_double_word(word));
825*17f11284SSerapheim Dimitropoulos 
826*17f11284SSerapheim Dimitropoulos 			uint64_t extra_word;
827*17f11284SSerapheim Dimitropoulos 			offset += sizeof (extra_word);
828*17f11284SSerapheim Dimitropoulos 			VERIFY0(dmu_read(os, space_map_object(sm), offset,
829*17f11284SSerapheim Dimitropoulos 			    sizeof (extra_word), &extra_word,
830*17f11284SSerapheim Dimitropoulos 			    DMU_READ_PREFETCH));
831*17f11284SSerapheim Dimitropoulos 
832*17f11284SSerapheim Dimitropoulos 			ASSERT3U(offset, <=, space_map_length(sm));
833*17f11284SSerapheim Dimitropoulos 
834*17f11284SSerapheim Dimitropoulos 			entry_run = SM2_RUN_DECODE(word) << mapshift;
835*17f11284SSerapheim Dimitropoulos 			entry_vdev = SM2_VDEV_DECODE(word);
836*17f11284SSerapheim Dimitropoulos 			entry_type = (SM2_TYPE_DECODE(extra_word) == SM_ALLOC) ?
837*17f11284SSerapheim Dimitropoulos 			    'A' : 'F';
838*17f11284SSerapheim Dimitropoulos 			entry_off = (SM2_OFFSET_DECODE(extra_word) <<
839*17f11284SSerapheim Dimitropoulos 			    mapshift) + sm->sm_start;
840*17f11284SSerapheim Dimitropoulos 			words = 2;
841fa9e4066Sahrens 		}
842*17f11284SSerapheim Dimitropoulos 
843*17f11284SSerapheim Dimitropoulos 		(void) printf("\t    [%6llu]    %c  range:"
844*17f11284SSerapheim Dimitropoulos 		    " %010llx-%010llx  size: %06llx vdev: %06llu words: %u\n",
845*17f11284SSerapheim Dimitropoulos 		    (u_longlong_t)(offset / sizeof (word)),
846*17f11284SSerapheim Dimitropoulos 		    entry_type, (u_longlong_t)entry_off,
847*17f11284SSerapheim Dimitropoulos 		    (u_longlong_t)(entry_off + entry_run),
848*17f11284SSerapheim Dimitropoulos 		    (u_longlong_t)entry_run,
849*17f11284SSerapheim Dimitropoulos 		    (u_longlong_t)entry_vdev, words);
850*17f11284SSerapheim Dimitropoulos 
851*17f11284SSerapheim Dimitropoulos 		if (entry_type == 'A')
852*17f11284SSerapheim Dimitropoulos 			alloc += entry_run;
853*17f11284SSerapheim Dimitropoulos 		else
854*17f11284SSerapheim Dimitropoulos 			alloc -= entry_run;
855fa9e4066Sahrens 	}
856*17f11284SSerapheim Dimitropoulos 	if ((uint64_t)alloc != space_map_allocated(sm)) {
857*17f11284SSerapheim Dimitropoulos 		(void) printf("space_map_object alloc (%lld) INCONSISTENT "
858*17f11284SSerapheim Dimitropoulos 		    "with space map summary (%lld)\n",
859*17f11284SSerapheim Dimitropoulos 		    (longlong_t)space_map_allocated(sm), (longlong_t)alloc);
860fa9e4066Sahrens 	}
861fa9e4066Sahrens }
862fa9e4066Sahrens 
863d6e555bdSGeorge Wilson static void
864d6e555bdSGeorge Wilson dump_metaslab_stats(metaslab_t *msp)
865d6e555bdSGeorge Wilson {
8663f9d6ad7SLin Ling 	char maxbuf[32];
86786714001SSerapheim Dimitropoulos 	range_tree_t *rt = msp->ms_allocatable;
86886714001SSerapheim Dimitropoulos 	avl_tree_t *t = &msp->ms_allocatable_by_size;
8690713e232SGeorge Wilson 	int free_pct = range_tree_space(rt) * 100 / msp->ms_size;
870d6e555bdSGeorge Wilson 
8710a055120SJason King 	/* max sure nicenum has enough space */
8720a055120SJason King 	CTASSERT(sizeof (maxbuf) >= NN_NUMBUF_SZ);
8730a055120SJason King 
8740a055120SJason King 	zdb_nicenum(metaslab_block_maxsize(msp), maxbuf, sizeof (maxbuf));
875d6e555bdSGeorge Wilson 
87687219db7SVictor Latushkin 	(void) printf("\t %25s %10lu   %7s  %6s   %4s %4d%%\n",
877d6e555bdSGeorge Wilson 	    "segments", avl_numnodes(t), "maxsize", maxbuf,
878d6e555bdSGeorge Wilson 	    "freepct", free_pct);
8790713e232SGeorge Wilson 	(void) printf("\tIn-memory histogram:\n");
8800713e232SGeorge Wilson 	dump_histogram(rt->rt_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
881d6e555bdSGeorge Wilson }
882d6e555bdSGeorge Wilson 
883fa9e4066Sahrens static void
884fa9e4066Sahrens dump_metaslab(metaslab_t *msp)
885fa9e4066Sahrens {
886fa9e4066Sahrens 	vdev_t *vd = msp->ms_group->mg_vd;
887fa9e4066Sahrens 	spa_t *spa = vd->vdev_spa;
8880713e232SGeorge Wilson 	space_map_t *sm = msp->ms_sm;
8893f9d6ad7SLin Ling 	char freebuf[32];
890fa9e4066Sahrens 
8910a055120SJason King 	zdb_nicenum(msp->ms_size - space_map_allocated(sm), freebuf,
8920a055120SJason King 	    sizeof (freebuf));
893fa9e4066Sahrens 
894fa9e4066Sahrens 	(void) printf(
89587219db7SVictor Latushkin 	    "\tmetaslab %6llu   offset %12llx   spacemap %6llu   free    %5s\n",
8960713e232SGeorge Wilson 	    (u_longlong_t)msp->ms_id, (u_longlong_t)msp->ms_start,
8970713e232SGeorge Wilson 	    (u_longlong_t)space_map_object(sm), freebuf);
898fa9e4066Sahrens 
8990713e232SGeorge Wilson 	if (dump_opt['m'] > 2 && !dump_opt['L']) {
900d6e555bdSGeorge Wilson 		mutex_enter(&msp->ms_lock);
9010713e232SGeorge Wilson 		metaslab_load_wait(msp);
9020713e232SGeorge Wilson 		if (!msp->ms_loaded) {
9030713e232SGeorge Wilson 			VERIFY0(metaslab_load(msp));
90486714001SSerapheim Dimitropoulos 			range_tree_stat_verify(msp->ms_allocatable);
9050713e232SGeorge Wilson 		}
906bc3975b5SVictor Latushkin 		dump_metaslab_stats(msp);
9070713e232SGeorge Wilson 		metaslab_unload(msp);
908d6e555bdSGeorge Wilson 		mutex_exit(&msp->ms_lock);
909d6e555bdSGeorge Wilson 	}
910d6e555bdSGeorge Wilson 
9110713e232SGeorge Wilson 	if (dump_opt['m'] > 1 && sm != NULL &&
9122acef22dSMatthew Ahrens 	    spa_feature_is_active(spa, SPA_FEATURE_SPACEMAP_HISTOGRAM)) {
9130713e232SGeorge Wilson 		/*
9140713e232SGeorge Wilson 		 * The space map histogram represents free space in chunks
9150713e232SGeorge Wilson 		 * of sm_shift (i.e. bucket 0 refers to 2^sm_shift).
9160713e232SGeorge Wilson 		 */
9172e4c9986SGeorge Wilson 		(void) printf("\tOn-disk histogram:\t\tfragmentation %llu\n",
9182e4c9986SGeorge Wilson 		    (u_longlong_t)msp->ms_fragmentation);
9190713e232SGeorge Wilson 		dump_histogram(sm->sm_phys->smp_histogram,
9202e4c9986SGeorge Wilson 		    SPACE_MAP_HISTOGRAM_SIZE, sm->sm_shift);
9210713e232SGeorge Wilson 	}
9220713e232SGeorge Wilson 
9230713e232SGeorge Wilson 	if (dump_opt['d'] > 5 || dump_opt['m'] > 3) {
9240713e232SGeorge Wilson 		ASSERT(msp->ms_size == (1ULL << vd->vdev_ms_shift));
925d6e555bdSGeorge Wilson 
9260713e232SGeorge Wilson 		dump_spacemap(spa->spa_meta_objset, msp->ms_sm);
927d6e555bdSGeorge Wilson 	}
92887219db7SVictor Latushkin }
929fa9e4066Sahrens 
93087219db7SVictor Latushkin static void
93187219db7SVictor Latushkin print_vdev_metaslab_header(vdev_t *vd)
93287219db7SVictor Latushkin {
93387219db7SVictor Latushkin 	(void) printf("\tvdev %10llu\n\t%-10s%5llu   %-19s   %-15s   %-10s\n",
93487219db7SVictor Latushkin 	    (u_longlong_t)vd->vdev_id,
93587219db7SVictor Latushkin 	    "metaslabs", (u_longlong_t)vd->vdev_ms_count,
93687219db7SVictor Latushkin 	    "offset", "spacemap", "free");
93787219db7SVictor Latushkin 	(void) printf("\t%15s   %19s   %15s   %10s\n",
93887219db7SVictor Latushkin 	    "---------------", "-------------------",
93987219db7SVictor Latushkin 	    "---------------", "-------------");
940fa9e4066Sahrens }
941fa9e4066Sahrens 
9422e4c9986SGeorge Wilson static void
9432e4c9986SGeorge Wilson dump_metaslab_groups(spa_t *spa)
9442e4c9986SGeorge Wilson {
9452e4c9986SGeorge Wilson 	vdev_t *rvd = spa->spa_root_vdev;
9462e4c9986SGeorge Wilson 	metaslab_class_t *mc = spa_normal_class(spa);
9472e4c9986SGeorge Wilson 	uint64_t fragmentation;
9482e4c9986SGeorge Wilson 
9492e4c9986SGeorge Wilson 	metaslab_class_histogram_verify(mc);
9502e4c9986SGeorge Wilson 
9513f7978d0SAlan Somers 	for (unsigned c = 0; c < rvd->vdev_children; c++) {
9522e4c9986SGeorge Wilson 		vdev_t *tvd = rvd->vdev_child[c];
9532e4c9986SGeorge Wilson 		metaslab_group_t *mg = tvd->vdev_mg;
9542e4c9986SGeorge Wilson 
9552e4c9986SGeorge Wilson 		if (mg->mg_class != mc)
9562e4c9986SGeorge Wilson 			continue;
9572e4c9986SGeorge Wilson 
9582e4c9986SGeorge Wilson 		metaslab_group_histogram_verify(mg);
9592e4c9986SGeorge Wilson 		mg->mg_fragmentation = metaslab_group_fragmentation(mg);
9602e4c9986SGeorge Wilson 
9612e4c9986SGeorge Wilson 		(void) printf("\tvdev %10llu\t\tmetaslabs%5llu\t\t"
9622e4c9986SGeorge Wilson 		    "fragmentation",
9632e4c9986SGeorge Wilson 		    (u_longlong_t)tvd->vdev_id,
9642e4c9986SGeorge Wilson 		    (u_longlong_t)tvd->vdev_ms_count);
9652e4c9986SGeorge Wilson 		if (mg->mg_fragmentation == ZFS_FRAG_INVALID) {
9662e4c9986SGeorge Wilson 			(void) printf("%3s\n", "-");
9672e4c9986SGeorge Wilson 		} else {
9682e4c9986SGeorge Wilson 			(void) printf("%3llu%%\n",
9692e4c9986SGeorge Wilson 			    (u_longlong_t)mg->mg_fragmentation);
9702e4c9986SGeorge Wilson 		}
9712e4c9986SGeorge Wilson 		dump_histogram(mg->mg_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
9722e4c9986SGeorge Wilson 	}
9732e4c9986SGeorge Wilson 
9742e4c9986SGeorge Wilson 	(void) printf("\tpool %s\tfragmentation", spa_name(spa));
9752e4c9986SGeorge Wilson 	fragmentation = metaslab_class_fragmentation(mc);
9762e4c9986SGeorge Wilson 	if (fragmentation == ZFS_FRAG_INVALID)
9772e4c9986SGeorge Wilson 		(void) printf("\t%3s\n", "-");
9782e4c9986SGeorge Wilson 	else
9792e4c9986SGeorge Wilson 		(void) printf("\t%3llu%%\n", (u_longlong_t)fragmentation);
9802e4c9986SGeorge Wilson 	dump_histogram(mc->mc_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
9812e4c9986SGeorge Wilson }
9822e4c9986SGeorge Wilson 
9835cabbc6bSPrashanth Sreenivasa static void
9845cabbc6bSPrashanth Sreenivasa print_vdev_indirect(vdev_t *vd)
9855cabbc6bSPrashanth Sreenivasa {
9865cabbc6bSPrashanth Sreenivasa 	vdev_indirect_config_t *vic = &vd->vdev_indirect_config;
9875cabbc6bSPrashanth Sreenivasa 	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
9885cabbc6bSPrashanth Sreenivasa 	vdev_indirect_births_t *vib = vd->vdev_indirect_births;
9895cabbc6bSPrashanth Sreenivasa 
9905cabbc6bSPrashanth Sreenivasa 	if (vim == NULL) {
9915cabbc6bSPrashanth Sreenivasa 		ASSERT3P(vib, ==, NULL);
9925cabbc6bSPrashanth Sreenivasa 		return;
9935cabbc6bSPrashanth Sreenivasa 	}
9945cabbc6bSPrashanth Sreenivasa 
9955cabbc6bSPrashanth Sreenivasa 	ASSERT3U(vdev_indirect_mapping_object(vim), ==,
9965cabbc6bSPrashanth Sreenivasa 	    vic->vic_mapping_object);
9975cabbc6bSPrashanth Sreenivasa 	ASSERT3U(vdev_indirect_births_object(vib), ==,
9985cabbc6bSPrashanth Sreenivasa 	    vic->vic_births_object);
9995cabbc6bSPrashanth Sreenivasa 
10005cabbc6bSPrashanth Sreenivasa 	(void) printf("indirect births obj %llu:\n",
10015cabbc6bSPrashanth Sreenivasa 	    (longlong_t)vic->vic_births_object);
10025cabbc6bSPrashanth Sreenivasa 	(void) printf("    vib_count = %llu\n",
10035cabbc6bSPrashanth Sreenivasa 	    (longlong_t)vdev_indirect_births_count(vib));
10045cabbc6bSPrashanth Sreenivasa 	for (uint64_t i = 0; i < vdev_indirect_births_count(vib); i++) {
10055cabbc6bSPrashanth Sreenivasa 		vdev_indirect_birth_entry_phys_t *cur_vibe =
10065cabbc6bSPrashanth Sreenivasa 		    &vib->vib_entries[i];
10075cabbc6bSPrashanth Sreenivasa 		(void) printf("\toffset %llx -> txg %llu\n",
10085cabbc6bSPrashanth Sreenivasa 		    (longlong_t)cur_vibe->vibe_offset,
10095cabbc6bSPrashanth Sreenivasa 		    (longlong_t)cur_vibe->vibe_phys_birth_txg);
10105cabbc6bSPrashanth Sreenivasa 	}
10115cabbc6bSPrashanth Sreenivasa 	(void) printf("\n");
10125cabbc6bSPrashanth Sreenivasa 
10135cabbc6bSPrashanth Sreenivasa 	(void) printf("indirect mapping obj %llu:\n",
10145cabbc6bSPrashanth Sreenivasa 	    (longlong_t)vic->vic_mapping_object);
10155cabbc6bSPrashanth Sreenivasa 	(void) printf("    vim_max_offset = 0x%llx\n",
10165cabbc6bSPrashanth Sreenivasa 	    (longlong_t)vdev_indirect_mapping_max_offset(vim));
10175cabbc6bSPrashanth Sreenivasa 	(void) printf("    vim_bytes_mapped = 0x%llx\n",
10185cabbc6bSPrashanth Sreenivasa 	    (longlong_t)vdev_indirect_mapping_bytes_mapped(vim));
10195cabbc6bSPrashanth Sreenivasa 	(void) printf("    vim_count = %llu\n",
10205cabbc6bSPrashanth Sreenivasa 	    (longlong_t)vdev_indirect_mapping_num_entries(vim));
10215cabbc6bSPrashanth Sreenivasa 
10225cabbc6bSPrashanth Sreenivasa 	if (dump_opt['d'] <= 5 && dump_opt['m'] <= 3)
10235cabbc6bSPrashanth Sreenivasa 		return;
10245cabbc6bSPrashanth Sreenivasa 
10255cabbc6bSPrashanth Sreenivasa 	uint32_t *counts = vdev_indirect_mapping_load_obsolete_counts(vim);
10265cabbc6bSPrashanth Sreenivasa 
10275cabbc6bSPrashanth Sreenivasa 	for (uint64_t i = 0; i < vdev_indirect_mapping_num_entries(vim); i++) {
10285cabbc6bSPrashanth Sreenivasa 		vdev_indirect_mapping_entry_phys_t *vimep =
10295cabbc6bSPrashanth Sreenivasa 		    &vim->vim_entries[i];
10305cabbc6bSPrashanth Sreenivasa 		(void) printf("\t<%llx:%llx:%llx> -> "
10315cabbc6bSPrashanth Sreenivasa 		    "<%llx:%llx:%llx> (%x obsolete)\n",
10325cabbc6bSPrashanth Sreenivasa 		    (longlong_t)vd->vdev_id,
10335cabbc6bSPrashanth Sreenivasa 		    (longlong_t)DVA_MAPPING_GET_SRC_OFFSET(vimep),
10345cabbc6bSPrashanth Sreenivasa 		    (longlong_t)DVA_GET_ASIZE(&vimep->vimep_dst),
10355cabbc6bSPrashanth Sreenivasa 		    (longlong_t)DVA_GET_VDEV(&vimep->vimep_dst),
10365cabbc6bSPrashanth Sreenivasa 		    (longlong_t)DVA_GET_OFFSET(&vimep->vimep_dst),
10375cabbc6bSPrashanth Sreenivasa 		    (longlong_t)DVA_GET_ASIZE(&vimep->vimep_dst),
10385cabbc6bSPrashanth Sreenivasa 		    counts[i]);
10395cabbc6bSPrashanth Sreenivasa 	}
10405cabbc6bSPrashanth Sreenivasa 	(void) printf("\n");
10415cabbc6bSPrashanth Sreenivasa 
10425cabbc6bSPrashanth Sreenivasa 	uint64_t obsolete_sm_object = vdev_obsolete_sm_object(vd);
10435cabbc6bSPrashanth Sreenivasa 	if (obsolete_sm_object != 0) {
10445cabbc6bSPrashanth Sreenivasa 		objset_t *mos = vd->vdev_spa->spa_meta_objset;
10455cabbc6bSPrashanth Sreenivasa 		(void) printf("obsolete space map object %llu:\n",
10465cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)obsolete_sm_object);
10475cabbc6bSPrashanth Sreenivasa 		ASSERT(vd->vdev_obsolete_sm != NULL);
10485cabbc6bSPrashanth Sreenivasa 		ASSERT3U(space_map_object(vd->vdev_obsolete_sm), ==,
10495cabbc6bSPrashanth Sreenivasa 		    obsolete_sm_object);
10505cabbc6bSPrashanth Sreenivasa 		dump_spacemap(mos, vd->vdev_obsolete_sm);
10515cabbc6bSPrashanth Sreenivasa 		(void) printf("\n");
10525cabbc6bSPrashanth Sreenivasa 	}
10535cabbc6bSPrashanth Sreenivasa }
10545cabbc6bSPrashanth Sreenivasa 
1055fa9e4066Sahrens static void
1056fa9e4066Sahrens dump_metaslabs(spa_t *spa)
1057fa9e4066Sahrens {
105887219db7SVictor Latushkin 	vdev_t *vd, *rvd = spa->spa_root_vdev;
105987219db7SVictor Latushkin 	uint64_t m, c = 0, children = rvd->vdev_children;
1060fa9e4066Sahrens 
1061fa9e4066Sahrens 	(void) printf("\nMetaslabs:\n");
1062fa9e4066Sahrens 
106387219db7SVictor Latushkin 	if (!dump_opt['d'] && zopt_objects > 0) {
106487219db7SVictor Latushkin 		c = zopt_object[0];
106587219db7SVictor Latushkin 
106687219db7SVictor Latushkin 		if (c >= children)
106787219db7SVictor Latushkin 			(void) fatal("bad vdev id: %llu", (u_longlong_t)c);
1068fa9e4066Sahrens 
106987219db7SVictor Latushkin 		if (zopt_objects > 1) {
107087219db7SVictor Latushkin 			vd = rvd->vdev_child[c];
107187219db7SVictor Latushkin 			print_vdev_metaslab_header(vd);
107287219db7SVictor Latushkin 
107387219db7SVictor Latushkin 			for (m = 1; m < zopt_objects; m++) {
107487219db7SVictor Latushkin 				if (zopt_object[m] < vd->vdev_ms_count)
107587219db7SVictor Latushkin 					dump_metaslab(
107687219db7SVictor Latushkin 					    vd->vdev_ms[zopt_object[m]]);
107787219db7SVictor Latushkin 				else
107887219db7SVictor Latushkin 					(void) fprintf(stderr, "bad metaslab "
107987219db7SVictor Latushkin 					    "number %llu\n",
108087219db7SVictor Latushkin 					    (u_longlong_t)zopt_object[m]);
108187219db7SVictor Latushkin 			}
108287219db7SVictor Latushkin 			(void) printf("\n");
108387219db7SVictor Latushkin 			return;
108487219db7SVictor Latushkin 		}
108587219db7SVictor Latushkin 		children = c + 1;
108687219db7SVictor Latushkin 	}
108787219db7SVictor Latushkin 	for (; c < children; c++) {
108887219db7SVictor Latushkin 		vd = rvd->vdev_child[c];
108987219db7SVictor Latushkin 		print_vdev_metaslab_header(vd);
1090fa9e4066Sahrens 
10915cabbc6bSPrashanth Sreenivasa 		print_vdev_indirect(vd);
10925cabbc6bSPrashanth Sreenivasa 
1093fa9e4066Sahrens 		for (m = 0; m < vd->vdev_ms_count; m++)
1094fa9e4066Sahrens 			dump_metaslab(vd->vdev_ms[m]);
1095fa9e4066Sahrens 		(void) printf("\n");
1096fa9e4066Sahrens 	}
1097fa9e4066Sahrens }
1098fa9e4066Sahrens 
1099b24ab676SJeff Bonwick static void
1100b24ab676SJeff Bonwick dump_dde(const ddt_t *ddt, const ddt_entry_t *dde, uint64_t index)
1101b24ab676SJeff Bonwick {
1102b24ab676SJeff Bonwick 	const ddt_phys_t *ddp = dde->dde_phys;
1103b24ab676SJeff Bonwick 	const ddt_key_t *ddk = &dde->dde_key;
11043f7978d0SAlan Somers 	const char *types[4] = { "ditto", "single", "double", "triple" };
1105b24ab676SJeff Bonwick 	char blkbuf[BP_SPRINTF_LEN];
1106b24ab676SJeff Bonwick 	blkptr_t blk;
1107b24ab676SJeff Bonwick 
1108b24ab676SJeff Bonwick 	for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
1109b24ab676SJeff Bonwick 		if (ddp->ddp_phys_birth == 0)
1110b24ab676SJeff Bonwick 			continue;
1111bbfd46c4SJeff Bonwick 		ddt_bp_create(ddt->ddt_checksum, ddk, ddp, &blk);
111243466aaeSMax Grossman 		snprintf_blkptr(blkbuf, sizeof (blkbuf), &blk);
1113b24ab676SJeff Bonwick 		(void) printf("index %llx refcnt %llu %s %s\n",
1114b24ab676SJeff Bonwick 		    (u_longlong_t)index, (u_longlong_t)ddp->ddp_refcnt,
1115b24ab676SJeff Bonwick 		    types[p], blkbuf);
1116b24ab676SJeff Bonwick 	}
1117b24ab676SJeff Bonwick }
1118b24ab676SJeff Bonwick 
1119b24ab676SJeff Bonwick static void
1120b24ab676SJeff Bonwick dump_dedup_ratio(const ddt_stat_t *dds)
1121b24ab676SJeff Bonwick {
1122b24ab676SJeff Bonwick 	double rL, rP, rD, D, dedup, compress, copies;
1123b24ab676SJeff Bonwick 
1124b24ab676SJeff Bonwick 	if (dds->dds_blocks == 0)
1125b24ab676SJeff Bonwick 		return;
1126b24ab676SJeff Bonwick 
1127b24ab676SJeff Bonwick 	rL = (double)dds->dds_ref_lsize;
1128b24ab676SJeff Bonwick 	rP = (double)dds->dds_ref_psize;
1129b24ab676SJeff Bonwick 	rD = (double)dds->dds_ref_dsize;
1130b24ab676SJeff Bonwick 	D = (double)dds->dds_dsize;
1131b24ab676SJeff Bonwick 
1132b24ab676SJeff Bonwick 	dedup = rD / D;
1133b24ab676SJeff Bonwick 	compress = rL / rP;
1134b24ab676SJeff Bonwick 	copies = rD / rP;
1135b24ab676SJeff Bonwick 
1136b24ab676SJeff Bonwick 	(void) printf("dedup = %.2f, compress = %.2f, copies = %.2f, "
1137b24ab676SJeff Bonwick 	    "dedup * compress / copies = %.2f\n\n",
1138b24ab676SJeff Bonwick 	    dedup, compress, copies, dedup * compress / copies);
1139b24ab676SJeff Bonwick }
1140b24ab676SJeff Bonwick 
1141b24ab676SJeff Bonwick static void
1142b24ab676SJeff Bonwick dump_ddt(ddt_t *ddt, enum ddt_type type, enum ddt_class class)
1143b24ab676SJeff Bonwick {
1144b24ab676SJeff Bonwick 	char name[DDT_NAMELEN];
1145b24ab676SJeff Bonwick 	ddt_entry_t dde;
1146b24ab676SJeff Bonwick 	uint64_t walk = 0;
1147b24ab676SJeff Bonwick 	dmu_object_info_t doi;
1148b24ab676SJeff Bonwick 	uint64_t count, dspace, mspace;
1149b24ab676SJeff Bonwick 	int error;
1150b24ab676SJeff Bonwick 
1151b24ab676SJeff Bonwick 	error = ddt_object_info(ddt, type, class, &doi);
1152b24ab676SJeff Bonwick 
1153b24ab676SJeff Bonwick 	if (error == ENOENT)
1154b24ab676SJeff Bonwick 		return;
1155b24ab676SJeff Bonwick 	ASSERT(error == 0);
1156b24ab676SJeff Bonwick 
11577448a079SGeorge Wilson 	if ((count = ddt_object_count(ddt, type, class)) == 0)
11587448a079SGeorge Wilson 		return;
11597448a079SGeorge Wilson 
1160b24ab676SJeff Bonwick 	dspace = doi.doi_physical_blocks_512 << 9;
1161b24ab676SJeff Bonwick 	mspace = doi.doi_fill_count * doi.doi_data_block_size;
1162b24ab676SJeff Bonwick 
1163b24ab676SJeff Bonwick 	ddt_object_name(ddt, type, class, name);
1164b24ab676SJeff Bonwick 
1165b24ab676SJeff Bonwick 	(void) printf("%s: %llu entries, size %llu on disk, %llu in core\n",
1166b24ab676SJeff Bonwick 	    name,
1167b24ab676SJeff Bonwick 	    (u_longlong_t)count,
1168b24ab676SJeff Bonwick 	    (u_longlong_t)(dspace / count),
1169b24ab676SJeff Bonwick 	    (u_longlong_t)(mspace / count));
1170b24ab676SJeff Bonwick 
1171b24ab676SJeff Bonwick 	if (dump_opt['D'] < 3)
1172b24ab676SJeff Bonwick 		return;
1173b24ab676SJeff Bonwick 
11749eb19f4dSGeorge Wilson 	zpool_dump_ddt(NULL, &ddt->ddt_histogram[type][class]);
1175b24ab676SJeff Bonwick 
1176b24ab676SJeff Bonwick 	if (dump_opt['D'] < 4)
1177b24ab676SJeff Bonwick 		return;
1178b24ab676SJeff Bonwick 
1179b24ab676SJeff Bonwick 	if (dump_opt['D'] < 5 && class == DDT_CLASS_UNIQUE)
1180b24ab676SJeff Bonwick 		return;
1181b24ab676SJeff Bonwick 
1182b24ab676SJeff Bonwick 	(void) printf("%s contents:\n\n", name);
1183b24ab676SJeff Bonwick 
1184bbfd46c4SJeff Bonwick 	while ((error = ddt_object_walk(ddt, type, class, &walk, &dde)) == 0)
1185b24ab676SJeff Bonwick 		dump_dde(ddt, &dde, walk);
1186b24ab676SJeff Bonwick 
1187*17f11284SSerapheim Dimitropoulos 	ASSERT3U(error, ==, ENOENT);
1188b24ab676SJeff Bonwick 
1189b24ab676SJeff Bonwick 	(void) printf("\n");
1190b24ab676SJeff Bonwick }
1191b24ab676SJeff Bonwick 
1192b24ab676SJeff Bonwick static void
1193b24ab676SJeff Bonwick dump_all_ddts(spa_t *spa)
1194b24ab676SJeff Bonwick {
11953f7978d0SAlan Somers 	ddt_histogram_t ddh_total;
11963f7978d0SAlan Somers 	ddt_stat_t dds_total;
11973f7978d0SAlan Somers 
11983f7978d0SAlan Somers 	bzero(&ddh_total, sizeof (ddh_total));
11993f7978d0SAlan Somers 	bzero(&dds_total, sizeof (dds_total));
1200b24ab676SJeff Bonwick 
1201b24ab676SJeff Bonwick 	for (enum zio_checksum c = 0; c < ZIO_CHECKSUM_FUNCTIONS; c++) {
1202b24ab676SJeff Bonwick 		ddt_t *ddt = spa->spa_ddt[c];
1203b24ab676SJeff Bonwick 		for (enum ddt_type type = 0; type < DDT_TYPES; type++) {
1204b24ab676SJeff Bonwick 			for (enum ddt_class class = 0; class < DDT_CLASSES;
1205b24ab676SJeff Bonwick 			    class++) {
1206b24ab676SJeff Bonwick 				dump_ddt(ddt, type, class);
1207b24ab676SJeff Bonwick 			}
1208b24ab676SJeff Bonwick 		}
1209b24ab676SJeff Bonwick 	}
1210b24ab676SJeff Bonwick 
12119eb19f4dSGeorge Wilson 	ddt_get_dedup_stats(spa, &dds_total);
1212b24ab676SJeff Bonwick 
1213b24ab676SJeff Bonwick 	if (dds_total.dds_blocks == 0) {
1214b24ab676SJeff Bonwick 		(void) printf("All DDTs are empty\n");
1215b24ab676SJeff Bonwick 		return;
1216b24ab676SJeff Bonwick 	}
1217b24ab676SJeff Bonwick 
1218b24ab676SJeff Bonwick 	(void) printf("\n");
1219b24ab676SJeff Bonwick 
1220b24ab676SJeff Bonwick 	if (dump_opt['D'] > 1) {
1221b24ab676SJeff Bonwick 		(void) printf("DDT histogram (aggregated over all DDTs):\n");
12229eb19f4dSGeorge Wilson 		ddt_get_dedup_histogram(spa, &ddh_total);
12239eb19f4dSGeorge Wilson 		zpool_dump_ddt(&dds_total, &ddh_total);
1224b24ab676SJeff Bonwick 	}
1225b24ab676SJeff Bonwick 
1226b24ab676SJeff Bonwick 	dump_dedup_ratio(&dds_total);
1227b24ab676SJeff Bonwick }
1228b24ab676SJeff Bonwick 
12298ad4d6ddSJeff Bonwick static void
12300713e232SGeorge Wilson dump_dtl_seg(void *arg, uint64_t start, uint64_t size)
12318ad4d6ddSJeff Bonwick {
12320713e232SGeorge Wilson 	char *prefix = arg;
12338ad4d6ddSJeff Bonwick 
12348ad4d6ddSJeff Bonwick 	(void) printf("%s [%llu,%llu) length %llu\n",
12358ad4d6ddSJeff Bonwick 	    prefix,
12368ad4d6ddSJeff Bonwick 	    (u_longlong_t)start,
12378ad4d6ddSJeff Bonwick 	    (u_longlong_t)(start + size),
12388ad4d6ddSJeff Bonwick 	    (u_longlong_t)(size));
12398ad4d6ddSJeff Bonwick }
12408ad4d6ddSJeff Bonwick 
1241fa9e4066Sahrens static void
1242fa9e4066Sahrens dump_dtl(vdev_t *vd, int indent)
1243fa9e4066Sahrens {
12448ad4d6ddSJeff Bonwick 	spa_t *spa = vd->vdev_spa;
12458ad4d6ddSJeff Bonwick 	boolean_t required;
12463f7978d0SAlan Somers 	const char *name[DTL_TYPES] = { "missing", "partial", "scrub",
12473f7978d0SAlan Somers 		"outage" };
12488ad4d6ddSJeff Bonwick 	char prefix[256];
12498ad4d6ddSJeff Bonwick 
12508f18d1faSGeorge Wilson 	spa_vdev_state_enter(spa, SCL_NONE);
12518ad4d6ddSJeff Bonwick 	required = vdev_dtl_required(vd);
12528ad4d6ddSJeff Bonwick 	(void) spa_vdev_state_exit(spa, NULL, 0);
1253fa9e4066Sahrens 
1254fa9e4066Sahrens 	if (indent == 0)
1255fa9e4066Sahrens 		(void) printf("\nDirty time logs:\n\n");
1256fa9e4066Sahrens 
12578ad4d6ddSJeff Bonwick 	(void) printf("\t%*s%s [%s]\n", indent, "",
1258e14bb325SJeff Bonwick 	    vd->vdev_path ? vd->vdev_path :
12598ad4d6ddSJeff Bonwick 	    vd->vdev_parent ? vd->vdev_ops->vdev_op_type : spa_name(spa),
12608ad4d6ddSJeff Bonwick 	    required ? "DTL-required" : "DTL-expendable");
1261fa9e4066Sahrens 
12628ad4d6ddSJeff Bonwick 	for (int t = 0; t < DTL_TYPES; t++) {
12630713e232SGeorge Wilson 		range_tree_t *rt = vd->vdev_dtl[t];
12640713e232SGeorge Wilson 		if (range_tree_space(rt) == 0)
12658ad4d6ddSJeff Bonwick 			continue;
12668ad4d6ddSJeff Bonwick 		(void) snprintf(prefix, sizeof (prefix), "\t%*s%s",
12678ad4d6ddSJeff Bonwick 		    indent + 2, "", name[t]);
12680713e232SGeorge Wilson 		range_tree_walk(rt, dump_dtl_seg, prefix);
12698ad4d6ddSJeff Bonwick 		if (dump_opt['d'] > 5 && vd->vdev_children == 0)
12700713e232SGeorge Wilson 			dump_spacemap(spa->spa_meta_objset, vd->vdev_dtl_sm);
1271fa9e4066Sahrens 	}
1272fa9e4066Sahrens 
12733f7978d0SAlan Somers 	for (unsigned c = 0; c < vd->vdev_children; c++)
1274fa9e4066Sahrens 		dump_dtl(vd->vdev_child[c], indent + 4);
1275fa9e4066Sahrens }
1276fa9e4066Sahrens 
12778f18d1faSGeorge Wilson static void
12788f18d1faSGeorge Wilson dump_history(spa_t *spa)
12798f18d1faSGeorge Wilson {
12808f18d1faSGeorge Wilson 	nvlist_t **events = NULL;
1281e4161df6SVictor Latushkin 	uint64_t resid, len, off = 0;
12828f18d1faSGeorge Wilson 	uint_t num = 0;
12838f18d1faSGeorge Wilson 	int error;
12848f18d1faSGeorge Wilson 	time_t tsec;
12858f18d1faSGeorge Wilson 	struct tm t;
12868f18d1faSGeorge Wilson 	char tbuf[30];
12878f18d1faSGeorge Wilson 	char internalstr[MAXPATHLEN];
12888f18d1faSGeorge Wilson 
12893f84190cSMatthew Ahrens 	char *buf = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
12908f18d1faSGeorge Wilson 	do {
12913f84190cSMatthew Ahrens 		len = SPA_MAXBLOCKSIZE;
1292e4161df6SVictor Latushkin 
12938f18d1faSGeorge Wilson 		if ((error = spa_history_get(spa, &off, &len, buf)) != 0) {
12948f18d1faSGeorge Wilson 			(void) fprintf(stderr, "Unable to read history: "
12958f18d1faSGeorge Wilson 			    "error %d\n", error);
12963f84190cSMatthew Ahrens 			umem_free(buf, SPA_MAXBLOCKSIZE);
12978f18d1faSGeorge Wilson 			return;
12988f18d1faSGeorge Wilson 		}
12998f18d1faSGeorge Wilson 
13008f18d1faSGeorge Wilson 		if (zpool_history_unpack(buf, len, &resid, &events, &num) != 0)
13018f18d1faSGeorge Wilson 			break;
13028f18d1faSGeorge Wilson 
13038f18d1faSGeorge Wilson 		off -= resid;
13048f18d1faSGeorge Wilson 	} while (len != 0);
13053f84190cSMatthew Ahrens 	umem_free(buf, SPA_MAXBLOCKSIZE);
13068f18d1faSGeorge Wilson 
13078f18d1faSGeorge Wilson 	(void) printf("\nHistory:\n");
13083f7978d0SAlan Somers 	for (unsigned i = 0; i < num; i++) {
13098f18d1faSGeorge Wilson 		uint64_t time, txg, ievent;
13108f18d1faSGeorge Wilson 		char *cmd, *intstr;
13114445fffbSMatthew Ahrens 		boolean_t printed = B_FALSE;
13128f18d1faSGeorge Wilson 
13138f18d1faSGeorge Wilson 		if (nvlist_lookup_uint64(events[i], ZPOOL_HIST_TIME,
13148f18d1faSGeorge Wilson 		    &time) != 0)
13154445fffbSMatthew Ahrens 			goto next;
13168f18d1faSGeorge Wilson 		if (nvlist_lookup_string(events[i], ZPOOL_HIST_CMD,
13178f18d1faSGeorge Wilson 		    &cmd) != 0) {
13188f18d1faSGeorge Wilson 			if (nvlist_lookup_uint64(events[i],
13198f18d1faSGeorge Wilson 			    ZPOOL_HIST_INT_EVENT, &ievent) != 0)
13204445fffbSMatthew Ahrens 				goto next;
13218f18d1faSGeorge Wilson 			verify(nvlist_lookup_uint64(events[i],
13228f18d1faSGeorge Wilson 			    ZPOOL_HIST_TXG, &txg) == 0);
13238f18d1faSGeorge Wilson 			verify(nvlist_lookup_string(events[i],
13248f18d1faSGeorge Wilson 			    ZPOOL_HIST_INT_STR, &intstr) == 0);
13254445fffbSMatthew Ahrens 			if (ievent >= ZFS_NUM_LEGACY_HISTORY_EVENTS)
13264445fffbSMatthew Ahrens 				goto next;
13278f18d1faSGeorge Wilson 
13288f18d1faSGeorge Wilson 			(void) snprintf(internalstr,
13298f18d1faSGeorge Wilson 			    sizeof (internalstr),
13303f7978d0SAlan Somers 			    "[internal %s txg:%ju] %s",
13313f7978d0SAlan Somers 			    zfs_history_event_names[ievent], (uintmax_t)txg,
13328f18d1faSGeorge Wilson 			    intstr);
13338f18d1faSGeorge Wilson 			cmd = internalstr;
13348f18d1faSGeorge Wilson 		}
13358f18d1faSGeorge Wilson 		tsec = time;
13368f18d1faSGeorge Wilson 		(void) localtime_r(&tsec, &t);
13378f18d1faSGeorge Wilson 		(void) strftime(tbuf, sizeof (tbuf), "%F.%T", &t);
13388f18d1faSGeorge Wilson 		(void) printf("%s %s\n", tbuf, cmd);
13394445fffbSMatthew Ahrens 		printed = B_TRUE;
13404445fffbSMatthew Ahrens 
13414445fffbSMatthew Ahrens next:
13424445fffbSMatthew Ahrens 		if (dump_opt['h'] > 1) {
13434445fffbSMatthew Ahrens 			if (!printed)
13444445fffbSMatthew Ahrens 				(void) printf("unrecognized record:\n");
13454445fffbSMatthew Ahrens 			dump_nvlist(events[i], 2);
13464445fffbSMatthew Ahrens 		}
13478f18d1faSGeorge Wilson 	}
13488f18d1faSGeorge Wilson }
13498f18d1faSGeorge Wilson 
1350fa9e4066Sahrens /*ARGSUSED*/
1351fa9e4066Sahrens static void
1352fa9e4066Sahrens dump_dnode(objset_t *os, uint64_t object, void *data, size_t size)
1353fa9e4066Sahrens {
1354fa9e4066Sahrens }
1355fa9e4066Sahrens 
1356fa9e4066Sahrens static uint64_t
13577802d7bfSMatthew Ahrens blkid2offset(const dnode_phys_t *dnp, const blkptr_t *bp,
13587802d7bfSMatthew Ahrens     const zbookmark_phys_t *zb)
1359fa9e4066Sahrens {
1360b24ab676SJeff Bonwick 	if (dnp == NULL) {
1361b24ab676SJeff Bonwick 		ASSERT(zb->zb_level < 0);
1362b24ab676SJeff Bonwick 		if (zb->zb_object == 0)
1363b24ab676SJeff Bonwick 			return (zb->zb_blkid);
1364b24ab676SJeff Bonwick 		return (zb->zb_blkid * BP_GET_LSIZE(bp));
1365b24ab676SJeff Bonwick 	}
1366b24ab676SJeff Bonwick 
1367b24ab676SJeff Bonwick 	ASSERT(zb->zb_level >= 0);
1368fa9e4066Sahrens 
1369b24ab676SJeff Bonwick 	return ((zb->zb_blkid <<
1370b24ab676SJeff Bonwick 	    (zb->zb_level * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT))) *
1371fa9e4066Sahrens 	    dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT);
1372fa9e4066Sahrens }
1373fa9e4066Sahrens 
137444cd46caSbillm static void
137543466aaeSMax Grossman snprintf_blkptr_compact(char *blkbuf, size_t buflen, const blkptr_t *bp)
137644cd46caSbillm {
1377cde58dbcSMatthew Ahrens 	const dva_t *dva = bp->blk_dva;
1378b24ab676SJeff Bonwick 	int ndvas = dump_opt['d'] > 5 ? BP_GET_NDVAS(bp) : 1;
1379b24ab676SJeff Bonwick 
1380490d05b9SMatthew Ahrens 	if (dump_opt['b'] >= 6) {
138143466aaeSMax Grossman 		snprintf_blkptr(blkbuf, buflen, bp);
1382b24ab676SJeff Bonwick 		return;
1383b24ab676SJeff Bonwick 	}
138444cd46caSbillm 
13855d7b4d43SMatthew Ahrens 	if (BP_IS_EMBEDDED(bp)) {
13865d7b4d43SMatthew Ahrens 		(void) sprintf(blkbuf,
13875d7b4d43SMatthew Ahrens 		    "EMBEDDED et=%u %llxL/%llxP B=%llu",
13885d7b4d43SMatthew Ahrens 		    (int)BPE_GET_ETYPE(bp),
13895d7b4d43SMatthew Ahrens 		    (u_longlong_t)BPE_GET_LSIZE(bp),
13905d7b4d43SMatthew Ahrens 		    (u_longlong_t)BPE_GET_PSIZE(bp),
13915d7b4d43SMatthew Ahrens 		    (u_longlong_t)bp->blk_birth);
13925d7b4d43SMatthew Ahrens 		return;
13935d7b4d43SMatthew Ahrens 	}
139444cd46caSbillm 
13955d7b4d43SMatthew Ahrens 	blkbuf[0] = '\0';
1396b24ab676SJeff Bonwick 	for (int i = 0; i < ndvas; i++)
139743466aaeSMax Grossman 		(void) snprintf(blkbuf + strlen(blkbuf),
139843466aaeSMax Grossman 		    buflen - strlen(blkbuf), "%llu:%llx:%llx ",
139944cd46caSbillm 		    (u_longlong_t)DVA_GET_VDEV(&dva[i]),
140044cd46caSbillm 		    (u_longlong_t)DVA_GET_OFFSET(&dva[i]),
140144cd46caSbillm 		    (u_longlong_t)DVA_GET_ASIZE(&dva[i]));
140244cd46caSbillm 
140343466aaeSMax Grossman 	if (BP_IS_HOLE(bp)) {
140443466aaeSMax Grossman 		(void) snprintf(blkbuf + strlen(blkbuf),
140570163ac5SPrakash Surya 		    buflen - strlen(blkbuf),
140670163ac5SPrakash Surya 		    "%llxL B=%llu",
140770163ac5SPrakash Surya 		    (u_longlong_t)BP_GET_LSIZE(bp),
140843466aaeSMax Grossman 		    (u_longlong_t)bp->blk_birth);
140943466aaeSMax Grossman 	} else {
141043466aaeSMax Grossman 		(void) snprintf(blkbuf + strlen(blkbuf),
141143466aaeSMax Grossman 		    buflen - strlen(blkbuf),
141243466aaeSMax Grossman 		    "%llxL/%llxP F=%llu B=%llu/%llu",
141343466aaeSMax Grossman 		    (u_longlong_t)BP_GET_LSIZE(bp),
141443466aaeSMax Grossman 		    (u_longlong_t)BP_GET_PSIZE(bp),
14155d7b4d43SMatthew Ahrens 		    (u_longlong_t)BP_GET_FILL(bp),
141643466aaeSMax Grossman 		    (u_longlong_t)bp->blk_birth,
141743466aaeSMax Grossman 		    (u_longlong_t)BP_PHYSICAL_BIRTH(bp));
141843466aaeSMax Grossman 	}
141944cd46caSbillm }
142044cd46caSbillm 
142188b7b0f2SMatthew Ahrens static void
14227802d7bfSMatthew Ahrens print_indirect(blkptr_t *bp, const zbookmark_phys_t *zb,
142388b7b0f2SMatthew Ahrens     const dnode_phys_t *dnp)
1424fa9e4066Sahrens {
142588b7b0f2SMatthew Ahrens 	char blkbuf[BP_SPRINTF_LEN];
1426fa9e4066Sahrens 	int l;
1427fa9e4066Sahrens 
14285d7b4d43SMatthew Ahrens 	if (!BP_IS_EMBEDDED(bp)) {
14295d7b4d43SMatthew Ahrens 		ASSERT3U(BP_GET_TYPE(bp), ==, dnp->dn_type);
14305d7b4d43SMatthew Ahrens 		ASSERT3U(BP_GET_LEVEL(bp), ==, zb->zb_level);
14315d7b4d43SMatthew Ahrens 	}
1432fa9e4066Sahrens 
1433b24ab676SJeff Bonwick 	(void) printf("%16llx ", (u_longlong_t)blkid2offset(dnp, bp, zb));
1434fa9e4066Sahrens 
1435fa9e4066Sahrens 	ASSERT(zb->zb_level >= 0);
1436fa9e4066Sahrens 
1437fa9e4066Sahrens 	for (l = dnp->dn_nlevels - 1; l >= -1; l--) {
1438fa9e4066Sahrens 		if (l == zb->zb_level) {
143988b7b0f2SMatthew Ahrens 			(void) printf("L%llx", (u_longlong_t)zb->zb_level);
1440fa9e4066Sahrens 		} else {
144188b7b0f2SMatthew Ahrens 			(void) printf(" ");
1442fa9e4066Sahrens 		}
1443fa9e4066Sahrens 	}
1444fa9e4066Sahrens 
144543466aaeSMax Grossman 	snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), bp);
144688b7b0f2SMatthew Ahrens 	(void) printf("%s\n", blkbuf);
144788b7b0f2SMatthew Ahrens }
144888b7b0f2SMatthew Ahrens 
144988b7b0f2SMatthew Ahrens static int
145088b7b0f2SMatthew Ahrens visit_indirect(spa_t *spa, const dnode_phys_t *dnp,
14517802d7bfSMatthew Ahrens     blkptr_t *bp, const zbookmark_phys_t *zb)
145288b7b0f2SMatthew Ahrens {
1453e4161df6SVictor Latushkin 	int err = 0;
145488b7b0f2SMatthew Ahrens 
145588b7b0f2SMatthew Ahrens 	if (bp->blk_birth == 0)
145688b7b0f2SMatthew Ahrens 		return (0);
145788b7b0f2SMatthew Ahrens 
145888b7b0f2SMatthew Ahrens 	print_indirect(bp, zb, dnp);
145988b7b0f2SMatthew Ahrens 
146043466aaeSMax Grossman 	if (BP_GET_LEVEL(bp) > 0 && !BP_IS_HOLE(bp)) {
14617adb730bSGeorge Wilson 		arc_flags_t flags = ARC_FLAG_WAIT;
146288b7b0f2SMatthew Ahrens 		int i;
146388b7b0f2SMatthew Ahrens 		blkptr_t *cbp;
146488b7b0f2SMatthew Ahrens 		int epb = BP_GET_LSIZE(bp) >> SPA_BLKPTRSHIFT;
146588b7b0f2SMatthew Ahrens 		arc_buf_t *buf;
146688b7b0f2SMatthew Ahrens 		uint64_t fill = 0;
146788b7b0f2SMatthew Ahrens 
14681b912ec7SGeorge Wilson 		err = arc_read(NULL, spa, bp, arc_getbuf_func, &buf,
146988b7b0f2SMatthew Ahrens 		    ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, zb);
147088b7b0f2SMatthew Ahrens 		if (err)
147188b7b0f2SMatthew Ahrens 			return (err);
14723f9d6ad7SLin Ling 		ASSERT(buf->b_data);
147388b7b0f2SMatthew Ahrens 
147488b7b0f2SMatthew Ahrens 		/* recursively visit blocks below this */
147588b7b0f2SMatthew Ahrens 		cbp = buf->b_data;
147688b7b0f2SMatthew Ahrens 		for (i = 0; i < epb; i++, cbp++) {
14777802d7bfSMatthew Ahrens 			zbookmark_phys_t czb;
147888b7b0f2SMatthew Ahrens 
147988b7b0f2SMatthew Ahrens 			SET_BOOKMARK(&czb, zb->zb_objset, zb->zb_object,
148088b7b0f2SMatthew Ahrens 			    zb->zb_level - 1,
148188b7b0f2SMatthew Ahrens 			    zb->zb_blkid * epb + i);
148288b7b0f2SMatthew Ahrens 			err = visit_indirect(spa, dnp, cbp, &czb);
148388b7b0f2SMatthew Ahrens 			if (err)
148488b7b0f2SMatthew Ahrens 				break;
14855d7b4d43SMatthew Ahrens 			fill += BP_GET_FILL(cbp);
148688b7b0f2SMatthew Ahrens 		}
14878ad4d6ddSJeff Bonwick 		if (!err)
14885d7b4d43SMatthew Ahrens 			ASSERT3U(fill, ==, BP_GET_FILL(bp));
1489dcbf3bd6SGeorge Wilson 		arc_buf_destroy(buf, &buf);
1490fa9e4066Sahrens 	}
1491fa9e4066Sahrens 
149288b7b0f2SMatthew Ahrens 	return (err);
1493fa9e4066Sahrens }
1494fa9e4066Sahrens 
1495fa9e4066Sahrens /*ARGSUSED*/
1496fa9e4066Sahrens static void
149788b7b0f2SMatthew Ahrens dump_indirect(dnode_t *dn)
1498fa9e4066Sahrens {
149988b7b0f2SMatthew Ahrens 	dnode_phys_t *dnp = dn->dn_phys;
150088b7b0f2SMatthew Ahrens 	int j;
15017802d7bfSMatthew Ahrens 	zbookmark_phys_t czb;
1502fa9e4066Sahrens 
1503fa9e4066Sahrens 	(void) printf("Indirect blocks:\n");
1504fa9e4066Sahrens 
1505503ad85cSMatthew Ahrens 	SET_BOOKMARK(&czb, dmu_objset_id(dn->dn_objset),
150688b7b0f2SMatthew Ahrens 	    dn->dn_object, dnp->dn_nlevels - 1, 0);
150788b7b0f2SMatthew Ahrens 	for (j = 0; j < dnp->dn_nblkptr; j++) {
150888b7b0f2SMatthew Ahrens 		czb.zb_blkid = j;
1509503ad85cSMatthew Ahrens 		(void) visit_indirect(dmu_objset_spa(dn->dn_objset), dnp,
151088b7b0f2SMatthew Ahrens 		    &dnp->dn_blkptr[j], &czb);
151188b7b0f2SMatthew Ahrens 	}
1512fa9e4066Sahrens 
1513fa9e4066Sahrens 	(void) printf("\n");
1514fa9e4066Sahrens }
1515fa9e4066Sahrens 
1516fa9e4066Sahrens /*ARGSUSED*/
1517fa9e4066Sahrens static void
1518fa9e4066Sahrens dump_dsl_dir(objset_t *os, uint64_t object, void *data, size_t size)
1519fa9e4066Sahrens {
1520fa9e4066Sahrens 	dsl_dir_phys_t *dd = data;
1521fa9e4066Sahrens 	time_t crtime;
15223f9d6ad7SLin Ling 	char nice[32];
1523fa9e4066Sahrens 
15240a055120SJason King 	/* make sure nicenum has enough space */
15250a055120SJason King 	CTASSERT(sizeof (nice) >= NN_NUMBUF_SZ);
15260a055120SJason King 
1527fa9e4066Sahrens 	if (dd == NULL)
1528fa9e4066Sahrens 		return;
1529fa9e4066Sahrens 
1530da6c28aaSamw 	ASSERT3U(size, >=, sizeof (dsl_dir_phys_t));
1531fa9e4066Sahrens 
1532fa9e4066Sahrens 	crtime = dd->dd_creation_time;
1533fa9e4066Sahrens 	(void) printf("\t\tcreation_time = %s", ctime(&crtime));
1534fa9e4066Sahrens 	(void) printf("\t\thead_dataset_obj = %llu\n",
1535fa9e4066Sahrens 	    (u_longlong_t)dd->dd_head_dataset_obj);
1536fa9e4066Sahrens 	(void) printf("\t\tparent_dir_obj = %llu\n",
1537fa9e4066Sahrens 	    (u_longlong_t)dd->dd_parent_obj);
15383cb34c60Sahrens 	(void) printf("\t\torigin_obj = %llu\n",
15393cb34c60Sahrens 	    (u_longlong_t)dd->dd_origin_obj);
1540fa9e4066Sahrens 	(void) printf("\t\tchild_dir_zapobj = %llu\n",
1541fa9e4066Sahrens 	    (u_longlong_t)dd->dd_child_dir_zapobj);
15420a055120SJason King 	zdb_nicenum(dd->dd_used_bytes, nice, sizeof (nice));
154374e7dc98SMatthew Ahrens 	(void) printf("\t\tused_bytes = %s\n", nice);
15440a055120SJason King 	zdb_nicenum(dd->dd_compressed_bytes, nice, sizeof (nice));
154574e7dc98SMatthew Ahrens 	(void) printf("\t\tcompressed_bytes = %s\n", nice);
15460a055120SJason King 	zdb_nicenum(dd->dd_uncompressed_bytes, nice, sizeof (nice));
154774e7dc98SMatthew Ahrens 	(void) printf("\t\tuncompressed_bytes = %s\n", nice);
15480a055120SJason King 	zdb_nicenum(dd->dd_quota, nice, sizeof (nice));
154974e7dc98SMatthew Ahrens 	(void) printf("\t\tquota = %s\n", nice);
15500a055120SJason King 	zdb_nicenum(dd->dd_reserved, nice, sizeof (nice));
155174e7dc98SMatthew Ahrens 	(void) printf("\t\treserved = %s\n", nice);
1552fa9e4066Sahrens 	(void) printf("\t\tprops_zapobj = %llu\n",
1553fa9e4066Sahrens 	    (u_longlong_t)dd->dd_props_zapobj);
1554ecd6cf80Smarks 	(void) printf("\t\tdeleg_zapobj = %llu\n",
1555ecd6cf80Smarks 	    (u_longlong_t)dd->dd_deleg_zapobj);
155674e7dc98SMatthew Ahrens 	(void) printf("\t\tflags = %llx\n",
155774e7dc98SMatthew Ahrens 	    (u_longlong_t)dd->dd_flags);
155874e7dc98SMatthew Ahrens 
155974e7dc98SMatthew Ahrens #define	DO(which) \
15600a055120SJason King 	zdb_nicenum(dd->dd_used_breakdown[DD_USED_ ## which], nice, \
15610a055120SJason King 	    sizeof (nice)); \
156274e7dc98SMatthew Ahrens 	(void) printf("\t\tused_breakdown[" #which "] = %s\n", nice)
156374e7dc98SMatthew Ahrens 	DO(HEAD);
156474e7dc98SMatthew Ahrens 	DO(SNAP);
156574e7dc98SMatthew Ahrens 	DO(CHILD);
156674e7dc98SMatthew Ahrens 	DO(CHILD_RSRV);
156774e7dc98SMatthew Ahrens 	DO(REFRSRV);
156874e7dc98SMatthew Ahrens #undef DO
1569fa9e4066Sahrens }
1570fa9e4066Sahrens 
1571fa9e4066Sahrens /*ARGSUSED*/
1572fa9e4066Sahrens static void
1573fa9e4066Sahrens dump_dsl_dataset(objset_t *os, uint64_t object, void *data, size_t size)
1574fa9e4066Sahrens {
1575fa9e4066Sahrens 	dsl_dataset_phys_t *ds = data;
1576fa9e4066Sahrens 	time_t crtime;
15773f9d6ad7SLin Ling 	char used[32], compressed[32], uncompressed[32], unique[32];
1578fbabab8fSmaybee 	char blkbuf[BP_SPRINTF_LEN];
1579fa9e4066Sahrens 
15800a055120SJason King 	/* make sure nicenum has enough space */
15810a055120SJason King 	CTASSERT(sizeof (used) >= NN_NUMBUF_SZ);
15820a055120SJason King 	CTASSERT(sizeof (compressed) >= NN_NUMBUF_SZ);
15830a055120SJason King 	CTASSERT(sizeof (uncompressed) >= NN_NUMBUF_SZ);
15840a055120SJason King 	CTASSERT(sizeof (unique) >= NN_NUMBUF_SZ);
15850a055120SJason King 
1586fa9e4066Sahrens 	if (ds == NULL)
1587fa9e4066Sahrens 		return;
1588fa9e4066Sahrens 
1589fa9e4066Sahrens 	ASSERT(size == sizeof (*ds));
1590fa9e4066Sahrens 	crtime = ds->ds_creation_time;
15910a055120SJason King 	zdb_nicenum(ds->ds_referenced_bytes, used, sizeof (used));
15920a055120SJason King 	zdb_nicenum(ds->ds_compressed_bytes, compressed, sizeof (compressed));
15930a055120SJason King 	zdb_nicenum(ds->ds_uncompressed_bytes, uncompressed,
15940a055120SJason King 	    sizeof (uncompressed));
15950a055120SJason King 	zdb_nicenum(ds->ds_unique_bytes, unique, sizeof (unique));
159643466aaeSMax Grossman 	snprintf_blkptr(blkbuf, sizeof (blkbuf), &ds->ds_bp);
1597fa9e4066Sahrens 
1598088f3894Sahrens 	(void) printf("\t\tdir_obj = %llu\n",
1599fa9e4066Sahrens 	    (u_longlong_t)ds->ds_dir_obj);
1600fa9e4066Sahrens 	(void) printf("\t\tprev_snap_obj = %llu\n",
1601fa9e4066Sahrens 	    (u_longlong_t)ds->ds_prev_snap_obj);
1602fa9e4066Sahrens 	(void) printf("\t\tprev_snap_txg = %llu\n",
1603fa9e4066Sahrens 	    (u_longlong_t)ds->ds_prev_snap_txg);
1604fa9e4066Sahrens 	(void) printf("\t\tnext_snap_obj = %llu\n",
1605fa9e4066Sahrens 	    (u_longlong_t)ds->ds_next_snap_obj);
1606fa9e4066Sahrens 	(void) printf("\t\tsnapnames_zapobj = %llu\n",
1607fa9e4066Sahrens 	    (u_longlong_t)ds->ds_snapnames_zapobj);
1608fa9e4066Sahrens 	(void) printf("\t\tnum_children = %llu\n",
1609fa9e4066Sahrens 	    (u_longlong_t)ds->ds_num_children);
1610842727c2SChris Kirby 	(void) printf("\t\tuserrefs_obj = %llu\n",
1611842727c2SChris Kirby 	    (u_longlong_t)ds->ds_userrefs_obj);
1612fa9e4066Sahrens 	(void) printf("\t\tcreation_time = %s", ctime(&crtime));
1613fa9e4066Sahrens 	(void) printf("\t\tcreation_txg = %llu\n",
1614fa9e4066Sahrens 	    (u_longlong_t)ds->ds_creation_txg);
1615fa9e4066Sahrens 	(void) printf("\t\tdeadlist_obj = %llu\n",
1616fa9e4066Sahrens 	    (u_longlong_t)ds->ds_deadlist_obj);
1617fa9e4066Sahrens 	(void) printf("\t\tused_bytes = %s\n", used);
1618fa9e4066Sahrens 	(void) printf("\t\tcompressed_bytes = %s\n", compressed);
1619fa9e4066Sahrens 	(void) printf("\t\tuncompressed_bytes = %s\n", uncompressed);
1620fa9e4066Sahrens 	(void) printf("\t\tunique = %s\n", unique);
1621fa9e4066Sahrens 	(void) printf("\t\tfsid_guid = %llu\n",
1622fa9e4066Sahrens 	    (u_longlong_t)ds->ds_fsid_guid);
1623fa9e4066Sahrens 	(void) printf("\t\tguid = %llu\n",
1624fa9e4066Sahrens 	    (u_longlong_t)ds->ds_guid);
162599653d4eSeschrock 	(void) printf("\t\tflags = %llx\n",
162699653d4eSeschrock 	    (u_longlong_t)ds->ds_flags);
1627088f3894Sahrens 	(void) printf("\t\tnext_clones_obj = %llu\n",
1628088f3894Sahrens 	    (u_longlong_t)ds->ds_next_clones_obj);
1629bb0ade09Sahrens 	(void) printf("\t\tprops_obj = %llu\n",
1630bb0ade09Sahrens 	    (u_longlong_t)ds->ds_props_obj);
1631fa9e4066Sahrens 	(void) printf("\t\tbp = %s\n", blkbuf);
1632fa9e4066Sahrens }
1633fa9e4066Sahrens 
1634ad135b5dSChristopher Siden /* ARGSUSED */
1635ad135b5dSChristopher Siden static int
1636ad135b5dSChristopher Siden dump_bptree_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
1637ad135b5dSChristopher Siden {
1638ad135b5dSChristopher Siden 	char blkbuf[BP_SPRINTF_LEN];
1639ad135b5dSChristopher Siden 
1640ad135b5dSChristopher Siden 	if (bp->blk_birth != 0) {
164143466aaeSMax Grossman 		snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
1642ad135b5dSChristopher Siden 		(void) printf("\t%s\n", blkbuf);
1643ad135b5dSChristopher Siden 	}
1644ad135b5dSChristopher Siden 	return (0);
1645ad135b5dSChristopher Siden }
1646ad135b5dSChristopher Siden 
1647ad135b5dSChristopher Siden static void
16483f7978d0SAlan Somers dump_bptree(objset_t *os, uint64_t obj, const char *name)
1649ad135b5dSChristopher Siden {
1650ad135b5dSChristopher Siden 	char bytes[32];
1651ad135b5dSChristopher Siden 	bptree_phys_t *bt;
1652ad135b5dSChristopher Siden 	dmu_buf_t *db;
1653ad135b5dSChristopher Siden 
16540a055120SJason King 	/* make sure nicenum has enough space */
16550a055120SJason King 	CTASSERT(sizeof (bytes) >= NN_NUMBUF_SZ);
16560a055120SJason King 
1657ad135b5dSChristopher Siden 	if (dump_opt['d'] < 3)
1658ad135b5dSChristopher Siden 		return;
1659ad135b5dSChristopher Siden 
1660b420f3adSRichard Lowe 	VERIFY3U(0, ==, dmu_bonus_hold(os, obj, FTAG, &db));
1661ad135b5dSChristopher Siden 	bt = db->db_data;
16620a055120SJason King 	zdb_nicenum(bt->bt_bytes, bytes, sizeof (bytes));
1663ad135b5dSChristopher Siden 	(void) printf("\n    %s: %llu datasets, %s\n",
1664ad135b5dSChristopher Siden 	    name, (unsigned long long)(bt->bt_end - bt->bt_begin), bytes);
1665ad135b5dSChristopher Siden 	dmu_buf_rele(db, FTAG);
1666ad135b5dSChristopher Siden 
1667ad135b5dSChristopher Siden 	if (dump_opt['d'] < 5)
1668ad135b5dSChristopher Siden 		return;
1669ad135b5dSChristopher Siden 
1670ad135b5dSChristopher Siden 	(void) printf("\n");
1671ad135b5dSChristopher Siden 
1672ad135b5dSChristopher Siden 	(void) bptree_iterate(os, obj, B_FALSE, dump_bptree_cb, NULL, NULL);
1673ad135b5dSChristopher Siden }
1674ad135b5dSChristopher Siden 
1675cde58dbcSMatthew Ahrens /* ARGSUSED */
1676cde58dbcSMatthew Ahrens static int
1677cde58dbcSMatthew Ahrens dump_bpobj_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
1678cde58dbcSMatthew Ahrens {
1679cde58dbcSMatthew Ahrens 	char blkbuf[BP_SPRINTF_LEN];
1680cde58dbcSMatthew Ahrens 
1681cde58dbcSMatthew Ahrens 	ASSERT(bp->blk_birth != 0);
168243466aaeSMax Grossman 	snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), bp);
1683cde58dbcSMatthew Ahrens 	(void) printf("\t%s\n", blkbuf);
1684cde58dbcSMatthew Ahrens 	return (0);
1685cde58dbcSMatthew Ahrens }
1686cde58dbcSMatthew Ahrens 
1687fa9e4066Sahrens static void
16883f7978d0SAlan Somers dump_full_bpobj(bpobj_t *bpo, const char *name, int indent)
1689fa9e4066Sahrens {
16903f9d6ad7SLin Ling 	char bytes[32];
16913f9d6ad7SLin Ling 	char comp[32];
16923f9d6ad7SLin Ling 	char uncomp[32];
1693fa9e4066Sahrens 
16940a055120SJason King 	/* make sure nicenum has enough space */
16950a055120SJason King 	CTASSERT(sizeof (bytes) >= NN_NUMBUF_SZ);
16960a055120SJason King 	CTASSERT(sizeof (comp) >= NN_NUMBUF_SZ);
16970a055120SJason King 	CTASSERT(sizeof (uncomp) >= NN_NUMBUF_SZ);
16980a055120SJason King 
1699fa9e4066Sahrens 	if (dump_opt['d'] < 3)
1700fa9e4066Sahrens 		return;
1701fa9e4066Sahrens 
17020a055120SJason King 	zdb_nicenum(bpo->bpo_phys->bpo_bytes, bytes, sizeof (bytes));
1703d0475637SMatthew Ahrens 	if (bpo->bpo_havesubobj && bpo->bpo_phys->bpo_subobjs != 0) {
17040a055120SJason King 		zdb_nicenum(bpo->bpo_phys->bpo_comp, comp, sizeof (comp));
17050a055120SJason King 		zdb_nicenum(bpo->bpo_phys->bpo_uncomp, uncomp, sizeof (uncomp));
1706d0475637SMatthew Ahrens 		(void) printf("    %*s: object %llu, %llu local blkptrs, "
1707732885fcSMatthew Ahrens 		    "%llu subobjs in object %llu, %s (%s/%s comp)\n",
1708d0475637SMatthew Ahrens 		    indent * 8, name,
1709d0475637SMatthew Ahrens 		    (u_longlong_t)bpo->bpo_object,
1710d0475637SMatthew Ahrens 		    (u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
1711cde58dbcSMatthew Ahrens 		    (u_longlong_t)bpo->bpo_phys->bpo_num_subobjs,
1712732885fcSMatthew Ahrens 		    (u_longlong_t)bpo->bpo_phys->bpo_subobjs,
171399653d4eSeschrock 		    bytes, comp, uncomp);
1714d0475637SMatthew Ahrens 
1715d0475637SMatthew Ahrens 		for (uint64_t i = 0; i < bpo->bpo_phys->bpo_num_subobjs; i++) {
1716d0475637SMatthew Ahrens 			uint64_t subobj;
1717d0475637SMatthew Ahrens 			bpobj_t subbpo;
1718d0475637SMatthew Ahrens 			int error;
1719d0475637SMatthew Ahrens 			VERIFY0(dmu_read(bpo->bpo_os,
1720d0475637SMatthew Ahrens 			    bpo->bpo_phys->bpo_subobjs,
1721d0475637SMatthew Ahrens 			    i * sizeof (subobj), sizeof (subobj), &subobj, 0));
1722d0475637SMatthew Ahrens 			error = bpobj_open(&subbpo, bpo->bpo_os, subobj);
1723d0475637SMatthew Ahrens 			if (error != 0) {
1724d0475637SMatthew Ahrens 				(void) printf("ERROR %u while trying to open "
1725d0475637SMatthew Ahrens 				    "subobj id %llu\n",
1726d0475637SMatthew Ahrens 				    error, (u_longlong_t)subobj);
1727d0475637SMatthew Ahrens 				continue;
1728d0475637SMatthew Ahrens 			}
1729732885fcSMatthew Ahrens 			dump_full_bpobj(&subbpo, "subobj", indent + 1);
173077061867SMatthew Ahrens 			bpobj_close(&subbpo);
1731d0475637SMatthew Ahrens 		}
173299653d4eSeschrock 	} else {
1733d0475637SMatthew Ahrens 		(void) printf("    %*s: object %llu, %llu blkptrs, %s\n",
1734d0475637SMatthew Ahrens 		    indent * 8, name,
1735d0475637SMatthew Ahrens 		    (u_longlong_t)bpo->bpo_object,
1736d0475637SMatthew Ahrens 		    (u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
1737d0475637SMatthew Ahrens 		    bytes);
173899653d4eSeschrock 	}
1739fa9e4066Sahrens 
1740cde58dbcSMatthew Ahrens 	if (dump_opt['d'] < 5)
1741fa9e4066Sahrens 		return;
1742fa9e4066Sahrens 
1743fa9e4066Sahrens 
1744d0475637SMatthew Ahrens 	if (indent == 0) {
1745d0475637SMatthew Ahrens 		(void) bpobj_iterate_nofree(bpo, dump_bpobj_cb, NULL, NULL);
1746d0475637SMatthew Ahrens 		(void) printf("\n");
1747d0475637SMatthew Ahrens 	}
1748cde58dbcSMatthew Ahrens }
174944cd46caSbillm 
1750cde58dbcSMatthew Ahrens static void
1751cde58dbcSMatthew Ahrens dump_deadlist(dsl_deadlist_t *dl)
1752cde58dbcSMatthew Ahrens {
1753cde58dbcSMatthew Ahrens 	dsl_deadlist_entry_t *dle;
1754d0475637SMatthew Ahrens 	uint64_t unused;
1755cde58dbcSMatthew Ahrens 	char bytes[32];
1756cde58dbcSMatthew Ahrens 	char comp[32];
1757cde58dbcSMatthew Ahrens 	char uncomp[32];
1758cde58dbcSMatthew Ahrens 
17590a055120SJason King 	/* make sure nicenum has enough space */
17600a055120SJason King 	CTASSERT(sizeof (bytes) >= NN_NUMBUF_SZ);
17610a055120SJason King 	CTASSERT(sizeof (comp) >= NN_NUMBUF_SZ);
17620a055120SJason King 	CTASSERT(sizeof (uncomp) >= NN_NUMBUF_SZ);
17630a055120SJason King 
1764cde58dbcSMatthew Ahrens 	if (dump_opt['d'] < 3)
1765cde58dbcSMatthew Ahrens 		return;
1766cde58dbcSMatthew Ahrens 
176790c76c66SMatthew Ahrens 	if (dl->dl_oldfmt) {
1768732885fcSMatthew Ahrens 		dump_full_bpobj(&dl->dl_bpobj, "old-format deadlist", 0);
176990c76c66SMatthew Ahrens 		return;
177090c76c66SMatthew Ahrens 	}
177190c76c66SMatthew Ahrens 
17720a055120SJason King 	zdb_nicenum(dl->dl_phys->dl_used, bytes, sizeof (bytes));
17730a055120SJason King 	zdb_nicenum(dl->dl_phys->dl_comp, comp, sizeof (comp));
17740a055120SJason King 	zdb_nicenum(dl->dl_phys->dl_uncomp, uncomp, sizeof (uncomp));
1775cde58dbcSMatthew Ahrens 	(void) printf("\n    Deadlist: %s (%s/%s comp)\n",
1776cde58dbcSMatthew Ahrens 	    bytes, comp, uncomp);
1777cde58dbcSMatthew Ahrens 
1778cde58dbcSMatthew Ahrens 	if (dump_opt['d'] < 4)
1779cde58dbcSMatthew Ahrens 		return;
1780cde58dbcSMatthew Ahrens 
1781cde58dbcSMatthew Ahrens 	(void) printf("\n");
1782cde58dbcSMatthew Ahrens 
1783d0475637SMatthew Ahrens 	/* force the tree to be loaded */
1784d0475637SMatthew Ahrens 	dsl_deadlist_space_range(dl, 0, UINT64_MAX, &unused, &unused, &unused);
1785d0475637SMatthew Ahrens 
1786cde58dbcSMatthew Ahrens 	for (dle = avl_first(&dl->dl_tree); dle;
1787cde58dbcSMatthew Ahrens 	    dle = AVL_NEXT(&dl->dl_tree, dle)) {
1788d0475637SMatthew Ahrens 		if (dump_opt['d'] >= 5) {
1789d0475637SMatthew Ahrens 			char buf[128];
1790de05b588SRichard Yao 			(void) snprintf(buf, sizeof (buf),
1791de05b588SRichard Yao 			    "mintxg %llu -> obj %llu",
1792d0475637SMatthew Ahrens 			    (longlong_t)dle->dle_mintxg,
1793d0475637SMatthew Ahrens 			    (longlong_t)dle->dle_bpobj.bpo_object);
1794fa9e4066Sahrens 
1795732885fcSMatthew Ahrens 			dump_full_bpobj(&dle->dle_bpobj, buf, 0);
1796d0475637SMatthew Ahrens 		} else {
1797d0475637SMatthew Ahrens 			(void) printf("mintxg %llu -> obj %llu\n",
1798d0475637SMatthew Ahrens 			    (longlong_t)dle->dle_mintxg,
1799d0475637SMatthew Ahrens 			    (longlong_t)dle->dle_bpobj.bpo_object);
1800d0475637SMatthew Ahrens 
1801d0475637SMatthew Ahrens 		}
1802cde58dbcSMatthew Ahrens 	}
1803fa9e4066Sahrens }
1804fa9e4066Sahrens 
1805e0d35c44Smarks static avl_tree_t idx_tree;
1806e0d35c44Smarks static avl_tree_t domain_tree;
1807e0d35c44Smarks static boolean_t fuid_table_loaded;
1808ed61ec1dSYuri Pankov static objset_t *sa_os = NULL;
1809ed61ec1dSYuri Pankov static sa_attr_type_t *sa_attr_table = NULL;
1810ed61ec1dSYuri Pankov 
1811ed61ec1dSYuri Pankov static int
1812ed61ec1dSYuri Pankov open_objset(const char *path, dmu_objset_type_t type, void *tag, objset_t **osp)
1813ed61ec1dSYuri Pankov {
1814ed61ec1dSYuri Pankov 	int err;
1815ed61ec1dSYuri Pankov 	uint64_t sa_attrs = 0;
1816ed61ec1dSYuri Pankov 	uint64_t version = 0;
1817ed61ec1dSYuri Pankov 
1818ed61ec1dSYuri Pankov 	VERIFY3P(sa_os, ==, NULL);
1819ed61ec1dSYuri Pankov 	err = dmu_objset_own(path, type, B_TRUE, tag, osp);
1820ed61ec1dSYuri Pankov 	if (err != 0) {
1821ed61ec1dSYuri Pankov 		(void) fprintf(stderr, "failed to own dataset '%s': %s\n", path,
1822ed61ec1dSYuri Pankov 		    strerror(err));
1823ed61ec1dSYuri Pankov 		return (err);
1824ed61ec1dSYuri Pankov 	}
1825ed61ec1dSYuri Pankov 
1826ed61ec1dSYuri Pankov 	if (dmu_objset_type(*osp) == DMU_OST_ZFS) {
1827ed61ec1dSYuri Pankov 		(void) zap_lookup(*osp, MASTER_NODE_OBJ, ZPL_VERSION_STR,
1828ed61ec1dSYuri Pankov 		    8, 1, &version);
1829ed61ec1dSYuri Pankov 		if (version >= ZPL_VERSION_SA) {
1830ed61ec1dSYuri Pankov 			(void) zap_lookup(*osp, MASTER_NODE_OBJ, ZFS_SA_ATTRS,
1831ed61ec1dSYuri Pankov 			    8, 1, &sa_attrs);
1832ed61ec1dSYuri Pankov 		}
1833ed61ec1dSYuri Pankov 		err = sa_setup(*osp, sa_attrs, zfs_attr_table, ZPL_END,
1834ed61ec1dSYuri Pankov 		    &sa_attr_table);
1835ed61ec1dSYuri Pankov 		if (err != 0) {
1836ed61ec1dSYuri Pankov 			(void) fprintf(stderr, "sa_setup failed: %s\n",
1837ed61ec1dSYuri Pankov 			    strerror(err));
1838ed61ec1dSYuri Pankov 			dmu_objset_disown(*osp, tag);
1839ed61ec1dSYuri Pankov 			*osp = NULL;
1840ed61ec1dSYuri Pankov 		}
1841ed61ec1dSYuri Pankov 	}
1842ed61ec1dSYuri Pankov 	sa_os = *osp;
1843ed61ec1dSYuri Pankov 
1844ed61ec1dSYuri Pankov 	return (0);
1845ed61ec1dSYuri Pankov }
1846ed61ec1dSYuri Pankov 
1847ed61ec1dSYuri Pankov static void
1848ed61ec1dSYuri Pankov close_objset(objset_t *os, void *tag)
1849ed61ec1dSYuri Pankov {
1850ed61ec1dSYuri Pankov 	VERIFY3P(os, ==, sa_os);
1851ed61ec1dSYuri Pankov 	if (os->os_sa != NULL)
1852ed61ec1dSYuri Pankov 		sa_tear_down(os);
1853ed61ec1dSYuri Pankov 	dmu_objset_disown(os, tag);
1854ed61ec1dSYuri Pankov 	sa_attr_table = NULL;
1855ed61ec1dSYuri Pankov 	sa_os = NULL;
1856ed61ec1dSYuri Pankov }
1857e0d35c44Smarks 
1858e0d35c44Smarks static void
1859e0d35c44Smarks fuid_table_destroy()
1860e0d35c44Smarks {
1861e0d35c44Smarks 	if (fuid_table_loaded) {
1862e0d35c44Smarks 		zfs_fuid_table_destroy(&idx_tree, &domain_tree);
1863e0d35c44Smarks 		fuid_table_loaded = B_FALSE;
1864e0d35c44Smarks 	}
1865e0d35c44Smarks }
1866e0d35c44Smarks 
1867e0d35c44Smarks /*
1868e0d35c44Smarks  * print uid or gid information.
1869e0d35c44Smarks  * For normal POSIX id just the id is printed in decimal format.
1870e0d35c44Smarks  * For CIFS files with FUID the fuid is printed in hex followed by
1871d0475637SMatthew Ahrens  * the domain-rid string.
1872e0d35c44Smarks  */
1873e0d35c44Smarks static void
1874e0d35c44Smarks print_idstr(uint64_t id, const char *id_type)
1875e0d35c44Smarks {
1876e0d35c44Smarks 	if (FUID_INDEX(id)) {
1877e0d35c44Smarks 		char *domain;
1878e0d35c44Smarks 
1879e0d35c44Smarks 		domain = zfs_fuid_idx_domain(&idx_tree, FUID_INDEX(id));
1880e0d35c44Smarks 		(void) printf("\t%s     %llx [%s-%d]\n", id_type,
1881e0d35c44Smarks 		    (u_longlong_t)id, domain, (int)FUID_RID(id));
1882e0d35c44Smarks 	} else {
1883e0d35c44Smarks 		(void) printf("\t%s     %llu\n", id_type, (u_longlong_t)id);
1884e0d35c44Smarks 	}
1885e0d35c44Smarks 
1886e0d35c44Smarks }
1887e0d35c44Smarks 
1888e0d35c44Smarks static void
18890a586ceaSMark Shellenbaum dump_uidgid(objset_t *os, uint64_t uid, uint64_t gid)
1890e0d35c44Smarks {
1891e0d35c44Smarks 	uint32_t uid_idx, gid_idx;
1892e0d35c44Smarks 
18930a586ceaSMark Shellenbaum 	uid_idx = FUID_INDEX(uid);
18940a586ceaSMark Shellenbaum 	gid_idx = FUID_INDEX(gid);
1895e0d35c44Smarks 
1896e0d35c44Smarks 	/* Load domain table, if not already loaded */
1897e0d35c44Smarks 	if (!fuid_table_loaded && (uid_idx || gid_idx)) {
1898e0d35c44Smarks 		uint64_t fuid_obj;
1899e0d35c44Smarks 
1900e0d35c44Smarks 		/* first find the fuid object.  It lives in the master node */
1901e0d35c44Smarks 		VERIFY(zap_lookup(os, MASTER_NODE_OBJ, ZFS_FUID_TABLES,
1902e0d35c44Smarks 		    8, 1, &fuid_obj) == 0);
190389459e17SMark Shellenbaum 		zfs_fuid_avl_tree_create(&idx_tree, &domain_tree);
1904e0d35c44Smarks 		(void) zfs_fuid_table_load(os, fuid_obj,
1905e0d35c44Smarks 		    &idx_tree, &domain_tree);
1906e0d35c44Smarks 		fuid_table_loaded = B_TRUE;
1907e0d35c44Smarks 	}
1908e0d35c44Smarks 
19090a586ceaSMark Shellenbaum 	print_idstr(uid, "uid");
19100a586ceaSMark Shellenbaum 	print_idstr(gid, "gid");
1911e0d35c44Smarks }
1912e0d35c44Smarks 
1913fa9e4066Sahrens /*ARGSUSED*/
1914fa9e4066Sahrens static void
1915fa9e4066Sahrens dump_znode(objset_t *os, uint64_t object, void *data, size_t size)
1916fa9e4066Sahrens {
1917fa9e4066Sahrens 	char path[MAXPATHLEN * 2];	/* allow for xattr and failure prefix */
19180a586ceaSMark Shellenbaum 	sa_handle_t *hdl;
19190a586ceaSMark Shellenbaum 	uint64_t xattr, rdev, gen;
19200a586ceaSMark Shellenbaum 	uint64_t uid, gid, mode, fsize, parent, links;
19218f2529deSMark Shellenbaum 	uint64_t pflags;
19220a586ceaSMark Shellenbaum 	uint64_t acctm[2], modtm[2], chgtm[2], crtm[2];
19230a586ceaSMark Shellenbaum 	time_t z_crtime, z_atime, z_mtime, z_ctime;
19248f2529deSMark Shellenbaum 	sa_bulk_attr_t bulk[12];
19250a586ceaSMark Shellenbaum 	int idx = 0;
192655434c77Sek 	int error;
1927fa9e4066Sahrens 
1928ed61ec1dSYuri Pankov 	VERIFY3P(os, ==, sa_os);
19290a586ceaSMark Shellenbaum 	if (sa_handle_get(os, object, NULL, SA_HDL_PRIVATE, &hdl)) {
19300a586ceaSMark Shellenbaum 		(void) printf("Failed to get handle for SA znode\n");
19310a586ceaSMark Shellenbaum 		return;
19320a586ceaSMark Shellenbaum 	}
19330a586ceaSMark Shellenbaum 
19340a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_UID], NULL, &uid, 8);
19350a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_GID], NULL, &gid, 8);
19360a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_LINKS], NULL,
19370a586ceaSMark Shellenbaum 	    &links, 8);
19380a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_GEN], NULL, &gen, 8);
19390a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_MODE], NULL,
19400a586ceaSMark Shellenbaum 	    &mode, 8);
19410a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_PARENT],
19420a586ceaSMark Shellenbaum 	    NULL, &parent, 8);
19430a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_SIZE], NULL,
19440a586ceaSMark Shellenbaum 	    &fsize, 8);
19450a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_ATIME], NULL,
19460a586ceaSMark Shellenbaum 	    acctm, 16);
19470a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_MTIME], NULL,
19480a586ceaSMark Shellenbaum 	    modtm, 16);
19490a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_CRTIME], NULL,
19500a586ceaSMark Shellenbaum 	    crtm, 16);
19510a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_CTIME], NULL,
19520a586ceaSMark Shellenbaum 	    chgtm, 16);
19538f2529deSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_FLAGS], NULL,
19548f2529deSMark Shellenbaum 	    &pflags, 8);
19550a586ceaSMark Shellenbaum 
19560a586ceaSMark Shellenbaum 	if (sa_bulk_lookup(hdl, bulk, idx)) {
19570a586ceaSMark Shellenbaum 		(void) sa_handle_destroy(hdl);
19580a586ceaSMark Shellenbaum 		return;
19590a586ceaSMark Shellenbaum 	}
1960fa9e4066Sahrens 
19610a586ceaSMark Shellenbaum 	z_crtime = (time_t)crtm[0];
19620a586ceaSMark Shellenbaum 	z_atime = (time_t)acctm[0];
19630a586ceaSMark Shellenbaum 	z_mtime = (time_t)modtm[0];
19640a586ceaSMark Shellenbaum 	z_ctime = (time_t)chgtm[0];
1965fa9e4066Sahrens 
1966e548d2faSAlan Somers 	if (dump_opt['d'] > 4) {
1967e548d2faSAlan Somers 		error = zfs_obj_to_path(os, object, path, sizeof (path));
1968e548d2faSAlan Somers 		if (error != 0) {
1969e548d2faSAlan Somers 			(void) snprintf(path, sizeof (path),
1970e548d2faSAlan Somers 			    "\?\?\?<object#%llu>", (u_longlong_t)object);
1971e548d2faSAlan Somers 		}
1972e548d2faSAlan Somers 		(void) printf("\tpath	%s\n", path);
1973e548d2faSAlan Somers 	}
19740a586ceaSMark Shellenbaum 	dump_uidgid(os, uid, gid);
1975fa9e4066Sahrens 	(void) printf("\tatime	%s", ctime(&z_atime));
1976fa9e4066Sahrens 	(void) printf("\tmtime	%s", ctime(&z_mtime));
1977fa9e4066Sahrens 	(void) printf("\tctime	%s", ctime(&z_ctime));
1978fa9e4066Sahrens 	(void) printf("\tcrtime	%s", ctime(&z_crtime));
19790a586ceaSMark Shellenbaum 	(void) printf("\tgen	%llu\n", (u_longlong_t)gen);
19800a586ceaSMark Shellenbaum 	(void) printf("\tmode	%llo\n", (u_longlong_t)mode);
19810a586ceaSMark Shellenbaum 	(void) printf("\tsize	%llu\n", (u_longlong_t)fsize);
19820a586ceaSMark Shellenbaum 	(void) printf("\tparent	%llu\n", (u_longlong_t)parent);
19830a586ceaSMark Shellenbaum 	(void) printf("\tlinks	%llu\n", (u_longlong_t)links);
19848f2529deSMark Shellenbaum 	(void) printf("\tpflags	%llx\n", (u_longlong_t)pflags);
19850a586ceaSMark Shellenbaum 	if (sa_lookup(hdl, sa_attr_table[ZPL_XATTR], &xattr,
19860a586ceaSMark Shellenbaum 	    sizeof (uint64_t)) == 0)
19870a586ceaSMark Shellenbaum 		(void) printf("\txattr	%llu\n", (u_longlong_t)xattr);
19880a586ceaSMark Shellenbaum 	if (sa_lookup(hdl, sa_attr_table[ZPL_RDEV], &rdev,
19890a586ceaSMark Shellenbaum 	    sizeof (uint64_t)) == 0)
19900a586ceaSMark Shellenbaum 		(void) printf("\trdev	0x%016llx\n", (u_longlong_t)rdev);
19910a586ceaSMark Shellenbaum 	sa_handle_destroy(hdl);
1992fa9e4066Sahrens }
1993fa9e4066Sahrens 
1994fa9e4066Sahrens /*ARGSUSED*/
1995fa9e4066Sahrens static void
1996fa9e4066Sahrens dump_acl(objset_t *os, uint64_t object, void *data, size_t size)
1997fa9e4066Sahrens {
1998fa9e4066Sahrens }
1999fa9e4066Sahrens 
2000fa9e4066Sahrens /*ARGSUSED*/
2001fa9e4066Sahrens static void
2002fa9e4066Sahrens dump_dmu_objset(objset_t *os, uint64_t object, void *data, size_t size)
2003fa9e4066Sahrens {
2004fa9e4066Sahrens }
2005fa9e4066Sahrens 
20066de8f417SVictor Latushkin static object_viewer_t *object_viewer[DMU_OT_NUMTYPES + 1] = {
2007fa9e4066Sahrens 	dump_none,		/* unallocated			*/
2008fa9e4066Sahrens 	dump_zap,		/* object directory		*/
2009fa9e4066Sahrens 	dump_uint64,		/* object array			*/
2010fa9e4066Sahrens 	dump_none,		/* packed nvlist		*/
2011fa9e4066Sahrens 	dump_packed_nvlist,	/* packed nvlist size		*/
2012732885fcSMatthew Ahrens 	dump_none,		/* bpobj			*/
2013732885fcSMatthew Ahrens 	dump_bpobj,		/* bpobj header			*/
2014fa9e4066Sahrens 	dump_none,		/* SPA space map header		*/
2015fa9e4066Sahrens 	dump_none,		/* SPA space map		*/
2016fa9e4066Sahrens 	dump_none,		/* ZIL intent log		*/
2017fa9e4066Sahrens 	dump_dnode,		/* DMU dnode			*/
2018fa9e4066Sahrens 	dump_dmu_objset,	/* DMU objset			*/
2019ea8dc4b6Seschrock 	dump_dsl_dir,		/* DSL directory		*/
2020fa9e4066Sahrens 	dump_zap,		/* DSL directory child map	*/
2021fa9e4066Sahrens 	dump_zap,		/* DSL dataset snap map		*/
2022fa9e4066Sahrens 	dump_zap,		/* DSL props			*/
2023fa9e4066Sahrens 	dump_dsl_dataset,	/* DSL dataset			*/
2024fa9e4066Sahrens 	dump_znode,		/* ZFS znode			*/
2025da6c28aaSamw 	dump_acl,		/* ZFS V0 ACL			*/
2026fa9e4066Sahrens 	dump_uint8,		/* ZFS plain file		*/
2027e7437265Sahrens 	dump_zpldir,		/* ZFS directory		*/
2028fa9e4066Sahrens 	dump_zap,		/* ZFS master node		*/
2029fa9e4066Sahrens 	dump_zap,		/* ZFS delete queue		*/
2030fa9e4066Sahrens 	dump_uint8,		/* zvol object			*/
2031fa9e4066Sahrens 	dump_zap,		/* zvol prop			*/
2032fa9e4066Sahrens 	dump_uint8,		/* other uint8[]		*/
2033fa9e4066Sahrens 	dump_uint64,		/* other uint64[]		*/
2034fa9e4066Sahrens 	dump_zap,		/* other ZAP			*/
2035ea8dc4b6Seschrock 	dump_zap,		/* persistent error log		*/
203606eeb2adSek 	dump_uint8,		/* SPA history			*/
20374445fffbSMatthew Ahrens 	dump_history_offsets,	/* SPA history offsets		*/
2038b1b8ab34Slling 	dump_zap,		/* Pool properties		*/
2039ecd6cf80Smarks 	dump_zap,		/* DSL permissions		*/
2040da6c28aaSamw 	dump_acl,		/* ZFS ACL			*/
2041da6c28aaSamw 	dump_uint8,		/* ZFS SYSACL			*/
2042da6c28aaSamw 	dump_none,		/* FUID nvlist			*/
2043da6c28aaSamw 	dump_packed_nvlist,	/* FUID nvlist size		*/
2044088f3894Sahrens 	dump_zap,		/* DSL dataset next clones	*/
2045088f3894Sahrens 	dump_zap,		/* DSL scrub queue		*/
204614843421SMatthew Ahrens 	dump_zap,		/* ZFS user/group used		*/
204714843421SMatthew Ahrens 	dump_zap,		/* ZFS user/group quota		*/
2048842727c2SChris Kirby 	dump_zap,		/* snapshot refcount tags	*/
2049486ae710SMatthew Ahrens 	dump_ddt_zap,		/* DDT ZAP object		*/
2050b24ab676SJeff Bonwick 	dump_zap,		/* DDT statistics		*/
20510a586ceaSMark Shellenbaum 	dump_znode,		/* SA object			*/
20520a586ceaSMark Shellenbaum 	dump_zap,		/* SA Master Node		*/
20530a586ceaSMark Shellenbaum 	dump_sa_attrs,		/* SA attribute registration	*/
20540a586ceaSMark Shellenbaum 	dump_sa_layouts,	/* SA attribute layouts		*/
20553f9d6ad7SLin Ling 	dump_zap,		/* DSL scrub translations	*/
20563f9d6ad7SLin Ling 	dump_none,		/* fake dedup BP		*/
2057cde58dbcSMatthew Ahrens 	dump_zap,		/* deadlist			*/
2058cde58dbcSMatthew Ahrens 	dump_none,		/* deadlist hdr			*/
2059cde58dbcSMatthew Ahrens 	dump_zap,		/* dsl clones			*/
2060732885fcSMatthew Ahrens 	dump_bpobj_subobjs,	/* bpobj subobjs		*/
20610a586ceaSMark Shellenbaum 	dump_unknown,		/* Unknown type, must be last	*/
2062fa9e4066Sahrens };
2063fa9e4066Sahrens 
2064fa9e4066Sahrens static void
2065fa9e4066Sahrens dump_object(objset_t *os, uint64_t object, int verbosity, int *print_header)
2066fa9e4066Sahrens {
2067fa9e4066Sahrens 	dmu_buf_t *db = NULL;
2068fa9e4066Sahrens 	dmu_object_info_t doi;
2069fa9e4066Sahrens 	dnode_t *dn;
2070fa9e4066Sahrens 	void *bonus = NULL;
2071fa9e4066Sahrens 	size_t bsize = 0;
20723f9d6ad7SLin Ling 	char iblk[32], dblk[32], lsize[32], asize[32], fill[32];
20733f9d6ad7SLin Ling 	char bonus_size[32];
2074fa9e4066Sahrens 	char aux[50];
2075fa9e4066Sahrens 	int error;
2076fa9e4066Sahrens 
20770a055120SJason King 	/* make sure nicenum has enough space */
20780a055120SJason King 	CTASSERT(sizeof (iblk) >= NN_NUMBUF_SZ);
20790a055120SJason King 	CTASSERT(sizeof (dblk) >= NN_NUMBUF_SZ);
20800a055120SJason King 	CTASSERT(sizeof (lsize) >= NN_NUMBUF_SZ);
20810a055120SJason King 	CTASSERT(sizeof (asize) >= NN_NUMBUF_SZ);
20820a055120SJason King 	CTASSERT(sizeof (bonus_size) >= NN_NUMBUF_SZ);
20830a055120SJason King 
2084fa9e4066Sahrens 	if (*print_header) {
2085b24ab676SJeff Bonwick 		(void) printf("\n%10s  %3s  %5s  %5s  %5s  %5s  %6s  %s\n",
2086b24ab676SJeff Bonwick 		    "Object", "lvl", "iblk", "dblk", "dsize", "lsize",
2087b24ab676SJeff Bonwick 		    "%full", "type");
2088fa9e4066Sahrens 		*print_header = 0;
2089fa9e4066Sahrens 	}
2090fa9e4066Sahrens 
2091fa9e4066Sahrens 	if (object == 0) {
2092744947dcSTom Erickson 		dn = DMU_META_DNODE(os);
2093fa9e4066Sahrens 	} else {
2094ea8dc4b6Seschrock 		error = dmu_bonus_hold(os, object, FTAG, &db);
2095ea8dc4b6Seschrock 		if (error)
2096ea8dc4b6Seschrock 			fatal("dmu_bonus_hold(%llu) failed, errno %u",
2097ea8dc4b6Seschrock 			    object, error);
2098fa9e4066Sahrens 		bonus = db->db_data;
2099fa9e4066Sahrens 		bsize = db->db_size;
2100744947dcSTom Erickson 		dn = DB_DNODE((dmu_buf_impl_t *)db);
2101fa9e4066Sahrens 	}
2102fa9e4066Sahrens 	dmu_object_info_from_dnode(dn, &doi);
2103fa9e4066Sahrens 
21040a055120SJason King 	zdb_nicenum(doi.doi_metadata_block_size, iblk, sizeof (iblk));
21050a055120SJason King 	zdb_nicenum(doi.doi_data_block_size, dblk, sizeof (dblk));
21060a055120SJason King 	zdb_nicenum(doi.doi_max_offset, lsize, sizeof (lsize));
21070a055120SJason King 	zdb_nicenum(doi.doi_physical_blocks_512 << 9, asize, sizeof (asize));
21080a055120SJason King 	zdb_nicenum(doi.doi_bonus_size, bonus_size, sizeof (bonus_size));
2109b24ab676SJeff Bonwick 	(void) sprintf(fill, "%6.2f", 100.0 * doi.doi_fill_count *
2110bbfd46c4SJeff Bonwick 	    doi.doi_data_block_size / (object == 0 ? DNODES_PER_BLOCK : 1) /
2111bbfd46c4SJeff Bonwick 	    doi.doi_max_offset);
2112fa9e4066Sahrens 
2113fa9e4066Sahrens 	aux[0] = '\0';
2114fa9e4066Sahrens 
2115e7437265Sahrens 	if (doi.doi_checksum != ZIO_CHECKSUM_INHERIT || verbosity >= 6) {
2116fa9e4066Sahrens 		(void) snprintf(aux + strlen(aux), sizeof (aux), " (K=%s)",
21176de8f417SVictor Latushkin 		    ZDB_CHECKSUM_NAME(doi.doi_checksum));
2118e7437265Sahrens 	}
2119fa9e4066Sahrens 
2120e7437265Sahrens 	if (doi.doi_compress != ZIO_COMPRESS_INHERIT || verbosity >= 6) {
2121fa9e4066Sahrens 		(void) snprintf(aux + strlen(aux), sizeof (aux), " (Z=%s)",
21226de8f417SVictor Latushkin 		    ZDB_COMPRESS_NAME(doi.doi_compress));
2123e7437265Sahrens 	}
2124fa9e4066Sahrens 
2125b24ab676SJeff Bonwick 	(void) printf("%10lld  %3u  %5s  %5s  %5s  %5s  %6s  %s%s\n",
2126b24ab676SJeff Bonwick 	    (u_longlong_t)object, doi.doi_indirection, iblk, dblk,
2127b24ab676SJeff Bonwick 	    asize, lsize, fill, ZDB_OT_NAME(doi.doi_type), aux);
2128fa9e4066Sahrens 
2129fa9e4066Sahrens 	if (doi.doi_bonus_type != DMU_OT_NONE && verbosity > 3) {
2130b24ab676SJeff Bonwick 		(void) printf("%10s  %3s  %5s  %5s  %5s  %5s  %6s  %s\n",
2131b24ab676SJeff Bonwick 		    "", "", "", "", "", bonus_size, "bonus",
21326de8f417SVictor Latushkin 		    ZDB_OT_NAME(doi.doi_bonus_type));
2133fa9e4066Sahrens 	}
2134fa9e4066Sahrens 
2135fa9e4066Sahrens 	if (verbosity >= 4) {
21360a586ceaSMark Shellenbaum 		(void) printf("\tdnode flags: %s%s%s\n",
213714843421SMatthew Ahrens 		    (dn->dn_phys->dn_flags & DNODE_FLAG_USED_BYTES) ?
213814843421SMatthew Ahrens 		    "USED_BYTES " : "",
213914843421SMatthew Ahrens 		    (dn->dn_phys->dn_flags & DNODE_FLAG_USERUSED_ACCOUNTED) ?
21400a586ceaSMark Shellenbaum 		    "USERUSED_ACCOUNTED " : "",
21410a586ceaSMark Shellenbaum 		    (dn->dn_phys->dn_flags & DNODE_FLAG_SPILL_BLKPTR) ?
21420a586ceaSMark Shellenbaum 		    "SPILL_BLKPTR" : "");
214314843421SMatthew Ahrens 		(void) printf("\tdnode maxblkid: %llu\n",
214414843421SMatthew Ahrens 		    (longlong_t)dn->dn_phys->dn_maxblkid);
214514843421SMatthew Ahrens 
21466de8f417SVictor Latushkin 		object_viewer[ZDB_OT_TYPE(doi.doi_bonus_type)](os, object,
21476de8f417SVictor Latushkin 		    bonus, bsize);
21486de8f417SVictor Latushkin 		object_viewer[ZDB_OT_TYPE(doi.doi_type)](os, object, NULL, 0);
2149fa9e4066Sahrens 		*print_header = 1;
2150fa9e4066Sahrens 	}
2151fa9e4066Sahrens 
2152fa9e4066Sahrens 	if (verbosity >= 5)
215388b7b0f2SMatthew Ahrens 		dump_indirect(dn);
2154fa9e4066Sahrens 
2155fa9e4066Sahrens 	if (verbosity >= 5) {
2156fa9e4066Sahrens 		/*
2157fa9e4066Sahrens 		 * Report the list of segments that comprise the object.
2158fa9e4066Sahrens 		 */
2159fa9e4066Sahrens 		uint64_t start = 0;
2160fa9e4066Sahrens 		uint64_t end;
2161fa9e4066Sahrens 		uint64_t blkfill = 1;
2162fa9e4066Sahrens 		int minlvl = 1;
2163fa9e4066Sahrens 
2164fa9e4066Sahrens 		if (dn->dn_type == DMU_OT_DNODE) {
2165fa9e4066Sahrens 			minlvl = 0;
2166fa9e4066Sahrens 			blkfill = DNODES_PER_BLOCK;
2167fa9e4066Sahrens 		}
2168fa9e4066Sahrens 
2169fa9e4066Sahrens 		for (;;) {
21703f9d6ad7SLin Ling 			char segsize[32];
21710a055120SJason King 			/* make sure nicenum has enough space */
21720a055120SJason King 			CTASSERT(sizeof (segsize) >= NN_NUMBUF_SZ);
2173cdb0ab79Smaybee 			error = dnode_next_offset(dn,
2174cdb0ab79Smaybee 			    0, &start, minlvl, blkfill, 0);
2175fa9e4066Sahrens 			if (error)
2176fa9e4066Sahrens 				break;
2177fa9e4066Sahrens 			end = start;
2178cdb0ab79Smaybee 			error = dnode_next_offset(dn,
2179cdb0ab79Smaybee 			    DNODE_FIND_HOLE, &end, minlvl, blkfill, 0);
21800a055120SJason King 			zdb_nicenum(end - start, segsize, sizeof (segsize));
2181fa9e4066Sahrens 			(void) printf("\t\tsegment [%016llx, %016llx)"
2182fa9e4066Sahrens 			    " size %5s\n", (u_longlong_t)start,
2183fa9e4066Sahrens 			    (u_longlong_t)end, segsize);
2184fa9e4066Sahrens 			if (error)
2185fa9e4066Sahrens 				break;
2186fa9e4066Sahrens 			start = end;
2187fa9e4066Sahrens 		}
2188fa9e4066Sahrens 	}
2189fa9e4066Sahrens 
2190fa9e4066Sahrens 	if (db != NULL)
2191ea8dc4b6Seschrock 		dmu_buf_rele(db, FTAG);
2192fa9e4066Sahrens }
2193fa9e4066Sahrens 
21943f7978d0SAlan Somers static const char *objset_types[DMU_OST_NUMTYPES] = {
2195fa9e4066Sahrens 	"NONE", "META", "ZPL", "ZVOL", "OTHER", "ANY" };
2196fa9e4066Sahrens 
2197fa9e4066Sahrens static void
2198fa9e4066Sahrens dump_dir(objset_t *os)
2199fa9e4066Sahrens {
2200fa9e4066Sahrens 	dmu_objset_stats_t dds;
2201fa9e4066Sahrens 	uint64_t object, object_count;
2202a2eea2e1Sahrens 	uint64_t refdbytes, usedobjs, scratch;
22033f9d6ad7SLin Ling 	char numbuf[32];
220414843421SMatthew Ahrens 	char blkbuf[BP_SPRINTF_LEN + 20];
22059adfa60dSMatthew Ahrens 	char osname[ZFS_MAX_DATASET_NAME_LEN];
22063f7978d0SAlan Somers 	const char *type = "UNKNOWN";
2207fa9e4066Sahrens 	int verbosity = dump_opt['d'];
2208fa9e4066Sahrens 	int print_header = 1;
22093f7978d0SAlan Somers 	unsigned i;
22103f7978d0SAlan Somers 	int error;
2211fa9e4066Sahrens 
22120a055120SJason King 	/* make sure nicenum has enough space */
22130a055120SJason King 	CTASSERT(sizeof (numbuf) >= NN_NUMBUF_SZ);
22140a055120SJason King 
22153b2aab18SMatthew Ahrens 	dsl_pool_config_enter(dmu_objset_pool(os), FTAG);
2216a2eea2e1Sahrens 	dmu_objset_fast_stat(os, &dds);
22173b2aab18SMatthew Ahrens 	dsl_pool_config_exit(dmu_objset_pool(os), FTAG);
2218fa9e4066Sahrens 
2219fa9e4066Sahrens 	if (dds.dds_type < DMU_OST_NUMTYPES)
2220fa9e4066Sahrens 		type = objset_types[dds.dds_type];
2221fa9e4066Sahrens 
2222fa9e4066Sahrens 	if (dds.dds_type == DMU_OST_META) {
2223fa9e4066Sahrens 		dds.dds_creation_txg = TXG_INITIAL;
22245d7b4d43SMatthew Ahrens 		usedobjs = BP_GET_FILL(os->os_rootbp);
2225c1379625SJustin T. Gibbs 		refdbytes = dsl_dir_phys(os->os_spa->spa_dsl_pool->dp_mos_dir)->
2226c1379625SJustin T. Gibbs 		    dd_used_bytes;
2227a2eea2e1Sahrens 	} else {
2228a2eea2e1Sahrens 		dmu_objset_space(os, &refdbytes, &scratch, &usedobjs, &scratch);
2229fa9e4066Sahrens 	}
2230fa9e4066Sahrens 
22315d7b4d43SMatthew Ahrens 	ASSERT3U(usedobjs, ==, BP_GET_FILL(os->os_rootbp));
2232fa9e4066Sahrens 
22330a055120SJason King 	zdb_nicenum(refdbytes, numbuf, sizeof (numbuf));
2234fa9e4066Sahrens 
2235fa9e4066Sahrens 	if (verbosity >= 4) {
223643466aaeSMax Grossman 		(void) snprintf(blkbuf, sizeof (blkbuf), ", rootbp ");
223743466aaeSMax Grossman 		(void) snprintf_blkptr(blkbuf + strlen(blkbuf),
223843466aaeSMax Grossman 		    sizeof (blkbuf) - strlen(blkbuf), os->os_rootbp);
2239fa9e4066Sahrens 	} else {
2240fa9e4066Sahrens 		blkbuf[0] = '\0';
2241fa9e4066Sahrens 	}
2242fa9e4066Sahrens 
2243fa9e4066Sahrens 	dmu_objset_name(os, osname);
2244fa9e4066Sahrens 
2245a2eea2e1Sahrens 	(void) printf("Dataset %s [%s], ID %llu, cr_txg %llu, "
2246fa9e4066Sahrens 	    "%s, %llu objects%s\n",
2247fa9e4066Sahrens 	    osname, type, (u_longlong_t)dmu_objset_id(os),
2248fa9e4066Sahrens 	    (u_longlong_t)dds.dds_creation_txg,
2249a2eea2e1Sahrens 	    numbuf, (u_longlong_t)usedobjs, blkbuf);
2250fa9e4066Sahrens 
2251b24ab676SJeff Bonwick 	if (zopt_objects != 0) {
2252b24ab676SJeff Bonwick 		for (i = 0; i < zopt_objects; i++)
2253b24ab676SJeff Bonwick 			dump_object(os, zopt_object[i], verbosity,
2254b24ab676SJeff Bonwick 			    &print_header);
2255b24ab676SJeff Bonwick 		(void) printf("\n");
2256b24ab676SJeff Bonwick 		return;
2257b24ab676SJeff Bonwick 	}
2258b24ab676SJeff Bonwick 
2259b24ab676SJeff Bonwick 	if (dump_opt['i'] != 0 || verbosity >= 2)
2260b24ab676SJeff Bonwick 		dump_intent_log(dmu_objset_zil(os));
2261fa9e4066Sahrens 
22625cabbc6bSPrashanth Sreenivasa 	if (dmu_objset_ds(os) != NULL) {
22635cabbc6bSPrashanth Sreenivasa 		dsl_dataset_t *ds = dmu_objset_ds(os);
22645cabbc6bSPrashanth Sreenivasa 		dump_deadlist(&ds->ds_deadlist);
22655cabbc6bSPrashanth Sreenivasa 
22665cabbc6bSPrashanth Sreenivasa 		if (dsl_dataset_remap_deadlist_exists(ds)) {
22675cabbc6bSPrashanth Sreenivasa 			(void) printf("ds_remap_deadlist:\n");
22685cabbc6bSPrashanth Sreenivasa 			dump_deadlist(&ds->ds_remap_deadlist);
22695cabbc6bSPrashanth Sreenivasa 		}
22705cabbc6bSPrashanth Sreenivasa 	}
2271fa9e4066Sahrens 
2272fa9e4066Sahrens 	if (verbosity < 2)
2273fa9e4066Sahrens 		return;
2274fa9e4066Sahrens 
227543466aaeSMax Grossman 	if (BP_IS_HOLE(os->os_rootbp))
2276088f3894Sahrens 		return;
2277088f3894Sahrens 
2278fa9e4066Sahrens 	dump_object(os, 0, verbosity, &print_header);
227914843421SMatthew Ahrens 	object_count = 0;
2280744947dcSTom Erickson 	if (DMU_USERUSED_DNODE(os) != NULL &&
2281744947dcSTom Erickson 	    DMU_USERUSED_DNODE(os)->dn_type != 0) {
228214843421SMatthew Ahrens 		dump_object(os, DMU_USERUSED_OBJECT, verbosity, &print_header);
228314843421SMatthew Ahrens 		dump_object(os, DMU_GROUPUSED_OBJECT, verbosity, &print_header);
228414843421SMatthew Ahrens 	}
2285fa9e4066Sahrens 
2286fa9e4066Sahrens 	object = 0;
22876754306eSahrens 	while ((error = dmu_object_next(os, &object, B_FALSE, 0)) == 0) {
2288fa9e4066Sahrens 		dump_object(os, object, verbosity, &print_header);
2289fa9e4066Sahrens 		object_count++;
2290fa9e4066Sahrens 	}
2291fa9e4066Sahrens 
2292a2eea2e1Sahrens 	ASSERT3U(object_count, ==, usedobjs);
2293fa9e4066Sahrens 
2294fa9e4066Sahrens 	(void) printf("\n");
2295fa9e4066Sahrens 
2296ccba0801SRich Morris 	if (error != ESRCH) {
2297ccba0801SRich Morris 		(void) fprintf(stderr, "dmu_object_next() = %d\n", error);
2298ccba0801SRich Morris 		abort();
2299ccba0801SRich Morris 	}
2300fa9e4066Sahrens }
2301fa9e4066Sahrens 
2302fa9e4066Sahrens static void
230353b9a4a9SVictor Latushkin dump_uberblock(uberblock_t *ub, const char *header, const char *footer)
2304fa9e4066Sahrens {
2305fa9e4066Sahrens 	time_t timestamp = ub->ub_timestamp;
2306fa9e4066Sahrens 
23073f7978d0SAlan Somers 	(void) printf("%s", header ? header : "");
2308fa9e4066Sahrens 	(void) printf("\tmagic = %016llx\n", (u_longlong_t)ub->ub_magic);
2309fa9e4066Sahrens 	(void) printf("\tversion = %llu\n", (u_longlong_t)ub->ub_version);
2310fa9e4066Sahrens 	(void) printf("\ttxg = %llu\n", (u_longlong_t)ub->ub_txg);
2311fa9e4066Sahrens 	(void) printf("\tguid_sum = %llu\n", (u_longlong_t)ub->ub_guid_sum);
2312fa9e4066Sahrens 	(void) printf("\ttimestamp = %llu UTC = %s",
2313fa9e4066Sahrens 	    (u_longlong_t)ub->ub_timestamp, asctime(localtime(&timestamp)));
2314fa9e4066Sahrens 	if (dump_opt['u'] >= 3) {
2315fbabab8fSmaybee 		char blkbuf[BP_SPRINTF_LEN];
231643466aaeSMax Grossman 		snprintf_blkptr(blkbuf, sizeof (blkbuf), &ub->ub_rootbp);
2317fa9e4066Sahrens 		(void) printf("\trootbp = %s\n", blkbuf);
2318fa9e4066Sahrens 	}
231986714001SSerapheim Dimitropoulos 	(void) printf("\tcheckpoint_txg = %llu\n",
232086714001SSerapheim Dimitropoulos 	    (u_longlong_t)ub->ub_checkpoint_txg);
23213f7978d0SAlan Somers 	(void) printf("%s", footer ? footer : "");
2322fa9e4066Sahrens }
2323fa9e4066Sahrens 
2324fa9e4066Sahrens static void
232507428bdfSVictor Latushkin dump_config(spa_t *spa)
2326fa9e4066Sahrens {
232707428bdfSVictor Latushkin 	dmu_buf_t *db;
232807428bdfSVictor Latushkin 	size_t nvsize = 0;
232907428bdfSVictor Latushkin 	int error = 0;
233007428bdfSVictor Latushkin 
2331fa9e4066Sahrens 
233207428bdfSVictor Latushkin 	error = dmu_bonus_hold(spa->spa_meta_objset,
233307428bdfSVictor Latushkin 	    spa->spa_config_object, FTAG, &db);
233407428bdfSVictor Latushkin 
233507428bdfSVictor Latushkin 	if (error == 0) {
233607428bdfSVictor Latushkin 		nvsize = *(uint64_t *)db->db_data;
233707428bdfSVictor Latushkin 		dmu_buf_rele(db, FTAG);
233807428bdfSVictor Latushkin 
233907428bdfSVictor Latushkin 		(void) printf("\nMOS Configuration:\n");
234007428bdfSVictor Latushkin 		dump_packed_nvlist(spa->spa_meta_objset,
234107428bdfSVictor Latushkin 		    spa->spa_config_object, (void *)&nvsize, 1);
234207428bdfSVictor Latushkin 	} else {
234307428bdfSVictor Latushkin 		(void) fprintf(stderr, "dmu_bonus_hold(%llu) failed, errno %d",
234407428bdfSVictor Latushkin 		    (u_longlong_t)spa->spa_config_object, error);
2345fa9e4066Sahrens 	}
2346fa9e4066Sahrens }
2347fa9e4066Sahrens 
2348c5904d13Seschrock static void
2349c5904d13Seschrock dump_cachefile(const char *cachefile)
2350c5904d13Seschrock {
2351c5904d13Seschrock 	int fd;
2352c5904d13Seschrock 	struct stat64 statbuf;
2353c5904d13Seschrock 	char *buf;
2354c5904d13Seschrock 	nvlist_t *config;
2355c5904d13Seschrock 
2356c5904d13Seschrock 	if ((fd = open64(cachefile, O_RDONLY)) < 0) {
2357c5904d13Seschrock 		(void) printf("cannot open '%s': %s\n", cachefile,
2358c5904d13Seschrock 		    strerror(errno));
2359c5904d13Seschrock 		exit(1);
2360c5904d13Seschrock 	}
2361c5904d13Seschrock 
2362c5904d13Seschrock 	if (fstat64(fd, &statbuf) != 0) {
2363c5904d13Seschrock 		(void) printf("failed to stat '%s': %s\n", cachefile,
2364c5904d13Seschrock 		    strerror(errno));
2365c5904d13Seschrock 		exit(1);
2366c5904d13Seschrock 	}
2367c5904d13Seschrock 
2368c5904d13Seschrock 	if ((buf = malloc(statbuf.st_size)) == NULL) {
2369c5904d13Seschrock 		(void) fprintf(stderr, "failed to allocate %llu bytes\n",
2370c5904d13Seschrock 		    (u_longlong_t)statbuf.st_size);
2371c5904d13Seschrock 		exit(1);
2372c5904d13Seschrock 	}
2373c5904d13Seschrock 
2374c5904d13Seschrock 	if (read(fd, buf, statbuf.st_size) != statbuf.st_size) {
2375c5904d13Seschrock 		(void) fprintf(stderr, "failed to read %llu bytes\n",
2376c5904d13Seschrock 		    (u_longlong_t)statbuf.st_size);
2377c5904d13Seschrock 		exit(1);
2378c5904d13Seschrock 	}
2379c5904d13Seschrock 
2380c5904d13Seschrock 	(void) close(fd);
2381c5904d13Seschrock 
2382c5904d13Seschrock 	if (nvlist_unpack(buf, statbuf.st_size, &config, 0) != 0) {
2383c5904d13Seschrock 		(void) fprintf(stderr, "failed to unpack nvlist\n");
2384c5904d13Seschrock 		exit(1);
2385c5904d13Seschrock 	}
2386c5904d13Seschrock 
2387c5904d13Seschrock 	free(buf);
2388c5904d13Seschrock 
2389c5904d13Seschrock 	dump_nvlist(config, 0);
2390c5904d13Seschrock 
2391c5904d13Seschrock 	nvlist_free(config);
2392c5904d13Seschrock }
2393c5904d13Seschrock 
239453b9a4a9SVictor Latushkin #define	ZDB_MAX_UB_HEADER_SIZE 32
239553b9a4a9SVictor Latushkin 
239653b9a4a9SVictor Latushkin static void
239753b9a4a9SVictor Latushkin dump_label_uberblocks(vdev_label_t *lbl, uint64_t ashift)
239853b9a4a9SVictor Latushkin {
239953b9a4a9SVictor Latushkin 	vdev_t vd;
240053b9a4a9SVictor Latushkin 	vdev_t *vdp = &vd;
240153b9a4a9SVictor Latushkin 	char header[ZDB_MAX_UB_HEADER_SIZE];
240253b9a4a9SVictor Latushkin 
240353b9a4a9SVictor Latushkin 	vd.vdev_ashift = ashift;
240453b9a4a9SVictor Latushkin 	vdp->vdev_top = vdp;
240553b9a4a9SVictor Latushkin 
240653b9a4a9SVictor Latushkin 	for (int i = 0; i < VDEV_UBERBLOCK_COUNT(vdp); i++) {
240753b9a4a9SVictor Latushkin 		uint64_t uoff = VDEV_UBERBLOCK_OFFSET(vdp, i);
240853b9a4a9SVictor Latushkin 		uberblock_t *ub = (void *)((char *)lbl + uoff);
240953b9a4a9SVictor Latushkin 
241053b9a4a9SVictor Latushkin 		if (uberblock_verify(ub))
241153b9a4a9SVictor Latushkin 			continue;
241253b9a4a9SVictor Latushkin 		(void) snprintf(header, ZDB_MAX_UB_HEADER_SIZE,
241353b9a4a9SVictor Latushkin 		    "Uberblock[%d]\n", i);
241453b9a4a9SVictor Latushkin 		dump_uberblock(ub, header, "");
241553b9a4a9SVictor Latushkin 	}
241653b9a4a9SVictor Latushkin }
241753b9a4a9SVictor Latushkin 
2418ed61ec1dSYuri Pankov static char curpath[PATH_MAX];
2419ed61ec1dSYuri Pankov 
2420ed61ec1dSYuri Pankov /*
2421ed61ec1dSYuri Pankov  * Iterate through the path components, recursively passing
2422ed61ec1dSYuri Pankov  * current one's obj and remaining path until we find the obj
2423ed61ec1dSYuri Pankov  * for the last one.
2424ed61ec1dSYuri Pankov  */
2425ed61ec1dSYuri Pankov static int
2426ed61ec1dSYuri Pankov dump_path_impl(objset_t *os, uint64_t obj, char *name)
2427ed61ec1dSYuri Pankov {
2428ed61ec1dSYuri Pankov 	int err;
2429ed61ec1dSYuri Pankov 	int header = 1;
2430ed61ec1dSYuri Pankov 	uint64_t child_obj;
2431ed61ec1dSYuri Pankov 	char *s;
2432ed61ec1dSYuri Pankov 	dmu_buf_t *db;
2433ed61ec1dSYuri Pankov 	dmu_object_info_t doi;
2434ed61ec1dSYuri Pankov 
2435ed61ec1dSYuri Pankov 	if ((s = strchr(name, '/')) != NULL)
2436ed61ec1dSYuri Pankov 		*s = '\0';
2437ed61ec1dSYuri Pankov 	err = zap_lookup(os, obj, name, 8, 1, &child_obj);
2438ed61ec1dSYuri Pankov 
2439ed61ec1dSYuri Pankov 	(void) strlcat(curpath, name, sizeof (curpath));
2440ed61ec1dSYuri Pankov 
2441ed61ec1dSYuri Pankov 	if (err != 0) {
2442ed61ec1dSYuri Pankov 		(void) fprintf(stderr, "failed to lookup %s: %s\n",
2443ed61ec1dSYuri Pankov 		    curpath, strerror(err));
2444ed61ec1dSYuri Pankov 		return (err);
2445ed61ec1dSYuri Pankov 	}
2446ed61ec1dSYuri Pankov 
2447ed61ec1dSYuri Pankov 	child_obj = ZFS_DIRENT_OBJ(child_obj);
2448ed61ec1dSYuri Pankov 	err = sa_buf_hold(os, child_obj, FTAG, &db);
2449ed61ec1dSYuri Pankov 	if (err != 0) {
2450ed61ec1dSYuri Pankov 		(void) fprintf(stderr,
2451ed61ec1dSYuri Pankov 		    "failed to get SA dbuf for obj %llu: %s\n",
2452ed61ec1dSYuri Pankov 		    (u_longlong_t)child_obj, strerror(err));
2453ed61ec1dSYuri Pankov 		return (EINVAL);
2454ed61ec1dSYuri Pankov 	}
2455ed61ec1dSYuri Pankov 	dmu_object_info_from_db(db, &doi);
2456ed61ec1dSYuri Pankov 	sa_buf_rele(db, FTAG);
2457ed61ec1dSYuri Pankov 
2458ed61ec1dSYuri Pankov 	if (doi.doi_bonus_type != DMU_OT_SA &&
2459ed61ec1dSYuri Pankov 	    doi.doi_bonus_type != DMU_OT_ZNODE) {
2460ed61ec1dSYuri Pankov 		(void) fprintf(stderr, "invalid bonus type %d for obj %llu\n",
2461ed61ec1dSYuri Pankov 		    doi.doi_bonus_type, (u_longlong_t)child_obj);
2462ed61ec1dSYuri Pankov 		return (EINVAL);
2463ed61ec1dSYuri Pankov 	}
2464ed61ec1dSYuri Pankov 
2465ed61ec1dSYuri Pankov 	if (dump_opt['v'] > 6) {
2466ed61ec1dSYuri Pankov 		(void) printf("obj=%llu %s type=%d bonustype=%d\n",
2467ed61ec1dSYuri Pankov 		    (u_longlong_t)child_obj, curpath, doi.doi_type,
2468ed61ec1dSYuri Pankov 		    doi.doi_bonus_type);
2469ed61ec1dSYuri Pankov 	}
2470ed61ec1dSYuri Pankov 
2471ed61ec1dSYuri Pankov 	(void) strlcat(curpath, "/", sizeof (curpath));
2472ed61ec1dSYuri Pankov 
2473ed61ec1dSYuri Pankov 	switch (doi.doi_type) {
2474ed61ec1dSYuri Pankov 	case DMU_OT_DIRECTORY_CONTENTS:
2475ed61ec1dSYuri Pankov 		if (s != NULL && *(s + 1) != '\0')
2476ed61ec1dSYuri Pankov 			return (dump_path_impl(os, child_obj, s + 1));
2477ed61ec1dSYuri Pankov 		/*FALLTHROUGH*/
2478ed61ec1dSYuri Pankov 	case DMU_OT_PLAIN_FILE_CONTENTS:
2479ed61ec1dSYuri Pankov 		dump_object(os, child_obj, dump_opt['v'], &header);
2480ed61ec1dSYuri Pankov 		return (0);
2481ed61ec1dSYuri Pankov 	default:
2482ed61ec1dSYuri Pankov 		(void) fprintf(stderr, "object %llu has non-file/directory "
2483ed61ec1dSYuri Pankov 		    "type %d\n", (u_longlong_t)obj, doi.doi_type);
2484ed61ec1dSYuri Pankov 		break;
2485ed61ec1dSYuri Pankov 	}
2486ed61ec1dSYuri Pankov 
2487ed61ec1dSYuri Pankov 	return (EINVAL);
2488ed61ec1dSYuri Pankov }
2489ed61ec1dSYuri Pankov 
2490ed61ec1dSYuri Pankov /*
2491ed61ec1dSYuri Pankov  * Dump the blocks for the object specified by path inside the dataset.
2492ed61ec1dSYuri Pankov  */
2493ed61ec1dSYuri Pankov static int
2494ed61ec1dSYuri Pankov dump_path(char *ds, char *path)
2495ed61ec1dSYuri Pankov {
2496ed61ec1dSYuri Pankov 	int err;
2497ed61ec1dSYuri Pankov 	objset_t *os;
2498ed61ec1dSYuri Pankov 	uint64_t root_obj;
2499ed61ec1dSYuri Pankov 
2500ed61ec1dSYuri Pankov 	err = open_objset(ds, DMU_OST_ZFS, FTAG, &os);
2501ed61ec1dSYuri Pankov 	if (err != 0)
2502ed61ec1dSYuri Pankov 		return (err);
2503ed61ec1dSYuri Pankov 
2504ed61ec1dSYuri Pankov 	err = zap_lookup(os, MASTER_NODE_OBJ, ZFS_ROOT_OBJ, 8, 1, &root_obj);
2505ed61ec1dSYuri Pankov 	if (err != 0) {
2506ed61ec1dSYuri Pankov 		(void) fprintf(stderr, "can't lookup root znode: %s\n",
2507ed61ec1dSYuri Pankov 		    strerror(err));
2508ed61ec1dSYuri Pankov 		dmu_objset_disown(os, FTAG);
2509ed61ec1dSYuri Pankov 		return (EINVAL);
2510ed61ec1dSYuri Pankov 	}
2511ed61ec1dSYuri Pankov 
2512ed61ec1dSYuri Pankov 	(void) snprintf(curpath, sizeof (curpath), "dataset=%s path=/", ds);
2513ed61ec1dSYuri Pankov 
2514ed61ec1dSYuri Pankov 	err = dump_path_impl(os, root_obj, path);
2515ed61ec1dSYuri Pankov 
2516ed61ec1dSYuri Pankov 	close_objset(os, FTAG);
2517ed61ec1dSYuri Pankov 	return (err);
2518ed61ec1dSYuri Pankov }
2519ed61ec1dSYuri Pankov 
252064723e36SYuri Pankov static int
2521fa9e4066Sahrens dump_label(const char *dev)
2522fa9e4066Sahrens {
2523fa9e4066Sahrens 	int fd;
2524fa9e4066Sahrens 	vdev_label_t label;
252564723e36SYuri Pankov 	char path[MAXPATHLEN];
252664723e36SYuri Pankov 	char *buf = label.vl_vdev_phys.vp_nvlist;
2527fa9e4066Sahrens 	size_t buflen = sizeof (label.vl_vdev_phys.vp_nvlist);
2528fa9e4066Sahrens 	struct stat64 statbuf;
252953b9a4a9SVictor Latushkin 	uint64_t psize, ashift;
253064723e36SYuri Pankov 	boolean_t label_found = B_FALSE;
253164723e36SYuri Pankov 
253264723e36SYuri Pankov 	(void) strlcpy(path, dev, sizeof (path));
253364723e36SYuri Pankov 	if (dev[0] == '/') {
253464723e36SYuri Pankov 		if (strncmp(dev, ZFS_DISK_ROOTD,
253564723e36SYuri Pankov 		    strlen(ZFS_DISK_ROOTD)) == 0) {
253664723e36SYuri Pankov 			(void) snprintf(path, sizeof (path), "%s%s",
253764723e36SYuri Pankov 			    ZFS_RDISK_ROOTD, dev + strlen(ZFS_DISK_ROOTD));
253864723e36SYuri Pankov 		}
253964723e36SYuri Pankov 	} else if (stat64(path, &statbuf) != 0) {
254064723e36SYuri Pankov 		char *s;
2541c6065d0fSGeorge Wilson 
254264723e36SYuri Pankov 		(void) snprintf(path, sizeof (path), "%s%s", ZFS_RDISK_ROOTD,
254364723e36SYuri Pankov 		    dev);
254422c8b958SYuri Pankov 		if (((s = strrchr(dev, 's')) == NULL &&
254522c8b958SYuri Pankov 		    (s = strchr(dev, 'p')) == NULL) ||
254622c8b958SYuri Pankov 		    !isdigit(*(s + 1)))
254764723e36SYuri Pankov 			(void) strlcat(path, "s0", sizeof (path));
2548fa9e4066Sahrens 	}
2549fa9e4066Sahrens 
255022c8b958SYuri Pankov 	if ((fd = open64(path, O_RDONLY)) < 0) {
255122c8b958SYuri Pankov 		(void) fprintf(stderr, "cannot open '%s': %s\n", path,
2552fa9e4066Sahrens 		    strerror(errno));
2553c6065d0fSGeorge Wilson 		exit(1);
2554c6065d0fSGeorge Wilson 	}
2555c6065d0fSGeorge Wilson 
255622c8b958SYuri Pankov 	if (fstat64(fd, &statbuf) != 0) {
255722c8b958SYuri Pankov 		(void) fprintf(stderr, "failed to stat '%s': %s\n", path,
255822c8b958SYuri Pankov 		    strerror(errno));
255922c8b958SYuri Pankov 		(void) close(fd);
256064723e36SYuri Pankov 		exit(1);
256164723e36SYuri Pankov 	}
256264723e36SYuri Pankov 
256322c8b958SYuri Pankov 	if (S_ISBLK(statbuf.st_mode)) {
256422c8b958SYuri Pankov 		(void) fprintf(stderr,
256522c8b958SYuri Pankov 		    "cannot use '%s': character device required\n", path);
256622c8b958SYuri Pankov 		(void) close(fd);
2567c6065d0fSGeorge Wilson 		exit(1);
2568fa9e4066Sahrens 	}
2569fa9e4066Sahrens 
2570fa9e4066Sahrens 	psize = statbuf.st_size;
2571fa9e4066Sahrens 	psize = P2ALIGN(psize, (uint64_t)sizeof (vdev_label_t));
2572fa9e4066Sahrens 
257353b9a4a9SVictor Latushkin 	for (int l = 0; l < VDEV_LABELS; l++) {
2574fa9e4066Sahrens 		nvlist_t *config = NULL;
2575fa9e4066Sahrens 
257664723e36SYuri Pankov 		if (!dump_opt['q']) {
257764723e36SYuri Pankov 			(void) printf("------------------------------------\n");
257864723e36SYuri Pankov 			(void) printf("LABEL %d\n", l);
257964723e36SYuri Pankov 			(void) printf("------------------------------------\n");
258064723e36SYuri Pankov 		}
2581fa9e4066Sahrens 
25820d981225Seschrock 		if (pread64(fd, &label, sizeof (label),
2583fa9e4066Sahrens 		    vdev_label_offset(psize, l, 0)) != sizeof (label)) {
258464723e36SYuri Pankov 			if (!dump_opt['q'])
258564723e36SYuri Pankov 				(void) printf("failed to read label %d\n", l);
2586fa9e4066Sahrens 			continue;
2587fa9e4066Sahrens 		}
2588fa9e4066Sahrens 
2589fa9e4066Sahrens 		if (nvlist_unpack(buf, buflen, &config, 0) != 0) {
259064723e36SYuri Pankov 			if (!dump_opt['q'])
259164723e36SYuri Pankov 				(void) printf("failed to unpack label %d\n", l);
259253b9a4a9SVictor Latushkin 			ashift = SPA_MINBLOCKSHIFT;
259353b9a4a9SVictor Latushkin 		} else {
259453b9a4a9SVictor Latushkin 			nvlist_t *vdev_tree = NULL;
259553b9a4a9SVictor Latushkin 
259664723e36SYuri Pankov 			if (!dump_opt['q'])
259764723e36SYuri Pankov 				dump_nvlist(config, 4);
259853b9a4a9SVictor Latushkin 			if ((nvlist_lookup_nvlist(config,
259953b9a4a9SVictor Latushkin 			    ZPOOL_CONFIG_VDEV_TREE, &vdev_tree) != 0) ||
260053b9a4a9SVictor Latushkin 			    (nvlist_lookup_uint64(vdev_tree,
260153b9a4a9SVictor Latushkin 			    ZPOOL_CONFIG_ASHIFT, &ashift) != 0))
260253b9a4a9SVictor Latushkin 				ashift = SPA_MINBLOCKSHIFT;
260353b9a4a9SVictor Latushkin 			nvlist_free(config);
260464723e36SYuri Pankov 			label_found = B_TRUE;
2605fa9e4066Sahrens 		}
260653b9a4a9SVictor Latushkin 		if (dump_opt['u'])
260753b9a4a9SVictor Latushkin 			dump_label_uberblocks(&label, ashift);
2608fa9e4066Sahrens 	}
2609c6065d0fSGeorge Wilson 
2610c6065d0fSGeorge Wilson 	(void) close(fd);
261164723e36SYuri Pankov 
261264723e36SYuri Pankov 	return (label_found ? 0 : 2);
2613fa9e4066Sahrens }
2614fa9e4066Sahrens 
2615ca0cc391SMatthew Ahrens static uint64_t dataset_feature_count[SPA_FEATURES];
26165cabbc6bSPrashanth Sreenivasa static uint64_t remap_deadlist_count = 0;
2617b5152584SMatthew Ahrens 
2618fa9e4066Sahrens /*ARGSUSED*/
26191d452cf5Sahrens static int
2620fd136879SMatthew Ahrens dump_one_dir(const char *dsname, void *arg)
2621fa9e4066Sahrens {
2622fa9e4066Sahrens 	int error;
2623fa9e4066Sahrens 	objset_t *os;
2624fa9e4066Sahrens 
2625ed61ec1dSYuri Pankov 	error = open_objset(dsname, DMU_OST_ANY, FTAG, &os);
2626ed61ec1dSYuri Pankov 	if (error != 0)
26271d452cf5Sahrens 		return (0);
2628ca0cc391SMatthew Ahrens 
2629ca0cc391SMatthew Ahrens 	for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
2630ca0cc391SMatthew Ahrens 		if (!dmu_objset_ds(os)->ds_feature_inuse[f])
2631ca0cc391SMatthew Ahrens 			continue;
2632ca0cc391SMatthew Ahrens 		ASSERT(spa_feature_table[f].fi_flags &
2633ca0cc391SMatthew Ahrens 		    ZFEATURE_FLAG_PER_DATASET);
2634ca0cc391SMatthew Ahrens 		dataset_feature_count[f]++;
2635ca0cc391SMatthew Ahrens 	}
2636ca0cc391SMatthew Ahrens 
26375cabbc6bSPrashanth Sreenivasa 	if (dsl_dataset_remap_deadlist_exists(dmu_objset_ds(os))) {
26385cabbc6bSPrashanth Sreenivasa 		remap_deadlist_count++;
26395cabbc6bSPrashanth Sreenivasa 	}
26405cabbc6bSPrashanth Sreenivasa 
2641fa9e4066Sahrens 	dump_dir(os);
2642ed61ec1dSYuri Pankov 	close_objset(os, FTAG);
2643e0d35c44Smarks 	fuid_table_destroy();
26441d452cf5Sahrens 	return (0);
2645fa9e4066Sahrens }
2646fa9e4066Sahrens 
2647fa9e4066Sahrens /*
2648b24ab676SJeff Bonwick  * Block statistics.
2649fa9e4066Sahrens  */
2650b5152584SMatthew Ahrens #define	PSIZE_HISTO_SIZE (SPA_OLD_MAXBLOCKSIZE / SPA_MINBLOCKSIZE + 2)
2651fa9e4066Sahrens typedef struct zdb_blkstats {
2652490d05b9SMatthew Ahrens 	uint64_t zb_asize;
2653490d05b9SMatthew Ahrens 	uint64_t zb_lsize;
2654490d05b9SMatthew Ahrens 	uint64_t zb_psize;
2655490d05b9SMatthew Ahrens 	uint64_t zb_count;
2656d5ee8a13SMatthew Ahrens 	uint64_t zb_gangs;
2657d5ee8a13SMatthew Ahrens 	uint64_t zb_ditto_samevdev;
2658490d05b9SMatthew Ahrens 	uint64_t zb_psize_histogram[PSIZE_HISTO_SIZE];
2659fa9e4066Sahrens } zdb_blkstats_t;
2660fa9e4066Sahrens 
2661b24ab676SJeff Bonwick /*
2662b24ab676SJeff Bonwick  * Extended object types to report deferred frees and dedup auto-ditto blocks.
2663b24ab676SJeff Bonwick  */
2664b24ab676SJeff Bonwick #define	ZDB_OT_DEFERRED	(DMU_OT_NUMTYPES + 0)
2665b24ab676SJeff Bonwick #define	ZDB_OT_DITTO	(DMU_OT_NUMTYPES + 1)
2666ad135b5dSChristopher Siden #define	ZDB_OT_OTHER	(DMU_OT_NUMTYPES + 2)
2667ad135b5dSChristopher Siden #define	ZDB_OT_TOTAL	(DMU_OT_NUMTYPES + 3)
2668b24ab676SJeff Bonwick 
26693f7978d0SAlan Somers static const char *zdb_ot_extname[] = {
2670b24ab676SJeff Bonwick 	"deferred free",
2671b24ab676SJeff Bonwick 	"dedup ditto",
2672ad135b5dSChristopher Siden 	"other",
2673b24ab676SJeff Bonwick 	"Total",
2674b24ab676SJeff Bonwick };
2675fa9e4066Sahrens 
267688b7b0f2SMatthew Ahrens #define	ZB_TOTAL	DN_MAX_LEVELS
2677fa9e4066Sahrens 
2678fa9e4066Sahrens typedef struct zdb_cb {
2679b24ab676SJeff Bonwick 	zdb_blkstats_t	zcb_type[ZB_TOTAL + 1][ZDB_OT_TOTAL + 1];
26805cabbc6bSPrashanth Sreenivasa 	uint64_t	zcb_removing_size;
268186714001SSerapheim Dimitropoulos 	uint64_t	zcb_checkpoint_size;
2682b24ab676SJeff Bonwick 	uint64_t	zcb_dedup_asize;
2683b24ab676SJeff Bonwick 	uint64_t	zcb_dedup_blocks;
26845d7b4d43SMatthew Ahrens 	uint64_t	zcb_embedded_blocks[NUM_BP_EMBEDDED_TYPES];
26855d7b4d43SMatthew Ahrens 	uint64_t	zcb_embedded_histogram[NUM_BP_EMBEDDED_TYPES]
26865d7b4d43SMatthew Ahrens 	    [BPE_PAYLOAD_SIZE];
2687490d05b9SMatthew Ahrens 	uint64_t	zcb_start;
26883f7978d0SAlan Somers 	hrtime_t	zcb_lastprint;
2689490d05b9SMatthew Ahrens 	uint64_t	zcb_totalasize;
2690fa9e4066Sahrens 	uint64_t	zcb_errors[256];
2691fa9e4066Sahrens 	int		zcb_readfails;
2692fa9e4066Sahrens 	int		zcb_haderrors;
2693cde58dbcSMatthew Ahrens 	spa_t		*zcb_spa;
26945cabbc6bSPrashanth Sreenivasa 	uint32_t	**zcb_vd_obsolete_counts;
2695fa9e4066Sahrens } zdb_cb_t;
2696fa9e4066Sahrens 
2697fa9e4066Sahrens static void
2698cde58dbcSMatthew Ahrens zdb_count_block(zdb_cb_t *zcb, zilog_t *zilog, const blkptr_t *bp,
2699b24ab676SJeff Bonwick     dmu_object_type_t type)
2700fa9e4066Sahrens {
2701b24ab676SJeff Bonwick 	uint64_t refcnt = 0;
2702b24ab676SJeff Bonwick 
2703b24ab676SJeff Bonwick 	ASSERT(type < ZDB_OT_TOTAL);
2704b24ab676SJeff Bonwick 
2705b24ab676SJeff Bonwick 	if (zilog && zil_bp_tree_add(zilog, bp) != 0)
2706b24ab676SJeff Bonwick 		return;
2707b24ab676SJeff Bonwick 
2708e14bb325SJeff Bonwick 	for (int i = 0; i < 4; i++) {
2709fa9e4066Sahrens 		int l = (i < 2) ? BP_GET_LEVEL(bp) : ZB_TOTAL;
2710b24ab676SJeff Bonwick 		int t = (i & 1) ? type : ZDB_OT_TOTAL;
2711d5ee8a13SMatthew Ahrens 		int equal;
2712fa9e4066Sahrens 		zdb_blkstats_t *zb = &zcb->zcb_type[l][t];
2713fa9e4066Sahrens 
2714fa9e4066Sahrens 		zb->zb_asize += BP_GET_ASIZE(bp);
2715fa9e4066Sahrens 		zb->zb_lsize += BP_GET_LSIZE(bp);
2716fa9e4066Sahrens 		zb->zb_psize += BP_GET_PSIZE(bp);
2717fa9e4066Sahrens 		zb->zb_count++;
2718b5152584SMatthew Ahrens 
2719b5152584SMatthew Ahrens 		/*
2720b5152584SMatthew Ahrens 		 * The histogram is only big enough to record blocks up to
2721b5152584SMatthew Ahrens 		 * SPA_OLD_MAXBLOCKSIZE; larger blocks go into the last,
2722b5152584SMatthew Ahrens 		 * "other", bucket.
2723b5152584SMatthew Ahrens 		 */
27243f7978d0SAlan Somers 		unsigned idx = BP_GET_PSIZE(bp) >> SPA_MINBLOCKSHIFT;
2725b5152584SMatthew Ahrens 		idx = MIN(idx, SPA_OLD_MAXBLOCKSIZE / SPA_MINBLOCKSIZE + 1);
2726b5152584SMatthew Ahrens 		zb->zb_psize_histogram[idx]++;
2727d5ee8a13SMatthew Ahrens 
2728d5ee8a13SMatthew Ahrens 		zb->zb_gangs += BP_COUNT_GANG(bp);
2729d5ee8a13SMatthew Ahrens 
2730d5ee8a13SMatthew Ahrens 		switch (BP_GET_NDVAS(bp)) {
2731d5ee8a13SMatthew Ahrens 		case 2:
2732d5ee8a13SMatthew Ahrens 			if (DVA_GET_VDEV(&bp->blk_dva[0]) ==
2733d5ee8a13SMatthew Ahrens 			    DVA_GET_VDEV(&bp->blk_dva[1]))
2734d5ee8a13SMatthew Ahrens 				zb->zb_ditto_samevdev++;
2735d5ee8a13SMatthew Ahrens 			break;
2736d5ee8a13SMatthew Ahrens 		case 3:
2737d5ee8a13SMatthew Ahrens 			equal = (DVA_GET_VDEV(&bp->blk_dva[0]) ==
2738d5ee8a13SMatthew Ahrens 			    DVA_GET_VDEV(&bp->blk_dva[1])) +
2739d5ee8a13SMatthew Ahrens 			    (DVA_GET_VDEV(&bp->blk_dva[0]) ==
2740d5ee8a13SMatthew Ahrens 			    DVA_GET_VDEV(&bp->blk_dva[2])) +
2741d5ee8a13SMatthew Ahrens 			    (DVA_GET_VDEV(&bp->blk_dva[1]) ==
2742d5ee8a13SMatthew Ahrens 			    DVA_GET_VDEV(&bp->blk_dva[2]));
2743d5ee8a13SMatthew Ahrens 			if (equal != 0)
2744d5ee8a13SMatthew Ahrens 				zb->zb_ditto_samevdev++;
2745d5ee8a13SMatthew Ahrens 			break;
2746d5ee8a13SMatthew Ahrens 		}
2747d5ee8a13SMatthew Ahrens 
2748fa9e4066Sahrens 	}
2749fa9e4066Sahrens 
27505d7b4d43SMatthew Ahrens 	if (BP_IS_EMBEDDED(bp)) {
27515d7b4d43SMatthew Ahrens 		zcb->zcb_embedded_blocks[BPE_GET_ETYPE(bp)]++;
27525d7b4d43SMatthew Ahrens 		zcb->zcb_embedded_histogram[BPE_GET_ETYPE(bp)]
27535d7b4d43SMatthew Ahrens 		    [BPE_GET_PSIZE(bp)]++;
27545d7b4d43SMatthew Ahrens 		return;
27555d7b4d43SMatthew Ahrens 	}
27565d7b4d43SMatthew Ahrens 
2757b24ab676SJeff Bonwick 	if (dump_opt['L'])
2758b24ab676SJeff Bonwick 		return;
2759b24ab676SJeff Bonwick 
2760b24ab676SJeff Bonwick 	if (BP_GET_DEDUP(bp)) {
2761b24ab676SJeff Bonwick 		ddt_t *ddt;
2762b24ab676SJeff Bonwick 		ddt_entry_t *dde;
2763b24ab676SJeff Bonwick 
2764cde58dbcSMatthew Ahrens 		ddt = ddt_select(zcb->zcb_spa, bp);
2765b24ab676SJeff Bonwick 		ddt_enter(ddt);
2766b24ab676SJeff Bonwick 		dde = ddt_lookup(ddt, bp, B_FALSE);
2767b24ab676SJeff Bonwick 
2768b24ab676SJeff Bonwick 		if (dde == NULL) {
2769b24ab676SJeff Bonwick 			refcnt = 0;
2770b24ab676SJeff Bonwick 		} else {
2771b24ab676SJeff Bonwick 			ddt_phys_t *ddp = ddt_phys_select(dde, bp);
2772b24ab676SJeff Bonwick 			ddt_phys_decref(ddp);
2773b24ab676SJeff Bonwick 			refcnt = ddp->ddp_refcnt;
2774b24ab676SJeff Bonwick 			if (ddt_phys_total_refcnt(dde) == 0)
2775b24ab676SJeff Bonwick 				ddt_remove(ddt, dde);
2776d41e7643Sek 		}
2777b24ab676SJeff Bonwick 		ddt_exit(ddt);
2778d41e7643Sek 	}
2779d41e7643Sek 
2780cde58dbcSMatthew Ahrens 	VERIFY3U(zio_wait(zio_claim(NULL, zcb->zcb_spa,
278186714001SSerapheim Dimitropoulos 	    refcnt ? 0 : spa_min_claim_txg(zcb->zcb_spa),
2782b24ab676SJeff Bonwick 	    bp, NULL, NULL, ZIO_FLAG_CANFAIL)), ==, 0);
2783fa9e4066Sahrens }
2784fa9e4066Sahrens 
278531d7e8faSGeorge Wilson static void
278631d7e8faSGeorge Wilson zdb_blkptr_done(zio_t *zio)
278731d7e8faSGeorge Wilson {
278831d7e8faSGeorge Wilson 	spa_t *spa = zio->io_spa;
278931d7e8faSGeorge Wilson 	blkptr_t *bp = zio->io_bp;
279031d7e8faSGeorge Wilson 	int ioerr = zio->io_error;
279131d7e8faSGeorge Wilson 	zdb_cb_t *zcb = zio->io_private;
27927802d7bfSMatthew Ahrens 	zbookmark_phys_t *zb = &zio->io_bookmark;
279331d7e8faSGeorge Wilson 
2794770499e1SDan Kimmel 	abd_free(zio->io_abd);
279531d7e8faSGeorge Wilson 
279631d7e8faSGeorge Wilson 	mutex_enter(&spa->spa_scrub_lock);
279731d7e8faSGeorge Wilson 	spa->spa_scrub_inflight--;
279831d7e8faSGeorge Wilson 	cv_broadcast(&spa->spa_scrub_io_cv);
279931d7e8faSGeorge Wilson 
280031d7e8faSGeorge Wilson 	if (ioerr && !(zio->io_flags & ZIO_FLAG_SPECULATIVE)) {
280131d7e8faSGeorge Wilson 		char blkbuf[BP_SPRINTF_LEN];
280231d7e8faSGeorge Wilson 
280331d7e8faSGeorge Wilson 		zcb->zcb_haderrors = 1;
280431d7e8faSGeorge Wilson 		zcb->zcb_errors[ioerr]++;
280531d7e8faSGeorge Wilson 
280631d7e8faSGeorge Wilson 		if (dump_opt['b'] >= 2)
280743466aaeSMax Grossman 			snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
280831d7e8faSGeorge Wilson 		else
280931d7e8faSGeorge Wilson 			blkbuf[0] = '\0';
281031d7e8faSGeorge Wilson 
281131d7e8faSGeorge Wilson 		(void) printf("zdb_blkptr_cb: "
281231d7e8faSGeorge Wilson 		    "Got error %d reading "
281331d7e8faSGeorge Wilson 		    "<%llu, %llu, %lld, %llx> %s -- skipping\n",
281431d7e8faSGeorge Wilson 		    ioerr,
281531d7e8faSGeorge Wilson 		    (u_longlong_t)zb->zb_objset,
281631d7e8faSGeorge Wilson 		    (u_longlong_t)zb->zb_object,
281731d7e8faSGeorge Wilson 		    (u_longlong_t)zb->zb_level,
281831d7e8faSGeorge Wilson 		    (u_longlong_t)zb->zb_blkid,
281931d7e8faSGeorge Wilson 		    blkbuf);
282031d7e8faSGeorge Wilson 	}
282131d7e8faSGeorge Wilson 	mutex_exit(&spa->spa_scrub_lock);
282231d7e8faSGeorge Wilson }
282331d7e8faSGeorge Wilson 
2824fa9e4066Sahrens static int
28251b912ec7SGeorge Wilson zdb_blkptr_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
28267802d7bfSMatthew Ahrens     const zbookmark_phys_t *zb, const dnode_phys_t *dnp, void *arg)
2827fa9e4066Sahrens {
2828fa9e4066Sahrens 	zdb_cb_t *zcb = arg;
28296365109dSVictor Latushkin 	dmu_object_type_t type;
2830468c413aSTim Haley 	boolean_t is_metadata;
2831fa9e4066Sahrens 
2832a2cdcdd2SPaul Dagnelie 	if (bp == NULL)
2833a2cdcdd2SPaul Dagnelie 		return (0);
2834a2cdcdd2SPaul Dagnelie 
283543466aaeSMax Grossman 	if (dump_opt['b'] >= 5 && bp->blk_birth > 0) {
283643466aaeSMax Grossman 		char blkbuf[BP_SPRINTF_LEN];
283743466aaeSMax Grossman 		snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
283843466aaeSMax Grossman 		(void) printf("objset %llu object %llu "
283943466aaeSMax Grossman 		    "level %lld offset 0x%llx %s\n",
284043466aaeSMax Grossman 		    (u_longlong_t)zb->zb_objset,
284143466aaeSMax Grossman 		    (u_longlong_t)zb->zb_object,
284243466aaeSMax Grossman 		    (longlong_t)zb->zb_level,
284343466aaeSMax Grossman 		    (u_longlong_t)blkid2offset(dnp, bp, zb),
284443466aaeSMax Grossman 		    blkbuf);
284543466aaeSMax Grossman 	}
284643466aaeSMax Grossman 
284743466aaeSMax Grossman 	if (BP_IS_HOLE(bp))
284888b7b0f2SMatthew Ahrens 		return (0);
2849e14bb325SJeff Bonwick 
28506365109dSVictor Latushkin 	type = BP_GET_TYPE(bp);
2851e14bb325SJeff Bonwick 
2852ad135b5dSChristopher Siden 	zdb_count_block(zcb, zilog, bp,
2853ad135b5dSChristopher Siden 	    (type & DMU_OT_NEWTYPE) ? ZDB_OT_OTHER : type);
28546365109dSVictor Latushkin 
2855ad135b5dSChristopher Siden 	is_metadata = (BP_GET_LEVEL(bp) != 0 || DMU_OT_IS_METADATA(type));
28566365109dSVictor Latushkin 
28575d7b4d43SMatthew Ahrens 	if (!BP_IS_EMBEDDED(bp) &&
28585d7b4d43SMatthew Ahrens 	    (dump_opt['c'] > 1 || (dump_opt['c'] && is_metadata))) {
2859468c413aSTim Haley 		size_t size = BP_GET_PSIZE(bp);
2860770499e1SDan Kimmel 		abd_t *abd = abd_alloc(size, B_FALSE);
2861b24ab676SJeff Bonwick 		int flags = ZIO_FLAG_CANFAIL | ZIO_FLAG_SCRUB | ZIO_FLAG_RAW;
2862b24ab676SJeff Bonwick 
2863b24ab676SJeff Bonwick 		/* If it's an intent log block, failure is expected. */
2864b24ab676SJeff Bonwick 		if (zb->zb_level == ZB_ZIL_LEVEL)
2865b24ab676SJeff Bonwick 			flags |= ZIO_FLAG_SPECULATIVE;
2866b24ab676SJeff Bonwick 
286731d7e8faSGeorge Wilson 		mutex_enter(&spa->spa_scrub_lock);
286831d7e8faSGeorge Wilson 		while (spa->spa_scrub_inflight > max_inflight)
286931d7e8faSGeorge Wilson 			cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock);
287031d7e8faSGeorge Wilson 		spa->spa_scrub_inflight++;
287131d7e8faSGeorge Wilson 		mutex_exit(&spa->spa_scrub_lock);
2872b24ab676SJeff Bonwick 
2873770499e1SDan Kimmel 		zio_nowait(zio_read(NULL, spa, bp, abd, size,
287431d7e8faSGeorge Wilson 		    zdb_blkptr_done, zcb, ZIO_PRIORITY_ASYNC_READ, flags, zb));
2875fa9e4066Sahrens 	}
2876fa9e4066Sahrens 
2877fa9e4066Sahrens 	zcb->zcb_readfails = 0;
2878fa9e4066Sahrens 
2879f7950bf1SMatthew Ahrens 	/* only call gethrtime() every 100 blocks */
2880f7950bf1SMatthew Ahrens 	static int iters;
2881f7950bf1SMatthew Ahrens 	if (++iters > 100)
2882f7950bf1SMatthew Ahrens 		iters = 0;
2883f7950bf1SMatthew Ahrens 	else
2884f7950bf1SMatthew Ahrens 		return (0);
2885f7950bf1SMatthew Ahrens 
2886f7950bf1SMatthew Ahrens 	if (dump_opt['b'] < 5 && gethrtime() > zcb->zcb_lastprint + NANOSEC) {
2887490d05b9SMatthew Ahrens 		uint64_t now = gethrtime();
2888490d05b9SMatthew Ahrens 		char buf[10];
2889490d05b9SMatthew Ahrens 		uint64_t bytes = zcb->zcb_type[ZB_TOTAL][ZDB_OT_TOTAL].zb_asize;
2890490d05b9SMatthew Ahrens 		int kb_per_sec =
2891490d05b9SMatthew Ahrens 		    1 + bytes / (1 + ((now - zcb->zcb_start) / 1000 / 1000));
2892490d05b9SMatthew Ahrens 		int sec_remaining =
2893490d05b9SMatthew Ahrens 		    (zcb->zcb_totalasize - bytes) / 1024 / kb_per_sec;
2894490d05b9SMatthew Ahrens 
28950a055120SJason King 		/* make sure nicenum has enough space */
28960a055120SJason King 		CTASSERT(sizeof (buf) >= NN_NUMBUF_SZ);
28970a055120SJason King 
2898490d05b9SMatthew Ahrens 		zfs_nicenum(bytes, buf, sizeof (buf));
2899490d05b9SMatthew Ahrens 		(void) fprintf(stderr,
2900490d05b9SMatthew Ahrens 		    "\r%5s completed (%4dMB/s) "
2901490d05b9SMatthew Ahrens 		    "estimated time remaining: %uhr %02umin %02usec        ",
2902490d05b9SMatthew Ahrens 		    buf, kb_per_sec / 1024,
2903490d05b9SMatthew Ahrens 		    sec_remaining / 60 / 60,
2904490d05b9SMatthew Ahrens 		    sec_remaining / 60 % 60,
2905490d05b9SMatthew Ahrens 		    sec_remaining % 60);
2906490d05b9SMatthew Ahrens 
2907490d05b9SMatthew Ahrens 		zcb->zcb_lastprint = now;
2908490d05b9SMatthew Ahrens 	}
2909490d05b9SMatthew Ahrens 
2910fa9e4066Sahrens 	return (0);
2911fa9e4066Sahrens }
2912fa9e4066Sahrens 
2913b24ab676SJeff Bonwick static void
29140713e232SGeorge Wilson zdb_leak(void *arg, uint64_t start, uint64_t size)
2915b24ab676SJeff Bonwick {
29160713e232SGeorge Wilson 	vdev_t *vd = arg;
2917b24ab676SJeff Bonwick 
2918b24ab676SJeff Bonwick 	(void) printf("leaked space: vdev %llu, offset 0x%llx, size %llu\n",
2919b24ab676SJeff Bonwick 	    (u_longlong_t)vd->vdev_id, (u_longlong_t)start, (u_longlong_t)size);
2920b24ab676SJeff Bonwick }
2921b24ab676SJeff Bonwick 
29220713e232SGeorge Wilson static metaslab_ops_t zdb_metaslab_ops = {
29232e4c9986SGeorge Wilson 	NULL	/* alloc */
2924b24ab676SJeff Bonwick };
2925b24ab676SJeff Bonwick 
2926b24ab676SJeff Bonwick static void
2927bbfd46c4SJeff Bonwick zdb_ddt_leak_init(spa_t *spa, zdb_cb_t *zcb)
2928b24ab676SJeff Bonwick {
29293f7978d0SAlan Somers 	ddt_bookmark_t ddb;
2930b24ab676SJeff Bonwick 	ddt_entry_t dde;
2931b24ab676SJeff Bonwick 	int error;
2932b24ab676SJeff Bonwick 
29333f7978d0SAlan Somers 	bzero(&ddb, sizeof (ddb));
2934bbfd46c4SJeff Bonwick 	while ((error = ddt_walk(spa, &ddb, &dde)) == 0) {
2935b24ab676SJeff Bonwick 		blkptr_t blk;
2936b24ab676SJeff Bonwick 		ddt_phys_t *ddp = dde.dde_phys;
2937bbfd46c4SJeff Bonwick 
2938bbfd46c4SJeff Bonwick 		if (ddb.ddb_class == DDT_CLASS_UNIQUE)
2939bbfd46c4SJeff Bonwick 			return;
2940bbfd46c4SJeff Bonwick 
2941b24ab676SJeff Bonwick 		ASSERT(ddt_phys_total_refcnt(&dde) > 1);
2942bbfd46c4SJeff Bonwick 
2943b24ab676SJeff Bonwick 		for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
2944b24ab676SJeff Bonwick 			if (ddp->ddp_phys_birth == 0)
2945b24ab676SJeff Bonwick 				continue;
2946bbfd46c4SJeff Bonwick 			ddt_bp_create(ddb.ddb_checksum,
2947bbfd46c4SJeff Bonwick 			    &dde.dde_key, ddp, &blk);
2948b24ab676SJeff Bonwick 			if (p == DDT_PHYS_DITTO) {
2949cde58dbcSMatthew Ahrens 				zdb_count_block(zcb, NULL, &blk, ZDB_OT_DITTO);
2950b24ab676SJeff Bonwick 			} else {
2951b24ab676SJeff Bonwick 				zcb->zcb_dedup_asize +=
2952b24ab676SJeff Bonwick 				    BP_GET_ASIZE(&blk) * (ddp->ddp_refcnt - 1);
2953b24ab676SJeff Bonwick 				zcb->zcb_dedup_blocks++;
2954b24ab676SJeff Bonwick 			}
2955b24ab676SJeff Bonwick 		}
2956b24ab676SJeff Bonwick 		if (!dump_opt['L']) {
2957bbfd46c4SJeff Bonwick 			ddt_t *ddt = spa->spa_ddt[ddb.ddb_checksum];
2958b24ab676SJeff Bonwick 			ddt_enter(ddt);
2959b24ab676SJeff Bonwick 			VERIFY(ddt_lookup(ddt, &blk, B_TRUE) != NULL);
2960b24ab676SJeff Bonwick 			ddt_exit(ddt);
2961b24ab676SJeff Bonwick 		}
2962b24ab676SJeff Bonwick 	}
2963b24ab676SJeff Bonwick 
2964b24ab676SJeff Bonwick 	ASSERT(error == ENOENT);
2965b24ab676SJeff Bonwick }
2966b24ab676SJeff Bonwick 
29675cabbc6bSPrashanth Sreenivasa /* ARGSUSED */
29685cabbc6bSPrashanth Sreenivasa static void
29695cabbc6bSPrashanth Sreenivasa claim_segment_impl_cb(uint64_t inner_offset, vdev_t *vd, uint64_t offset,
29705cabbc6bSPrashanth Sreenivasa     uint64_t size, void *arg)
29715cabbc6bSPrashanth Sreenivasa {
29725cabbc6bSPrashanth Sreenivasa 	/*
29735cabbc6bSPrashanth Sreenivasa 	 * This callback was called through a remap from
29745cabbc6bSPrashanth Sreenivasa 	 * a device being removed. Therefore, the vdev that
29755cabbc6bSPrashanth Sreenivasa 	 * this callback is applied to is a concrete
29765cabbc6bSPrashanth Sreenivasa 	 * vdev.
29775cabbc6bSPrashanth Sreenivasa 	 */
29785cabbc6bSPrashanth Sreenivasa 	ASSERT(vdev_is_concrete(vd));
29795cabbc6bSPrashanth Sreenivasa 
29805cabbc6bSPrashanth Sreenivasa 	VERIFY0(metaslab_claim_impl(vd, offset, size,
298186714001SSerapheim Dimitropoulos 	    spa_min_claim_txg(vd->vdev_spa)));
29825cabbc6bSPrashanth Sreenivasa }
29835cabbc6bSPrashanth Sreenivasa 
29845cabbc6bSPrashanth Sreenivasa static void
29855cabbc6bSPrashanth Sreenivasa claim_segment_cb(void *arg, uint64_t offset, uint64_t size)
29865cabbc6bSPrashanth Sreenivasa {
29875cabbc6bSPrashanth Sreenivasa 	vdev_t *vd = arg;
29885cabbc6bSPrashanth Sreenivasa 
29895cabbc6bSPrashanth Sreenivasa 	vdev_indirect_ops.vdev_op_remap(vd, offset, size,
29905cabbc6bSPrashanth Sreenivasa 	    claim_segment_impl_cb, NULL);
29915cabbc6bSPrashanth Sreenivasa }
29925cabbc6bSPrashanth Sreenivasa 
29935cabbc6bSPrashanth Sreenivasa /*
29945cabbc6bSPrashanth Sreenivasa  * After accounting for all allocated blocks that are directly referenced,
29955cabbc6bSPrashanth Sreenivasa  * we might have missed a reference to a block from a partially complete
29965cabbc6bSPrashanth Sreenivasa  * (and thus unused) indirect mapping object. We perform a secondary pass
29975cabbc6bSPrashanth Sreenivasa  * through the metaslabs we have already mapped and claim the destination
29985cabbc6bSPrashanth Sreenivasa  * blocks.
29995cabbc6bSPrashanth Sreenivasa  */
30005cabbc6bSPrashanth Sreenivasa static void
30015cabbc6bSPrashanth Sreenivasa zdb_claim_removing(spa_t *spa, zdb_cb_t *zcb)
30025cabbc6bSPrashanth Sreenivasa {
30035cabbc6bSPrashanth Sreenivasa 	if (spa->spa_vdev_removal == NULL)
30045cabbc6bSPrashanth Sreenivasa 		return;
30055cabbc6bSPrashanth Sreenivasa 
30065cabbc6bSPrashanth Sreenivasa 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
30075cabbc6bSPrashanth Sreenivasa 
30085cabbc6bSPrashanth Sreenivasa 	spa_vdev_removal_t *svr = spa->spa_vdev_removal;
30095cabbc6bSPrashanth Sreenivasa 	vdev_t *vd = svr->svr_vdev;
30105cabbc6bSPrashanth Sreenivasa 	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
30115cabbc6bSPrashanth Sreenivasa 
30125cabbc6bSPrashanth Sreenivasa 	for (uint64_t msi = 0; msi < vd->vdev_ms_count; msi++) {
30135cabbc6bSPrashanth Sreenivasa 		metaslab_t *msp = vd->vdev_ms[msi];
30145cabbc6bSPrashanth Sreenivasa 
30155cabbc6bSPrashanth Sreenivasa 		if (msp->ms_start >= vdev_indirect_mapping_max_offset(vim))
30165cabbc6bSPrashanth Sreenivasa 			break;
30175cabbc6bSPrashanth Sreenivasa 
30185cabbc6bSPrashanth Sreenivasa 		ASSERT0(range_tree_space(svr->svr_allocd_segs));
30195cabbc6bSPrashanth Sreenivasa 
30205cabbc6bSPrashanth Sreenivasa 		if (msp->ms_sm != NULL) {
30215cabbc6bSPrashanth Sreenivasa 			VERIFY0(space_map_load(msp->ms_sm,
30225cabbc6bSPrashanth Sreenivasa 			    svr->svr_allocd_segs, SM_ALLOC));
30235cabbc6bSPrashanth Sreenivasa 
30245cabbc6bSPrashanth Sreenivasa 			/*
30255cabbc6bSPrashanth Sreenivasa 			 * Clear everything past what has been synced,
30265cabbc6bSPrashanth Sreenivasa 			 * because we have not allocated mappings for it yet.
30275cabbc6bSPrashanth Sreenivasa 			 */
30285cabbc6bSPrashanth Sreenivasa 			range_tree_clear(svr->svr_allocd_segs,
30295cabbc6bSPrashanth Sreenivasa 			    vdev_indirect_mapping_max_offset(vim),
30305cabbc6bSPrashanth Sreenivasa 			    msp->ms_sm->sm_start + msp->ms_sm->sm_size -
30315cabbc6bSPrashanth Sreenivasa 			    vdev_indirect_mapping_max_offset(vim));
30325cabbc6bSPrashanth Sreenivasa 		}
30335cabbc6bSPrashanth Sreenivasa 
30345cabbc6bSPrashanth Sreenivasa 		zcb->zcb_removing_size +=
30355cabbc6bSPrashanth Sreenivasa 		    range_tree_space(svr->svr_allocd_segs);
30365cabbc6bSPrashanth Sreenivasa 		range_tree_vacate(svr->svr_allocd_segs, claim_segment_cb, vd);
30375cabbc6bSPrashanth Sreenivasa 	}
30385cabbc6bSPrashanth Sreenivasa 
30395cabbc6bSPrashanth Sreenivasa 	spa_config_exit(spa, SCL_CONFIG, FTAG);
30405cabbc6bSPrashanth Sreenivasa }
30415cabbc6bSPrashanth Sreenivasa 
30425cabbc6bSPrashanth Sreenivasa /* ARGSUSED */
30435cabbc6bSPrashanth Sreenivasa static int
30445cabbc6bSPrashanth Sreenivasa increment_indirect_mapping_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
30455cabbc6bSPrashanth Sreenivasa {
30465cabbc6bSPrashanth Sreenivasa 	zdb_cb_t *zcb = arg;
30475cabbc6bSPrashanth Sreenivasa 	spa_t *spa = zcb->zcb_spa;
30485cabbc6bSPrashanth Sreenivasa 	vdev_t *vd;
30495cabbc6bSPrashanth Sreenivasa 	const dva_t *dva = &bp->blk_dva[0];
30505cabbc6bSPrashanth Sreenivasa 
30515cabbc6bSPrashanth Sreenivasa 	ASSERT(!dump_opt['L']);
30525cabbc6bSPrashanth Sreenivasa 	ASSERT3U(BP_GET_NDVAS(bp), ==, 1);
30535cabbc6bSPrashanth Sreenivasa 
30545cabbc6bSPrashanth Sreenivasa 	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
30555cabbc6bSPrashanth Sreenivasa 	vd = vdev_lookup_top(zcb->zcb_spa, DVA_GET_VDEV(dva));
30565cabbc6bSPrashanth Sreenivasa 	ASSERT3P(vd, !=, NULL);
30575cabbc6bSPrashanth Sreenivasa 	spa_config_exit(spa, SCL_VDEV, FTAG);
30585cabbc6bSPrashanth Sreenivasa 
30595cabbc6bSPrashanth Sreenivasa 	ASSERT(vd->vdev_indirect_config.vic_mapping_object != 0);
30605cabbc6bSPrashanth Sreenivasa 	ASSERT3P(zcb->zcb_vd_obsolete_counts[vd->vdev_id], !=, NULL);
30615cabbc6bSPrashanth Sreenivasa 
30625cabbc6bSPrashanth Sreenivasa 	vdev_indirect_mapping_increment_obsolete_count(
30635cabbc6bSPrashanth Sreenivasa 	    vd->vdev_indirect_mapping,
30645cabbc6bSPrashanth Sreenivasa 	    DVA_GET_OFFSET(dva), DVA_GET_ASIZE(dva),
30655cabbc6bSPrashanth Sreenivasa 	    zcb->zcb_vd_obsolete_counts[vd->vdev_id]);
30665cabbc6bSPrashanth Sreenivasa 
30675cabbc6bSPrashanth Sreenivasa 	return (0);
30685cabbc6bSPrashanth Sreenivasa }
30695cabbc6bSPrashanth Sreenivasa 
30705cabbc6bSPrashanth Sreenivasa static uint32_t *
30715cabbc6bSPrashanth Sreenivasa zdb_load_obsolete_counts(vdev_t *vd)
30725cabbc6bSPrashanth Sreenivasa {
30735cabbc6bSPrashanth Sreenivasa 	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
30745cabbc6bSPrashanth Sreenivasa 	spa_t *spa = vd->vdev_spa;
30755cabbc6bSPrashanth Sreenivasa 	spa_condensing_indirect_phys_t *scip =
30765cabbc6bSPrashanth Sreenivasa 	    &spa->spa_condensing_indirect_phys;
30775cabbc6bSPrashanth Sreenivasa 	uint32_t *counts;
30785cabbc6bSPrashanth Sreenivasa 
30795cabbc6bSPrashanth Sreenivasa 	EQUIV(vdev_obsolete_sm_object(vd) != 0, vd->vdev_obsolete_sm != NULL);
30805cabbc6bSPrashanth Sreenivasa 	counts = vdev_indirect_mapping_load_obsolete_counts(vim);
30815cabbc6bSPrashanth Sreenivasa 	if (vd->vdev_obsolete_sm != NULL) {
30825cabbc6bSPrashanth Sreenivasa 		vdev_indirect_mapping_load_obsolete_spacemap(vim, counts,
30835cabbc6bSPrashanth Sreenivasa 		    vd->vdev_obsolete_sm);
30845cabbc6bSPrashanth Sreenivasa 	}
30855cabbc6bSPrashanth Sreenivasa 	if (scip->scip_vdev == vd->vdev_id &&
30865cabbc6bSPrashanth Sreenivasa 	    scip->scip_prev_obsolete_sm_object != 0) {
30875cabbc6bSPrashanth Sreenivasa 		space_map_t *prev_obsolete_sm = NULL;
30885cabbc6bSPrashanth Sreenivasa 		VERIFY0(space_map_open(&prev_obsolete_sm, spa->spa_meta_objset,
30895cabbc6bSPrashanth Sreenivasa 		    scip->scip_prev_obsolete_sm_object, 0, vd->vdev_asize, 0));
30905cabbc6bSPrashanth Sreenivasa 		space_map_update(prev_obsolete_sm);
30915cabbc6bSPrashanth Sreenivasa 		vdev_indirect_mapping_load_obsolete_spacemap(vim, counts,
30925cabbc6bSPrashanth Sreenivasa 		    prev_obsolete_sm);
30935cabbc6bSPrashanth Sreenivasa 		space_map_close(prev_obsolete_sm);
30945cabbc6bSPrashanth Sreenivasa 	}
30955cabbc6bSPrashanth Sreenivasa 	return (counts);
30965cabbc6bSPrashanth Sreenivasa }
30975cabbc6bSPrashanth Sreenivasa 
309886714001SSerapheim Dimitropoulos typedef struct checkpoint_sm_exclude_entry_arg {
309986714001SSerapheim Dimitropoulos 	vdev_t *cseea_vd;
310086714001SSerapheim Dimitropoulos 	uint64_t cseea_checkpoint_size;
310186714001SSerapheim Dimitropoulos } checkpoint_sm_exclude_entry_arg_t;
310286714001SSerapheim Dimitropoulos 
310386714001SSerapheim Dimitropoulos static int
3104*17f11284SSerapheim Dimitropoulos checkpoint_sm_exclude_entry_cb(space_map_entry_t *sme, void *arg)
310586714001SSerapheim Dimitropoulos {
310686714001SSerapheim Dimitropoulos 	checkpoint_sm_exclude_entry_arg_t *cseea = arg;
310786714001SSerapheim Dimitropoulos 	vdev_t *vd = cseea->cseea_vd;
3108*17f11284SSerapheim Dimitropoulos 	metaslab_t *ms = vd->vdev_ms[sme->sme_offset >> vd->vdev_ms_shift];
3109*17f11284SSerapheim Dimitropoulos 	uint64_t end = sme->sme_offset + sme->sme_run;
311086714001SSerapheim Dimitropoulos 
3111*17f11284SSerapheim Dimitropoulos 	ASSERT(sme->sme_type == SM_FREE);
311286714001SSerapheim Dimitropoulos 
311386714001SSerapheim Dimitropoulos 	/*
311486714001SSerapheim Dimitropoulos 	 * Since the vdev_checkpoint_sm exists in the vdev level
311586714001SSerapheim Dimitropoulos 	 * and the ms_sm space maps exist in the metaslab level,
311686714001SSerapheim Dimitropoulos 	 * an entry in the checkpoint space map could theoretically
311786714001SSerapheim Dimitropoulos 	 * cross the boundaries of the metaslab that it belongs.
311886714001SSerapheim Dimitropoulos 	 *
311986714001SSerapheim Dimitropoulos 	 * In reality, because of the way that we populate and
312086714001SSerapheim Dimitropoulos 	 * manipulate the checkpoint's space maps currently,
312186714001SSerapheim Dimitropoulos 	 * there shouldn't be any entries that cross metaslabs.
312286714001SSerapheim Dimitropoulos 	 * Hence the assertion below.
312386714001SSerapheim Dimitropoulos 	 *
312486714001SSerapheim Dimitropoulos 	 * That said, there is no fundamental requirement that
312586714001SSerapheim Dimitropoulos 	 * the checkpoint's space map entries should not cross
312686714001SSerapheim Dimitropoulos 	 * metaslab boundaries. So if needed we could add code
312786714001SSerapheim Dimitropoulos 	 * that handles metaslab-crossing segments in the future.
312886714001SSerapheim Dimitropoulos 	 */
3129*17f11284SSerapheim Dimitropoulos 	VERIFY3U(sme->sme_offset, >=, ms->ms_start);
313086714001SSerapheim Dimitropoulos 	VERIFY3U(end, <=, ms->ms_start + ms->ms_size);
313186714001SSerapheim Dimitropoulos 
313286714001SSerapheim Dimitropoulos 	/*
313386714001SSerapheim Dimitropoulos 	 * By removing the entry from the allocated segments we
313486714001SSerapheim Dimitropoulos 	 * also verify that the entry is there to begin with.
313586714001SSerapheim Dimitropoulos 	 */
313686714001SSerapheim Dimitropoulos 	mutex_enter(&ms->ms_lock);
3137*17f11284SSerapheim Dimitropoulos 	range_tree_remove(ms->ms_allocatable, sme->sme_offset, sme->sme_run);
313886714001SSerapheim Dimitropoulos 	mutex_exit(&ms->ms_lock);
313986714001SSerapheim Dimitropoulos 
3140*17f11284SSerapheim Dimitropoulos 	cseea->cseea_checkpoint_size += sme->sme_run;
314186714001SSerapheim Dimitropoulos 	return (0);
314286714001SSerapheim Dimitropoulos }
314386714001SSerapheim Dimitropoulos 
314486714001SSerapheim Dimitropoulos static void
314586714001SSerapheim Dimitropoulos zdb_leak_init_vdev_exclude_checkpoint(vdev_t *vd, zdb_cb_t *zcb)
314686714001SSerapheim Dimitropoulos {
314786714001SSerapheim Dimitropoulos 	spa_t *spa = vd->vdev_spa;
314886714001SSerapheim Dimitropoulos 	space_map_t *checkpoint_sm = NULL;
314986714001SSerapheim Dimitropoulos 	uint64_t checkpoint_sm_obj;
315086714001SSerapheim Dimitropoulos 
315186714001SSerapheim Dimitropoulos 	/*
315286714001SSerapheim Dimitropoulos 	 * If there is no vdev_top_zap, we are in a pool whose
315386714001SSerapheim Dimitropoulos 	 * version predates the pool checkpoint feature.
315486714001SSerapheim Dimitropoulos 	 */
315586714001SSerapheim Dimitropoulos 	if (vd->vdev_top_zap == 0)
315686714001SSerapheim Dimitropoulos 		return;
315786714001SSerapheim Dimitropoulos 
315886714001SSerapheim Dimitropoulos 	/*
315986714001SSerapheim Dimitropoulos 	 * If there is no reference of the vdev_checkpoint_sm in
316086714001SSerapheim Dimitropoulos 	 * the vdev_top_zap, then one of the following scenarios
316186714001SSerapheim Dimitropoulos 	 * is true:
316286714001SSerapheim Dimitropoulos 	 *
316386714001SSerapheim Dimitropoulos 	 * 1] There is no checkpoint
316486714001SSerapheim Dimitropoulos 	 * 2] There is a checkpoint, but no checkpointed blocks
316586714001SSerapheim Dimitropoulos 	 *    have been freed yet
316686714001SSerapheim Dimitropoulos 	 * 3] The current vdev is indirect
316786714001SSerapheim Dimitropoulos 	 *
316886714001SSerapheim Dimitropoulos 	 * In these cases we return immediately.
316986714001SSerapheim Dimitropoulos 	 */
317086714001SSerapheim Dimitropoulos 	if (zap_contains(spa_meta_objset(spa), vd->vdev_top_zap,
317186714001SSerapheim Dimitropoulos 	    VDEV_TOP_ZAP_POOL_CHECKPOINT_SM) != 0)
317286714001SSerapheim Dimitropoulos 		return;
317386714001SSerapheim Dimitropoulos 
317486714001SSerapheim Dimitropoulos 	VERIFY0(zap_lookup(spa_meta_objset(spa), vd->vdev_top_zap,
317586714001SSerapheim Dimitropoulos 	    VDEV_TOP_ZAP_POOL_CHECKPOINT_SM, sizeof (uint64_t), 1,
317686714001SSerapheim Dimitropoulos 	    &checkpoint_sm_obj));
317786714001SSerapheim Dimitropoulos 
317886714001SSerapheim Dimitropoulos 	checkpoint_sm_exclude_entry_arg_t cseea;
317986714001SSerapheim Dimitropoulos 	cseea.cseea_vd = vd;
318086714001SSerapheim Dimitropoulos 	cseea.cseea_checkpoint_size = 0;
318186714001SSerapheim Dimitropoulos 
318286714001SSerapheim Dimitropoulos 	VERIFY0(space_map_open(&checkpoint_sm, spa_meta_objset(spa),
318386714001SSerapheim Dimitropoulos 	    checkpoint_sm_obj, 0, vd->vdev_asize, vd->vdev_ashift));
318486714001SSerapheim Dimitropoulos 	space_map_update(checkpoint_sm);
318586714001SSerapheim Dimitropoulos 
318686714001SSerapheim Dimitropoulos 	VERIFY0(space_map_iterate(checkpoint_sm,
318786714001SSerapheim Dimitropoulos 	    checkpoint_sm_exclude_entry_cb, &cseea));
318886714001SSerapheim Dimitropoulos 	space_map_close(checkpoint_sm);
318986714001SSerapheim Dimitropoulos 
319086714001SSerapheim Dimitropoulos 	zcb->zcb_checkpoint_size += cseea.cseea_checkpoint_size;
319186714001SSerapheim Dimitropoulos }
319286714001SSerapheim Dimitropoulos 
319386714001SSerapheim Dimitropoulos static void
319486714001SSerapheim Dimitropoulos zdb_leak_init_exclude_checkpoint(spa_t *spa, zdb_cb_t *zcb)
319586714001SSerapheim Dimitropoulos {
319686714001SSerapheim Dimitropoulos 	vdev_t *rvd = spa->spa_root_vdev;
319786714001SSerapheim Dimitropoulos 	for (uint64_t c = 0; c < rvd->vdev_children; c++) {
319886714001SSerapheim Dimitropoulos 		ASSERT3U(c, ==, rvd->vdev_child[c]->vdev_id);
319986714001SSerapheim Dimitropoulos 		zdb_leak_init_vdev_exclude_checkpoint(rvd->vdev_child[c], zcb);
320086714001SSerapheim Dimitropoulos 	}
320186714001SSerapheim Dimitropoulos }
320286714001SSerapheim Dimitropoulos 
320386714001SSerapheim Dimitropoulos static void
320486714001SSerapheim Dimitropoulos load_concrete_ms_allocatable_trees(spa_t *spa, maptype_t maptype)
320586714001SSerapheim Dimitropoulos {
320686714001SSerapheim Dimitropoulos 	vdev_t *rvd = spa->spa_root_vdev;
320786714001SSerapheim Dimitropoulos 	for (uint64_t i = 0; i < rvd->vdev_children; i++) {
320886714001SSerapheim Dimitropoulos 		vdev_t *vd = rvd->vdev_child[i];
320986714001SSerapheim Dimitropoulos 
321086714001SSerapheim Dimitropoulos 		ASSERT3U(i, ==, vd->vdev_id);
321186714001SSerapheim Dimitropoulos 
321286714001SSerapheim Dimitropoulos 		if (vd->vdev_ops == &vdev_indirect_ops)
321386714001SSerapheim Dimitropoulos 			continue;
321486714001SSerapheim Dimitropoulos 
321586714001SSerapheim Dimitropoulos 		for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
321686714001SSerapheim Dimitropoulos 			metaslab_t *msp = vd->vdev_ms[m];
321786714001SSerapheim Dimitropoulos 
321886714001SSerapheim Dimitropoulos 			(void) fprintf(stderr,
321986714001SSerapheim Dimitropoulos 			    "\rloading concrete vdev %llu, "
322086714001SSerapheim Dimitropoulos 			    "metaslab %llu of %llu ...",
322186714001SSerapheim Dimitropoulos 			    (longlong_t)vd->vdev_id,
322286714001SSerapheim Dimitropoulos 			    (longlong_t)msp->ms_id,
322386714001SSerapheim Dimitropoulos 			    (longlong_t)vd->vdev_ms_count);
322486714001SSerapheim Dimitropoulos 
322586714001SSerapheim Dimitropoulos 			mutex_enter(&msp->ms_lock);
322686714001SSerapheim Dimitropoulos 			metaslab_unload(msp);
322786714001SSerapheim Dimitropoulos 
322886714001SSerapheim Dimitropoulos 			/*
322986714001SSerapheim Dimitropoulos 			 * We don't want to spend the CPU manipulating the
323086714001SSerapheim Dimitropoulos 			 * size-ordered tree, so clear the range_tree ops.
323186714001SSerapheim Dimitropoulos 			 */
323286714001SSerapheim Dimitropoulos 			msp->ms_allocatable->rt_ops = NULL;
323386714001SSerapheim Dimitropoulos 
323486714001SSerapheim Dimitropoulos 			if (msp->ms_sm != NULL) {
323586714001SSerapheim Dimitropoulos 				VERIFY0(space_map_load(msp->ms_sm,
323686714001SSerapheim Dimitropoulos 				    msp->ms_allocatable, maptype));
323786714001SSerapheim Dimitropoulos 			}
323886714001SSerapheim Dimitropoulos 			if (!msp->ms_loaded)
323986714001SSerapheim Dimitropoulos 				msp->ms_loaded = B_TRUE;
324086714001SSerapheim Dimitropoulos 			mutex_exit(&msp->ms_lock);
324186714001SSerapheim Dimitropoulos 		}
324286714001SSerapheim Dimitropoulos 	}
324386714001SSerapheim Dimitropoulos }
324486714001SSerapheim Dimitropoulos 
324586714001SSerapheim Dimitropoulos /*
324686714001SSerapheim Dimitropoulos  * vm_idxp is an in-out parameter which (for indirect vdevs) is the
324786714001SSerapheim Dimitropoulos  * index in vim_entries that has the first entry in this metaslab.
324886714001SSerapheim Dimitropoulos  * On return, it will be set to the first entry after this metaslab.
324986714001SSerapheim Dimitropoulos  */
325086714001SSerapheim Dimitropoulos static void
325186714001SSerapheim Dimitropoulos load_indirect_ms_allocatable_tree(vdev_t *vd, metaslab_t *msp,
325286714001SSerapheim Dimitropoulos     uint64_t *vim_idxp)
325386714001SSerapheim Dimitropoulos {
325486714001SSerapheim Dimitropoulos 	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
325586714001SSerapheim Dimitropoulos 
325686714001SSerapheim Dimitropoulos 	mutex_enter(&msp->ms_lock);
325786714001SSerapheim Dimitropoulos 	metaslab_unload(msp);
325886714001SSerapheim Dimitropoulos 
325986714001SSerapheim Dimitropoulos 	/*
326086714001SSerapheim Dimitropoulos 	 * We don't want to spend the CPU manipulating the
326186714001SSerapheim Dimitropoulos 	 * size-ordered tree, so clear the range_tree ops.
326286714001SSerapheim Dimitropoulos 	 */
326386714001SSerapheim Dimitropoulos 	msp->ms_allocatable->rt_ops = NULL;
326486714001SSerapheim Dimitropoulos 
326586714001SSerapheim Dimitropoulos 	for (; *vim_idxp < vdev_indirect_mapping_num_entries(vim);
326686714001SSerapheim Dimitropoulos 	    (*vim_idxp)++) {
326786714001SSerapheim Dimitropoulos 		vdev_indirect_mapping_entry_phys_t *vimep =
326886714001SSerapheim Dimitropoulos 		    &vim->vim_entries[*vim_idxp];
326986714001SSerapheim Dimitropoulos 		uint64_t ent_offset = DVA_MAPPING_GET_SRC_OFFSET(vimep);
327086714001SSerapheim Dimitropoulos 		uint64_t ent_len = DVA_GET_ASIZE(&vimep->vimep_dst);
327186714001SSerapheim Dimitropoulos 		ASSERT3U(ent_offset, >=, msp->ms_start);
327286714001SSerapheim Dimitropoulos 		if (ent_offset >= msp->ms_start + msp->ms_size)
327386714001SSerapheim Dimitropoulos 			break;
327486714001SSerapheim Dimitropoulos 
327586714001SSerapheim Dimitropoulos 		/*
327686714001SSerapheim Dimitropoulos 		 * Mappings do not cross metaslab boundaries,
327786714001SSerapheim Dimitropoulos 		 * because we create them by walking the metaslabs.
327886714001SSerapheim Dimitropoulos 		 */
327986714001SSerapheim Dimitropoulos 		ASSERT3U(ent_offset + ent_len, <=,
328086714001SSerapheim Dimitropoulos 		    msp->ms_start + msp->ms_size);
328186714001SSerapheim Dimitropoulos 		range_tree_add(msp->ms_allocatable, ent_offset, ent_len);
328286714001SSerapheim Dimitropoulos 	}
328386714001SSerapheim Dimitropoulos 
328486714001SSerapheim Dimitropoulos 	if (!msp->ms_loaded)
328586714001SSerapheim Dimitropoulos 		msp->ms_loaded = B_TRUE;
328686714001SSerapheim Dimitropoulos 	mutex_exit(&msp->ms_lock);
328786714001SSerapheim Dimitropoulos }
328886714001SSerapheim Dimitropoulos 
328986714001SSerapheim Dimitropoulos static void
329086714001SSerapheim Dimitropoulos zdb_leak_init_prepare_indirect_vdevs(spa_t *spa, zdb_cb_t *zcb)
329186714001SSerapheim Dimitropoulos {
329286714001SSerapheim Dimitropoulos 	vdev_t *rvd = spa->spa_root_vdev;
329386714001SSerapheim Dimitropoulos 	for (uint64_t c = 0; c < rvd->vdev_children; c++) {
329486714001SSerapheim Dimitropoulos 		vdev_t *vd = rvd->vdev_child[c];
329586714001SSerapheim Dimitropoulos 
329686714001SSerapheim Dimitropoulos 		ASSERT3U(c, ==, vd->vdev_id);
329786714001SSerapheim Dimitropoulos 
329886714001SSerapheim Dimitropoulos 		if (vd->vdev_ops != &vdev_indirect_ops)
329986714001SSerapheim Dimitropoulos 			continue;
330086714001SSerapheim Dimitropoulos 
330186714001SSerapheim Dimitropoulos 		/*
330286714001SSerapheim Dimitropoulos 		 * Note: we don't check for mapping leaks on
330386714001SSerapheim Dimitropoulos 		 * removing vdevs because their ms_allocatable's
330486714001SSerapheim Dimitropoulos 		 * are used to look for leaks in allocated space.
330586714001SSerapheim Dimitropoulos 		 */
330686714001SSerapheim Dimitropoulos 		zcb->zcb_vd_obsolete_counts[c] = zdb_load_obsolete_counts(vd);
330786714001SSerapheim Dimitropoulos 
330886714001SSerapheim Dimitropoulos 		/*
330986714001SSerapheim Dimitropoulos 		 * Normally, indirect vdevs don't have any
331086714001SSerapheim Dimitropoulos 		 * metaslabs.  We want to set them up for
331186714001SSerapheim Dimitropoulos 		 * zio_claim().
331286714001SSerapheim Dimitropoulos 		 */
331386714001SSerapheim Dimitropoulos 		VERIFY0(vdev_metaslab_init(vd, 0));
331486714001SSerapheim Dimitropoulos 
331586714001SSerapheim Dimitropoulos 		vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
331686714001SSerapheim Dimitropoulos 		uint64_t vim_idx = 0;
331786714001SSerapheim Dimitropoulos 		for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
331886714001SSerapheim Dimitropoulos 
331986714001SSerapheim Dimitropoulos 			(void) fprintf(stderr,
332086714001SSerapheim Dimitropoulos 			    "\rloading indirect vdev %llu, "
332186714001SSerapheim Dimitropoulos 			    "metaslab %llu of %llu ...",
332286714001SSerapheim Dimitropoulos 			    (longlong_t)vd->vdev_id,
332386714001SSerapheim Dimitropoulos 			    (longlong_t)vd->vdev_ms[m]->ms_id,
332486714001SSerapheim Dimitropoulos 			    (longlong_t)vd->vdev_ms_count);
332586714001SSerapheim Dimitropoulos 
332686714001SSerapheim Dimitropoulos 			load_indirect_ms_allocatable_tree(vd, vd->vdev_ms[m],
332786714001SSerapheim Dimitropoulos 			    &vim_idx);
332886714001SSerapheim Dimitropoulos 		}
332986714001SSerapheim Dimitropoulos 		ASSERT3U(vim_idx, ==, vdev_indirect_mapping_num_entries(vim));
333086714001SSerapheim Dimitropoulos 	}
333186714001SSerapheim Dimitropoulos }
333286714001SSerapheim Dimitropoulos 
3333b24ab676SJeff Bonwick static void
3334b24ab676SJeff Bonwick zdb_leak_init(spa_t *spa, zdb_cb_t *zcb)
3335b24ab676SJeff Bonwick {
3336cde58dbcSMatthew Ahrens 	zcb->zcb_spa = spa;
3337cde58dbcSMatthew Ahrens 
3338b24ab676SJeff Bonwick 	if (!dump_opt['L']) {
33395cabbc6bSPrashanth Sreenivasa 		dsl_pool_t *dp = spa->spa_dsl_pool;
3340b24ab676SJeff Bonwick 		vdev_t *rvd = spa->spa_root_vdev;
33418363e80aSGeorge Wilson 
33428363e80aSGeorge Wilson 		/*
33438363e80aSGeorge Wilson 		 * We are going to be changing the meaning of the metaslab's
334486714001SSerapheim Dimitropoulos 		 * ms_allocatable.  Ensure that the allocator doesn't try to
33458363e80aSGeorge Wilson 		 * use the tree.
33468363e80aSGeorge Wilson 		 */
33478363e80aSGeorge Wilson 		spa->spa_normal_class->mc_ops = &zdb_metaslab_ops;
33488363e80aSGeorge Wilson 		spa->spa_log_class->mc_ops = &zdb_metaslab_ops;
33498363e80aSGeorge Wilson 
33505cabbc6bSPrashanth Sreenivasa 		zcb->zcb_vd_obsolete_counts =
33515cabbc6bSPrashanth Sreenivasa 		    umem_zalloc(rvd->vdev_children * sizeof (uint32_t *),
33525cabbc6bSPrashanth Sreenivasa 		    UMEM_NOFAIL);
33535cabbc6bSPrashanth Sreenivasa 
335486714001SSerapheim Dimitropoulos 		/*
335586714001SSerapheim Dimitropoulos 		 * For leak detection, we overload the ms_allocatable trees
335686714001SSerapheim Dimitropoulos 		 * to contain allocated segments instead of free segments.
335786714001SSerapheim Dimitropoulos 		 * As a result, we can't use the normal metaslab_load/unload
335886714001SSerapheim Dimitropoulos 		 * interfaces.
335986714001SSerapheim Dimitropoulos 		 */
336086714001SSerapheim Dimitropoulos 		zdb_leak_init_prepare_indirect_vdevs(spa, zcb);
336186714001SSerapheim Dimitropoulos 		load_concrete_ms_allocatable_trees(spa, SM_ALLOC);
33625cabbc6bSPrashanth Sreenivasa 
336386714001SSerapheim Dimitropoulos 		/*
336486714001SSerapheim Dimitropoulos 		 * On load_concrete_ms_allocatable_trees() we loaded all the
336586714001SSerapheim Dimitropoulos 		 * allocated entries from the ms_sm to the ms_allocatable for
336686714001SSerapheim Dimitropoulos 		 * each metaslab. If the pool has a checkpoint or is in the
336786714001SSerapheim Dimitropoulos 		 * middle of discarding a checkpoint, some of these blocks
336886714001SSerapheim Dimitropoulos 		 * may have been freed but their ms_sm may not have been
336986714001SSerapheim Dimitropoulos 		 * updated because they are referenced by the checkpoint. In
337086714001SSerapheim Dimitropoulos 		 * order to avoid false-positives during leak-detection, we
337186714001SSerapheim Dimitropoulos 		 * go through the vdev's checkpoint space map and exclude all
337286714001SSerapheim Dimitropoulos 		 * its entries from their relevant ms_allocatable.
337386714001SSerapheim Dimitropoulos 		 *
337486714001SSerapheim Dimitropoulos 		 * We also aggregate the space held by the checkpoint and add
337586714001SSerapheim Dimitropoulos 		 * it to zcb_checkpoint_size.
337686714001SSerapheim Dimitropoulos 		 *
337786714001SSerapheim Dimitropoulos 		 * Note that at this point we are also verifying that all the
337886714001SSerapheim Dimitropoulos 		 * entries on the checkpoint_sm are marked as allocated in
337986714001SSerapheim Dimitropoulos 		 * the ms_sm of their relevant metaslab.
338086714001SSerapheim Dimitropoulos 		 * [see comment in checkpoint_sm_exclude_entry_cb()]
338186714001SSerapheim Dimitropoulos 		 */
338286714001SSerapheim Dimitropoulos 		zdb_leak_init_exclude_checkpoint(spa, zcb);
33835cabbc6bSPrashanth Sreenivasa 
338486714001SSerapheim Dimitropoulos 		/* for cleaner progress output */
338506be9802SMatthew Ahrens 		(void) fprintf(stderr, "\n");
33865cabbc6bSPrashanth Sreenivasa 
33875cabbc6bSPrashanth Sreenivasa 		if (bpobj_is_open(&dp->dp_obsolete_bpobj)) {
33885cabbc6bSPrashanth Sreenivasa 			ASSERT(spa_feature_is_enabled(spa,
33895cabbc6bSPrashanth Sreenivasa 			    SPA_FEATURE_DEVICE_REMOVAL));
33905cabbc6bSPrashanth Sreenivasa 			(void) bpobj_iterate_nofree(&dp->dp_obsolete_bpobj,
33915cabbc6bSPrashanth Sreenivasa 			    increment_indirect_mapping_cb, zcb, NULL);
33925cabbc6bSPrashanth Sreenivasa 		}
339386714001SSerapheim Dimitropoulos 	} else {
339486714001SSerapheim Dimitropoulos 		/*
339586714001SSerapheim Dimitropoulos 		 * If leak tracing is disabled, we still need to consider
339686714001SSerapheim Dimitropoulos 		 * any checkpointed space in our space verification.
339786714001SSerapheim Dimitropoulos 		 */
339886714001SSerapheim Dimitropoulos 		zcb->zcb_checkpoint_size += spa_get_checkpoint_space(spa);
3399b24ab676SJeff Bonwick 	}
3400b24ab676SJeff Bonwick 
3401b24ab676SJeff Bonwick 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
3402bbfd46c4SJeff Bonwick 	zdb_ddt_leak_init(spa, zcb);
3403b24ab676SJeff Bonwick 	spa_config_exit(spa, SCL_CONFIG, FTAG);
3404b24ab676SJeff Bonwick }
3405b24ab676SJeff Bonwick 
34065cabbc6bSPrashanth Sreenivasa static boolean_t
34075cabbc6bSPrashanth Sreenivasa zdb_check_for_obsolete_leaks(vdev_t *vd, zdb_cb_t *zcb)
34085cabbc6bSPrashanth Sreenivasa {
34095cabbc6bSPrashanth Sreenivasa 	boolean_t leaks = B_FALSE;
34105cabbc6bSPrashanth Sreenivasa 	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
34115cabbc6bSPrashanth Sreenivasa 	uint64_t total_leaked = 0;
34125cabbc6bSPrashanth Sreenivasa 
34135cabbc6bSPrashanth Sreenivasa 	ASSERT(vim != NULL);
34145cabbc6bSPrashanth Sreenivasa 
34155cabbc6bSPrashanth Sreenivasa 	for (uint64_t i = 0; i < vdev_indirect_mapping_num_entries(vim); i++) {
34165cabbc6bSPrashanth Sreenivasa 		vdev_indirect_mapping_entry_phys_t *vimep =
34175cabbc6bSPrashanth Sreenivasa 		    &vim->vim_entries[i];
34185cabbc6bSPrashanth Sreenivasa 		uint64_t obsolete_bytes = 0;
34195cabbc6bSPrashanth Sreenivasa 		uint64_t offset = DVA_MAPPING_GET_SRC_OFFSET(vimep);
34205cabbc6bSPrashanth Sreenivasa 		metaslab_t *msp = vd->vdev_ms[offset >> vd->vdev_ms_shift];
34215cabbc6bSPrashanth Sreenivasa 
34225cabbc6bSPrashanth Sreenivasa 		/*
34235cabbc6bSPrashanth Sreenivasa 		 * This is not very efficient but it's easy to
34245cabbc6bSPrashanth Sreenivasa 		 * verify correctness.
34255cabbc6bSPrashanth Sreenivasa 		 */
34265cabbc6bSPrashanth Sreenivasa 		for (uint64_t inner_offset = 0;
34275cabbc6bSPrashanth Sreenivasa 		    inner_offset < DVA_GET_ASIZE(&vimep->vimep_dst);
34285cabbc6bSPrashanth Sreenivasa 		    inner_offset += 1 << vd->vdev_ashift) {
342986714001SSerapheim Dimitropoulos 			if (range_tree_contains(msp->ms_allocatable,
34305cabbc6bSPrashanth Sreenivasa 			    offset + inner_offset, 1 << vd->vdev_ashift)) {
34315cabbc6bSPrashanth Sreenivasa 				obsolete_bytes += 1 << vd->vdev_ashift;
34325cabbc6bSPrashanth Sreenivasa 			}
34335cabbc6bSPrashanth Sreenivasa 		}
34345cabbc6bSPrashanth Sreenivasa 
34355cabbc6bSPrashanth Sreenivasa 		int64_t bytes_leaked = obsolete_bytes -
34365cabbc6bSPrashanth Sreenivasa 		    zcb->zcb_vd_obsolete_counts[vd->vdev_id][i];
34375cabbc6bSPrashanth Sreenivasa 		ASSERT3U(DVA_GET_ASIZE(&vimep->vimep_dst), >=,
34385cabbc6bSPrashanth Sreenivasa 		    zcb->zcb_vd_obsolete_counts[vd->vdev_id][i]);
34395cabbc6bSPrashanth Sreenivasa 		if (bytes_leaked != 0 &&
34405cabbc6bSPrashanth Sreenivasa 		    (vdev_obsolete_counts_are_precise(vd) ||
34415cabbc6bSPrashanth Sreenivasa 		    dump_opt['d'] >= 5)) {
34425cabbc6bSPrashanth Sreenivasa 			(void) printf("obsolete indirect mapping count "
34435cabbc6bSPrashanth Sreenivasa 			    "mismatch on %llu:%llx:%llx : %llx bytes leaked\n",
34445cabbc6bSPrashanth Sreenivasa 			    (u_longlong_t)vd->vdev_id,
34455cabbc6bSPrashanth Sreenivasa 			    (u_longlong_t)DVA_MAPPING_GET_SRC_OFFSET(vimep),
34465cabbc6bSPrashanth Sreenivasa 			    (u_longlong_t)DVA_GET_ASIZE(&vimep->vimep_dst),
34475cabbc6bSPrashanth Sreenivasa 			    (u_longlong_t)bytes_leaked);
34485cabbc6bSPrashanth Sreenivasa 		}
34495cabbc6bSPrashanth Sreenivasa 		total_leaked += ABS(bytes_leaked);
34505cabbc6bSPrashanth Sreenivasa 	}
34515cabbc6bSPrashanth Sreenivasa 
34525cabbc6bSPrashanth Sreenivasa 	if (!vdev_obsolete_counts_are_precise(vd) && total_leaked > 0) {
34535cabbc6bSPrashanth Sreenivasa 		int pct_leaked = total_leaked * 100 /
34545cabbc6bSPrashanth Sreenivasa 		    vdev_indirect_mapping_bytes_mapped(vim);
34555cabbc6bSPrashanth Sreenivasa 		(void) printf("cannot verify obsolete indirect mapping "
34565cabbc6bSPrashanth Sreenivasa 		    "counts of vdev %llu because precise feature was not "
34575cabbc6bSPrashanth Sreenivasa 		    "enabled when it was removed: %d%% (%llx bytes) of mapping"
34585cabbc6bSPrashanth Sreenivasa 		    "unreferenced\n",
34595cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)vd->vdev_id, pct_leaked,
34605cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)total_leaked);
34615cabbc6bSPrashanth Sreenivasa 	} else if (total_leaked > 0) {
34625cabbc6bSPrashanth Sreenivasa 		(void) printf("obsolete indirect mapping count mismatch "
34635cabbc6bSPrashanth Sreenivasa 		    "for vdev %llu -- %llx total bytes mismatched\n",
34645cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)vd->vdev_id,
34655cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)total_leaked);
34665cabbc6bSPrashanth Sreenivasa 		leaks |= B_TRUE;
34675cabbc6bSPrashanth Sreenivasa 	}
34685cabbc6bSPrashanth Sreenivasa 
34695cabbc6bSPrashanth Sreenivasa 	vdev_indirect_mapping_free_obsolete_counts(vim,
34705cabbc6bSPrashanth Sreenivasa 	    zcb->zcb_vd_obsolete_counts[vd->vdev_id]);
34715cabbc6bSPrashanth Sreenivasa 	zcb->zcb_vd_obsolete_counts[vd->vdev_id] = NULL;
34725cabbc6bSPrashanth Sreenivasa 
34735cabbc6bSPrashanth Sreenivasa 	return (leaks);
34745cabbc6bSPrashanth Sreenivasa }
34755cabbc6bSPrashanth Sreenivasa 
34765cabbc6bSPrashanth Sreenivasa static boolean_t
34775cabbc6bSPrashanth Sreenivasa zdb_leak_fini(spa_t *spa, zdb_cb_t *zcb)
3478b24ab676SJeff Bonwick {
34795cabbc6bSPrashanth Sreenivasa 	boolean_t leaks = B_FALSE;
3480b24ab676SJeff Bonwick 	if (!dump_opt['L']) {
3481b24ab676SJeff Bonwick 		vdev_t *rvd = spa->spa_root_vdev;
34823f7978d0SAlan Somers 		for (unsigned c = 0; c < rvd->vdev_children; c++) {
3483b24ab676SJeff Bonwick 			vdev_t *vd = rvd->vdev_child[c];
34848363e80aSGeorge Wilson 			metaslab_group_t *mg = vd->vdev_mg;
34855cabbc6bSPrashanth Sreenivasa 
34865cabbc6bSPrashanth Sreenivasa 			if (zcb->zcb_vd_obsolete_counts[c] != NULL) {
34875cabbc6bSPrashanth Sreenivasa 				leaks |= zdb_check_for_obsolete_leaks(vd, zcb);
34885cabbc6bSPrashanth Sreenivasa 			}
34895cabbc6bSPrashanth Sreenivasa 
34905cabbc6bSPrashanth Sreenivasa 			for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
3491b24ab676SJeff Bonwick 				metaslab_t *msp = vd->vdev_ms[m];
34928363e80aSGeorge Wilson 				ASSERT3P(mg, ==, msp->ms_group);
34930713e232SGeorge Wilson 
34940713e232SGeorge Wilson 				/*
349586714001SSerapheim Dimitropoulos 				 * ms_allocatable has been overloaded
349686714001SSerapheim Dimitropoulos 				 * to contain allocated segments. Now that
349786714001SSerapheim Dimitropoulos 				 * we finished traversing all blocks, any
349886714001SSerapheim Dimitropoulos 				 * block that remains in the ms_allocatable
34990713e232SGeorge Wilson 				 * represents an allocated block that we
35000713e232SGeorge Wilson 				 * did not claim during the traversal.
35010713e232SGeorge Wilson 				 * Claimed blocks would have been removed
350286714001SSerapheim Dimitropoulos 				 * from the ms_allocatable.  For indirect
350386714001SSerapheim Dimitropoulos 				 * vdevs, space remaining in the tree
350486714001SSerapheim Dimitropoulos 				 * represents parts of the mapping that are
350586714001SSerapheim Dimitropoulos 				 * not referenced, which is not a bug.
35060713e232SGeorge Wilson 				 */
35075cabbc6bSPrashanth Sreenivasa 				if (vd->vdev_ops == &vdev_indirect_ops) {
350886714001SSerapheim Dimitropoulos 					range_tree_vacate(msp->ms_allocatable,
35095cabbc6bSPrashanth Sreenivasa 					    NULL, NULL);
35105cabbc6bSPrashanth Sreenivasa 				} else {
351186714001SSerapheim Dimitropoulos 					range_tree_vacate(msp->ms_allocatable,
35125cabbc6bSPrashanth Sreenivasa 					    zdb_leak, vd);
35135cabbc6bSPrashanth Sreenivasa 				}
35148363e80aSGeorge Wilson 
35158363e80aSGeorge Wilson 				if (msp->ms_loaded) {
35168363e80aSGeorge Wilson 					msp->ms_loaded = B_FALSE;
35178363e80aSGeorge Wilson 				}
3518b24ab676SJeff Bonwick 			}
3519b24ab676SJeff Bonwick 		}
35205cabbc6bSPrashanth Sreenivasa 
35215cabbc6bSPrashanth Sreenivasa 		umem_free(zcb->zcb_vd_obsolete_counts,
35225cabbc6bSPrashanth Sreenivasa 		    rvd->vdev_children * sizeof (uint32_t *));
35235cabbc6bSPrashanth Sreenivasa 		zcb->zcb_vd_obsolete_counts = NULL;
3524b24ab676SJeff Bonwick 	}
35255cabbc6bSPrashanth Sreenivasa 	return (leaks);
3526b24ab676SJeff Bonwick }
3527b24ab676SJeff Bonwick 
3528cde58dbcSMatthew Ahrens /* ARGSUSED */
3529cde58dbcSMatthew Ahrens static int
3530cde58dbcSMatthew Ahrens count_block_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
3531cde58dbcSMatthew Ahrens {
3532cde58dbcSMatthew Ahrens 	zdb_cb_t *zcb = arg;
3533cde58dbcSMatthew Ahrens 
3534490d05b9SMatthew Ahrens 	if (dump_opt['b'] >= 5) {
3535cde58dbcSMatthew Ahrens 		char blkbuf[BP_SPRINTF_LEN];
353643466aaeSMax Grossman 		snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
3537cde58dbcSMatthew Ahrens 		(void) printf("[%s] %s\n",
3538cde58dbcSMatthew Ahrens 		    "deferred free", blkbuf);
3539cde58dbcSMatthew Ahrens 	}
3540cde58dbcSMatthew Ahrens 	zdb_count_block(zcb, NULL, bp, ZDB_OT_DEFERRED);
3541cde58dbcSMatthew Ahrens 	return (0);
3542cde58dbcSMatthew Ahrens }
3543cde58dbcSMatthew Ahrens 
3544fa9e4066Sahrens static int
3545fa9e4066Sahrens dump_block_stats(spa_t *spa)
3546fa9e4066Sahrens {
35473f7978d0SAlan Somers 	zdb_cb_t zcb;
3548fa9e4066Sahrens 	zdb_blkstats_t *zb, *tzb;
3549b24ab676SJeff Bonwick 	uint64_t norm_alloc, norm_space, total_alloc, total_found;
3550cd088ea4SVictor Latushkin 	int flags = TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA | TRAVERSE_HARD;
35515d7b4d43SMatthew Ahrens 	boolean_t leaks = B_FALSE;
3552fa9e4066Sahrens 
35533f7978d0SAlan Somers 	bzero(&zcb, sizeof (zcb));
3554490d05b9SMatthew Ahrens 	(void) printf("\nTraversing all blocks %s%s%s%s%s...\n\n",
3555b24ab676SJeff Bonwick 	    (dump_opt['c'] || !dump_opt['L']) ? "to verify " : "",
3556b24ab676SJeff Bonwick 	    (dump_opt['c'] == 1) ? "metadata " : "",
3557b24ab676SJeff Bonwick 	    dump_opt['c'] ? "checksums " : "",
3558b24ab676SJeff Bonwick 	    (dump_opt['c'] && !dump_opt['L']) ? "and verify " : "",
3559b24ab676SJeff Bonwick 	    !dump_opt['L'] ? "nothing leaked " : "");
3560fa9e4066Sahrens 
3561fa9e4066Sahrens 	/*
3562e14bb325SJeff Bonwick 	 * Load all space maps as SM_ALLOC maps, then traverse the pool
3563e14bb325SJeff Bonwick 	 * claiming each block we discover.  If the pool is perfectly
3564e14bb325SJeff Bonwick 	 * consistent, the space maps will be empty when we're done.
3565e14bb325SJeff Bonwick 	 * Anything left over is a leak; any block we can't claim (because
3566e14bb325SJeff Bonwick 	 * it's not part of any space map) is a double allocation,
3567e14bb325SJeff Bonwick 	 * reference to a freed block, or an unclaimed log block.
3568fa9e4066Sahrens 	 */
3569b24ab676SJeff Bonwick 	zdb_leak_init(spa, &zcb);
3570fa9e4066Sahrens 
3571fa9e4066Sahrens 	/*
3572fa9e4066Sahrens 	 * If there's a deferred-free bplist, process that first.
3573fa9e4066Sahrens 	 */
3574cde58dbcSMatthew Ahrens 	(void) bpobj_iterate_nofree(&spa->spa_deferred_bpobj,
3575cde58dbcSMatthew Ahrens 	    count_block_cb, &zcb, NULL);
35765cabbc6bSPrashanth Sreenivasa 
35773b2aab18SMatthew Ahrens 	if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
35783b2aab18SMatthew Ahrens 		(void) bpobj_iterate_nofree(&spa->spa_dsl_pool->dp_free_bpobj,
35793b2aab18SMatthew Ahrens 		    count_block_cb, &zcb, NULL);
35803b2aab18SMatthew Ahrens 	}
35815cabbc6bSPrashanth Sreenivasa 
35825cabbc6bSPrashanth Sreenivasa 	zdb_claim_removing(spa, &zcb);
35835cabbc6bSPrashanth Sreenivasa 
35842acef22dSMatthew Ahrens 	if (spa_feature_is_active(spa, SPA_FEATURE_ASYNC_DESTROY)) {
3585b420f3adSRichard Lowe 		VERIFY3U(0, ==, bptree_iterate(spa->spa_meta_objset,
3586ad135b5dSChristopher Siden 		    spa->spa_dsl_pool->dp_bptree_obj, B_FALSE, count_block_cb,
3587ad135b5dSChristopher Siden 		    &zcb, NULL));
3588ad135b5dSChristopher Siden 	}
3589fa9e4066Sahrens 
3590bbfd46c4SJeff Bonwick 	if (dump_opt['c'] > 1)
3591bbfd46c4SJeff Bonwick 		flags |= TRAVERSE_PREFETCH_DATA;
3592bbfd46c4SJeff Bonwick 
3593490d05b9SMatthew Ahrens 	zcb.zcb_totalasize = metaslab_class_get_alloc(spa_normal_class(spa));
3594490d05b9SMatthew Ahrens 	zcb.zcb_start = zcb.zcb_lastprint = gethrtime();
3595bbfd46c4SJeff Bonwick 	zcb.zcb_haderrors |= traverse_pool(spa, 0, flags, zdb_blkptr_cb, &zcb);
3596fa9e4066Sahrens 
359731d7e8faSGeorge Wilson 	/*
359831d7e8faSGeorge Wilson 	 * If we've traversed the data blocks then we need to wait for those
359931d7e8faSGeorge Wilson 	 * I/Os to complete. We leverage "The Godfather" zio to wait on
360031d7e8faSGeorge Wilson 	 * all async I/Os to complete.
360131d7e8faSGeorge Wilson 	 */
360231d7e8faSGeorge Wilson 	if (dump_opt['c']) {
36036f834bc1SMatthew Ahrens 		for (int i = 0; i < max_ncpus; i++) {
36046f834bc1SMatthew Ahrens 			(void) zio_wait(spa->spa_async_zio_root[i]);
36056f834bc1SMatthew Ahrens 			spa->spa_async_zio_root[i] = zio_root(spa, NULL, NULL,
36066f834bc1SMatthew Ahrens 			    ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE |
36076f834bc1SMatthew Ahrens 			    ZIO_FLAG_GODFATHER);
36086f834bc1SMatthew Ahrens 		}
360931d7e8faSGeorge Wilson 	}
361031d7e8faSGeorge Wilson 
3611b24ab676SJeff Bonwick 	if (zcb.zcb_haderrors) {
3612fa9e4066Sahrens 		(void) printf("\nError counts:\n\n");
3613fa9e4066Sahrens 		(void) printf("\t%5s  %s\n", "errno", "count");
3614b24ab676SJeff Bonwick 		for (int e = 0; e < 256; e++) {
3615fa9e4066Sahrens 			if (zcb.zcb_errors[e] != 0) {
3616fa9e4066Sahrens 				(void) printf("\t%5d  %llu\n",
3617fa9e4066Sahrens 				    e, (u_longlong_t)zcb.zcb_errors[e]);
3618fa9e4066Sahrens 			}
3619fa9e4066Sahrens 		}
3620fa9e4066Sahrens 	}
3621fa9e4066Sahrens 
3622fa9e4066Sahrens 	/*
3623fa9e4066Sahrens 	 * Report any leaked segments.
3624fa9e4066Sahrens 	 */
36255cabbc6bSPrashanth Sreenivasa 	leaks |= zdb_leak_fini(spa, &zcb);
3626fa9e4066Sahrens 
3627b24ab676SJeff Bonwick 	tzb = &zcb.zcb_type[ZB_TOTAL][ZDB_OT_TOTAL];
36288654d025Sperrin 
3629b24ab676SJeff Bonwick 	norm_alloc = metaslab_class_get_alloc(spa_normal_class(spa));
3630b24ab676SJeff Bonwick 	norm_space = metaslab_class_get_space(spa_normal_class(spa));
36318654d025Sperrin 
3632b24ab676SJeff Bonwick 	total_alloc = norm_alloc + metaslab_class_get_alloc(spa_log_class(spa));
36335cabbc6bSPrashanth Sreenivasa 	total_found = tzb->zb_asize - zcb.zcb_dedup_asize +
363486714001SSerapheim Dimitropoulos 	    zcb.zcb_removing_size + zcb.zcb_checkpoint_size;
3635fa9e4066Sahrens 
3636b24ab676SJeff Bonwick 	if (total_found == total_alloc) {
363782a0a985SVictor Latushkin 		if (!dump_opt['L'])
363882a0a985SVictor Latushkin 			(void) printf("\n\tNo leaks (block sum matches space"
363982a0a985SVictor Latushkin 			    " maps exactly)\n");
3640fa9e4066Sahrens 	} else {
3641fa9e4066Sahrens 		(void) printf("block traversal size %llu != alloc %llu "
364282a0a985SVictor Latushkin 		    "(%s %lld)\n",
3643b24ab676SJeff Bonwick 		    (u_longlong_t)total_found,
3644b24ab676SJeff Bonwick 		    (u_longlong_t)total_alloc,
364582a0a985SVictor Latushkin 		    (dump_opt['L']) ? "unreachable" : "leaked",
3646b24ab676SJeff Bonwick 		    (longlong_t)(total_alloc - total_found));
36475d7b4d43SMatthew Ahrens 		leaks = B_TRUE;
3648fa9e4066Sahrens 	}
3649fa9e4066Sahrens 
3650fa9e4066Sahrens 	if (tzb->zb_count == 0)
3651fa9e4066Sahrens 		return (2);
3652fa9e4066Sahrens 
3653fa9e4066Sahrens 	(void) printf("\n");
3654fa9e4066Sahrens 	(void) printf("\tbp count:      %10llu\n",
3655fa9e4066Sahrens 	    (u_longlong_t)tzb->zb_count);
3656d5ee8a13SMatthew Ahrens 	(void) printf("\tganged count:  %10llu\n",
3657d5ee8a13SMatthew Ahrens 	    (longlong_t)tzb->zb_gangs);
3658b24ab676SJeff Bonwick 	(void) printf("\tbp logical:    %10llu      avg: %6llu\n",
3659fa9e4066Sahrens 	    (u_longlong_t)tzb->zb_lsize,
3660fa9e4066Sahrens 	    (u_longlong_t)(tzb->zb_lsize / tzb->zb_count));
3661b24ab676SJeff Bonwick 	(void) printf("\tbp physical:   %10llu      avg:"
3662b24ab676SJeff Bonwick 	    " %6llu     compression: %6.2f\n",
3663fa9e4066Sahrens 	    (u_longlong_t)tzb->zb_psize,
3664fa9e4066Sahrens 	    (u_longlong_t)(tzb->zb_psize / tzb->zb_count),
3665fa9e4066Sahrens 	    (double)tzb->zb_lsize / tzb->zb_psize);
3666b24ab676SJeff Bonwick 	(void) printf("\tbp allocated:  %10llu      avg:"
3667b24ab676SJeff Bonwick 	    " %6llu     compression: %6.2f\n",
3668fa9e4066Sahrens 	    (u_longlong_t)tzb->zb_asize,
3669fa9e4066Sahrens 	    (u_longlong_t)(tzb->zb_asize / tzb->zb_count),
3670fa9e4066Sahrens 	    (double)tzb->zb_lsize / tzb->zb_asize);
3671b24ab676SJeff Bonwick 	(void) printf("\tbp deduped:    %10llu    ref>1:"
3672b24ab676SJeff Bonwick 	    " %6llu   deduplication: %6.2f\n",
3673b24ab676SJeff Bonwick 	    (u_longlong_t)zcb.zcb_dedup_asize,
3674b24ab676SJeff Bonwick 	    (u_longlong_t)zcb.zcb_dedup_blocks,
3675b24ab676SJeff Bonwick 	    (double)zcb.zcb_dedup_asize / tzb->zb_asize + 1.0);
3676b24ab676SJeff Bonwick 	(void) printf("\tSPA allocated: %10llu     used: %5.2f%%\n",
3677b24ab676SJeff Bonwick 	    (u_longlong_t)norm_alloc, 100.0 * norm_alloc / norm_space);
3678fa9e4066Sahrens 
36795d7b4d43SMatthew Ahrens 	for (bp_embedded_type_t i = 0; i < NUM_BP_EMBEDDED_TYPES; i++) {
36805d7b4d43SMatthew Ahrens 		if (zcb.zcb_embedded_blocks[i] == 0)
36815d7b4d43SMatthew Ahrens 			continue;
36825d7b4d43SMatthew Ahrens 		(void) printf("\n");
36835d7b4d43SMatthew Ahrens 		(void) printf("\tadditional, non-pointer bps of type %u: "
36845d7b4d43SMatthew Ahrens 		    "%10llu\n",
36855d7b4d43SMatthew Ahrens 		    i, (u_longlong_t)zcb.zcb_embedded_blocks[i]);
36865d7b4d43SMatthew Ahrens 
36875d7b4d43SMatthew Ahrens 		if (dump_opt['b'] >= 3) {
36885d7b4d43SMatthew Ahrens 			(void) printf("\t number of (compressed) bytes:  "
36895d7b4d43SMatthew Ahrens 			    "number of bps\n");
36905d7b4d43SMatthew Ahrens 			dump_histogram(zcb.zcb_embedded_histogram[i],
36915d7b4d43SMatthew Ahrens 			    sizeof (zcb.zcb_embedded_histogram[i]) /
36925d7b4d43SMatthew Ahrens 			    sizeof (zcb.zcb_embedded_histogram[i][0]), 0);
36935d7b4d43SMatthew Ahrens 		}
36945d7b4d43SMatthew Ahrens 	}
36955d7b4d43SMatthew Ahrens 
3696d5ee8a13SMatthew Ahrens 	if (tzb->zb_ditto_samevdev != 0) {
3697d5ee8a13SMatthew Ahrens 		(void) printf("\tDittoed blocks on same vdev: %llu\n",
3698d5ee8a13SMatthew Ahrens 		    (longlong_t)tzb->zb_ditto_samevdev);
3699d5ee8a13SMatthew Ahrens 	}
3700d5ee8a13SMatthew Ahrens 
37015cabbc6bSPrashanth Sreenivasa 	for (uint64_t v = 0; v < spa->spa_root_vdev->vdev_children; v++) {
37025cabbc6bSPrashanth Sreenivasa 		vdev_t *vd = spa->spa_root_vdev->vdev_child[v];
37035cabbc6bSPrashanth Sreenivasa 		vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
37045cabbc6bSPrashanth Sreenivasa 
37055cabbc6bSPrashanth Sreenivasa 		if (vim == NULL) {
37065cabbc6bSPrashanth Sreenivasa 			continue;
37075cabbc6bSPrashanth Sreenivasa 		}
37085cabbc6bSPrashanth Sreenivasa 
37095cabbc6bSPrashanth Sreenivasa 		char mem[32];
37105cabbc6bSPrashanth Sreenivasa 		zdb_nicenum(vdev_indirect_mapping_num_entries(vim),
37115cabbc6bSPrashanth Sreenivasa 		    mem, vdev_indirect_mapping_size(vim));
37125cabbc6bSPrashanth Sreenivasa 
37135cabbc6bSPrashanth Sreenivasa 		(void) printf("\tindirect vdev id %llu has %llu segments "
37145cabbc6bSPrashanth Sreenivasa 		    "(%s in memory)\n",
37155cabbc6bSPrashanth Sreenivasa 		    (longlong_t)vd->vdev_id,
37165cabbc6bSPrashanth Sreenivasa 		    (longlong_t)vdev_indirect_mapping_num_entries(vim), mem);
37175cabbc6bSPrashanth Sreenivasa 	}
37185cabbc6bSPrashanth Sreenivasa 
3719fa9e4066Sahrens 	if (dump_opt['b'] >= 2) {
3720fa9e4066Sahrens 		int l, t, level;
3721fa9e4066Sahrens 		(void) printf("\nBlocks\tLSIZE\tPSIZE\tASIZE"
3722fa9e4066Sahrens 		    "\t  avg\t comp\t%%Total\tType\n");
3723fa9e4066Sahrens 
3724b24ab676SJeff Bonwick 		for (t = 0; t <= ZDB_OT_TOTAL; t++) {
37253f9d6ad7SLin Ling 			char csize[32], lsize[32], psize[32], asize[32];
3726d5ee8a13SMatthew Ahrens 			char avg[32], gang[32];
37273f7978d0SAlan Somers 			const char *typename;
3728fa9e4066Sahrens 
37290a055120SJason King 			/* make sure nicenum has enough space */
37300a055120SJason King 			CTASSERT(sizeof (csize) >= NN_NUMBUF_SZ);
37310a055120SJason King 			CTASSERT(sizeof (lsize) >= NN_NUMBUF_SZ);
37320a055120SJason King 			CTASSERT(sizeof (psize) >= NN_NUMBUF_SZ);
37330a055120SJason King 			CTASSERT(sizeof (asize) >= NN_NUMBUF_SZ);
37340a055120SJason King 			CTASSERT(sizeof (avg) >= NN_NUMBUF_SZ);
37350a055120SJason King 			CTASSERT(sizeof (gang) >= NN_NUMBUF_SZ);
37360a055120SJason King 
3737b24ab676SJeff Bonwick 			if (t < DMU_OT_NUMTYPES)
3738b24ab676SJeff Bonwick 				typename = dmu_ot[t].ot_name;
3739b24ab676SJeff Bonwick 			else
3740b24ab676SJeff Bonwick 				typename = zdb_ot_extname[t - DMU_OT_NUMTYPES];
3741fa9e4066Sahrens 
3742fa9e4066Sahrens 			if (zcb.zcb_type[ZB_TOTAL][t].zb_asize == 0) {
3743fa9e4066Sahrens 				(void) printf("%6s\t%5s\t%5s\t%5s"
3744fa9e4066Sahrens 				    "\t%5s\t%5s\t%6s\t%s\n",
3745fa9e4066Sahrens 				    "-",
3746fa9e4066Sahrens 				    "-",
3747fa9e4066Sahrens 				    "-",
3748fa9e4066Sahrens 				    "-",
3749fa9e4066Sahrens 				    "-",
3750fa9e4066Sahrens 				    "-",
3751fa9e4066Sahrens 				    "-",
3752fa9e4066Sahrens 				    typename);
3753fa9e4066Sahrens 				continue;
3754fa9e4066Sahrens 			}
3755fa9e4066Sahrens 
3756fa9e4066Sahrens 			for (l = ZB_TOTAL - 1; l >= -1; l--) {
3757fa9e4066Sahrens 				level = (l == -1 ? ZB_TOTAL : l);
3758fa9e4066Sahrens 				zb = &zcb.zcb_type[level][t];
3759fa9e4066Sahrens 
3760fa9e4066Sahrens 				if (zb->zb_asize == 0)
3761fa9e4066Sahrens 					continue;
3762fa9e4066Sahrens 
3763fa9e4066Sahrens 				if (dump_opt['b'] < 3 && level != ZB_TOTAL)
3764fa9e4066Sahrens 					continue;
3765fa9e4066Sahrens 
3766fa9e4066Sahrens 				if (level == 0 && zb->zb_asize ==
3767fa9e4066Sahrens 				    zcb.zcb_type[ZB_TOTAL][t].zb_asize)
3768fa9e4066Sahrens 					continue;
3769fa9e4066Sahrens 
37700a055120SJason King 				zdb_nicenum(zb->zb_count, csize,
37710a055120SJason King 				    sizeof (csize));
37720a055120SJason King 				zdb_nicenum(zb->zb_lsize, lsize,
37730a055120SJason King 				    sizeof (lsize));
37740a055120SJason King 				zdb_nicenum(zb->zb_psize, psize,
37750a055120SJason King 				    sizeof (psize));
37760a055120SJason King 				zdb_nicenum(zb->zb_asize, asize,
37770a055120SJason King 				    sizeof (asize));
37780a055120SJason King 				zdb_nicenum(zb->zb_asize / zb->zb_count, avg,
37790a055120SJason King 				    sizeof (avg));
37800a055120SJason King 				zdb_nicenum(zb->zb_gangs, gang, sizeof (gang));
3781fa9e4066Sahrens 
3782fa9e4066Sahrens 				(void) printf("%6s\t%5s\t%5s\t%5s\t%5s"
3783fa9e4066Sahrens 				    "\t%5.2f\t%6.2f\t",
3784fa9e4066Sahrens 				    csize, lsize, psize, asize, avg,
3785fa9e4066Sahrens 				    (double)zb->zb_lsize / zb->zb_psize,
3786fa9e4066Sahrens 				    100.0 * zb->zb_asize / tzb->zb_asize);
3787fa9e4066Sahrens 
3788fa9e4066Sahrens 				if (level == ZB_TOTAL)
3789fa9e4066Sahrens 					(void) printf("%s\n", typename);
3790fa9e4066Sahrens 				else
3791fa9e4066Sahrens 					(void) printf("    L%d %s\n",
3792fa9e4066Sahrens 					    level, typename);
3793490d05b9SMatthew Ahrens 
3794d5ee8a13SMatthew Ahrens 				if (dump_opt['b'] >= 3 && zb->zb_gangs > 0) {
3795d5ee8a13SMatthew Ahrens 					(void) printf("\t number of ganged "
3796d5ee8a13SMatthew Ahrens 					    "blocks: %s\n", gang);
3797d5ee8a13SMatthew Ahrens 				}
3798d5ee8a13SMatthew Ahrens 
3799490d05b9SMatthew Ahrens 				if (dump_opt['b'] >= 4) {
3800490d05b9SMatthew Ahrens 					(void) printf("psize "
3801490d05b9SMatthew Ahrens 					    "(in 512-byte sectors): "
3802490d05b9SMatthew Ahrens 					    "number of blocks\n");
3803490d05b9SMatthew Ahrens 					dump_histogram(zb->zb_psize_histogram,
38040713e232SGeorge Wilson 					    PSIZE_HISTO_SIZE, 0);
3805490d05b9SMatthew Ahrens 				}
3806fa9e4066Sahrens 			}
3807fa9e4066Sahrens 		}
3808fa9e4066Sahrens 	}
3809fa9e4066Sahrens 
3810fa9e4066Sahrens 	(void) printf("\n");
3811fa9e4066Sahrens 
3812fa9e4066Sahrens 	if (leaks)
3813fa9e4066Sahrens 		return (2);
3814fa9e4066Sahrens 
3815fa9e4066Sahrens 	if (zcb.zcb_haderrors)
3816fa9e4066Sahrens 		return (3);
3817fa9e4066Sahrens 
3818fa9e4066Sahrens 	return (0);
3819fa9e4066Sahrens }
3820fa9e4066Sahrens 
3821b24ab676SJeff Bonwick typedef struct zdb_ddt_entry {
3822b24ab676SJeff Bonwick 	ddt_key_t	zdde_key;
3823b24ab676SJeff Bonwick 	uint64_t	zdde_ref_blocks;
3824b24ab676SJeff Bonwick 	uint64_t	zdde_ref_lsize;
3825b24ab676SJeff Bonwick 	uint64_t	zdde_ref_psize;
3826b24ab676SJeff Bonwick 	uint64_t	zdde_ref_dsize;
3827b24ab676SJeff Bonwick 	avl_node_t	zdde_node;
3828b24ab676SJeff Bonwick } zdb_ddt_entry_t;
3829b24ab676SJeff Bonwick 
3830b24ab676SJeff Bonwick /* ARGSUSED */
3831b24ab676SJeff Bonwick static int
3832b24ab676SJeff Bonwick zdb_ddt_add_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
38337802d7bfSMatthew Ahrens     const zbookmark_phys_t *zb, const dnode_phys_t *dnp, void *arg)
3834b24ab676SJeff Bonwick {
3835b24ab676SJeff Bonwick 	avl_tree_t *t = arg;
3836b24ab676SJeff Bonwick 	avl_index_t where;
3837b24ab676SJeff Bonwick 	zdb_ddt_entry_t *zdde, zdde_search;
3838b24ab676SJeff Bonwick 
3839a2cdcdd2SPaul Dagnelie 	if (bp == NULL || BP_IS_HOLE(bp) || BP_IS_EMBEDDED(bp))
3840b24ab676SJeff Bonwick 		return (0);
3841b24ab676SJeff Bonwick 
3842b24ab676SJeff Bonwick 	if (dump_opt['S'] > 1 && zb->zb_level == ZB_ROOT_LEVEL) {
3843b24ab676SJeff Bonwick 		(void) printf("traversing objset %llu, %llu objects, "
3844b24ab676SJeff Bonwick 		    "%lu blocks so far\n",
3845b24ab676SJeff Bonwick 		    (u_longlong_t)zb->zb_objset,
38465d7b4d43SMatthew Ahrens 		    (u_longlong_t)BP_GET_FILL(bp),
3847b24ab676SJeff Bonwick 		    avl_numnodes(t));
3848b24ab676SJeff Bonwick 	}
3849b24ab676SJeff Bonwick 
3850bbfd46c4SJeff Bonwick 	if (BP_IS_HOLE(bp) || BP_GET_CHECKSUM(bp) == ZIO_CHECKSUM_OFF ||
3851ad135b5dSChristopher Siden 	    BP_GET_LEVEL(bp) > 0 || DMU_OT_IS_METADATA(BP_GET_TYPE(bp)))
3852b24ab676SJeff Bonwick 		return (0);
3853b24ab676SJeff Bonwick 
3854b24ab676SJeff Bonwick 	ddt_key_fill(&zdde_search.zdde_key, bp);
3855b24ab676SJeff Bonwick 
3856b24ab676SJeff Bonwick 	zdde = avl_find(t, &zdde_search, &where);
3857b24ab676SJeff Bonwick 
3858b24ab676SJeff Bonwick 	if (zdde == NULL) {
3859b24ab676SJeff Bonwick 		zdde = umem_zalloc(sizeof (*zdde), UMEM_NOFAIL);
3860b24ab676SJeff Bonwick 		zdde->zdde_key = zdde_search.zdde_key;
3861b24ab676SJeff Bonwick 		avl_insert(t, zdde, where);
3862b24ab676SJeff Bonwick 	}
3863b24ab676SJeff Bonwick 
3864b24ab676SJeff Bonwick 	zdde->zdde_ref_blocks += 1;
3865b24ab676SJeff Bonwick 	zdde->zdde_ref_lsize += BP_GET_LSIZE(bp);
3866b24ab676SJeff Bonwick 	zdde->zdde_ref_psize += BP_GET_PSIZE(bp);
3867b24ab676SJeff Bonwick 	zdde->zdde_ref_dsize += bp_get_dsize_sync(spa, bp);
3868b24ab676SJeff Bonwick 
3869b24ab676SJeff Bonwick 	return (0);
3870b24ab676SJeff Bonwick }
3871b24ab676SJeff Bonwick 
3872b24ab676SJeff Bonwick static void
3873b24ab676SJeff Bonwick dump_simulated_ddt(spa_t *spa)
3874b24ab676SJeff Bonwick {
3875b24ab676SJeff Bonwick 	avl_tree_t t;
3876b24ab676SJeff Bonwick 	void *cookie = NULL;
3877b24ab676SJeff Bonwick 	zdb_ddt_entry_t *zdde;
38783f7978d0SAlan Somers 	ddt_histogram_t ddh_total;
38793f7978d0SAlan Somers 	ddt_stat_t dds_total;
3880b24ab676SJeff Bonwick 
38813f7978d0SAlan Somers 	bzero(&ddh_total, sizeof (ddh_total));
38823f7978d0SAlan Somers 	bzero(&dds_total, sizeof (dds_total));
3883b24ab676SJeff Bonwick 	avl_create(&t, ddt_entry_compare,
3884b24ab676SJeff Bonwick 	    sizeof (zdb_ddt_entry_t), offsetof(zdb_ddt_entry_t, zdde_node));
3885b24ab676SJeff Bonwick 
3886b24ab676SJeff Bonwick 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
3887b24ab676SJeff Bonwick 
3888bbfd46c4SJeff Bonwick 	(void) traverse_pool(spa, 0, TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA,
3889bbfd46c4SJeff Bonwick 	    zdb_ddt_add_cb, &t);
3890b24ab676SJeff Bonwick 
3891b24ab676SJeff Bonwick 	spa_config_exit(spa, SCL_CONFIG, FTAG);
3892b24ab676SJeff Bonwick 
3893b24ab676SJeff Bonwick 	while ((zdde = avl_destroy_nodes(&t, &cookie)) != NULL) {
3894b24ab676SJeff Bonwick 		ddt_stat_t dds;
3895b24ab676SJeff Bonwick 		uint64_t refcnt = zdde->zdde_ref_blocks;
3896b24ab676SJeff Bonwick 		ASSERT(refcnt != 0);
3897b24ab676SJeff Bonwick 
3898b24ab676SJeff Bonwick 		dds.dds_blocks = zdde->zdde_ref_blocks / refcnt;
3899b24ab676SJeff Bonwick 		dds.dds_lsize = zdde->zdde_ref_lsize / refcnt;
3900b24ab676SJeff Bonwick 		dds.dds_psize = zdde->zdde_ref_psize / refcnt;
3901b24ab676SJeff Bonwick 		dds.dds_dsize = zdde->zdde_ref_dsize / refcnt;
3902b24ab676SJeff Bonwick 
3903b24ab676SJeff Bonwick 		dds.dds_ref_blocks = zdde->zdde_ref_blocks;
3904b24ab676SJeff Bonwick 		dds.dds_ref_lsize = zdde->zdde_ref_lsize;
3905b24ab676SJeff Bonwick 		dds.dds_ref_psize = zdde->zdde_ref_psize;
3906b24ab676SJeff Bonwick 		dds.dds_ref_dsize = zdde->zdde_ref_dsize;
3907b24ab676SJeff Bonwick 
3908bf16b11eSMatthew Ahrens 		ddt_stat_add(&ddh_total.ddh_stat[highbit64(refcnt) - 1],
3909bf16b11eSMatthew Ahrens 		    &dds, 0);
3910b24ab676SJeff Bonwick 
3911b24ab676SJeff Bonwick 		umem_free(zdde, sizeof (*zdde));
3912b24ab676SJeff Bonwick 	}
3913b24ab676SJeff Bonwick 
3914b24ab676SJeff Bonwick 	avl_destroy(&t);
3915b24ab676SJeff Bonwick 
3916b24ab676SJeff Bonwick 	ddt_histogram_stat(&dds_total, &ddh_total);
3917b24ab676SJeff Bonwick 
3918b24ab676SJeff Bonwick 	(void) printf("Simulated DDT histogram:\n");
3919b24ab676SJeff Bonwick 
39209eb19f4dSGeorge Wilson 	zpool_dump_ddt(&dds_total, &ddh_total);
3921b24ab676SJeff Bonwick 
3922b24ab676SJeff Bonwick 	dump_dedup_ratio(&dds_total);
3923b24ab676SJeff Bonwick }
3924b24ab676SJeff Bonwick 
39255cabbc6bSPrashanth Sreenivasa static int
39265cabbc6bSPrashanth Sreenivasa verify_device_removal_feature_counts(spa_t *spa)
39275cabbc6bSPrashanth Sreenivasa {
39285cabbc6bSPrashanth Sreenivasa 	uint64_t dr_feature_refcount = 0;
39295cabbc6bSPrashanth Sreenivasa 	uint64_t oc_feature_refcount = 0;
39305cabbc6bSPrashanth Sreenivasa 	uint64_t indirect_vdev_count = 0;
39315cabbc6bSPrashanth Sreenivasa 	uint64_t precise_vdev_count = 0;
39325cabbc6bSPrashanth Sreenivasa 	uint64_t obsolete_counts_object_count = 0;
39335cabbc6bSPrashanth Sreenivasa 	uint64_t obsolete_sm_count = 0;
39345cabbc6bSPrashanth Sreenivasa 	uint64_t obsolete_counts_count = 0;
39355cabbc6bSPrashanth Sreenivasa 	uint64_t scip_count = 0;
39365cabbc6bSPrashanth Sreenivasa 	uint64_t obsolete_bpobj_count = 0;
39375cabbc6bSPrashanth Sreenivasa 	int ret = 0;
39385cabbc6bSPrashanth Sreenivasa 
39395cabbc6bSPrashanth Sreenivasa 	spa_condensing_indirect_phys_t *scip =
39405cabbc6bSPrashanth Sreenivasa 	    &spa->spa_condensing_indirect_phys;
39415cabbc6bSPrashanth Sreenivasa 	if (scip->scip_next_mapping_object != 0) {
39425cabbc6bSPrashanth Sreenivasa 		vdev_t *vd = spa->spa_root_vdev->vdev_child[scip->scip_vdev];
39435cabbc6bSPrashanth Sreenivasa 		ASSERT(scip->scip_prev_obsolete_sm_object != 0);
39445cabbc6bSPrashanth Sreenivasa 		ASSERT3P(vd->vdev_ops, ==, &vdev_indirect_ops);
39455cabbc6bSPrashanth Sreenivasa 
39465cabbc6bSPrashanth Sreenivasa 		(void) printf("Condensing indirect vdev %llu: new mapping "
39475cabbc6bSPrashanth Sreenivasa 		    "object %llu, prev obsolete sm %llu\n",
39485cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)scip->scip_vdev,
39495cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)scip->scip_next_mapping_object,
39505cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)scip->scip_prev_obsolete_sm_object);
39515cabbc6bSPrashanth Sreenivasa 		if (scip->scip_prev_obsolete_sm_object != 0) {
39525cabbc6bSPrashanth Sreenivasa 			space_map_t *prev_obsolete_sm = NULL;
39535cabbc6bSPrashanth Sreenivasa 			VERIFY0(space_map_open(&prev_obsolete_sm,
39545cabbc6bSPrashanth Sreenivasa 			    spa->spa_meta_objset,
39555cabbc6bSPrashanth Sreenivasa 			    scip->scip_prev_obsolete_sm_object,
39565cabbc6bSPrashanth Sreenivasa 			    0, vd->vdev_asize, 0));
39575cabbc6bSPrashanth Sreenivasa 			space_map_update(prev_obsolete_sm);
39585cabbc6bSPrashanth Sreenivasa 			dump_spacemap(spa->spa_meta_objset, prev_obsolete_sm);
39595cabbc6bSPrashanth Sreenivasa 			(void) printf("\n");
39605cabbc6bSPrashanth Sreenivasa 			space_map_close(prev_obsolete_sm);
39615cabbc6bSPrashanth Sreenivasa 		}
39625cabbc6bSPrashanth Sreenivasa 
39635cabbc6bSPrashanth Sreenivasa 		scip_count += 2;
39645cabbc6bSPrashanth Sreenivasa 	}
39655cabbc6bSPrashanth Sreenivasa 
39665cabbc6bSPrashanth Sreenivasa 	for (uint64_t i = 0; i < spa->spa_root_vdev->vdev_children; i++) {
39675cabbc6bSPrashanth Sreenivasa 		vdev_t *vd = spa->spa_root_vdev->vdev_child[i];
39685cabbc6bSPrashanth Sreenivasa 		vdev_indirect_config_t *vic = &vd->vdev_indirect_config;
39695cabbc6bSPrashanth Sreenivasa 
39705cabbc6bSPrashanth Sreenivasa 		if (vic->vic_mapping_object != 0) {
39715cabbc6bSPrashanth Sreenivasa 			ASSERT(vd->vdev_ops == &vdev_indirect_ops ||
39725cabbc6bSPrashanth Sreenivasa 			    vd->vdev_removing);
39735cabbc6bSPrashanth Sreenivasa 			indirect_vdev_count++;
39745cabbc6bSPrashanth Sreenivasa 
39755cabbc6bSPrashanth Sreenivasa 			if (vd->vdev_indirect_mapping->vim_havecounts) {
39765cabbc6bSPrashanth Sreenivasa 				obsolete_counts_count++;
39775cabbc6bSPrashanth Sreenivasa 			}
39785cabbc6bSPrashanth Sreenivasa 		}
39795cabbc6bSPrashanth Sreenivasa 		if (vdev_obsolete_counts_are_precise(vd)) {
39805cabbc6bSPrashanth Sreenivasa 			ASSERT(vic->vic_mapping_object != 0);
39815cabbc6bSPrashanth Sreenivasa 			precise_vdev_count++;
39825cabbc6bSPrashanth Sreenivasa 		}
39835cabbc6bSPrashanth Sreenivasa 		if (vdev_obsolete_sm_object(vd) != 0) {
39845cabbc6bSPrashanth Sreenivasa 			ASSERT(vic->vic_mapping_object != 0);
39855cabbc6bSPrashanth Sreenivasa 			obsolete_sm_count++;
39865cabbc6bSPrashanth Sreenivasa 		}
39875cabbc6bSPrashanth Sreenivasa 	}
39885cabbc6bSPrashanth Sreenivasa 
39895cabbc6bSPrashanth Sreenivasa 	(void) feature_get_refcount(spa,
39905cabbc6bSPrashanth Sreenivasa 	    &spa_feature_table[SPA_FEATURE_DEVICE_REMOVAL],
39915cabbc6bSPrashanth Sreenivasa 	    &dr_feature_refcount);
39925cabbc6bSPrashanth Sreenivasa 	(void) feature_get_refcount(spa,
39935cabbc6bSPrashanth Sreenivasa 	    &spa_feature_table[SPA_FEATURE_OBSOLETE_COUNTS],
39945cabbc6bSPrashanth Sreenivasa 	    &oc_feature_refcount);
39955cabbc6bSPrashanth Sreenivasa 
39965cabbc6bSPrashanth Sreenivasa 	if (dr_feature_refcount != indirect_vdev_count) {
39975cabbc6bSPrashanth Sreenivasa 		ret = 1;
39985cabbc6bSPrashanth Sreenivasa 		(void) printf("Number of indirect vdevs (%llu) " \
39995cabbc6bSPrashanth Sreenivasa 		    "does not match feature count (%llu)\n",
40005cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)indirect_vdev_count,
40015cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)dr_feature_refcount);
40025cabbc6bSPrashanth Sreenivasa 	} else {
40035cabbc6bSPrashanth Sreenivasa 		(void) printf("Verified device_removal feature refcount " \
40045cabbc6bSPrashanth Sreenivasa 		    "of %llu is correct\n",
40055cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)dr_feature_refcount);
40065cabbc6bSPrashanth Sreenivasa 	}
40075cabbc6bSPrashanth Sreenivasa 
40085cabbc6bSPrashanth Sreenivasa 	if (zap_contains(spa_meta_objset(spa), DMU_POOL_DIRECTORY_OBJECT,
40095cabbc6bSPrashanth Sreenivasa 	    DMU_POOL_OBSOLETE_BPOBJ) == 0) {
40105cabbc6bSPrashanth Sreenivasa 		obsolete_bpobj_count++;
40115cabbc6bSPrashanth Sreenivasa 	}
40125cabbc6bSPrashanth Sreenivasa 
40135cabbc6bSPrashanth Sreenivasa 
40145cabbc6bSPrashanth Sreenivasa 	obsolete_counts_object_count = precise_vdev_count;
40155cabbc6bSPrashanth Sreenivasa 	obsolete_counts_object_count += obsolete_sm_count;
40165cabbc6bSPrashanth Sreenivasa 	obsolete_counts_object_count += obsolete_counts_count;
40175cabbc6bSPrashanth Sreenivasa 	obsolete_counts_object_count += scip_count;
40185cabbc6bSPrashanth Sreenivasa 	obsolete_counts_object_count += obsolete_bpobj_count;
40195cabbc6bSPrashanth Sreenivasa 	obsolete_counts_object_count += remap_deadlist_count;
40205cabbc6bSPrashanth Sreenivasa 
40215cabbc6bSPrashanth Sreenivasa 	if (oc_feature_refcount != obsolete_counts_object_count) {
40225cabbc6bSPrashanth Sreenivasa 		ret = 1;
40235cabbc6bSPrashanth Sreenivasa 		(void) printf("Number of obsolete counts objects (%llu) " \
40245cabbc6bSPrashanth Sreenivasa 		    "does not match feature count (%llu)\n",
40255cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)obsolete_counts_object_count,
40265cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)oc_feature_refcount);
40275cabbc6bSPrashanth Sreenivasa 		(void) printf("pv:%llu os:%llu oc:%llu sc:%llu "
40285cabbc6bSPrashanth Sreenivasa 		    "ob:%llu rd:%llu\n",
40295cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)precise_vdev_count,
40305cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)obsolete_sm_count,
40315cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)obsolete_counts_count,
40325cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)scip_count,
40335cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)obsolete_bpobj_count,
40345cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)remap_deadlist_count);
40355cabbc6bSPrashanth Sreenivasa 	} else {
40365cabbc6bSPrashanth Sreenivasa 		(void) printf("Verified indirect_refcount feature refcount " \
40375cabbc6bSPrashanth Sreenivasa 		    "of %llu is correct\n",
40385cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)oc_feature_refcount);
40395cabbc6bSPrashanth Sreenivasa 	}
40405cabbc6bSPrashanth Sreenivasa 	return (ret);
40415cabbc6bSPrashanth Sreenivasa }
40425cabbc6bSPrashanth Sreenivasa 
404386714001SSerapheim Dimitropoulos #define	BOGUS_SUFFIX "_CHECKPOINTED_UNIVERSE"
404486714001SSerapheim Dimitropoulos /*
404586714001SSerapheim Dimitropoulos  * Import the checkpointed state of the pool specified by the target
404686714001SSerapheim Dimitropoulos  * parameter as readonly. The function also accepts a pool config
404786714001SSerapheim Dimitropoulos  * as an optional parameter, else it attempts to infer the config by
404886714001SSerapheim Dimitropoulos  * the name of the target pool.
404986714001SSerapheim Dimitropoulos  *
405086714001SSerapheim Dimitropoulos  * Note that the checkpointed state's pool name will be the name of
405186714001SSerapheim Dimitropoulos  * the original pool with the above suffix appened to it. In addition,
405286714001SSerapheim Dimitropoulos  * if the target is not a pool name (e.g. a path to a dataset) then
405386714001SSerapheim Dimitropoulos  * the new_path parameter is populated with the updated path to
405486714001SSerapheim Dimitropoulos  * reflect the fact that we are looking into the checkpointed state.
405586714001SSerapheim Dimitropoulos  *
405686714001SSerapheim Dimitropoulos  * The function returns a newly-allocated copy of the name of the
405786714001SSerapheim Dimitropoulos  * pool containing the checkpointed state. When this copy is no
405886714001SSerapheim Dimitropoulos  * longer needed it should be freed with free(3C). Same thing
405986714001SSerapheim Dimitropoulos  * applies to the new_path parameter if allocated.
406086714001SSerapheim Dimitropoulos  */
406186714001SSerapheim Dimitropoulos static char *
406286714001SSerapheim Dimitropoulos import_checkpointed_state(char *target, nvlist_t *cfg, char **new_path)
406386714001SSerapheim Dimitropoulos {
406486714001SSerapheim Dimitropoulos 	int error = 0;
406586714001SSerapheim Dimitropoulos 	char *poolname, *bogus_name;
406686714001SSerapheim Dimitropoulos 
406786714001SSerapheim Dimitropoulos 	/* If the target is not a pool, the extract the pool name */
406886714001SSerapheim Dimitropoulos 	char *path_start = strchr(target, '/');
406986714001SSerapheim Dimitropoulos 	if (path_start != NULL) {
407086714001SSerapheim Dimitropoulos 		size_t poolname_len = path_start - target;
407186714001SSerapheim Dimitropoulos 		poolname = strndup(target, poolname_len);
407286714001SSerapheim Dimitropoulos 	} else {
407386714001SSerapheim Dimitropoulos 		poolname = target;
407486714001SSerapheim Dimitropoulos 	}
407586714001SSerapheim Dimitropoulos 
407686714001SSerapheim Dimitropoulos 	if (cfg == NULL) {
407786714001SSerapheim Dimitropoulos 		error = spa_get_stats(poolname, &cfg, NULL, 0);
407886714001SSerapheim Dimitropoulos 		if (error != 0) {
407986714001SSerapheim Dimitropoulos 			fatal("Tried to read config of pool \"%s\" but "
408086714001SSerapheim Dimitropoulos 			    "spa_get_stats() failed with error %d\n",
408186714001SSerapheim Dimitropoulos 			    poolname, error);
408286714001SSerapheim Dimitropoulos 		}
408386714001SSerapheim Dimitropoulos 	}
408486714001SSerapheim Dimitropoulos 
408586714001SSerapheim Dimitropoulos 	(void) asprintf(&bogus_name, "%s%s", poolname, BOGUS_SUFFIX);
408686714001SSerapheim Dimitropoulos 	fnvlist_add_string(cfg, ZPOOL_CONFIG_POOL_NAME, bogus_name);
408786714001SSerapheim Dimitropoulos 
408886714001SSerapheim Dimitropoulos 	error = spa_import(bogus_name, cfg, NULL,
408986714001SSerapheim Dimitropoulos 	    ZFS_IMPORT_MISSING_LOG | ZFS_IMPORT_CHECKPOINT);
409086714001SSerapheim Dimitropoulos 	if (error != 0) {
409186714001SSerapheim Dimitropoulos 		fatal("Tried to import pool \"%s\" but spa_import() failed "
409286714001SSerapheim Dimitropoulos 		    "with error %d\n", bogus_name, error);
409386714001SSerapheim Dimitropoulos 	}
409486714001SSerapheim Dimitropoulos 
409586714001SSerapheim Dimitropoulos 	if (new_path != NULL && path_start != NULL)
409686714001SSerapheim Dimitropoulos 		(void) asprintf(new_path, "%s%s", bogus_name, path_start);
409786714001SSerapheim Dimitropoulos 
409886714001SSerapheim Dimitropoulos 	if (target != poolname)
409986714001SSerapheim Dimitropoulos 		free(poolname);
410086714001SSerapheim Dimitropoulos 
410186714001SSerapheim Dimitropoulos 	return (bogus_name);
410286714001SSerapheim Dimitropoulos }
410386714001SSerapheim Dimitropoulos 
410486714001SSerapheim Dimitropoulos typedef struct verify_checkpoint_sm_entry_cb_arg {
410586714001SSerapheim Dimitropoulos 	vdev_t *vcsec_vd;
410686714001SSerapheim Dimitropoulos 
410786714001SSerapheim Dimitropoulos 	/* the following fields are only used for printing progress */
410886714001SSerapheim Dimitropoulos 	uint64_t vcsec_entryid;
410986714001SSerapheim Dimitropoulos 	uint64_t vcsec_num_entries;
411086714001SSerapheim Dimitropoulos } verify_checkpoint_sm_entry_cb_arg_t;
411186714001SSerapheim Dimitropoulos 
411286714001SSerapheim Dimitropoulos #define	ENTRIES_PER_PROGRESS_UPDATE 10000
411386714001SSerapheim Dimitropoulos 
411486714001SSerapheim Dimitropoulos static int
4115*17f11284SSerapheim Dimitropoulos verify_checkpoint_sm_entry_cb(space_map_entry_t *sme, void *arg)
411686714001SSerapheim Dimitropoulos {
411786714001SSerapheim Dimitropoulos 	verify_checkpoint_sm_entry_cb_arg_t *vcsec = arg;
411886714001SSerapheim Dimitropoulos 	vdev_t *vd = vcsec->vcsec_vd;
4119*17f11284SSerapheim Dimitropoulos 	metaslab_t *ms = vd->vdev_ms[sme->sme_offset >> vd->vdev_ms_shift];
4120*17f11284SSerapheim Dimitropoulos 	uint64_t end = sme->sme_offset + sme->sme_run;
412186714001SSerapheim Dimitropoulos 
4122*17f11284SSerapheim Dimitropoulos 	ASSERT(sme->sme_type == SM_FREE);
412386714001SSerapheim Dimitropoulos 
412486714001SSerapheim Dimitropoulos 	if ((vcsec->vcsec_entryid % ENTRIES_PER_PROGRESS_UPDATE) == 0) {
412586714001SSerapheim Dimitropoulos 		(void) fprintf(stderr,
412686714001SSerapheim Dimitropoulos 		    "\rverifying vdev %llu, space map entry %llu of %llu ...",
412786714001SSerapheim Dimitropoulos 		    (longlong_t)vd->vdev_id,
412886714001SSerapheim Dimitropoulos 		    (longlong_t)vcsec->vcsec_entryid,
412986714001SSerapheim Dimitropoulos 		    (longlong_t)vcsec->vcsec_num_entries);
413086714001SSerapheim Dimitropoulos 	}
413186714001SSerapheim Dimitropoulos 	vcsec->vcsec_entryid++;
413286714001SSerapheim Dimitropoulos 
413386714001SSerapheim Dimitropoulos 	/*
413486714001SSerapheim Dimitropoulos 	 * See comment in checkpoint_sm_exclude_entry_cb()
413586714001SSerapheim Dimitropoulos 	 */
4136*17f11284SSerapheim Dimitropoulos 	VERIFY3U(sme->sme_offset, >=, ms->ms_start);
413786714001SSerapheim Dimitropoulos 	VERIFY3U(end, <=, ms->ms_start + ms->ms_size);
413886714001SSerapheim Dimitropoulos 
413986714001SSerapheim Dimitropoulos 	/*
414086714001SSerapheim Dimitropoulos 	 * The entries in the vdev_checkpoint_sm should be marked as
414186714001SSerapheim Dimitropoulos 	 * allocated in the checkpointed state of the pool, therefore
414286714001SSerapheim Dimitropoulos 	 * their respective ms_allocateable trees should not contain them.
414386714001SSerapheim Dimitropoulos 	 */
414486714001SSerapheim Dimitropoulos 	mutex_enter(&ms->ms_lock);
4145*17f11284SSerapheim Dimitropoulos 	range_tree_verify(ms->ms_allocatable, sme->sme_offset, sme->sme_run);
414686714001SSerapheim Dimitropoulos 	mutex_exit(&ms->ms_lock);
414786714001SSerapheim Dimitropoulos 
414886714001SSerapheim Dimitropoulos 	return (0);
414986714001SSerapheim Dimitropoulos }
415086714001SSerapheim Dimitropoulos 
415186714001SSerapheim Dimitropoulos /*
415286714001SSerapheim Dimitropoulos  * Verify that all segments in the vdev_checkpoint_sm are allocated
415386714001SSerapheim Dimitropoulos  * according to the checkpoint's ms_sm (i.e. are not in the checkpoint's
415486714001SSerapheim Dimitropoulos  * ms_allocatable).
415586714001SSerapheim Dimitropoulos  *
415686714001SSerapheim Dimitropoulos  * Do so by comparing the checkpoint space maps (vdev_checkpoint_sm) of
415786714001SSerapheim Dimitropoulos  * each vdev in the current state of the pool to the metaslab space maps
415886714001SSerapheim Dimitropoulos  * (ms_sm) of the checkpointed state of the pool.
415986714001SSerapheim Dimitropoulos  *
416086714001SSerapheim Dimitropoulos  * Note that the function changes the state of the ms_allocatable
416186714001SSerapheim Dimitropoulos  * trees of the current spa_t. The entries of these ms_allocatable
416286714001SSerapheim Dimitropoulos  * trees are cleared out and then repopulated from with the free
416386714001SSerapheim Dimitropoulos  * entries of their respective ms_sm space maps.
416486714001SSerapheim Dimitropoulos  */
416586714001SSerapheim Dimitropoulos static void
416686714001SSerapheim Dimitropoulos verify_checkpoint_vdev_spacemaps(spa_t *checkpoint, spa_t *current)
416786714001SSerapheim Dimitropoulos {
416886714001SSerapheim Dimitropoulos 	vdev_t *ckpoint_rvd = checkpoint->spa_root_vdev;
416986714001SSerapheim Dimitropoulos 	vdev_t *current_rvd = current->spa_root_vdev;
417086714001SSerapheim Dimitropoulos 
417186714001SSerapheim Dimitropoulos 	load_concrete_ms_allocatable_trees(checkpoint, SM_FREE);
417286714001SSerapheim Dimitropoulos 
417386714001SSerapheim Dimitropoulos 	for (uint64_t c = 0; c < ckpoint_rvd->vdev_children; c++) {
417486714001SSerapheim Dimitropoulos 		vdev_t *ckpoint_vd = ckpoint_rvd->vdev_child[c];
417586714001SSerapheim Dimitropoulos 		vdev_t *current_vd = current_rvd->vdev_child[c];
417686714001SSerapheim Dimitropoulos 
417786714001SSerapheim Dimitropoulos 		space_map_t *checkpoint_sm = NULL;
417886714001SSerapheim Dimitropoulos 		uint64_t checkpoint_sm_obj;
417986714001SSerapheim Dimitropoulos 
418086714001SSerapheim Dimitropoulos 		if (ckpoint_vd->vdev_ops == &vdev_indirect_ops) {
418186714001SSerapheim Dimitropoulos 			/*
418286714001SSerapheim Dimitropoulos 			 * Since we don't allow device removal in a pool
418386714001SSerapheim Dimitropoulos 			 * that has a checkpoint, we expect that all removed
418486714001SSerapheim Dimitropoulos 			 * vdevs were removed from the pool before the
418586714001SSerapheim Dimitropoulos 			 * checkpoint.
418686714001SSerapheim Dimitropoulos 			 */
418786714001SSerapheim Dimitropoulos 			ASSERT3P(current_vd->vdev_ops, ==, &vdev_indirect_ops);
418886714001SSerapheim Dimitropoulos 			continue;
418986714001SSerapheim Dimitropoulos 		}
419086714001SSerapheim Dimitropoulos 
419186714001SSerapheim Dimitropoulos 		/*
419286714001SSerapheim Dimitropoulos 		 * If the checkpoint space map doesn't exist, then nothing
419386714001SSerapheim Dimitropoulos 		 * here is checkpointed so there's nothing to verify.
419486714001SSerapheim Dimitropoulos 		 */
419586714001SSerapheim Dimitropoulos 		if (current_vd->vdev_top_zap == 0 ||
419686714001SSerapheim Dimitropoulos 		    zap_contains(spa_meta_objset(current),
419786714001SSerapheim Dimitropoulos 		    current_vd->vdev_top_zap,
419886714001SSerapheim Dimitropoulos 		    VDEV_TOP_ZAP_POOL_CHECKPOINT_SM) != 0)
419986714001SSerapheim Dimitropoulos 			continue;
420086714001SSerapheim Dimitropoulos 
420186714001SSerapheim Dimitropoulos 		VERIFY0(zap_lookup(spa_meta_objset(current),
420286714001SSerapheim Dimitropoulos 		    current_vd->vdev_top_zap, VDEV_TOP_ZAP_POOL_CHECKPOINT_SM,
420386714001SSerapheim Dimitropoulos 		    sizeof (uint64_t), 1, &checkpoint_sm_obj));
420486714001SSerapheim Dimitropoulos 
420586714001SSerapheim Dimitropoulos 		VERIFY0(space_map_open(&checkpoint_sm, spa_meta_objset(current),
420686714001SSerapheim Dimitropoulos 		    checkpoint_sm_obj, 0, current_vd->vdev_asize,
420786714001SSerapheim Dimitropoulos 		    current_vd->vdev_ashift));
420886714001SSerapheim Dimitropoulos 		space_map_update(checkpoint_sm);
420986714001SSerapheim Dimitropoulos 
421086714001SSerapheim Dimitropoulos 		verify_checkpoint_sm_entry_cb_arg_t vcsec;
421186714001SSerapheim Dimitropoulos 		vcsec.vcsec_vd = ckpoint_vd;
421286714001SSerapheim Dimitropoulos 		vcsec.vcsec_entryid = 0;
421386714001SSerapheim Dimitropoulos 		vcsec.vcsec_num_entries =
421486714001SSerapheim Dimitropoulos 		    space_map_length(checkpoint_sm) / sizeof (uint64_t);
421586714001SSerapheim Dimitropoulos 		VERIFY0(space_map_iterate(checkpoint_sm,
421686714001SSerapheim Dimitropoulos 		    verify_checkpoint_sm_entry_cb, &vcsec));
421786714001SSerapheim Dimitropoulos 		dump_spacemap(current->spa_meta_objset, checkpoint_sm);
421886714001SSerapheim Dimitropoulos 		space_map_close(checkpoint_sm);
421986714001SSerapheim Dimitropoulos 	}
422086714001SSerapheim Dimitropoulos 
422186714001SSerapheim Dimitropoulos 	/*
422286714001SSerapheim Dimitropoulos 	 * If we've added vdevs since we took the checkpoint, ensure
422386714001SSerapheim Dimitropoulos 	 * that their checkpoint space maps are empty.
422486714001SSerapheim Dimitropoulos 	 */
422586714001SSerapheim Dimitropoulos 	if (ckpoint_rvd->vdev_children < current_rvd->vdev_children) {
422686714001SSerapheim Dimitropoulos 		for (uint64_t c = ckpoint_rvd->vdev_children;
422786714001SSerapheim Dimitropoulos 		    c < current_rvd->vdev_children; c++) {
422886714001SSerapheim Dimitropoulos 			vdev_t *current_vd = current_rvd->vdev_child[c];
422986714001SSerapheim Dimitropoulos 			ASSERT3P(current_vd->vdev_checkpoint_sm, ==, NULL);
423086714001SSerapheim Dimitropoulos 		}
423186714001SSerapheim Dimitropoulos 	}
423286714001SSerapheim Dimitropoulos 
423386714001SSerapheim Dimitropoulos 	/* for cleaner progress output */
423486714001SSerapheim Dimitropoulos 	(void) fprintf(stderr, "\n");
423586714001SSerapheim Dimitropoulos }
423686714001SSerapheim Dimitropoulos 
423786714001SSerapheim Dimitropoulos /*
423886714001SSerapheim Dimitropoulos  * Verifies that all space that's allocated in the checkpoint is
423986714001SSerapheim Dimitropoulos  * still allocated in the current version, by checking that everything
424086714001SSerapheim Dimitropoulos  * in checkpoint's ms_allocatable (which is actually allocated, not
424186714001SSerapheim Dimitropoulos  * allocatable/free) is not present in current's ms_allocatable.
424286714001SSerapheim Dimitropoulos  *
424386714001SSerapheim Dimitropoulos  * Note that the function changes the state of the ms_allocatable
424486714001SSerapheim Dimitropoulos  * trees of both spas when called. The entries of all ms_allocatable
424586714001SSerapheim Dimitropoulos  * trees are cleared out and then repopulated from their respective
424686714001SSerapheim Dimitropoulos  * ms_sm space maps. In the checkpointed state we load the allocated
424786714001SSerapheim Dimitropoulos  * entries, and in the current state we load the free entries.
424886714001SSerapheim Dimitropoulos  */
424986714001SSerapheim Dimitropoulos static void
425086714001SSerapheim Dimitropoulos verify_checkpoint_ms_spacemaps(spa_t *checkpoint, spa_t *current)
425186714001SSerapheim Dimitropoulos {
425286714001SSerapheim Dimitropoulos 	vdev_t *ckpoint_rvd = checkpoint->spa_root_vdev;
425386714001SSerapheim Dimitropoulos 	vdev_t *current_rvd = current->spa_root_vdev;
425486714001SSerapheim Dimitropoulos 
425586714001SSerapheim Dimitropoulos 	load_concrete_ms_allocatable_trees(checkpoint, SM_ALLOC);
425686714001SSerapheim Dimitropoulos 	load_concrete_ms_allocatable_trees(current, SM_FREE);
425786714001SSerapheim Dimitropoulos 
425886714001SSerapheim Dimitropoulos 	for (uint64_t i = 0; i < ckpoint_rvd->vdev_children; i++) {
425986714001SSerapheim Dimitropoulos 		vdev_t *ckpoint_vd = ckpoint_rvd->vdev_child[i];
426086714001SSerapheim Dimitropoulos 		vdev_t *current_vd = current_rvd->vdev_child[i];
426186714001SSerapheim Dimitropoulos 
426286714001SSerapheim Dimitropoulos 		if (ckpoint_vd->vdev_ops == &vdev_indirect_ops) {
426386714001SSerapheim Dimitropoulos 			/*
426486714001SSerapheim Dimitropoulos 			 * See comment in verify_checkpoint_vdev_spacemaps()
426586714001SSerapheim Dimitropoulos 			 */
426686714001SSerapheim Dimitropoulos 			ASSERT3P(current_vd->vdev_ops, ==, &vdev_indirect_ops);
426786714001SSerapheim Dimitropoulos 			continue;
426886714001SSerapheim Dimitropoulos 		}
426986714001SSerapheim Dimitropoulos 
427086714001SSerapheim Dimitropoulos 		for (uint64_t m = 0; m < ckpoint_vd->vdev_ms_count; m++) {
427186714001SSerapheim Dimitropoulos 			metaslab_t *ckpoint_msp = ckpoint_vd->vdev_ms[m];
427286714001SSerapheim Dimitropoulos 			metaslab_t *current_msp = current_vd->vdev_ms[m];
427386714001SSerapheim Dimitropoulos 
427486714001SSerapheim Dimitropoulos 			(void) fprintf(stderr,
427586714001SSerapheim Dimitropoulos 			    "\rverifying vdev %llu of %llu, "
427686714001SSerapheim Dimitropoulos 			    "metaslab %llu of %llu ...",
427786714001SSerapheim Dimitropoulos 			    (longlong_t)current_vd->vdev_id,
427886714001SSerapheim Dimitropoulos 			    (longlong_t)current_rvd->vdev_children,
427986714001SSerapheim Dimitropoulos 			    (longlong_t)current_vd->vdev_ms[m]->ms_id,
428086714001SSerapheim Dimitropoulos 			    (longlong_t)current_vd->vdev_ms_count);
428186714001SSerapheim Dimitropoulos 
428286714001SSerapheim Dimitropoulos 			/*
428386714001SSerapheim Dimitropoulos 			 * We walk through the ms_allocatable trees that
428486714001SSerapheim Dimitropoulos 			 * are loaded with the allocated blocks from the
428586714001SSerapheim Dimitropoulos 			 * ms_sm spacemaps of the checkpoint. For each
428686714001SSerapheim Dimitropoulos 			 * one of these ranges we ensure that none of them
428786714001SSerapheim Dimitropoulos 			 * exists in the ms_allocatable trees of the
428886714001SSerapheim Dimitropoulos 			 * current state which are loaded with the ranges
428986714001SSerapheim Dimitropoulos 			 * that are currently free.
429086714001SSerapheim Dimitropoulos 			 *
429186714001SSerapheim Dimitropoulos 			 * This way we ensure that none of the blocks that
429286714001SSerapheim Dimitropoulos 			 * are part of the checkpoint were freed by mistake.
429386714001SSerapheim Dimitropoulos 			 */
429486714001SSerapheim Dimitropoulos 			range_tree_walk(ckpoint_msp->ms_allocatable,
429586714001SSerapheim Dimitropoulos 			    (range_tree_func_t *)range_tree_verify,
429686714001SSerapheim Dimitropoulos 			    current_msp->ms_allocatable);
429786714001SSerapheim Dimitropoulos 		}
429886714001SSerapheim Dimitropoulos 	}
429986714001SSerapheim Dimitropoulos 
430086714001SSerapheim Dimitropoulos 	/* for cleaner progress output */
430186714001SSerapheim Dimitropoulos 	(void) fprintf(stderr, "\n");
430286714001SSerapheim Dimitropoulos }
430386714001SSerapheim Dimitropoulos 
430486714001SSerapheim Dimitropoulos static void
430586714001SSerapheim Dimitropoulos verify_checkpoint_blocks(spa_t *spa)
430686714001SSerapheim Dimitropoulos {
430786714001SSerapheim Dimitropoulos 	spa_t *checkpoint_spa;
430886714001SSerapheim Dimitropoulos 	char *checkpoint_pool;
430986714001SSerapheim Dimitropoulos 	nvlist_t *config = NULL;
431086714001SSerapheim Dimitropoulos 	int error = 0;
431186714001SSerapheim Dimitropoulos 
431286714001SSerapheim Dimitropoulos 	/*
431386714001SSerapheim Dimitropoulos 	 * We import the checkpointed state of the pool (under a different
431486714001SSerapheim Dimitropoulos 	 * name) so we can do verification on it against the current state
431586714001SSerapheim Dimitropoulos 	 * of the pool.
431686714001SSerapheim Dimitropoulos 	 */
431786714001SSerapheim Dimitropoulos 	checkpoint_pool = import_checkpointed_state(spa->spa_name, config,
431886714001SSerapheim Dimitropoulos 	    NULL);
431986714001SSerapheim Dimitropoulos 	ASSERT(strcmp(spa->spa_name, checkpoint_pool) != 0);
432086714001SSerapheim Dimitropoulos 
432186714001SSerapheim Dimitropoulos 	error = spa_open(checkpoint_pool, &checkpoint_spa, FTAG);
432286714001SSerapheim Dimitropoulos 	if (error != 0) {
432386714001SSerapheim Dimitropoulos 		fatal("Tried to open pool \"%s\" but spa_open() failed with "
432486714001SSerapheim Dimitropoulos 		    "error %d\n", checkpoint_pool, error);
432586714001SSerapheim Dimitropoulos 	}
432686714001SSerapheim Dimitropoulos 
432786714001SSerapheim Dimitropoulos 	/*
432886714001SSerapheim Dimitropoulos 	 * Ensure that ranges in the checkpoint space maps of each vdev
432986714001SSerapheim Dimitropoulos 	 * are allocated according to the checkpointed state's metaslab
433086714001SSerapheim Dimitropoulos 	 * space maps.
433186714001SSerapheim Dimitropoulos 	 */
433286714001SSerapheim Dimitropoulos 	verify_checkpoint_vdev_spacemaps(checkpoint_spa, spa);
433386714001SSerapheim Dimitropoulos 
433486714001SSerapheim Dimitropoulos 	/*
433586714001SSerapheim Dimitropoulos 	 * Ensure that allocated ranges in the checkpoint's metaslab
433686714001SSerapheim Dimitropoulos 	 * space maps remain allocated in the metaslab space maps of
433786714001SSerapheim Dimitropoulos 	 * the current state.
433886714001SSerapheim Dimitropoulos 	 */
433986714001SSerapheim Dimitropoulos 	verify_checkpoint_ms_spacemaps(checkpoint_spa, spa);
434086714001SSerapheim Dimitropoulos 
434186714001SSerapheim Dimitropoulos 	/*
434286714001SSerapheim Dimitropoulos 	 * Once we are done, we get rid of the checkpointed state.
434386714001SSerapheim Dimitropoulos 	 */
434486714001SSerapheim Dimitropoulos 	spa_close(checkpoint_spa, FTAG);
434586714001SSerapheim Dimitropoulos 	free(checkpoint_pool);
434686714001SSerapheim Dimitropoulos }
434786714001SSerapheim Dimitropoulos 
434886714001SSerapheim Dimitropoulos static void
434986714001SSerapheim Dimitropoulos dump_leftover_checkpoint_blocks(spa_t *spa)
435086714001SSerapheim Dimitropoulos {
435186714001SSerapheim Dimitropoulos 	vdev_t *rvd = spa->spa_root_vdev;
435286714001SSerapheim Dimitropoulos 
435386714001SSerapheim Dimitropoulos 	for (uint64_t i = 0; i < rvd->vdev_children; i++) {
435486714001SSerapheim Dimitropoulos 		vdev_t *vd = rvd->vdev_child[i];
435586714001SSerapheim Dimitropoulos 
435686714001SSerapheim Dimitropoulos 		space_map_t *checkpoint_sm = NULL;
435786714001SSerapheim Dimitropoulos 		uint64_t checkpoint_sm_obj;
435886714001SSerapheim Dimitropoulos 
435986714001SSerapheim Dimitropoulos 		if (vd->vdev_top_zap == 0)
436086714001SSerapheim Dimitropoulos 			continue;
436186714001SSerapheim Dimitropoulos 
436286714001SSerapheim Dimitropoulos 		if (zap_contains(spa_meta_objset(spa), vd->vdev_top_zap,
436386714001SSerapheim Dimitropoulos 		    VDEV_TOP_ZAP_POOL_CHECKPOINT_SM) != 0)
436486714001SSerapheim Dimitropoulos 			continue;
436586714001SSerapheim Dimitropoulos 
436686714001SSerapheim Dimitropoulos 		VERIFY0(zap_lookup(spa_meta_objset(spa), vd->vdev_top_zap,
436786714001SSerapheim Dimitropoulos 		    VDEV_TOP_ZAP_POOL_CHECKPOINT_SM,
436886714001SSerapheim Dimitropoulos 		    sizeof (uint64_t), 1, &checkpoint_sm_obj));
436986714001SSerapheim Dimitropoulos 
437086714001SSerapheim Dimitropoulos 		VERIFY0(space_map_open(&checkpoint_sm, spa_meta_objset(spa),
437186714001SSerapheim Dimitropoulos 		    checkpoint_sm_obj, 0, vd->vdev_asize, vd->vdev_ashift));
437286714001SSerapheim Dimitropoulos 		space_map_update(checkpoint_sm);
437386714001SSerapheim Dimitropoulos 		dump_spacemap(spa->spa_meta_objset, checkpoint_sm);
437486714001SSerapheim Dimitropoulos 		space_map_close(checkpoint_sm);
437586714001SSerapheim Dimitropoulos 	}
437686714001SSerapheim Dimitropoulos }
437786714001SSerapheim Dimitropoulos 
437886714001SSerapheim Dimitropoulos static int
437986714001SSerapheim Dimitropoulos verify_checkpoint(spa_t *spa)
438086714001SSerapheim Dimitropoulos {
438186714001SSerapheim Dimitropoulos 	uberblock_t checkpoint;
438286714001SSerapheim Dimitropoulos 	int error;
438386714001SSerapheim Dimitropoulos 
438486714001SSerapheim Dimitropoulos 	if (!spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT))
438586714001SSerapheim Dimitropoulos 		return (0);
438686714001SSerapheim Dimitropoulos 
438786714001SSerapheim Dimitropoulos 	error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
438886714001SSerapheim Dimitropoulos 	    DMU_POOL_ZPOOL_CHECKPOINT, sizeof (uint64_t),
438986714001SSerapheim Dimitropoulos 	    sizeof (uberblock_t) / sizeof (uint64_t), &checkpoint);
439086714001SSerapheim Dimitropoulos 
4391*17f11284SSerapheim Dimitropoulos 	if (error == ENOENT && !dump_opt['L']) {
439286714001SSerapheim Dimitropoulos 		/*
439386714001SSerapheim Dimitropoulos 		 * If the feature is active but the uberblock is missing
439486714001SSerapheim Dimitropoulos 		 * then we must be in the middle of discarding the
439586714001SSerapheim Dimitropoulos 		 * checkpoint.
439686714001SSerapheim Dimitropoulos 		 */
439786714001SSerapheim Dimitropoulos 		(void) printf("\nPartially discarded checkpoint "
439886714001SSerapheim Dimitropoulos 		    "state found:\n");
439986714001SSerapheim Dimitropoulos 		dump_leftover_checkpoint_blocks(spa);
440086714001SSerapheim Dimitropoulos 		return (0);
440186714001SSerapheim Dimitropoulos 	} else if (error != 0) {
440286714001SSerapheim Dimitropoulos 		(void) printf("lookup error %d when looking for "
440386714001SSerapheim Dimitropoulos 		    "checkpointed uberblock in MOS\n", error);
440486714001SSerapheim Dimitropoulos 		return (error);
440586714001SSerapheim Dimitropoulos 	}
440686714001SSerapheim Dimitropoulos 	dump_uberblock(&checkpoint, "\nCheckpointed uberblock found:\n", "\n");
440786714001SSerapheim Dimitropoulos 
440886714001SSerapheim Dimitropoulos 	if (checkpoint.ub_checkpoint_txg == 0) {
440986714001SSerapheim Dimitropoulos 		(void) printf("\nub_checkpoint_txg not set in checkpointed "
441086714001SSerapheim Dimitropoulos 		    "uberblock\n");
441186714001SSerapheim Dimitropoulos 		error = 3;
441286714001SSerapheim Dimitropoulos 	}
441386714001SSerapheim Dimitropoulos 
4414*17f11284SSerapheim Dimitropoulos 	if (error == 0 && !dump_opt['L'])
441586714001SSerapheim Dimitropoulos 		verify_checkpoint_blocks(spa);
441686714001SSerapheim Dimitropoulos 
441786714001SSerapheim Dimitropoulos 	return (error);
441886714001SSerapheim Dimitropoulos }
441986714001SSerapheim Dimitropoulos 
4420fa9e4066Sahrens static void
4421fa9e4066Sahrens dump_zpool(spa_t *spa)
4422fa9e4066Sahrens {
4423fa9e4066Sahrens 	dsl_pool_t *dp = spa_get_dsl(spa);
4424fa9e4066Sahrens 	int rc = 0;
4425fa9e4066Sahrens 
4426b24ab676SJeff Bonwick 	if (dump_opt['S']) {
4427b24ab676SJeff Bonwick 		dump_simulated_ddt(spa);
4428b24ab676SJeff Bonwick 		return;
4429b24ab676SJeff Bonwick 	}
4430b24ab676SJeff Bonwick 
443107428bdfSVictor Latushkin 	if (!dump_opt['e'] && dump_opt['C'] > 1) {
443207428bdfSVictor Latushkin 		(void) printf("\nCached configuration:\n");
443307428bdfSVictor Latushkin 		dump_nvlist(spa->spa_config, 8);
443407428bdfSVictor Latushkin 	}
443507428bdfSVictor Latushkin 
443607428bdfSVictor Latushkin 	if (dump_opt['C'])
443707428bdfSVictor Latushkin 		dump_config(spa);
443807428bdfSVictor Latushkin 
4439fa9e4066Sahrens 	if (dump_opt['u'])
444053b9a4a9SVictor Latushkin 		dump_uberblock(&spa->spa_uberblock, "\nUberblock:\n", "\n");
4441fa9e4066Sahrens 
4442b24ab676SJeff Bonwick 	if (dump_opt['D'])
4443b24ab676SJeff Bonwick 		dump_all_ddts(spa);
4444b24ab676SJeff Bonwick 
444587219db7SVictor Latushkin 	if (dump_opt['d'] > 2 || dump_opt['m'])
444687219db7SVictor Latushkin 		dump_metaslabs(spa);
44472e4c9986SGeorge Wilson 	if (dump_opt['M'])
44482e4c9986SGeorge Wilson 		dump_metaslab_groups(spa);
444987219db7SVictor Latushkin 
445087219db7SVictor Latushkin 	if (dump_opt['d'] || dump_opt['i']) {
4451fa9e4066Sahrens 		dump_dir(dp->dp_meta_objset);
4452fa9e4066Sahrens 		if (dump_opt['d'] >= 3) {
44535cabbc6bSPrashanth Sreenivasa 			dsl_pool_t *dp = spa->spa_dsl_pool;
4454732885fcSMatthew Ahrens 			dump_full_bpobj(&spa->spa_deferred_bpobj,
4455d0475637SMatthew Ahrens 			    "Deferred frees", 0);
4456cde58dbcSMatthew Ahrens 			if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
44575cabbc6bSPrashanth Sreenivasa 				dump_full_bpobj(&dp->dp_free_bpobj,
4458d0475637SMatthew Ahrens 				    "Pool snapshot frees", 0);
4459ad135b5dSChristopher Siden 			}
44605cabbc6bSPrashanth Sreenivasa 			if (bpobj_is_open(&dp->dp_obsolete_bpobj)) {
44615cabbc6bSPrashanth Sreenivasa 				ASSERT(spa_feature_is_enabled(spa,
44625cabbc6bSPrashanth Sreenivasa 				    SPA_FEATURE_DEVICE_REMOVAL));
44635cabbc6bSPrashanth Sreenivasa 				dump_full_bpobj(&dp->dp_obsolete_bpobj,
44645cabbc6bSPrashanth Sreenivasa 				    "Pool obsolete blocks", 0);
44655cabbc6bSPrashanth Sreenivasa 			}
4466ad135b5dSChristopher Siden 
4467ad135b5dSChristopher Siden 			if (spa_feature_is_active(spa,
44682acef22dSMatthew Ahrens 			    SPA_FEATURE_ASYNC_DESTROY)) {
4469ad135b5dSChristopher Siden 				dump_bptree(spa->spa_meta_objset,
44705cabbc6bSPrashanth Sreenivasa 				    dp->dp_bptree_obj,
4471ad135b5dSChristopher Siden 				    "Pool dataset frees");
4472cde58dbcSMatthew Ahrens 			}
4473fa9e4066Sahrens 			dump_dtl(spa->spa_root_vdev, 0);
4474fa9e4066Sahrens 		}
447507428bdfSVictor Latushkin 		(void) dmu_objset_find(spa_name(spa), dump_one_dir,
447607428bdfSVictor Latushkin 		    NULL, DS_FIND_SNAPSHOTS | DS_FIND_CHILDREN);
4477b5152584SMatthew Ahrens 
4478ca0cc391SMatthew Ahrens 		for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
4479ca0cc391SMatthew Ahrens 			uint64_t refcount;
4480ca0cc391SMatthew Ahrens 
4481ca0cc391SMatthew Ahrens 			if (!(spa_feature_table[f].fi_flags &
4482c5d1600cSMatthew Ahrens 			    ZFEATURE_FLAG_PER_DATASET) ||
4483c5d1600cSMatthew Ahrens 			    !spa_feature_is_enabled(spa, f)) {
4484ca0cc391SMatthew Ahrens 				ASSERT0(dataset_feature_count[f]);
4485ca0cc391SMatthew Ahrens 				continue;
4486ca0cc391SMatthew Ahrens 			}
4487ca0cc391SMatthew Ahrens 			(void) feature_get_refcount(spa,
4488ca0cc391SMatthew Ahrens 			    &spa_feature_table[f], &refcount);
4489ca0cc391SMatthew Ahrens 			if (dataset_feature_count[f] != refcount) {
4490ca0cc391SMatthew Ahrens 				(void) printf("%s feature refcount mismatch: "
4491ca0cc391SMatthew Ahrens 				    "%lld datasets != %lld refcount\n",
4492ca0cc391SMatthew Ahrens 				    spa_feature_table[f].fi_uname,
4493ca0cc391SMatthew Ahrens 				    (longlong_t)dataset_feature_count[f],
4494ca0cc391SMatthew Ahrens 				    (longlong_t)refcount);
4495ca0cc391SMatthew Ahrens 				rc = 2;
4496ca0cc391SMatthew Ahrens 			} else {
4497ca0cc391SMatthew Ahrens 				(void) printf("Verified %s feature refcount "
4498ca0cc391SMatthew Ahrens 				    "of %llu is correct\n",
4499ca0cc391SMatthew Ahrens 				    spa_feature_table[f].fi_uname,
4500ca0cc391SMatthew Ahrens 				    (longlong_t)refcount);
4501ca0cc391SMatthew Ahrens 			}
4502b5152584SMatthew Ahrens 		}
45035cabbc6bSPrashanth Sreenivasa 
45045cabbc6bSPrashanth Sreenivasa 		if (rc == 0) {
45055cabbc6bSPrashanth Sreenivasa 			rc = verify_device_removal_feature_counts(spa);
45065cabbc6bSPrashanth Sreenivasa 		}
4507fa9e4066Sahrens 	}
4508b5152584SMatthew Ahrens 	if (rc == 0 && (dump_opt['b'] || dump_opt['c']))
4509fa9e4066Sahrens 		rc = dump_block_stats(spa);
4510fa9e4066Sahrens 
45110713e232SGeorge Wilson 	if (rc == 0)
45120713e232SGeorge Wilson 		rc = verify_spacemap_refcounts(spa);
45130713e232SGeorge Wilson 
4514fa9e4066Sahrens 	if (dump_opt['s'])
4515fa9e4066Sahrens 		show_pool_stats(spa);
4516fa9e4066Sahrens 
45178f18d1faSGeorge Wilson 	if (dump_opt['h'])
45188f18d1faSGeorge Wilson 		dump_history(spa);
45198f18d1faSGeorge Wilson 
4520*17f11284SSerapheim Dimitropoulos 	if (rc == 0)
452186714001SSerapheim Dimitropoulos 		rc = verify_checkpoint(spa);
452286714001SSerapheim Dimitropoulos 
452329bdd2f9SPavel Zakharov 	if (rc != 0) {
452429bdd2f9SPavel Zakharov 		dump_debug_buffer();
4525fa9e4066Sahrens 		exit(rc);
452629bdd2f9SPavel Zakharov 	}
4527fa9e4066Sahrens }
4528fa9e4066Sahrens 
452944cd46caSbillm #define	ZDB_FLAG_CHECKSUM	0x0001
453044cd46caSbillm #define	ZDB_FLAG_DECOMPRESS	0x0002
453144cd46caSbillm #define	ZDB_FLAG_BSWAP		0x0004
453244cd46caSbillm #define	ZDB_FLAG_GBH		0x0008
453344cd46caSbillm #define	ZDB_FLAG_INDIRECT	0x0010
453444cd46caSbillm #define	ZDB_FLAG_PHYS		0x0020
453544cd46caSbillm #define	ZDB_FLAG_RAW		0x0040
453644cd46caSbillm #define	ZDB_FLAG_PRINT_BLKPTR	0x0080
453744cd46caSbillm 
45383f7978d0SAlan Somers static int flagbits[256];
453944cd46caSbillm 
454044cd46caSbillm static void
454144cd46caSbillm zdb_print_blkptr(blkptr_t *bp, int flags)
454244cd46caSbillm {
4543b24ab676SJeff Bonwick 	char blkbuf[BP_SPRINTF_LEN];
454444cd46caSbillm 
454544cd46caSbillm 	if (flags & ZDB_FLAG_BSWAP)
454644cd46caSbillm 		byteswap_uint64_array((void *)bp, sizeof (blkptr_t));
4547b24ab676SJeff Bonwick 
454843466aaeSMax Grossman 	snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
4549b24ab676SJeff Bonwick 	(void) printf("%s\n", blkbuf);
455044cd46caSbillm }
455144cd46caSbillm 
455244cd46caSbillm static void
455344cd46caSbillm zdb_dump_indirect(blkptr_t *bp, int nbps, int flags)
455444cd46caSbillm {
455544cd46caSbillm 	int i;
455644cd46caSbillm 
455744cd46caSbillm 	for (i = 0; i < nbps; i++)
455844cd46caSbillm 		zdb_print_blkptr(&bp[i], flags);
455944cd46caSbillm }
456044cd46caSbillm 
456144cd46caSbillm static void
456244cd46caSbillm zdb_dump_gbh(void *buf, int flags)
456344cd46caSbillm {
456444cd46caSbillm 	zdb_dump_indirect((blkptr_t *)buf, SPA_GBH_NBLKPTRS, flags);
456544cd46caSbillm }
456644cd46caSbillm 
456744cd46caSbillm static void
456844cd46caSbillm zdb_dump_block_raw(void *buf, uint64_t size, int flags)
456944cd46caSbillm {
457044cd46caSbillm 	if (flags & ZDB_FLAG_BSWAP)
457144cd46caSbillm 		byteswap_uint64_array(buf, size);
4572b24ab676SJeff Bonwick 	(void) write(1, buf, size);
457344cd46caSbillm }
457444cd46caSbillm 
457544cd46caSbillm static void
457644cd46caSbillm zdb_dump_block(char *label, void *buf, uint64_t size, int flags)
457744cd46caSbillm {
457844cd46caSbillm 	uint64_t *d = (uint64_t *)buf;
45793f7978d0SAlan Somers 	unsigned nwords = size / sizeof (uint64_t);
458044cd46caSbillm 	int do_bswap = !!(flags & ZDB_FLAG_BSWAP);
45813f7978d0SAlan Somers 	unsigned i, j;
45823f7978d0SAlan Somers 	const char *hdr;
45833f7978d0SAlan Somers 	char *c;
458444cd46caSbillm 
458544cd46caSbillm 
458644cd46caSbillm 	if (do_bswap)
458744cd46caSbillm 		hdr = " 7 6 5 4 3 2 1 0   f e d c b a 9 8";
458844cd46caSbillm 	else
458944cd46caSbillm 		hdr = " 0 1 2 3 4 5 6 7   8 9 a b c d e f";
459044cd46caSbillm 
459144cd46caSbillm 	(void) printf("\n%s\n%6s   %s  0123456789abcdef\n", label, "", hdr);
459244cd46caSbillm 
459344cd46caSbillm 	for (i = 0; i < nwords; i += 2) {
459444cd46caSbillm 		(void) printf("%06llx:  %016llx  %016llx  ",
459544cd46caSbillm 		    (u_longlong_t)(i * sizeof (uint64_t)),
459644cd46caSbillm 		    (u_longlong_t)(do_bswap ? BSWAP_64(d[i]) : d[i]),
459744cd46caSbillm 		    (u_longlong_t)(do_bswap ? BSWAP_64(d[i + 1]) : d[i + 1]));
459844cd46caSbillm 
459944cd46caSbillm 		c = (char *)&d[i];
460044cd46caSbillm 		for (j = 0; j < 2 * sizeof (uint64_t); j++)
460144cd46caSbillm 			(void) printf("%c", isprint(c[j]) ? c[j] : '.');
460244cd46caSbillm 		(void) printf("\n");
460344cd46caSbillm 	}
460444cd46caSbillm }
460544cd46caSbillm 
460644cd46caSbillm /*
460744cd46caSbillm  * There are two acceptable formats:
460844cd46caSbillm  *	leaf_name	  - For example: c1t0d0 or /tmp/ztest.0a
460944cd46caSbillm  *	child[.child]*    - For example: 0.1.1
461044cd46caSbillm  *
461144cd46caSbillm  * The second form can be used to specify arbitrary vdevs anywhere
461244cd46caSbillm  * in the heirarchy.  For example, in a pool with a mirror of
461344cd46caSbillm  * RAID-Zs, you can specify either RAID-Z vdev with 0.0 or 0.1 .
461444cd46caSbillm  */
461544cd46caSbillm static vdev_t *
46163f7978d0SAlan Somers zdb_vdev_lookup(vdev_t *vdev, const char *path)
461744cd46caSbillm {
461844cd46caSbillm 	char *s, *p, *q;
46193f7978d0SAlan Somers 	unsigned i;
462044cd46caSbillm 
462144cd46caSbillm 	if (vdev == NULL)
462244cd46caSbillm 		return (NULL);
462344cd46caSbillm 
462444cd46caSbillm 	/* First, assume the x.x.x.x format */
46253f7978d0SAlan Somers 	i = strtoul(path, &s, 10);
462644cd46caSbillm 	if (s == path || (s && *s != '.' && *s != '\0'))
462744cd46caSbillm 		goto name;
46283f7978d0SAlan Somers 	if (i >= vdev->vdev_children)
462944cd46caSbillm 		return (NULL);
463044cd46caSbillm 
463144cd46caSbillm 	vdev = vdev->vdev_child[i];
463244cd46caSbillm 	if (*s == '\0')
463344cd46caSbillm 		return (vdev);
463444cd46caSbillm 	return (zdb_vdev_lookup(vdev, s+1));
463544cd46caSbillm 
463644cd46caSbillm name:
463744cd46caSbillm 	for (i = 0; i < vdev->vdev_children; i++) {
463844cd46caSbillm 		vdev_t *vc = vdev->vdev_child[i];
463944cd46caSbillm 
464044cd46caSbillm 		if (vc->vdev_path == NULL) {
464144cd46caSbillm 			vc = zdb_vdev_lookup(vc, path);
464244cd46caSbillm 			if (vc == NULL)
464344cd46caSbillm 				continue;
464444cd46caSbillm 			else
464544cd46caSbillm 				return (vc);
464644cd46caSbillm 		}
464744cd46caSbillm 
464844cd46caSbillm 		p = strrchr(vc->vdev_path, '/');
464944cd46caSbillm 		p = p ? p + 1 : vc->vdev_path;
465044cd46caSbillm 		q = &vc->vdev_path[strlen(vc->vdev_path) - 2];
465144cd46caSbillm 
465244cd46caSbillm 		if (strcmp(vc->vdev_path, path) == 0)
465344cd46caSbillm 			return (vc);
465444cd46caSbillm 		if (strcmp(p, path) == 0)
465544cd46caSbillm 			return (vc);
465644cd46caSbillm 		if (strcmp(q, "s0") == 0 && strncmp(p, path, q - p) == 0)
465744cd46caSbillm 			return (vc);
465844cd46caSbillm 	}
465944cd46caSbillm 
466044cd46caSbillm 	return (NULL);
466144cd46caSbillm }
466244cd46caSbillm 
4663770499e1SDan Kimmel /* ARGSUSED */
4664770499e1SDan Kimmel static int
4665770499e1SDan Kimmel random_get_pseudo_bytes_cb(void *buf, size_t len, void *unused)
4666770499e1SDan Kimmel {
4667770499e1SDan Kimmel 	return (random_get_pseudo_bytes(buf, len));
4668770499e1SDan Kimmel }
4669770499e1SDan Kimmel 
467044cd46caSbillm /*
467144cd46caSbillm  * Read a block from a pool and print it out.  The syntax of the
467244cd46caSbillm  * block descriptor is:
467344cd46caSbillm  *
467444cd46caSbillm  *	pool:vdev_specifier:offset:size[:flags]
467544cd46caSbillm  *
467644cd46caSbillm  *	pool           - The name of the pool you wish to read from
467744cd46caSbillm  *	vdev_specifier - Which vdev (see comment for zdb_vdev_lookup)
467844cd46caSbillm  *	offset         - offset, in hex, in bytes
467944cd46caSbillm  *	size           - Amount of data to read, in hex, in bytes
468044cd46caSbillm  *	flags          - A string of characters specifying options
468144cd46caSbillm  *		 b: Decode a blkptr at given offset within block
468244cd46caSbillm  *		*c: Calculate and display checksums
4683b24ab676SJeff Bonwick  *		 d: Decompress data before dumping
468444cd46caSbillm  *		 e: Byteswap data before dumping
4685b24ab676SJeff Bonwick  *		 g: Display data as a gang block header
4686b24ab676SJeff Bonwick  *		 i: Display as an indirect block
468744cd46caSbillm  *		 p: Do I/O to physical offset
468844cd46caSbillm  *		 r: Dump raw data to stdout
468944cd46caSbillm  *
469044cd46caSbillm  *              * = not yet implemented
469144cd46caSbillm  */
469244cd46caSbillm static void
469307428bdfSVictor Latushkin zdb_read_block(char *thing, spa_t *spa)
469444cd46caSbillm {
4695b24ab676SJeff Bonwick 	blkptr_t blk, *bp = &blk;
4696b24ab676SJeff Bonwick 	dva_t *dva = bp->blk_dva;
469744cd46caSbillm 	int flags = 0;
4698b24ab676SJeff Bonwick 	uint64_t offset = 0, size = 0, psize = 0, lsize = 0, blkptr_offset = 0;
469944cd46caSbillm 	zio_t *zio;
470044cd46caSbillm 	vdev_t *vd;
4701770499e1SDan Kimmel 	abd_t *pabd;
4702770499e1SDan Kimmel 	void *lbuf, *buf;
47033f7978d0SAlan Somers 	const char *s, *vdev;
47043f7978d0SAlan Somers 	char *p, *dup, *flagstr;
4705b24ab676SJeff Bonwick 	int i, error;
470644cd46caSbillm 
470744cd46caSbillm 	dup = strdup(thing);
470844cd46caSbillm 	s = strtok(dup, ":");
470944cd46caSbillm 	vdev = s ? s : "";
471044cd46caSbillm 	s = strtok(NULL, ":");
471144cd46caSbillm 	offset = strtoull(s ? s : "", NULL, 16);
471244cd46caSbillm 	s = strtok(NULL, ":");
471344cd46caSbillm 	size = strtoull(s ? s : "", NULL, 16);
471444cd46caSbillm 	s = strtok(NULL, ":");
47153f7978d0SAlan Somers 	if (s)
47163f7978d0SAlan Somers 		flagstr = strdup(s);
47173f7978d0SAlan Somers 	else
47183f7978d0SAlan Somers 		flagstr = strdup("");
471944cd46caSbillm 
472044cd46caSbillm 	s = NULL;
472144cd46caSbillm 	if (size == 0)
472244cd46caSbillm 		s = "size must not be zero";
472344cd46caSbillm 	if (!IS_P2ALIGNED(size, DEV_BSIZE))
472444cd46caSbillm 		s = "size must be a multiple of sector size";
472544cd46caSbillm 	if (!IS_P2ALIGNED(offset, DEV_BSIZE))
472644cd46caSbillm 		s = "offset must be a multiple of sector size";
472744cd46caSbillm 	if (s) {
472844cd46caSbillm 		(void) printf("Invalid block specifier: %s  - %s\n", thing, s);
472944cd46caSbillm 		free(dup);
473044cd46caSbillm 		return;
473144cd46caSbillm 	}
473244cd46caSbillm 
473344cd46caSbillm 	for (s = strtok(flagstr, ":"); s; s = strtok(NULL, ":")) {
473444cd46caSbillm 		for (i = 0; flagstr[i]; i++) {
47355ad82045Snd 			int bit = flagbits[(uchar_t)flagstr[i]];
473644cd46caSbillm 
473744cd46caSbillm 			if (bit == 0) {
473844cd46caSbillm 				(void) printf("***Invalid flag: %c\n",
473944cd46caSbillm 				    flagstr[i]);
474044cd46caSbillm 				continue;
474144cd46caSbillm 			}
474244cd46caSbillm 			flags |= bit;
474344cd46caSbillm 
474444cd46caSbillm 			/* If it's not something with an argument, keep going */
4745b24ab676SJeff Bonwick 			if ((bit & (ZDB_FLAG_CHECKSUM |
474644cd46caSbillm 			    ZDB_FLAG_PRINT_BLKPTR)) == 0)
474744cd46caSbillm 				continue;
474844cd46caSbillm 
474944cd46caSbillm 			p = &flagstr[i + 1];
475044cd46caSbillm 			if (bit == ZDB_FLAG_PRINT_BLKPTR)
475144cd46caSbillm 				blkptr_offset = strtoull(p, &p, 16);
475244cd46caSbillm 			if (*p != ':' && *p != '\0') {
475344cd46caSbillm 				(void) printf("***Invalid flag arg: '%s'\n", s);
475444cd46caSbillm 				free(dup);
475544cd46caSbillm 				return;
475644cd46caSbillm 			}
475744cd46caSbillm 		}
475844cd46caSbillm 	}
47593f7978d0SAlan Somers 	free(flagstr);
476044cd46caSbillm 
476144cd46caSbillm 	vd = zdb_vdev_lookup(spa->spa_root_vdev, vdev);
476244cd46caSbillm 	if (vd == NULL) {
476344cd46caSbillm 		(void) printf("***Invalid vdev: %s\n", vdev);
476444cd46caSbillm 		free(dup);
476544cd46caSbillm 		return;
476644cd46caSbillm 	} else {
476744cd46caSbillm 		if (vd->vdev_path)
4768b24ab676SJeff Bonwick 			(void) fprintf(stderr, "Found vdev: %s\n",
4769b24ab676SJeff Bonwick 			    vd->vdev_path);
477044cd46caSbillm 		else
4771b24ab676SJeff Bonwick 			(void) fprintf(stderr, "Found vdev type: %s\n",
477244cd46caSbillm 			    vd->vdev_ops->vdev_op_type);
477344cd46caSbillm 	}
477444cd46caSbillm 
4775b24ab676SJeff Bonwick 	psize = size;
4776b24ab676SJeff Bonwick 	lsize = size;
477744cd46caSbillm 
4778770499e1SDan Kimmel 	pabd = abd_alloc_linear(SPA_MAXBLOCKSIZE, B_FALSE);
4779b24ab676SJeff Bonwick 	lbuf = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
4780b24ab676SJeff Bonwick 
4781b24ab676SJeff Bonwick 	BP_ZERO(bp);
4782b24ab676SJeff Bonwick 
4783b24ab676SJeff Bonwick 	DVA_SET_VDEV(&dva[0], vd->vdev_id);
4784b24ab676SJeff Bonwick 	DVA_SET_OFFSET(&dva[0], offset);
4785b24ab676SJeff Bonwick 	DVA_SET_GANG(&dva[0], !!(flags & ZDB_FLAG_GBH));
4786b24ab676SJeff Bonwick 	DVA_SET_ASIZE(&dva[0], vdev_psize_to_asize(vd, psize));
4787b24ab676SJeff Bonwick 
4788b24ab676SJeff Bonwick 	BP_SET_BIRTH(bp, TXG_INITIAL, TXG_INITIAL);
4789b24ab676SJeff Bonwick 
4790b24ab676SJeff Bonwick 	BP_SET_LSIZE(bp, lsize);
4791b24ab676SJeff Bonwick 	BP_SET_PSIZE(bp, psize);
4792b24ab676SJeff Bonwick 	BP_SET_COMPRESS(bp, ZIO_COMPRESS_OFF);
4793b24ab676SJeff Bonwick 	BP_SET_CHECKSUM(bp, ZIO_CHECKSUM_OFF);
4794b24ab676SJeff Bonwick 	BP_SET_TYPE(bp, DMU_OT_NONE);
4795b24ab676SJeff Bonwick 	BP_SET_LEVEL(bp, 0);
4796b24ab676SJeff Bonwick 	BP_SET_DEDUP(bp, 0);
4797b24ab676SJeff Bonwick 	BP_SET_BYTEORDER(bp, ZFS_HOST_BYTEORDER);
479844cd46caSbillm 
4799e14bb325SJeff Bonwick 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
480044cd46caSbillm 	zio = zio_root(spa, NULL, NULL, 0);
4801b24ab676SJeff Bonwick 
4802b24ab676SJeff Bonwick 	if (vd == vd->vdev_top) {
4803b24ab676SJeff Bonwick 		/*
4804b24ab676SJeff Bonwick 		 * Treat this as a normal block read.
4805b24ab676SJeff Bonwick 		 */
4806770499e1SDan Kimmel 		zio_nowait(zio_read(zio, spa, bp, pabd, psize, NULL, NULL,
4807b24ab676SJeff Bonwick 		    ZIO_PRIORITY_SYNC_READ,
4808b24ab676SJeff Bonwick 		    ZIO_FLAG_CANFAIL | ZIO_FLAG_RAW, NULL));
4809b24ab676SJeff Bonwick 	} else {
4810b24ab676SJeff Bonwick 		/*
4811b24ab676SJeff Bonwick 		 * Treat this as a vdev child I/O.
4812b24ab676SJeff Bonwick 		 */
4813770499e1SDan Kimmel 		zio_nowait(zio_vdev_child_io(zio, bp, vd, offset, pabd,
4814770499e1SDan Kimmel 		    psize, ZIO_TYPE_READ, ZIO_PRIORITY_SYNC_READ,
4815b24ab676SJeff Bonwick 		    ZIO_FLAG_DONT_CACHE | ZIO_FLAG_DONT_QUEUE |
4816b24ab676SJeff Bonwick 		    ZIO_FLAG_DONT_PROPAGATE | ZIO_FLAG_DONT_RETRY |
48175cabbc6bSPrashanth Sreenivasa 		    ZIO_FLAG_CANFAIL | ZIO_FLAG_RAW | ZIO_FLAG_OPTIONAL,
48185cabbc6bSPrashanth Sreenivasa 		    NULL, NULL));
4819b24ab676SJeff Bonwick 	}
4820b24ab676SJeff Bonwick 
482144cd46caSbillm 	error = zio_wait(zio);
4822e14bb325SJeff Bonwick 	spa_config_exit(spa, SCL_STATE, FTAG);
482344cd46caSbillm 
482444cd46caSbillm 	if (error) {
482544cd46caSbillm 		(void) printf("Read of %s failed, error: %d\n", thing, error);
482644cd46caSbillm 		goto out;
482744cd46caSbillm 	}
482844cd46caSbillm 
4829b24ab676SJeff Bonwick 	if (flags & ZDB_FLAG_DECOMPRESS) {
4830b24ab676SJeff Bonwick 		/*
4831b24ab676SJeff Bonwick 		 * We don't know how the data was compressed, so just try
4832b24ab676SJeff Bonwick 		 * every decompress function at every inflated blocksize.
4833b24ab676SJeff Bonwick 		 */
4834b24ab676SJeff Bonwick 		enum zio_compress c;
4835b24ab676SJeff Bonwick 		void *pbuf2 = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
4836b24ab676SJeff Bonwick 		void *lbuf2 = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
4837b24ab676SJeff Bonwick 
4838770499e1SDan Kimmel 		abd_copy_to_buf(pbuf2, pabd, psize);
4839b24ab676SJeff Bonwick 
4840770499e1SDan Kimmel 		VERIFY0(abd_iterate_func(pabd, psize, SPA_MAXBLOCKSIZE - psize,
4841770499e1SDan Kimmel 		    random_get_pseudo_bytes_cb, NULL));
4842b24ab676SJeff Bonwick 
4843770499e1SDan Kimmel 		VERIFY0(random_get_pseudo_bytes((uint8_t *)pbuf2 + psize,
4844770499e1SDan Kimmel 		    SPA_MAXBLOCKSIZE - psize));
4845b24ab676SJeff Bonwick 
4846b24ab676SJeff Bonwick 		for (lsize = SPA_MAXBLOCKSIZE; lsize > psize;
4847b24ab676SJeff Bonwick 		    lsize -= SPA_MINBLOCKSIZE) {
4848b24ab676SJeff Bonwick 			for (c = 0; c < ZIO_COMPRESS_FUNCTIONS; c++) {
4849770499e1SDan Kimmel 				if (zio_decompress_data(c, pabd,
4850770499e1SDan Kimmel 				    lbuf, psize, lsize) == 0 &&
4851770499e1SDan Kimmel 				    zio_decompress_data_buf(c, pbuf2,
4852770499e1SDan Kimmel 				    lbuf2, psize, lsize) == 0 &&
4853b24ab676SJeff Bonwick 				    bcmp(lbuf, lbuf2, lsize) == 0)
4854b24ab676SJeff Bonwick 					break;
4855b24ab676SJeff Bonwick 			}
4856b24ab676SJeff Bonwick 			if (c != ZIO_COMPRESS_FUNCTIONS)
4857b24ab676SJeff Bonwick 				break;
4858b24ab676SJeff Bonwick 			lsize -= SPA_MINBLOCKSIZE;
4859b24ab676SJeff Bonwick 		}
4860b24ab676SJeff Bonwick 
4861b24ab676SJeff Bonwick 		umem_free(pbuf2, SPA_MAXBLOCKSIZE);
4862b24ab676SJeff Bonwick 		umem_free(lbuf2, SPA_MAXBLOCKSIZE);
4863b24ab676SJeff Bonwick 
4864b24ab676SJeff Bonwick 		if (lsize <= psize) {
4865b24ab676SJeff Bonwick 			(void) printf("Decompress of %s failed\n", thing);
4866b24ab676SJeff Bonwick 			goto out;
4867b24ab676SJeff Bonwick 		}
4868b24ab676SJeff Bonwick 		buf = lbuf;
4869b24ab676SJeff Bonwick 		size = lsize;
4870b24ab676SJeff Bonwick 	} else {
4871770499e1SDan Kimmel 		buf = abd_to_buf(pabd);
4872b24ab676SJeff Bonwick 		size = psize;
4873b24ab676SJeff Bonwick 	}
4874b24ab676SJeff Bonwick 
487544cd46caSbillm 	if (flags & ZDB_FLAG_PRINT_BLKPTR)
487644cd46caSbillm 		zdb_print_blkptr((blkptr_t *)(void *)
487744cd46caSbillm 		    ((uintptr_t)buf + (uintptr_t)blkptr_offset), flags);
487844cd46caSbillm 	else if (flags & ZDB_FLAG_RAW)
487944cd46caSbillm 		zdb_dump_block_raw(buf, size, flags);
488044cd46caSbillm 	else if (flags & ZDB_FLAG_INDIRECT)
488144cd46caSbillm 		zdb_dump_indirect((blkptr_t *)buf, size / sizeof (blkptr_t),
488244cd46caSbillm 		    flags);
488344cd46caSbillm 	else if (flags & ZDB_FLAG_GBH)
488444cd46caSbillm 		zdb_dump_gbh(buf, flags);
488544cd46caSbillm 	else
488644cd46caSbillm 		zdb_dump_block(thing, buf, size, flags);
488744cd46caSbillm 
488844cd46caSbillm out:
4889770499e1SDan Kimmel 	abd_free(pabd);
4890b24ab676SJeff Bonwick 	umem_free(lbuf, SPA_MAXBLOCKSIZE);
489144cd46caSbillm 	free(dup);
489244cd46caSbillm }
489344cd46caSbillm 
48944923c69fSMatthew Ahrens static void
48954923c69fSMatthew Ahrens zdb_embedded_block(char *thing)
48964923c69fSMatthew Ahrens {
48973f7978d0SAlan Somers 	blkptr_t bp;
48984923c69fSMatthew Ahrens 	unsigned long long *words = (void *)&bp;
48994923c69fSMatthew Ahrens 	char buf[SPA_MAXBLOCKSIZE];
49004923c69fSMatthew Ahrens 	int err;
49014923c69fSMatthew Ahrens 
49023f7978d0SAlan Somers 	bzero(&bp, sizeof (bp));
49034923c69fSMatthew Ahrens 	err = sscanf(thing, "%llx:%llx:%llx:%llx:%llx:%llx:%llx:%llx:"
49044923c69fSMatthew Ahrens 	    "%llx:%llx:%llx:%llx:%llx:%llx:%llx:%llx",
49054923c69fSMatthew Ahrens 	    words + 0, words + 1, words + 2, words + 3,
49064923c69fSMatthew Ahrens 	    words + 4, words + 5, words + 6, words + 7,
49074923c69fSMatthew Ahrens 	    words + 8, words + 9, words + 10, words + 11,
49084923c69fSMatthew Ahrens 	    words + 12, words + 13, words + 14, words + 15);
49094923c69fSMatthew Ahrens 	if (err != 16) {
49104923c69fSMatthew Ahrens 		(void) printf("invalid input format\n");
49114923c69fSMatthew Ahrens 		exit(1);
49124923c69fSMatthew Ahrens 	}
49134923c69fSMatthew Ahrens 	ASSERT3U(BPE_GET_LSIZE(&bp), <=, SPA_MAXBLOCKSIZE);
49144923c69fSMatthew Ahrens 	err = decode_embedded_bp(&bp, buf, BPE_GET_LSIZE(&bp));
49154923c69fSMatthew Ahrens 	if (err != 0) {
49164923c69fSMatthew Ahrens 		(void) printf("decode failed: %u\n", err);
49174923c69fSMatthew Ahrens 		exit(1);
49184923c69fSMatthew Ahrens 	}
49194923c69fSMatthew Ahrens 	zdb_dump_block_raw(buf, BPE_GET_LSIZE(&bp), 0);
49204923c69fSMatthew Ahrens }
49214923c69fSMatthew Ahrens 
4922de6628f0Sck static boolean_t
49233ad6c7f9SVictor Latushkin pool_match(nvlist_t *cfg, char *tgt)
4924de6628f0Sck {
49253ad6c7f9SVictor Latushkin 	uint64_t v, guid = strtoull(tgt, NULL, 0);
4926de6628f0Sck 	char *s;
4927de6628f0Sck 
4928de6628f0Sck 	if (guid != 0) {
49293ad6c7f9SVictor Latushkin 		if (nvlist_lookup_uint64(cfg, ZPOOL_CONFIG_POOL_GUID, &v) == 0)
49303ad6c7f9SVictor Latushkin 			return (v == guid);
4931de6628f0Sck 	} else {
49323ad6c7f9SVictor Latushkin 		if (nvlist_lookup_string(cfg, ZPOOL_CONFIG_POOL_NAME, &s) == 0)
49333ad6c7f9SVictor Latushkin 			return (strcmp(s, tgt) == 0);
4934de6628f0Sck 	}
49353ad6c7f9SVictor Latushkin 	return (B_FALSE);
4936de6628f0Sck }
4937de6628f0Sck 
49383ad6c7f9SVictor Latushkin static char *
49393ad6c7f9SVictor Latushkin find_zpool(char **target, nvlist_t **configp, int dirc, char **dirv)
4940de6628f0Sck {
4941de6628f0Sck 	nvlist_t *pools;
4942de6628f0Sck 	nvlist_t *match = NULL;
49433ad6c7f9SVictor Latushkin 	char *name = NULL;
49443ad6c7f9SVictor Latushkin 	char *sepp = NULL;
49459adfa60dSMatthew Ahrens 	char sep = '\0';
49463ad6c7f9SVictor Latushkin 	int count = 0;
49473f7978d0SAlan Somers 	importargs_t args;
4948d41c4376SMark J Musante 
49493f7978d0SAlan Somers 	bzero(&args, sizeof (args));
4950d41c4376SMark J Musante 	args.paths = dirc;
4951d41c4376SMark J Musante 	args.path = dirv;
4952d41c4376SMark J Musante 	args.can_be_active = B_TRUE;
4953de6628f0Sck 
49543ad6c7f9SVictor Latushkin 	if ((sepp = strpbrk(*target, "/@")) != NULL) {
49553ad6c7f9SVictor Latushkin 		sep = *sepp;
49563ad6c7f9SVictor Latushkin 		*sepp = '\0';
49573ad6c7f9SVictor Latushkin 	}
49583ad6c7f9SVictor Latushkin 
4959d41c4376SMark J Musante 	pools = zpool_search_import(g_zfs, &args);
4960de6628f0Sck 
4961de6628f0Sck 	if (pools != NULL) {
4962de6628f0Sck 		nvpair_t *elem = NULL;
4963de6628f0Sck 		while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) {
4964de6628f0Sck 			verify(nvpair_value_nvlist(elem, configp) == 0);
49653ad6c7f9SVictor Latushkin 			if (pool_match(*configp, *target)) {
49663ad6c7f9SVictor Latushkin 				count++;
4967de6628f0Sck 				if (match != NULL) {
49683ad6c7f9SVictor Latushkin 					/* print previously found config */
49693ad6c7f9SVictor Latushkin 					if (name != NULL) {
49703ad6c7f9SVictor Latushkin 						(void) printf("%s\n", name);
49713ad6c7f9SVictor Latushkin 						dump_nvlist(match, 8);
49723ad6c7f9SVictor Latushkin 						name = NULL;
49733ad6c7f9SVictor Latushkin 					}
49743ad6c7f9SVictor Latushkin 					(void) printf("%s\n",
49753ad6c7f9SVictor Latushkin 					    nvpair_name(elem));
49763ad6c7f9SVictor Latushkin 					dump_nvlist(*configp, 8);
4977de6628f0Sck 				} else {
4978de6628f0Sck 					match = *configp;
49793ad6c7f9SVictor Latushkin 					name = nvpair_name(elem);
4980de6628f0Sck 				}
4981de6628f0Sck 			}
4982de6628f0Sck 		}
4983de6628f0Sck 	}
49843ad6c7f9SVictor Latushkin 	if (count > 1)
49853ad6c7f9SVictor Latushkin 		(void) fatal("\tMatched %d pools - use pool GUID "
49863ad6c7f9SVictor Latushkin 		    "instead of pool name or \n"
49873ad6c7f9SVictor Latushkin 		    "\tpool name part of a dataset name to select pool", count);
49883ad6c7f9SVictor Latushkin 
49893ad6c7f9SVictor Latushkin 	if (sepp)
49903ad6c7f9SVictor Latushkin 		*sepp = sep;
49913ad6c7f9SVictor Latushkin 	/*
49923ad6c7f9SVictor Latushkin 	 * If pool GUID was specified for pool id, replace it with pool name
49933ad6c7f9SVictor Latushkin 	 */
49943ad6c7f9SVictor Latushkin 	if (name && (strstr(*target, name) != *target)) {
49953ad6c7f9SVictor Latushkin 		int sz = 1 + strlen(name) + ((sepp) ? strlen(sepp) : 0);
49963ad6c7f9SVictor Latushkin 
49973ad6c7f9SVictor Latushkin 		*target = umem_alloc(sz, UMEM_NOFAIL);
49983ad6c7f9SVictor Latushkin 		(void) snprintf(*target, sz, "%s%s", name, sepp ? sepp : "");
49993ad6c7f9SVictor Latushkin 	}
5000de6628f0Sck 
50013ad6c7f9SVictor Latushkin 	*configp = name ? match : NULL;
5002de6628f0Sck 
50033ad6c7f9SVictor Latushkin 	return (name);
5004de6628f0Sck }
5005de6628f0Sck 
5006fa9e4066Sahrens int
5007fa9e4066Sahrens main(int argc, char **argv)
5008fa9e4066Sahrens {
50093f7978d0SAlan Somers 	int c;
5010fa9e4066Sahrens 	struct rlimit rl = { 1024, 1024 };
50113ad6c7f9SVictor Latushkin 	spa_t *spa = NULL;
5012fa9e4066Sahrens 	objset_t *os = NULL;
5013fa9e4066Sahrens 	int dump_all = 1;
5014fa9e4066Sahrens 	int verbose = 0;
5015c8ee1847SVictor Latushkin 	int error = 0;
50163ad6c7f9SVictor Latushkin 	char **searchdirs = NULL;
50173ad6c7f9SVictor Latushkin 	int nsearch = 0;
50183ad6c7f9SVictor Latushkin 	char *target;
5019468c413aSTim Haley 	nvlist_t *policy = NULL;
5020468c413aSTim Haley 	uint64_t max_txg = UINT64_MAX;
5021dfd5965fSRichard Yao 	int flags = ZFS_IMPORT_MISSING_LOG;
5022c8ee1847SVictor Latushkin 	int rewind = ZPOOL_NEVER_REWIND;
5023ae24175bSCyril Plisko 	char *spa_config_path_env;
5024b702644aSTim Chase 	boolean_t target_is_spa = B_TRUE;
502586714001SSerapheim Dimitropoulos 	nvlist_t *cfg = NULL;
5026fa9e4066Sahrens 
5027fa9e4066Sahrens 	(void) setrlimit(RLIMIT_NOFILE, &rl);
5028004388ebScasper 	(void) enable_extended_FILE_stdio(-1, -1);
5029fa9e4066Sahrens 
5030fa9e4066Sahrens 	dprintf_setup(&argc, argv);
5031fa9e4066Sahrens 
5032ae24175bSCyril Plisko 	/*
5033ae24175bSCyril Plisko 	 * If there is an environment variable SPA_CONFIG_PATH it overrides
5034ae24175bSCyril Plisko 	 * default spa_config_path setting. If -U flag is specified it will
5035ae24175bSCyril Plisko 	 * override this environment variable settings once again.
5036ae24175bSCyril Plisko 	 */
5037ae24175bSCyril Plisko 	spa_config_path_env = getenv("SPA_CONFIG_PATH");
5038ae24175bSCyril Plisko 	if (spa_config_path_env != NULL)
5039ae24175bSCyril Plisko 		spa_config_path = spa_config_path_env;
5040ae24175bSCyril Plisko 
5041df15e419SMatthew Ahrens 	while ((c = getopt(argc, argv,
504286714001SSerapheim Dimitropoulos 	    "AbcCdDeEFGhiI:klLmMo:Op:PqRsSt:uU:vVx:X")) != -1) {
5043fa9e4066Sahrens 		switch (c) {
5044fa9e4066Sahrens 		case 'b':
5045fa9e4066Sahrens 		case 'c':
5046ed61ec1dSYuri Pankov 		case 'C':
5047b24ab676SJeff Bonwick 		case 'd':
5048ed61ec1dSYuri Pankov 		case 'D':
50494923c69fSMatthew Ahrens 		case 'E':
5050ed61ec1dSYuri Pankov 		case 'G':
5051b24ab676SJeff Bonwick 		case 'h':
5052b24ab676SJeff Bonwick 		case 'i':
5053b24ab676SJeff Bonwick 		case 'l':
5054d6e555bdSGeorge Wilson 		case 'm':
50552e4c9986SGeorge Wilson 		case 'M':
5056ed61ec1dSYuri Pankov 		case 'O':
505744cd46caSbillm 		case 'R':
5058ed61ec1dSYuri Pankov 		case 's':
5059b24ab676SJeff Bonwick 		case 'S':
5060ed61ec1dSYuri Pankov 		case 'u':
5061fa9e4066Sahrens 			dump_opt[c]++;
5062fa9e4066Sahrens 			dump_all = 0;
5063fa9e4066Sahrens 			break;
5064feef89cfSVictor Latushkin 		case 'A':
5065ed61ec1dSYuri Pankov 		case 'e':
5066c8ee1847SVictor Latushkin 		case 'F':
506786714001SSerapheim Dimitropoulos 		case 'k':
506882a0a985SVictor Latushkin 		case 'L':
50693f9d6ad7SLin Ling 		case 'P':
507064723e36SYuri Pankov 		case 'q':
5071ed61ec1dSYuri Pankov 		case 'X':
507282a0a985SVictor Latushkin 			dump_opt[c]++;
507382a0a985SVictor Latushkin 			break;
5074ed61ec1dSYuri Pankov 		/* NB: Sort single match options below. */
50752e4c9986SGeorge Wilson 		case 'I':
507631d7e8faSGeorge Wilson 			max_inflight = strtoull(optarg, NULL, 0);
507731d7e8faSGeorge Wilson 			if (max_inflight == 0) {
507831d7e8faSGeorge Wilson 				(void) fprintf(stderr, "maximum number "
507931d7e8faSGeorge Wilson 				    "of inflight I/Os must be greater "
508031d7e8faSGeorge Wilson 				    "than 0\n");
508131d7e8faSGeorge Wilson 				usage();
508231d7e8faSGeorge Wilson 			}
508331d7e8faSGeorge Wilson 			break;
5084ed61ec1dSYuri Pankov 		case 'o':
5085ed61ec1dSYuri Pankov 			error = set_global_var(optarg);
5086ed61ec1dSYuri Pankov 			if (error != 0)
5087ed61ec1dSYuri Pankov 				usage();
5088ed61ec1dSYuri Pankov 			break;
5089de6628f0Sck 		case 'p':
50903ad6c7f9SVictor Latushkin 			if (searchdirs == NULL) {
50913ad6c7f9SVictor Latushkin 				searchdirs = umem_alloc(sizeof (char *),
50923ad6c7f9SVictor Latushkin 				    UMEM_NOFAIL);
50933ad6c7f9SVictor Latushkin 			} else {
50943ad6c7f9SVictor Latushkin 				char **tmp = umem_alloc((nsearch + 1) *
50953ad6c7f9SVictor Latushkin 				    sizeof (char *), UMEM_NOFAIL);
50963ad6c7f9SVictor Latushkin 				bcopy(searchdirs, tmp, nsearch *
50973ad6c7f9SVictor Latushkin 				    sizeof (char *));
50983ad6c7f9SVictor Latushkin 				umem_free(searchdirs,
50993ad6c7f9SVictor Latushkin 				    nsearch * sizeof (char *));
51003ad6c7f9SVictor Latushkin 				searchdirs = tmp;
51013ad6c7f9SVictor Latushkin 			}
51023ad6c7f9SVictor Latushkin 			searchdirs[nsearch++] = optarg;
5103de6628f0Sck 			break;
51042e551927SVictor Latushkin 		case 't':
5105468c413aSTim Haley 			max_txg = strtoull(optarg, NULL, 0);
5106468c413aSTim Haley 			if (max_txg < TXG_INITIAL) {
51072e551927SVictor Latushkin 				(void) fprintf(stderr, "incorrect txg "
51082e551927SVictor Latushkin 				    "specified: %s\n", optarg);
51092e551927SVictor Latushkin 				usage();
51102e551927SVictor Latushkin 			}
51112e551927SVictor Latushkin 			break;
5112b24ab676SJeff Bonwick 		case 'U':
5113b24ab676SJeff Bonwick 			spa_config_path = optarg;
51144923c69fSMatthew Ahrens 			if (spa_config_path[0] != '/') {
51154923c69fSMatthew Ahrens 				(void) fprintf(stderr,
51164923c69fSMatthew Ahrens 				    "cachefile must be an absolute path "
51174923c69fSMatthew Ahrens 				    "(i.e. start with a slash)\n");
51184923c69fSMatthew Ahrens 				usage();
51194923c69fSMatthew Ahrens 			}
5120b24ab676SJeff Bonwick 			break;
51212e4c9986SGeorge Wilson 		case 'v':
51222e4c9986SGeorge Wilson 			verbose++;
51232e4c9986SGeorge Wilson 			break;
5124dfd5965fSRichard Yao 		case 'V':
5125dfd5965fSRichard Yao 			flags = ZFS_IMPORT_VERBATIM;
5126dfd5965fSRichard Yao 			break;
51272e4c9986SGeorge Wilson 		case 'x':
51282e4c9986SGeorge Wilson 			vn_dumpdir = optarg;
51292e4c9986SGeorge Wilson 			break;
5130fa9e4066Sahrens 		default:
5131fa9e4066Sahrens 			usage();
5132fa9e4066Sahrens 			break;
5133fa9e4066Sahrens 		}
5134fa9e4066Sahrens 	}
5135fa9e4066Sahrens 
51363ad6c7f9SVictor Latushkin 	if (!dump_opt['e'] && searchdirs != NULL) {
513788b7b0f2SMatthew Ahrens 		(void) fprintf(stderr, "-p option requires use of -e\n");
513888b7b0f2SMatthew Ahrens 		usage();
513988b7b0f2SMatthew Ahrens 	}
5140de6628f0Sck 
514106be9802SMatthew Ahrens 	/*
514206be9802SMatthew Ahrens 	 * ZDB does not typically re-read blocks; therefore limit the ARC
514306be9802SMatthew Ahrens 	 * to 256 MB, which can be used entirely for metadata.
514406be9802SMatthew Ahrens 	 */
514506be9802SMatthew Ahrens 	zfs_arc_max = zfs_arc_meta_limit = 256 * 1024 * 1024;
514606be9802SMatthew Ahrens 
5147f7950bf1SMatthew Ahrens 	/*
5148f7950bf1SMatthew Ahrens 	 * "zdb -c" uses checksum-verifying scrub i/os which are async reads.
5149f7950bf1SMatthew Ahrens 	 * "zdb -b" uses traversal prefetch which uses async reads.
5150f7950bf1SMatthew Ahrens 	 * For good performance, let several of them be active at once.
5151f7950bf1SMatthew Ahrens 	 */
5152f7950bf1SMatthew Ahrens 	zfs_vdev_async_read_max_active = 10;
5153f7950bf1SMatthew Ahrens 
51544dd77f9eSMatthew Ahrens 	/*
51554dd77f9eSMatthew Ahrens 	 * Disable reference tracking for better performance.
51564dd77f9eSMatthew Ahrens 	 */
51574dd77f9eSMatthew Ahrens 	reference_tracking_enable = B_FALSE;
51584dd77f9eSMatthew Ahrens 
5159e144c4e6SPavel Zakharov 	/*
5160e144c4e6SPavel Zakharov 	 * Do not fail spa_load when spa_load_verify fails. This is needed
5161e144c4e6SPavel Zakharov 	 * to load non-idle pools.
5162e144c4e6SPavel Zakharov 	 */
5163e144c4e6SPavel Zakharov 	spa_load_verify_dryrun = B_TRUE;
5164e144c4e6SPavel Zakharov 
5165fa9e4066Sahrens 	kernel_init(FREAD);
5166de6628f0Sck 	g_zfs = libzfs_init();
516791ebeef5Sahrens 	ASSERT(g_zfs != NULL);
5168fa9e4066Sahrens 
5169b24ab676SJeff Bonwick 	if (dump_all)
5170b24ab676SJeff Bonwick 		verbose = MAX(verbose, 1);
5171b24ab676SJeff Bonwick 
5172fa9e4066Sahrens 	for (c = 0; c < 256; c++) {
517386714001SSerapheim Dimitropoulos 		if (dump_all && strchr("AeEFklLOPRSX", c) == NULL)
5174fa9e4066Sahrens 			dump_opt[c] = 1;
5175fa9e4066Sahrens 		if (dump_opt[c])
5176fa9e4066Sahrens 			dump_opt[c] += verbose;
5177fa9e4066Sahrens 	}
5178fa9e4066Sahrens 
5179feef89cfSVictor Latushkin 	aok = (dump_opt['A'] == 1) || (dump_opt['A'] > 2);
5180feef89cfSVictor Latushkin 	zfs_recover = (dump_opt['A'] > 1);
5181feef89cfSVictor Latushkin 
5182fa9e4066Sahrens 	argc -= optind;
5183fa9e4066Sahrens 	argv += optind;
5184fa9e4066Sahrens 
518507428bdfSVictor Latushkin 	if (argc < 2 && dump_opt['R'])
518607428bdfSVictor Latushkin 		usage();
51874923c69fSMatthew Ahrens 
51884923c69fSMatthew Ahrens 	if (dump_opt['E']) {
51894923c69fSMatthew Ahrens 		if (argc != 1)
51904923c69fSMatthew Ahrens 			usage();
51914923c69fSMatthew Ahrens 		zdb_embedded_block(argv[0]);
51924923c69fSMatthew Ahrens 		return (0);
51934923c69fSMatthew Ahrens 	}
51944923c69fSMatthew Ahrens 
5195fa9e4066Sahrens 	if (argc < 1) {
51963ad6c7f9SVictor Latushkin 		if (!dump_opt['e'] && dump_opt['C']) {
5197e829d913Sck 			dump_cachefile(spa_config_path);
5198fa9e4066Sahrens 			return (0);
5199fa9e4066Sahrens 		}
5200fa9e4066Sahrens 		usage();
5201fa9e4066Sahrens 	}
5202fa9e4066Sahrens 
520364723e36SYuri Pankov 	if (dump_opt['l'])
520464723e36SYuri Pankov 		return (dump_label(argv[0]));
5205fa9e4066Sahrens 
5206ed61ec1dSYuri Pankov 	if (dump_opt['O']) {
5207ed61ec1dSYuri Pankov 		if (argc != 2)
5208ed61ec1dSYuri Pankov 			usage();
5209ed61ec1dSYuri Pankov 		dump_opt['v'] = verbose + 3;
5210ed61ec1dSYuri Pankov 		return (dump_path(argv[0], argv[1]));
5211ed61ec1dSYuri Pankov 	}
5212ed61ec1dSYuri Pankov 
5213c8ee1847SVictor Latushkin 	if (dump_opt['X'] || dump_opt['F'])
5214c8ee1847SVictor Latushkin 		rewind = ZPOOL_DO_REWIND |
5215c8ee1847SVictor Latushkin 		    (dump_opt['X'] ? ZPOOL_EXTREME_REWIND : 0);
5216c8ee1847SVictor Latushkin 
5217c8ee1847SVictor Latushkin 	if (nvlist_alloc(&policy, NV_UNIQUE_NAME_TYPE, 0) != 0 ||
52185dafeea3SPavel Zakharov 	    nvlist_add_uint64(policy, ZPOOL_LOAD_REQUEST_TXG, max_txg) != 0 ||
52195dafeea3SPavel Zakharov 	    nvlist_add_uint32(policy, ZPOOL_LOAD_REWIND_POLICY, rewind) != 0)
5220c8ee1847SVictor Latushkin 		fatal("internal error: %s", strerror(ENOMEM));
5221c8ee1847SVictor Latushkin 
5222c5904d13Seschrock 	error = 0;
52233ad6c7f9SVictor Latushkin 	target = argv[0];
5224990b4856Slling 
52253ad6c7f9SVictor Latushkin 	if (dump_opt['e']) {
52263ad6c7f9SVictor Latushkin 		char *name = find_zpool(&target, &cfg, nsearch, searchdirs);
5227990b4856Slling 
52283ad6c7f9SVictor Latushkin 		error = ENOENT;
52293ad6c7f9SVictor Latushkin 		if (name) {
523007428bdfSVictor Latushkin 			if (dump_opt['C'] > 1) {
523107428bdfSVictor Latushkin 				(void) printf("\nConfiguration for import:\n");
523207428bdfSVictor Latushkin 				dump_nvlist(cfg, 8);
523307428bdfSVictor Latushkin 			}
523486714001SSerapheim Dimitropoulos 
5235c8ee1847SVictor Latushkin 			if (nvlist_add_nvlist(cfg,
52365dafeea3SPavel Zakharov 			    ZPOOL_LOAD_POLICY, policy) != 0) {
5237468c413aSTim Haley 				fatal("can't open '%s': %s",
5238468c413aSTim Haley 				    target, strerror(ENOMEM));
5239468c413aSTim Haley 			}
5240dfd5965fSRichard Yao 			error = spa_import(name, cfg, NULL, flags);
5241de6628f0Sck 		}
5242c5904d13Seschrock 	}
5243c5904d13Seschrock 
524486714001SSerapheim Dimitropoulos 	char *checkpoint_pool = NULL;
524586714001SSerapheim Dimitropoulos 	char *checkpoint_target = NULL;
524686714001SSerapheim Dimitropoulos 	if (dump_opt['k']) {
524786714001SSerapheim Dimitropoulos 		checkpoint_pool = import_checkpointed_state(target, cfg,
524886714001SSerapheim Dimitropoulos 		    &checkpoint_target);
524986714001SSerapheim Dimitropoulos 
525086714001SSerapheim Dimitropoulos 		if (checkpoint_target != NULL)
525186714001SSerapheim Dimitropoulos 			target = checkpoint_target;
525286714001SSerapheim Dimitropoulos 
525386714001SSerapheim Dimitropoulos 	}
525486714001SSerapheim Dimitropoulos 
5255b702644aSTim Chase 	if (strpbrk(target, "/@") != NULL) {
5256b702644aSTim Chase 		size_t targetlen;
5257b702644aSTim Chase 
5258b702644aSTim Chase 		target_is_spa = B_FALSE;
5259b702644aSTim Chase 		/*
5260b702644aSTim Chase 		 * Remove any trailing slash.  Later code would get confused
5261b702644aSTim Chase 		 * by it, but we want to allow it so that "pool/" can
5262b702644aSTim Chase 		 * indicate that we want to dump the topmost filesystem,
5263b702644aSTim Chase 		 * rather than the whole pool.
5264b702644aSTim Chase 		 */
5265b702644aSTim Chase 		targetlen = strlen(target);
5266b702644aSTim Chase 		if (targetlen != 0 && target[targetlen - 1] == '/')
5267b702644aSTim Chase 			target[targetlen - 1] = '\0';
5268b702644aSTim Chase 	}
5269b702644aSTim Chase 
5270c5904d13Seschrock 	if (error == 0) {
527186714001SSerapheim Dimitropoulos 		if (dump_opt['k'] && (target_is_spa || dump_opt['R'])) {
527286714001SSerapheim Dimitropoulos 			ASSERT(checkpoint_pool != NULL);
527386714001SSerapheim Dimitropoulos 			ASSERT(checkpoint_target == NULL);
527486714001SSerapheim Dimitropoulos 
527586714001SSerapheim Dimitropoulos 			error = spa_open(checkpoint_pool, &spa, FTAG);
527686714001SSerapheim Dimitropoulos 			if (error != 0) {
527786714001SSerapheim Dimitropoulos 				fatal("Tried to open pool \"%s\" but "
527886714001SSerapheim Dimitropoulos 				    "spa_open() failed with error %d\n",
527986714001SSerapheim Dimitropoulos 				    checkpoint_pool, error);
528086714001SSerapheim Dimitropoulos 			}
528186714001SSerapheim Dimitropoulos 
528286714001SSerapheim Dimitropoulos 		} else if (target_is_spa || dump_opt['R']) {
528380eb36f2SGeorge Wilson 			error = spa_open_rewind(target, &spa, FTAG, policy,
528480eb36f2SGeorge Wilson 			    NULL);
52858f18d1faSGeorge Wilson 			if (error) {
52868f18d1faSGeorge Wilson 				/*
52878f18d1faSGeorge Wilson 				 * If we're missing the log device then
52888f18d1faSGeorge Wilson 				 * try opening the pool after clearing the
52898f18d1faSGeorge Wilson 				 * log state.
52908f18d1faSGeorge Wilson 				 */
52918f18d1faSGeorge Wilson 				mutex_enter(&spa_namespace_lock);
52923ad6c7f9SVictor Latushkin 				if ((spa = spa_lookup(target)) != NULL &&
52938f18d1faSGeorge Wilson 				    spa->spa_log_state == SPA_LOG_MISSING) {
52948f18d1faSGeorge Wilson 					spa->spa_log_state = SPA_LOG_CLEAR;
52958f18d1faSGeorge Wilson 					error = 0;
52968f18d1faSGeorge Wilson 				}
52978f18d1faSGeorge Wilson 				mutex_exit(&spa_namespace_lock);
52988f18d1faSGeorge Wilson 
529980eb36f2SGeorge Wilson 				if (!error) {
530080eb36f2SGeorge Wilson 					error = spa_open_rewind(target, &spa,
530180eb36f2SGeorge Wilson 					    FTAG, policy, NULL);
530280eb36f2SGeorge Wilson 				}
53038f18d1faSGeorge Wilson 			}
530407428bdfSVictor Latushkin 		} else {
5305ed61ec1dSYuri Pankov 			error = open_objset(target, DMU_OST_ANY, FTAG, &os);
5306c5904d13Seschrock 		}
5307fa9e4066Sahrens 	}
530880eb36f2SGeorge Wilson 	nvlist_free(policy);
530980eb36f2SGeorge Wilson 
5310fa9e4066Sahrens 	if (error)
53113ad6c7f9SVictor Latushkin 		fatal("can't open '%s': %s", target, strerror(error));
5312fa9e4066Sahrens 
5313fa9e4066Sahrens 	argv++;
531407428bdfSVictor Latushkin 	argc--;
531507428bdfSVictor Latushkin 	if (!dump_opt['R']) {
531607428bdfSVictor Latushkin 		if (argc > 0) {
531707428bdfSVictor Latushkin 			zopt_objects = argc;
531807428bdfSVictor Latushkin 			zopt_object = calloc(zopt_objects, sizeof (uint64_t));
53193f7978d0SAlan Somers 			for (unsigned i = 0; i < zopt_objects; i++) {
532007428bdfSVictor Latushkin 				errno = 0;
532107428bdfSVictor Latushkin 				zopt_object[i] = strtoull(argv[i], NULL, 0);
532207428bdfSVictor Latushkin 				if (zopt_object[i] == 0 && errno != 0)
532387219db7SVictor Latushkin 					fatal("bad number %s: %s",
532407428bdfSVictor Latushkin 					    argv[i], strerror(errno));
532507428bdfSVictor Latushkin 			}
5326fa9e4066Sahrens 		}
5327e690fb27SChristopher Siden 		if (os != NULL) {
5328e690fb27SChristopher Siden 			dump_dir(os);
5329e690fb27SChristopher Siden 		} else if (zopt_objects > 0 && !dump_opt['m']) {
5330e690fb27SChristopher Siden 			dump_dir(spa->spa_meta_objset);
5331e690fb27SChristopher Siden 		} else {
5332e690fb27SChristopher Siden 			dump_zpool(spa);
5333e690fb27SChristopher Siden 		}
5334fa9e4066Sahrens 	} else {
533507428bdfSVictor Latushkin 		flagbits['b'] = ZDB_FLAG_PRINT_BLKPTR;
533607428bdfSVictor Latushkin 		flagbits['c'] = ZDB_FLAG_CHECKSUM;
533707428bdfSVictor Latushkin 		flagbits['d'] = ZDB_FLAG_DECOMPRESS;
533807428bdfSVictor Latushkin 		flagbits['e'] = ZDB_FLAG_BSWAP;
533907428bdfSVictor Latushkin 		flagbits['g'] = ZDB_FLAG_GBH;
534007428bdfSVictor Latushkin 		flagbits['i'] = ZDB_FLAG_INDIRECT;
534107428bdfSVictor Latushkin 		flagbits['p'] = ZDB_FLAG_PHYS;
534207428bdfSVictor Latushkin 		flagbits['r'] = ZDB_FLAG_RAW;
534307428bdfSVictor Latushkin 
53443f7978d0SAlan Somers 		for (int i = 0; i < argc; i++)
534507428bdfSVictor Latushkin 			zdb_read_block(argv[i], spa);
5346fa9e4066Sahrens 	}
5347fa9e4066Sahrens 
534886714001SSerapheim Dimitropoulos 	if (dump_opt['k']) {
534986714001SSerapheim Dimitropoulos 		free(checkpoint_pool);
535086714001SSerapheim Dimitropoulos 		if (!target_is_spa)
535186714001SSerapheim Dimitropoulos 			free(checkpoint_target);
535286714001SSerapheim Dimitropoulos 	}
535386714001SSerapheim Dimitropoulos 
5354ed61ec1dSYuri Pankov 	if (os != NULL)
5355ed61ec1dSYuri Pankov 		close_objset(os, FTAG);
5356ed61ec1dSYuri Pankov 	else
5357ed61ec1dSYuri Pankov 		spa_close(spa, FTAG);
535807428bdfSVictor Latushkin 
5359e0d35c44Smarks 	fuid_table_destroy();
5360e0d35c44Smarks 
536129bdd2f9SPavel Zakharov 	dump_debug_buffer();
536229bdd2f9SPavel Zakharov 
5363de6628f0Sck 	libzfs_fini(g_zfs);
5364fa9e4066Sahrens 	kernel_fini();
5365fa9e4066Sahrens 
5366fa9e4066Sahrens 	return (0);
5367fa9e4066Sahrens }
5368