xref: /illumos-gate/usr/src/cmd/zdb/zdb.c (revision 32114f88)
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.
24af1d63abSPaul Dagnelie  * Copyright (c) 2011, 2019 by Delphix. All rights reserved.
25c3d26abcSMatthew Ahrens  * Copyright (c) 2014 Integros [integros.com]
26ed61ec1dSYuri Pankov  * Copyright 2017 Nexenta Systems, Inc.
27e0f1c0afSOlaf Faaland  * Copyright (c) 2017, 2018 Lawrence Livermore National Security, LLC.
28f06dce2cSAndrew Stormont  * Copyright 2017 RackTop Systems.
29fa9e4066Sahrens  */
30fa9e4066Sahrens 
31fa9e4066Sahrens #include <stdio.h>
32490d05b9SMatthew Ahrens #include <unistd.h>
33004388ebScasper #include <stdio_ext.h>
34fa9e4066Sahrens #include <stdlib.h>
3544cd46caSbillm #include <ctype.h>
36fa9e4066Sahrens #include <sys/zfs_context.h>
37fa9e4066Sahrens #include <sys/spa.h>
38fa9e4066Sahrens #include <sys/spa_impl.h>
39fa9e4066Sahrens #include <sys/dmu.h>
40fa9e4066Sahrens #include <sys/zap.h>
41fa9e4066Sahrens #include <sys/fs/zfs.h>
42fa9e4066Sahrens #include <sys/zfs_znode.h>
430a586ceaSMark Shellenbaum #include <sys/zfs_sa.h>
440a586ceaSMark Shellenbaum #include <sys/sa.h>
450a586ceaSMark Shellenbaum #include <sys/sa_impl.h>
46fa9e4066Sahrens #include <sys/vdev.h>
47fa9e4066Sahrens #include <sys/vdev_impl.h>
48fa9e4066Sahrens #include <sys/metaslab_impl.h>
49fa9e4066Sahrens #include <sys/dmu_objset.h>
50fa9e4066Sahrens #include <sys/dsl_dir.h>
51fa9e4066Sahrens #include <sys/dsl_dataset.h>
52fa9e4066Sahrens #include <sys/dsl_pool.h>
53fa9e4066Sahrens #include <sys/dbuf.h>
54fa9e4066Sahrens #include <sys/zil.h>
55fa9e4066Sahrens #include <sys/zil_impl.h>
56fa9e4066Sahrens #include <sys/stat.h>
57fa9e4066Sahrens #include <sys/resource.h>
58fa9e4066Sahrens #include <sys/dmu_traverse.h>
59fa9e4066Sahrens #include <sys/zio_checksum.h>
60fa9e4066Sahrens #include <sys/zio_compress.h>
61e0d35c44Smarks #include <sys/zfs_fuid.h>
6288b7b0f2SMatthew Ahrens #include <sys/arc.h>
63b24ab676SJeff Bonwick #include <sys/ddt.h>
64ad135b5dSChristopher Siden #include <sys/zfeature.h>
65770499e1SDan Kimmel #include <sys/abd.h>
664923c69fSMatthew Ahrens #include <sys/blkptr.h>
6717fb938fSMatthew Ahrens #include <sys/dsl_scan.h>
68eb633035STom Caputi #include <sys/dsl_crypt.h>
694445fffbSMatthew Ahrens #include <zfs_comutil.h>
700a055120SJason King #include <libcmdutils.h>
71de6628f0Sck #undef verify
72de6628f0Sck #include <libzfs.h>
73fa9e4066Sahrens 
743f7978d0SAlan Somers #include "zdb.h"
753f7978d0SAlan Somers 
76e690fb27SChristopher Siden #define	ZDB_COMPRESS_NAME(idx) ((idx) < ZIO_COMPRESS_FUNCTIONS ?	\
77e690fb27SChristopher Siden 	zio_compress_table[(idx)].ci_name : "UNKNOWN")
78e690fb27SChristopher Siden #define	ZDB_CHECKSUM_NAME(idx) ((idx) < ZIO_CHECKSUM_FUNCTIONS ?	\
79e690fb27SChristopher Siden 	zio_checksum_table[(idx)].ci_name : "UNKNOWN")
80e690fb27SChristopher Siden #define	ZDB_OT_NAME(idx) ((idx) < DMU_OT_NUMTYPES ?	\
81e690fb27SChristopher Siden 	dmu_ot[(idx)].ot_name : DMU_OT_IS_VALID(idx) ?	\
82e690fb27SChristopher Siden 	dmu_ot_byteswap[DMU_OT_BYTESWAP(idx)].ob_name : "UNKNOWN")
83e690fb27SChristopher Siden #define	ZDB_OT_TYPE(idx) ((idx) < DMU_OT_NUMTYPES ? (idx) :		\
845cabbc6bSPrashanth Sreenivasa 	(idx) == DMU_OTN_ZAP_DATA || (idx) == DMU_OTN_ZAP_METADATA ?	\
855cabbc6bSPrashanth Sreenivasa 	DMU_OT_ZAP_OTHER : \
865cabbc6bSPrashanth Sreenivasa 	(idx) == DMU_OTN_UINT64_DATA || (idx) == DMU_OTN_UINT64_METADATA ? \
875cabbc6bSPrashanth Sreenivasa 	DMU_OT_UINT64_OTHER : DMU_OT_NUMTYPES)
886de8f417SVictor Latushkin 
89feef89cfSVictor Latushkin #ifndef lint
904dd77f9eSMatthew Ahrens extern int reference_tracking_enable;
917fd05ac4SMatthew Ahrens extern boolean_t zfs_recover;
9206be9802SMatthew Ahrens extern uint64_t zfs_arc_max, zfs_arc_meta_limit;
93f7950bf1SMatthew Ahrens extern int zfs_vdev_async_read_max_active;
94f06dce2cSAndrew Stormont extern int aok;
95e144c4e6SPavel Zakharov extern boolean_t spa_load_verify_dryrun;
96feef89cfSVictor Latushkin #else
974dd77f9eSMatthew Ahrens int reference_tracking_enable;
987fd05ac4SMatthew Ahrens boolean_t zfs_recover;
9906be9802SMatthew Ahrens uint64_t zfs_arc_max, zfs_arc_meta_limit;
100f7950bf1SMatthew Ahrens int zfs_vdev_async_read_max_active;
101f06dce2cSAndrew Stormont int aok;
102e144c4e6SPavel Zakharov boolean_t spa_load_verify_dryrun;
103feef89cfSVictor Latushkin #endif
104feef89cfSVictor Latushkin 
1053f7978d0SAlan Somers static const char cmdname[] = "zdb";
106fa9e4066Sahrens uint8_t dump_opt[256];
107fa9e4066Sahrens 
108fa9e4066Sahrens typedef void object_viewer_t(objset_t *, uint64_t, void *data, size_t size);
109fa9e4066Sahrens 
110fa9e4066Sahrens uint64_t *zopt_object = NULL;
1113f7978d0SAlan Somers static unsigned zopt_objects = 0;
112de6628f0Sck libzfs_handle_t *g_zfs;
11306be9802SMatthew Ahrens uint64_t max_inflight = 1000;
11420b5dafbSPaul Dagnelie static int leaked_objects = 0;
115fa9e4066Sahrens 
116732885fcSMatthew Ahrens static void snprintf_blkptr_compact(char *, size_t, const blkptr_t *);
11717fb938fSMatthew Ahrens static void mos_obj_refd(uint64_t);
118732885fcSMatthew Ahrens 
119fa9e4066Sahrens /*
120fa9e4066Sahrens  * These libumem hooks provide a reasonable set of defaults for the allocator's
121fa9e4066Sahrens  * debugging facilities.
122fa9e4066Sahrens  */
123fa9e4066Sahrens const char *
124fa9e4066Sahrens _umem_debug_init()
125fa9e4066Sahrens {
126fa9e4066Sahrens 	return ("default,verbose"); /* $UMEM_DEBUG setting */
127fa9e4066Sahrens }
128fa9e4066Sahrens 
129fa9e4066Sahrens const char *
130fa9e4066Sahrens _umem_logging_init(void)
131fa9e4066Sahrens {
132fa9e4066Sahrens 	return ("fail,contents"); /* $UMEM_LOGGING setting */
133fa9e4066Sahrens }
134fa9e4066Sahrens 
135fa9e4066Sahrens static void
136fa9e4066Sahrens usage(void)
137fa9e4066Sahrens {
138fa9e4066Sahrens 	(void) fprintf(stderr,
13986714001SSerapheim Dimitropoulos 	    "Usage:\t%s [-AbcdDFGhikLMPsvX] [-e [-V] [-p <path> ...]] "
140ed61ec1dSYuri Pankov 	    "[-I <inflight I/Os>]\n"
141ed61ec1dSYuri Pankov 	    "\t\t[-o <var>=<value>]... [-t <txg>] [-U <cache>] [-x <dumpdir>]\n"
142ed61ec1dSYuri Pankov 	    "\t\t[<poolname> [<object> ...]]\n"
143dfd5965fSRichard Yao 	    "\t%s [-AdiPv] [-e [-V] [-p <path> ...]] [-U <cache>] <dataset> "
144ed61ec1dSYuri Pankov 	    "[<object> ...]\n"
145ed61ec1dSYuri Pankov 	    "\t%s -C [-A] [-U <cache>]\n"
146ed61ec1dSYuri Pankov 	    "\t%s -l [-Aqu] <device>\n"
147dfd5965fSRichard Yao 	    "\t%s -m [-AFLPX] [-e [-V] [-p <path> ...]] [-t <txg>] "
148dfd5965fSRichard Yao 	    "[-U <cache>]\n\t\t<poolname> [<vdev> [<metaslab> ...]]\n"
149ed61ec1dSYuri Pankov 	    "\t%s -O <dataset> <path>\n"
150dfd5965fSRichard Yao 	    "\t%s -R [-A] [-e [-V] [-p <path> ...]] [-U <cache>]\n"
151ed61ec1dSYuri Pankov 	    "\t\t<poolname> <vdev>:<offset>:<size>[:<flags>]\n"
1524923c69fSMatthew Ahrens 	    "\t%s -E [-A] word0:word1:...:word15\n"
153dfd5965fSRichard Yao 	    "\t%s -S [-AP] [-e [-V] [-p <path> ...]] [-U <cache>] "
154dfd5965fSRichard Yao 	    "<poolname>\n\n",
155ed61ec1dSYuri Pankov 	    cmdname, cmdname, cmdname, cmdname, cmdname, cmdname, cmdname,
1564923c69fSMatthew Ahrens 	    cmdname, cmdname);
1573ad6c7f9SVictor Latushkin 
1583ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    Dataset name must include at least one "
1593ad6c7f9SVictor Latushkin 	    "separator character '/' or '@'\n");
1603ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    If dataset name is specified, only that "
1613ad6c7f9SVictor Latushkin 	    "dataset is dumped\n");
1623ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    If object numbers are specified, only "
1633ad6c7f9SVictor Latushkin 	    "those objects are dumped\n\n");
1643ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    Options to control amount of output:\n");
1653ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -b block statistics\n");
1663ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -c checksum all metadata (twice for "
1676365109dSVictor Latushkin 	    "all data) blocks\n");
168ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -C config (or cachefile if alone)\n");
169ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -d dataset(s)\n");
170f0ba89beSJeff Bonwick 	(void) fprintf(stderr, "        -D dedup statistics\n");
1714923c69fSMatthew Ahrens 	(void) fprintf(stderr, "        -E decode and display block from an "
1724923c69fSMatthew Ahrens 	    "embedded block pointer\n");
173ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -h pool history\n");
174ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -i intent logs\n");
17564723e36SYuri Pankov 	(void) fprintf(stderr, "        -l read label contents\n");
17686714001SSerapheim Dimitropoulos 	(void) fprintf(stderr, "        -k examine the checkpointed state "
17786714001SSerapheim Dimitropoulos 	    "of the pool\n");
17882a0a985SVictor Latushkin 	(void) fprintf(stderr, "        -L disable leak tracking (do not "
17982a0a985SVictor Latushkin 	    "load spacemaps)\n");
180ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -m metaslabs\n");
181ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -M metaslab groups\n");
182ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -O perform object lookups by path\n");
183d41e7643Sek 	(void) fprintf(stderr, "        -R read and display block from a "
184ed61ec1dSYuri Pankov 	    "device\n");
185ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -s report stats on zdb's I/O\n");
186ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -S simulate dedup to measure effect\n");
187ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -v verbose (applies to all "
188ed61ec1dSYuri Pankov 	    "others)\n\n");
1893ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    Below options are intended for use "
190df15e419SMatthew Ahrens 	    "with other options:\n");
191feef89cfSVictor Latushkin 	(void) fprintf(stderr, "        -A ignore assertions (-A), enable "
192feef89cfSVictor Latushkin 	    "panic recovery (-AA) or both (-AAA)\n");
1933ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -e pool is exported/destroyed/"
1943ad6c7f9SVictor Latushkin 	    "has altroot/not in a cachefile\n");
195ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -F attempt automatic rewind within "
196ed61ec1dSYuri Pankov 	    "safe range of transaction groups\n");
197ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -G dump zfs_dbgmsg buffer before "
198ed61ec1dSYuri Pankov 	    "exiting\n");
1992e4c9986SGeorge Wilson 	(void) fprintf(stderr, "        -I <number of inflight I/Os> -- "
200df15e419SMatthew Ahrens 	    "specify the maximum number of "
201df15e419SMatthew Ahrens 	    "checksumming I/Os [default is 200]\n");
2020e60744cSPavel Zakharov 	(void) fprintf(stderr, "        -o <variable>=<value> set global "
2030e60744cSPavel Zakharov 	    "variable to an unsigned 32-bit integer value\n");
204ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -p <path> -- use one or more with "
205ed61ec1dSYuri Pankov 	    "-e to specify path to vdev dir\n");
206ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -P print numbers in parseable form\n");
20764723e36SYuri Pankov 	(void) fprintf(stderr, "        -q don't print label contents\n");
208ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -t <txg> -- highest txg to use when "
209ed61ec1dSYuri Pankov 	    "searching for uberblocks\n");
21064723e36SYuri Pankov 	(void) fprintf(stderr, "        -u uberblock\n");
211ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -U <cachefile_path> -- use alternate "
212ed61ec1dSYuri Pankov 	    "cachefile\n");
213dfd5965fSRichard Yao 	(void) fprintf(stderr, "        -V do verbatim import\n");
214ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -x <dumpdir> -- "
215ed61ec1dSYuri Pankov 	    "dump all read blocks into specified directory\n");
216ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -X attempt extreme rewind (does not "
217ed61ec1dSYuri Pankov 	    "work with dataset)\n\n");
218fa9e4066Sahrens 	(void) fprintf(stderr, "Specify an option more than once (e.g. -bb) "
219fa9e4066Sahrens 	    "to make only that option verbose\n");
220fa9e4066Sahrens 	(void) fprintf(stderr, "Default is to dump everything non-verbosely\n");
221fa9e4066Sahrens 	exit(1);
222fa9e4066Sahrens }
223fa9e4066Sahrens 
22429bdd2f9SPavel Zakharov static void
22529bdd2f9SPavel Zakharov dump_debug_buffer()
22629bdd2f9SPavel Zakharov {
22729bdd2f9SPavel Zakharov 	if (dump_opt['G']) {
22829bdd2f9SPavel Zakharov 		(void) printf("\n");
22929bdd2f9SPavel Zakharov 		zfs_dbgmsg_print("zdb");
23029bdd2f9SPavel Zakharov 	}
23129bdd2f9SPavel Zakharov }
23229bdd2f9SPavel Zakharov 
233ccba0801SRich Morris /*
234ccba0801SRich Morris  * Called for usage errors that are discovered after a call to spa_open(),
235ccba0801SRich Morris  * dmu_bonus_hold(), or pool_match().  abort() is called for other errors.
236ccba0801SRich Morris  */
237ccba0801SRich Morris 
238fa9e4066Sahrens static void
239fa9e4066Sahrens fatal(const char *fmt, ...)
240fa9e4066Sahrens {
241fa9e4066Sahrens 	va_list ap;
242fa9e4066Sahrens 
243fa9e4066Sahrens 	va_start(ap, fmt);
244fa9e4066Sahrens 	(void) fprintf(stderr, "%s: ", cmdname);
245fa9e4066Sahrens 	(void) vfprintf(stderr, fmt, ap);
246fa9e4066Sahrens 	va_end(ap);
247fa9e4066Sahrens 	(void) fprintf(stderr, "\n");
248fa9e4066Sahrens 
24929bdd2f9SPavel Zakharov 	dump_debug_buffer();
25029bdd2f9SPavel Zakharov 
251ccba0801SRich Morris 	exit(1);
252fa9e4066Sahrens }
253fa9e4066Sahrens 
254fa9e4066Sahrens /* ARGSUSED */
255fa9e4066Sahrens static void
256fa9e4066Sahrens dump_packed_nvlist(objset_t *os, uint64_t object, void *data, size_t size)
257fa9e4066Sahrens {
258fa9e4066Sahrens 	nvlist_t *nv;
259fa9e4066Sahrens 	size_t nvsize = *(uint64_t *)data;
260fa9e4066Sahrens 	char *packed = umem_alloc(nvsize, UMEM_NOFAIL);
261fa9e4066Sahrens 
2627bfdf011SNeil Perrin 	VERIFY(0 == dmu_read(os, object, 0, nvsize, packed, DMU_READ_PREFETCH));
263fa9e4066Sahrens 
264fa9e4066Sahrens 	VERIFY(nvlist_unpack(packed, nvsize, &nv, 0) == 0);
265fa9e4066Sahrens 
266fa9e4066Sahrens 	umem_free(packed, nvsize);
267fa9e4066Sahrens 
268fa9e4066Sahrens 	dump_nvlist(nv, 8);
269fa9e4066Sahrens 
270fa9e4066Sahrens 	nvlist_free(nv);
271fa9e4066Sahrens }
272fa9e4066Sahrens 
2734445fffbSMatthew Ahrens /* ARGSUSED */
2744445fffbSMatthew Ahrens static void
2754445fffbSMatthew Ahrens dump_history_offsets(objset_t *os, uint64_t object, void *data, size_t size)
2764445fffbSMatthew Ahrens {
2774445fffbSMatthew Ahrens 	spa_history_phys_t *shp = data;
2784445fffbSMatthew Ahrens 
2794445fffbSMatthew Ahrens 	if (shp == NULL)
2804445fffbSMatthew Ahrens 		return;
2814445fffbSMatthew Ahrens 
2824445fffbSMatthew Ahrens 	(void) printf("\t\tpool_create_len = %llu\n",
2834445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_pool_create_len);
2844445fffbSMatthew Ahrens 	(void) printf("\t\tphys_max_off = %llu\n",
2854445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_phys_max_off);
2864445fffbSMatthew Ahrens 	(void) printf("\t\tbof = %llu\n",
2874445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_bof);
2884445fffbSMatthew Ahrens 	(void) printf("\t\teof = %llu\n",
2894445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_eof);
2904445fffbSMatthew Ahrens 	(void) printf("\t\trecords_lost = %llu\n",
2914445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_records_lost);
2924445fffbSMatthew Ahrens }
2934445fffbSMatthew Ahrens 
2943f9d6ad7SLin Ling static void
2950a055120SJason King zdb_nicenum(uint64_t num, char *buf, size_t buflen)
2963f9d6ad7SLin Ling {
2973f9d6ad7SLin Ling 	if (dump_opt['P'])
2980a055120SJason King 		(void) snprintf(buf, buflen, "%llu", (longlong_t)num);
2993f9d6ad7SLin Ling 	else
3000a055120SJason King 		nicenum(num, buf, sizeof (buf));
3013f9d6ad7SLin Ling }
3023f9d6ad7SLin Ling 
3033f7978d0SAlan Somers static const char histo_stars[] = "****************************************";
3043f7978d0SAlan Somers static const uint64_t histo_width = sizeof (histo_stars) - 1;
305fa9e4066Sahrens 
306fa9e4066Sahrens static void
3070713e232SGeorge Wilson dump_histogram(const uint64_t *histo, int size, int offset)
308fa9e4066Sahrens {
309fa9e4066Sahrens 	int i;
310490d05b9SMatthew Ahrens 	int minidx = size - 1;
311fa9e4066Sahrens 	int maxidx = 0;
312fa9e4066Sahrens 	uint64_t max = 0;
313fa9e4066Sahrens 
314490d05b9SMatthew Ahrens 	for (i = 0; i < size; i++) {
315fa9e4066Sahrens 		if (histo[i] > max)
316fa9e4066Sahrens 			max = histo[i];
317fa9e4066Sahrens 		if (histo[i] > 0 && i > maxidx)
318fa9e4066Sahrens 			maxidx = i;
319fa9e4066Sahrens 		if (histo[i] > 0 && i < minidx)
320fa9e4066Sahrens 			minidx = i;
321fa9e4066Sahrens 	}
322fa9e4066Sahrens 
323490d05b9SMatthew Ahrens 	if (max < histo_width)
324490d05b9SMatthew Ahrens 		max = histo_width;
325fa9e4066Sahrens 
326490d05b9SMatthew Ahrens 	for (i = minidx; i <= maxidx; i++) {
327490d05b9SMatthew Ahrens 		(void) printf("\t\t\t%3u: %6llu %s\n",
3280713e232SGeorge Wilson 		    i + offset, (u_longlong_t)histo[i],
329490d05b9SMatthew Ahrens 		    &histo_stars[(max - histo[i]) * histo_width / max]);
330490d05b9SMatthew Ahrens 	}
331fa9e4066Sahrens }
332fa9e4066Sahrens 
333fa9e4066Sahrens static void
334fa9e4066Sahrens dump_zap_stats(objset_t *os, uint64_t object)
335fa9e4066Sahrens {
336fa9e4066Sahrens 	int error;
337fa9e4066Sahrens 	zap_stats_t zs;
338fa9e4066Sahrens 
339fa9e4066Sahrens 	error = zap_get_stats(os, object, &zs);
340fa9e4066Sahrens 	if (error)
341fa9e4066Sahrens 		return;
342fa9e4066Sahrens 
343fa9e4066Sahrens 	if (zs.zs_ptrtbl_len == 0) {
344fa9e4066Sahrens 		ASSERT(zs.zs_num_blocks == 1);
345fa9e4066Sahrens 		(void) printf("\tmicrozap: %llu bytes, %llu entries\n",
346fa9e4066Sahrens 		    (u_longlong_t)zs.zs_blocksize,
347fa9e4066Sahrens 		    (u_longlong_t)zs.zs_num_entries);
348fa9e4066Sahrens 		return;
349fa9e4066Sahrens 	}
350fa9e4066Sahrens 
351fa9e4066Sahrens 	(void) printf("\tFat ZAP stats:\n");
3528248818dSnd 
3538248818dSnd 	(void) printf("\t\tPointer table:\n");
3548248818dSnd 	(void) printf("\t\t\t%llu elements\n",
355fa9e4066Sahrens 	    (u_longlong_t)zs.zs_ptrtbl_len);
3568248818dSnd 	(void) printf("\t\t\tzt_blk: %llu\n",
3578248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_zt_blk);
3588248818dSnd 	(void) printf("\t\t\tzt_numblks: %llu\n",
3598248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_zt_numblks);
3608248818dSnd 	(void) printf("\t\t\tzt_shift: %llu\n",
3618248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_zt_shift);
3628248818dSnd 	(void) printf("\t\t\tzt_blks_copied: %llu\n",
3638248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_blks_copied);
3648248818dSnd 	(void) printf("\t\t\tzt_nextblk: %llu\n",
3658248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_nextblk);
3668248818dSnd 
367fa9e4066Sahrens 	(void) printf("\t\tZAP entries: %llu\n",
368fa9e4066Sahrens 	    (u_longlong_t)zs.zs_num_entries);
369fa9e4066Sahrens 	(void) printf("\t\tLeaf blocks: %llu\n",
370fa9e4066Sahrens 	    (u_longlong_t)zs.zs_num_leafs);
371fa9e4066Sahrens 	(void) printf("\t\tTotal blocks: %llu\n",
372fa9e4066Sahrens 	    (u_longlong_t)zs.zs_num_blocks);
3738248818dSnd 	(void) printf("\t\tzap_block_type: 0x%llx\n",
3748248818dSnd 	    (u_longlong_t)zs.zs_block_type);
3758248818dSnd 	(void) printf("\t\tzap_magic: 0x%llx\n",
3768248818dSnd 	    (u_longlong_t)zs.zs_magic);
3778248818dSnd 	(void) printf("\t\tzap_salt: 0x%llx\n",
3788248818dSnd 	    (u_longlong_t)zs.zs_salt);
379fa9e4066Sahrens 
380fa9e4066Sahrens 	(void) printf("\t\tLeafs with 2^n pointers:\n");
3810713e232SGeorge Wilson 	dump_histogram(zs.zs_leafs_with_2n_pointers, ZAP_HISTOGRAM_SIZE, 0);
382fa9e4066Sahrens 
383fa9e4066Sahrens 	(void) printf("\t\tBlocks with n*5 entries:\n");
3840713e232SGeorge Wilson 	dump_histogram(zs.zs_blocks_with_n5_entries, ZAP_HISTOGRAM_SIZE, 0);
385fa9e4066Sahrens 
386fa9e4066Sahrens 	(void) printf("\t\tBlocks n/10 full:\n");
3870713e232SGeorge Wilson 	dump_histogram(zs.zs_blocks_n_tenths_full, ZAP_HISTOGRAM_SIZE, 0);
388fa9e4066Sahrens 
389fa9e4066Sahrens 	(void) printf("\t\tEntries with n chunks:\n");
3900713e232SGeorge Wilson 	dump_histogram(zs.zs_entries_using_n_chunks, ZAP_HISTOGRAM_SIZE, 0);
391fa9e4066Sahrens 
392fa9e4066Sahrens 	(void) printf("\t\tBuckets with n entries:\n");
3930713e232SGeorge Wilson 	dump_histogram(zs.zs_buckets_with_n_entries, ZAP_HISTOGRAM_SIZE, 0);
394fa9e4066Sahrens }
395fa9e4066Sahrens 
396fa9e4066Sahrens /*ARGSUSED*/
397fa9e4066Sahrens static void
398fa9e4066Sahrens dump_none(objset_t *os, uint64_t object, void *data, size_t size)
399fa9e4066Sahrens {
400fa9e4066Sahrens }
401fa9e4066Sahrens 
4026de8f417SVictor Latushkin /*ARGSUSED*/
4036de8f417SVictor Latushkin static void
4046de8f417SVictor Latushkin dump_unknown(objset_t *os, uint64_t object, void *data, size_t size)
4056de8f417SVictor Latushkin {
4066de8f417SVictor Latushkin 	(void) printf("\tUNKNOWN OBJECT TYPE\n");
4076de8f417SVictor Latushkin }
4086de8f417SVictor Latushkin 
409fa9e4066Sahrens /*ARGSUSED*/
4103f7978d0SAlan Somers static void
411fa9e4066Sahrens dump_uint8(objset_t *os, uint64_t object, void *data, size_t size)
412fa9e4066Sahrens {
413fa9e4066Sahrens }
414fa9e4066Sahrens 
415fa9e4066Sahrens /*ARGSUSED*/
416fa9e4066Sahrens static void
417fa9e4066Sahrens dump_uint64(objset_t *os, uint64_t object, void *data, size_t size)
418fa9e4066Sahrens {
419fa9e4066Sahrens }
420fa9e4066Sahrens 
421fa9e4066Sahrens /*ARGSUSED*/
422fa9e4066Sahrens static void
423fa9e4066Sahrens dump_zap(objset_t *os, uint64_t object, void *data, size_t size)
424fa9e4066Sahrens {
425fa9e4066Sahrens 	zap_cursor_t zc;
426fa9e4066Sahrens 	zap_attribute_t attr;
427fa9e4066Sahrens 	void *prop;
4283f7978d0SAlan Somers 	unsigned i;
429fa9e4066Sahrens 
430fa9e4066Sahrens 	dump_zap_stats(os, object);
431fa9e4066Sahrens 	(void) printf("\n");
432fa9e4066Sahrens 
433fa9e4066Sahrens 	for (zap_cursor_init(&zc, os, object);
434fa9e4066Sahrens 	    zap_cursor_retrieve(&zc, &attr) == 0;
435fa9e4066Sahrens 	    zap_cursor_advance(&zc)) {
436fa9e4066Sahrens 		(void) printf("\t\t%s = ", attr.za_name);
437fa9e4066Sahrens 		if (attr.za_num_integers == 0) {
438fa9e4066Sahrens 			(void) printf("\n");
439fa9e4066Sahrens 			continue;
440fa9e4066Sahrens 		}
441fa9e4066Sahrens 		prop = umem_zalloc(attr.za_num_integers *
442fa9e4066Sahrens 		    attr.za_integer_length, UMEM_NOFAIL);
443fa9e4066Sahrens 		(void) zap_lookup(os, object, attr.za_name,
444fa9e4066Sahrens 		    attr.za_integer_length, attr.za_num_integers, prop);
445fa9e4066Sahrens 		if (attr.za_integer_length == 1) {
4462d37a1a3SToomas Soome 			if (strcmp(attr.za_name,
4472d37a1a3SToomas Soome 			    DSL_CRYPTO_KEY_MASTER_KEY) == 0 ||
4482d37a1a3SToomas Soome 			    strcmp(attr.za_name,
4492d37a1a3SToomas Soome 			    DSL_CRYPTO_KEY_HMAC_KEY) == 0 ||
4502d37a1a3SToomas Soome 			    strcmp(attr.za_name, DSL_CRYPTO_KEY_IV) == 0 ||
451*32114f88SToomas Soome 			    strcmp(attr.za_name, DSL_CRYPTO_KEY_MAC) == 0 ||
452*32114f88SToomas Soome 			    strcmp(attr.za_name, DMU_POOL_CHECKSUM_SALT) == 0) {
4532d37a1a3SToomas Soome 				uint8_t *u8 = prop;
4542d37a1a3SToomas Soome 
4552d37a1a3SToomas Soome 				for (i = 0; i < attr.za_num_integers; i++) {
4562d37a1a3SToomas Soome 					(void) printf("%02x", u8[i]);
4572d37a1a3SToomas Soome 				}
4582d37a1a3SToomas Soome 			} else {
4592d37a1a3SToomas Soome 				(void) printf("%s", (char *)prop);
4602d37a1a3SToomas Soome 			}
461fa9e4066Sahrens 		} else {
462fa9e4066Sahrens 			for (i = 0; i < attr.za_num_integers; i++) {
463fa9e4066Sahrens 				switch (attr.za_integer_length) {
464fa9e4066Sahrens 				case 2:
465fa9e4066Sahrens 					(void) printf("%u ",
466fa9e4066Sahrens 					    ((uint16_t *)prop)[i]);
467fa9e4066Sahrens 					break;
468fa9e4066Sahrens 				case 4:
469fa9e4066Sahrens 					(void) printf("%u ",
470fa9e4066Sahrens 					    ((uint32_t *)prop)[i]);
471fa9e4066Sahrens 					break;
472fa9e4066Sahrens 				case 8:
473fa9e4066Sahrens 					(void) printf("%lld ",
474fa9e4066Sahrens 					    (u_longlong_t)((int64_t *)prop)[i]);
475fa9e4066Sahrens 					break;
476fa9e4066Sahrens 				}
477fa9e4066Sahrens 			}
478fa9e4066Sahrens 		}
479fa9e4066Sahrens 		(void) printf("\n");
480fa9e4066Sahrens 		umem_free(prop, attr.za_num_integers * attr.za_integer_length);
481fa9e4066Sahrens 	}
48287e5029aSahrens 	zap_cursor_fini(&zc);
483fa9e4066Sahrens }
484fa9e4066Sahrens 
485732885fcSMatthew Ahrens static void
486732885fcSMatthew Ahrens dump_bpobj(objset_t *os, uint64_t object, void *data, size_t size)
487732885fcSMatthew Ahrens {
488732885fcSMatthew Ahrens 	bpobj_phys_t *bpop = data;
489732885fcSMatthew Ahrens 	char bytes[32], comp[32], uncomp[32];
490732885fcSMatthew Ahrens 
4910a055120SJason King 	/* make sure the output won't get truncated */
4920a055120SJason King 	CTASSERT(sizeof (bytes) >= NN_NUMBUF_SZ);
4930a055120SJason King 	CTASSERT(sizeof (comp) >= NN_NUMBUF_SZ);
4940a055120SJason King 	CTASSERT(sizeof (uncomp) >= NN_NUMBUF_SZ);
4950a055120SJason King 
496732885fcSMatthew Ahrens 	if (bpop == NULL)
497732885fcSMatthew Ahrens 		return;
498732885fcSMatthew Ahrens 
4990a055120SJason King 	zdb_nicenum(bpop->bpo_bytes, bytes, sizeof (bytes));
5000a055120SJason King 	zdb_nicenum(bpop->bpo_comp, comp, sizeof (comp));
5010a055120SJason King 	zdb_nicenum(bpop->bpo_uncomp, uncomp, sizeof (uncomp));
502732885fcSMatthew Ahrens 
503732885fcSMatthew Ahrens 	(void) printf("\t\tnum_blkptrs = %llu\n",
504732885fcSMatthew Ahrens 	    (u_longlong_t)bpop->bpo_num_blkptrs);
505732885fcSMatthew Ahrens 	(void) printf("\t\tbytes = %s\n", bytes);
506732885fcSMatthew Ahrens 	if (size >= BPOBJ_SIZE_V1) {
507732885fcSMatthew Ahrens 		(void) printf("\t\tcomp = %s\n", comp);
508732885fcSMatthew Ahrens 		(void) printf("\t\tuncomp = %s\n", uncomp);
509732885fcSMatthew Ahrens 	}
510732885fcSMatthew Ahrens 	if (size >= sizeof (*bpop)) {
511732885fcSMatthew Ahrens 		(void) printf("\t\tsubobjs = %llu\n",
512732885fcSMatthew Ahrens 		    (u_longlong_t)bpop->bpo_subobjs);
513732885fcSMatthew Ahrens 		(void) printf("\t\tnum_subobjs = %llu\n",
514732885fcSMatthew Ahrens 		    (u_longlong_t)bpop->bpo_num_subobjs);
515732885fcSMatthew Ahrens 	}
516732885fcSMatthew Ahrens 
517732885fcSMatthew Ahrens 	if (dump_opt['d'] < 5)
518732885fcSMatthew Ahrens 		return;
519732885fcSMatthew Ahrens 
520732885fcSMatthew Ahrens 	for (uint64_t i = 0; i < bpop->bpo_num_blkptrs; i++) {
521732885fcSMatthew Ahrens 		char blkbuf[BP_SPRINTF_LEN];
522732885fcSMatthew Ahrens 		blkptr_t bp;
523732885fcSMatthew Ahrens 
524732885fcSMatthew Ahrens 		int err = dmu_read(os, object,
525732885fcSMatthew Ahrens 		    i * sizeof (bp), sizeof (bp), &bp, 0);
526732885fcSMatthew Ahrens 		if (err != 0) {
527732885fcSMatthew Ahrens 			(void) printf("got error %u from dmu_read\n", err);
528732885fcSMatthew Ahrens 			break;
529732885fcSMatthew Ahrens 		}
530732885fcSMatthew Ahrens 		snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), &bp);
531732885fcSMatthew Ahrens 		(void) printf("\t%s\n", blkbuf);
532732885fcSMatthew Ahrens 	}
533732885fcSMatthew Ahrens }
534732885fcSMatthew Ahrens 
535732885fcSMatthew Ahrens /* ARGSUSED */
536732885fcSMatthew Ahrens static void
537732885fcSMatthew Ahrens dump_bpobj_subobjs(objset_t *os, uint64_t object, void *data, size_t size)
538732885fcSMatthew Ahrens {
539732885fcSMatthew Ahrens 	dmu_object_info_t doi;
540732885fcSMatthew Ahrens 
541732885fcSMatthew Ahrens 	VERIFY0(dmu_object_info(os, object, &doi));
542732885fcSMatthew Ahrens 	uint64_t *subobjs = kmem_alloc(doi.doi_max_offset, KM_SLEEP);
543732885fcSMatthew Ahrens 
544732885fcSMatthew Ahrens 	int err = dmu_read(os, object, 0, doi.doi_max_offset, subobjs, 0);
545732885fcSMatthew Ahrens 	if (err != 0) {
546732885fcSMatthew Ahrens 		(void) printf("got error %u from dmu_read\n", err);
547732885fcSMatthew Ahrens 		kmem_free(subobjs, doi.doi_max_offset);
548732885fcSMatthew Ahrens 		return;
549732885fcSMatthew Ahrens 	}
550732885fcSMatthew Ahrens 
551732885fcSMatthew Ahrens 	int64_t last_nonzero = -1;
552732885fcSMatthew Ahrens 	for (uint64_t i = 0; i < doi.doi_max_offset / 8; i++) {
553732885fcSMatthew Ahrens 		if (subobjs[i] != 0)
554732885fcSMatthew Ahrens 			last_nonzero = i;
555732885fcSMatthew Ahrens 	}
556732885fcSMatthew Ahrens 
557732885fcSMatthew Ahrens 	for (int64_t i = 0; i <= last_nonzero; i++) {
558732885fcSMatthew Ahrens 		(void) printf("\t%llu\n", (longlong_t)subobjs[i]);
559732885fcSMatthew Ahrens 	}
560732885fcSMatthew Ahrens 	kmem_free(subobjs, doi.doi_max_offset);
561732885fcSMatthew Ahrens }
562732885fcSMatthew Ahrens 
563486ae710SMatthew Ahrens /*ARGSUSED*/
564486ae710SMatthew Ahrens static void
565486ae710SMatthew Ahrens dump_ddt_zap(objset_t *os, uint64_t object, void *data, size_t size)
566486ae710SMatthew Ahrens {
567486ae710SMatthew Ahrens 	dump_zap_stats(os, object);
568486ae710SMatthew Ahrens 	/* contents are printed elsewhere, properly decoded */
569486ae710SMatthew Ahrens }
570486ae710SMatthew Ahrens 
5710a586ceaSMark Shellenbaum /*ARGSUSED*/
5720a586ceaSMark Shellenbaum static void
5730a586ceaSMark Shellenbaum dump_sa_attrs(objset_t *os, uint64_t object, void *data, size_t size)
5740a586ceaSMark Shellenbaum {
5750a586ceaSMark Shellenbaum 	zap_cursor_t zc;
5760a586ceaSMark Shellenbaum 	zap_attribute_t attr;
5770a586ceaSMark Shellenbaum 
5780a586ceaSMark Shellenbaum 	dump_zap_stats(os, object);
5790a586ceaSMark Shellenbaum 	(void) printf("\n");
5800a586ceaSMark Shellenbaum 
5810a586ceaSMark Shellenbaum 	for (zap_cursor_init(&zc, os, object);
5820a586ceaSMark Shellenbaum 	    zap_cursor_retrieve(&zc, &attr) == 0;
5830a586ceaSMark Shellenbaum 	    zap_cursor_advance(&zc)) {
5840a586ceaSMark Shellenbaum 		(void) printf("\t\t%s = ", attr.za_name);
5850a586ceaSMark Shellenbaum 		if (attr.za_num_integers == 0) {
5860a586ceaSMark Shellenbaum 			(void) printf("\n");
5870a586ceaSMark Shellenbaum 			continue;
5880a586ceaSMark Shellenbaum 		}
5890a586ceaSMark Shellenbaum 		(void) printf(" %llx : [%d:%d:%d]\n",
5900a586ceaSMark Shellenbaum 		    (u_longlong_t)attr.za_first_integer,
5910a586ceaSMark Shellenbaum 		    (int)ATTR_LENGTH(attr.za_first_integer),
5920a586ceaSMark Shellenbaum 		    (int)ATTR_BSWAP(attr.za_first_integer),
5930a586ceaSMark Shellenbaum 		    (int)ATTR_NUM(attr.za_first_integer));
5940a586ceaSMark Shellenbaum 	}
5950a586ceaSMark Shellenbaum 	zap_cursor_fini(&zc);
5960a586ceaSMark Shellenbaum }
5970a586ceaSMark Shellenbaum 
5980a586ceaSMark Shellenbaum /*ARGSUSED*/
5990a586ceaSMark Shellenbaum static void
6000a586ceaSMark Shellenbaum dump_sa_layouts(objset_t *os, uint64_t object, void *data, size_t size)
6010a586ceaSMark Shellenbaum {
6020a586ceaSMark Shellenbaum 	zap_cursor_t zc;
6030a586ceaSMark Shellenbaum 	zap_attribute_t attr;
6040a586ceaSMark Shellenbaum 	uint16_t *layout_attrs;
6053f7978d0SAlan Somers 	unsigned i;
6060a586ceaSMark Shellenbaum 
6070a586ceaSMark Shellenbaum 	dump_zap_stats(os, object);
6080a586ceaSMark Shellenbaum 	(void) printf("\n");
6090a586ceaSMark Shellenbaum 
6100a586ceaSMark Shellenbaum 	for (zap_cursor_init(&zc, os, object);
6110a586ceaSMark Shellenbaum 	    zap_cursor_retrieve(&zc, &attr) == 0;
6120a586ceaSMark Shellenbaum 	    zap_cursor_advance(&zc)) {
6130a586ceaSMark Shellenbaum 		(void) printf("\t\t%s = [", attr.za_name);
6140a586ceaSMark Shellenbaum 		if (attr.za_num_integers == 0) {
6150a586ceaSMark Shellenbaum 			(void) printf("\n");
6160a586ceaSMark Shellenbaum 			continue;
6170a586ceaSMark Shellenbaum 		}
6180a586ceaSMark Shellenbaum 
6190a586ceaSMark Shellenbaum 		VERIFY(attr.za_integer_length == 2);
6200a586ceaSMark Shellenbaum 		layout_attrs = umem_zalloc(attr.za_num_integers *
6210a586ceaSMark Shellenbaum 		    attr.za_integer_length, UMEM_NOFAIL);
6220a586ceaSMark Shellenbaum 
6230a586ceaSMark Shellenbaum 		VERIFY(zap_lookup(os, object, attr.za_name,
6240a586ceaSMark Shellenbaum 		    attr.za_integer_length,
6250a586ceaSMark Shellenbaum 		    attr.za_num_integers, layout_attrs) == 0);
6260a586ceaSMark Shellenbaum 
6270a586ceaSMark Shellenbaum 		for (i = 0; i != attr.za_num_integers; i++)
6280a586ceaSMark Shellenbaum 			(void) printf(" %d ", (int)layout_attrs[i]);
6290a586ceaSMark Shellenbaum 		(void) printf("]\n");
6300a586ceaSMark Shellenbaum 		umem_free(layout_attrs,
6310a586ceaSMark Shellenbaum 		    attr.za_num_integers * attr.za_integer_length);
6320a586ceaSMark Shellenbaum 	}
6330a586ceaSMark Shellenbaum 	zap_cursor_fini(&zc);
6340a586ceaSMark Shellenbaum }
6350a586ceaSMark Shellenbaum 
636e7437265Sahrens /*ARGSUSED*/
637e7437265Sahrens static void
638e7437265Sahrens dump_zpldir(objset_t *os, uint64_t object, void *data, size_t size)
639e7437265Sahrens {
640e7437265Sahrens 	zap_cursor_t zc;
641e7437265Sahrens 	zap_attribute_t attr;
642e7437265Sahrens 	const char *typenames[] = {
643e7437265Sahrens 		/* 0 */ "not specified",
644e7437265Sahrens 		/* 1 */ "FIFO",
645e7437265Sahrens 		/* 2 */ "Character Device",
646e7437265Sahrens 		/* 3 */ "3 (invalid)",
647e7437265Sahrens 		/* 4 */ "Directory",
648e7437265Sahrens 		/* 5 */ "5 (invalid)",
649e7437265Sahrens 		/* 6 */ "Block Device",
650e7437265Sahrens 		/* 7 */ "7 (invalid)",
651e7437265Sahrens 		/* 8 */ "Regular File",
652e7437265Sahrens 		/* 9 */ "9 (invalid)",
653e7437265Sahrens 		/* 10 */ "Symbolic Link",
654e7437265Sahrens 		/* 11 */ "11 (invalid)",
655e7437265Sahrens 		/* 12 */ "Socket",
656e7437265Sahrens 		/* 13 */ "Door",
657e7437265Sahrens 		/* 14 */ "Event Port",
658e7437265Sahrens 		/* 15 */ "15 (invalid)",
659e7437265Sahrens 	};
660e7437265Sahrens 
661e7437265Sahrens 	dump_zap_stats(os, object);
662e7437265Sahrens 	(void) printf("\n");
663e7437265Sahrens 
664e7437265Sahrens 	for (zap_cursor_init(&zc, os, object);
665e7437265Sahrens 	    zap_cursor_retrieve(&zc, &attr) == 0;
666e7437265Sahrens 	    zap_cursor_advance(&zc)) {
667e7437265Sahrens 		(void) printf("\t\t%s = %lld (type: %s)\n",
668e7437265Sahrens 		    attr.za_name, ZFS_DIRENT_OBJ(attr.za_first_integer),
669e7437265Sahrens 		    typenames[ZFS_DIRENT_TYPE(attr.za_first_integer)]);
670e7437265Sahrens 	}
671e7437265Sahrens 	zap_cursor_fini(&zc);
672e7437265Sahrens }
673e7437265Sahrens 
6743f7978d0SAlan Somers static int
6750713e232SGeorge Wilson get_dtl_refcount(vdev_t *vd)
6760713e232SGeorge Wilson {
6770713e232SGeorge Wilson 	int refcount = 0;
6780713e232SGeorge Wilson 
6790713e232SGeorge Wilson 	if (vd->vdev_ops->vdev_op_leaf) {
6800713e232SGeorge Wilson 		space_map_t *sm = vd->vdev_dtl_sm;
6810713e232SGeorge Wilson 
6820713e232SGeorge Wilson 		if (sm != NULL &&
6830713e232SGeorge Wilson 		    sm->sm_dbuf->db_size == sizeof (space_map_phys_t))
6840713e232SGeorge Wilson 			return (1);
6850713e232SGeorge Wilson 		return (0);
6860713e232SGeorge Wilson 	}
6870713e232SGeorge Wilson 
6883f7978d0SAlan Somers 	for (unsigned c = 0; c < vd->vdev_children; c++)
6890713e232SGeorge Wilson 		refcount += get_dtl_refcount(vd->vdev_child[c]);
6900713e232SGeorge Wilson 	return (refcount);
6910713e232SGeorge Wilson }
6920713e232SGeorge Wilson 
6933f7978d0SAlan Somers static int
6940713e232SGeorge Wilson get_metaslab_refcount(vdev_t *vd)
6950713e232SGeorge Wilson {
6960713e232SGeorge Wilson 	int refcount = 0;
6970713e232SGeorge Wilson 
6985cabbc6bSPrashanth Sreenivasa 	if (vd->vdev_top == vd) {
6995cabbc6bSPrashanth Sreenivasa 		for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
7000713e232SGeorge Wilson 			space_map_t *sm = vd->vdev_ms[m]->ms_sm;
7010713e232SGeorge Wilson 
7020713e232SGeorge Wilson 			if (sm != NULL &&
7030713e232SGeorge Wilson 			    sm->sm_dbuf->db_size == sizeof (space_map_phys_t))
7040713e232SGeorge Wilson 				refcount++;
7050713e232SGeorge Wilson 		}
7060713e232SGeorge Wilson 	}
7073f7978d0SAlan Somers 	for (unsigned c = 0; c < vd->vdev_children; c++)
7080713e232SGeorge Wilson 		refcount += get_metaslab_refcount(vd->vdev_child[c]);
7090713e232SGeorge Wilson 
7100713e232SGeorge Wilson 	return (refcount);
7110713e232SGeorge Wilson }
7120713e232SGeorge Wilson 
7135cabbc6bSPrashanth Sreenivasa static int
7145cabbc6bSPrashanth Sreenivasa get_obsolete_refcount(vdev_t *vd)
7155cabbc6bSPrashanth Sreenivasa {
7165cabbc6bSPrashanth Sreenivasa 	int refcount = 0;
7175cabbc6bSPrashanth Sreenivasa 
7185cabbc6bSPrashanth Sreenivasa 	uint64_t obsolete_sm_obj = vdev_obsolete_sm_object(vd);
7195cabbc6bSPrashanth Sreenivasa 	if (vd->vdev_top == vd && obsolete_sm_obj != 0) {
7205cabbc6bSPrashanth Sreenivasa 		dmu_object_info_t doi;
7215cabbc6bSPrashanth Sreenivasa 		VERIFY0(dmu_object_info(vd->vdev_spa->spa_meta_objset,
7225cabbc6bSPrashanth Sreenivasa 		    obsolete_sm_obj, &doi));
7235cabbc6bSPrashanth Sreenivasa 		if (doi.doi_bonus_size == sizeof (space_map_phys_t)) {
7245cabbc6bSPrashanth Sreenivasa 			refcount++;
7255cabbc6bSPrashanth Sreenivasa 		}
7265cabbc6bSPrashanth Sreenivasa 	} else {
7275cabbc6bSPrashanth Sreenivasa 		ASSERT3P(vd->vdev_obsolete_sm, ==, NULL);
7285cabbc6bSPrashanth Sreenivasa 		ASSERT3U(obsolete_sm_obj, ==, 0);
7295cabbc6bSPrashanth Sreenivasa 	}
7305cabbc6bSPrashanth Sreenivasa 	for (unsigned c = 0; c < vd->vdev_children; c++) {
7315cabbc6bSPrashanth Sreenivasa 		refcount += get_obsolete_refcount(vd->vdev_child[c]);
7325cabbc6bSPrashanth Sreenivasa 	}
7335cabbc6bSPrashanth Sreenivasa 
7345cabbc6bSPrashanth Sreenivasa 	return (refcount);
7355cabbc6bSPrashanth Sreenivasa }
7365cabbc6bSPrashanth Sreenivasa 
7375cabbc6bSPrashanth Sreenivasa static int
7385cabbc6bSPrashanth Sreenivasa get_prev_obsolete_spacemap_refcount(spa_t *spa)
7395cabbc6bSPrashanth Sreenivasa {
7405cabbc6bSPrashanth Sreenivasa 	uint64_t prev_obj =
7415cabbc6bSPrashanth Sreenivasa 	    spa->spa_condensing_indirect_phys.scip_prev_obsolete_sm_object;
7425cabbc6bSPrashanth Sreenivasa 	if (prev_obj != 0) {
7435cabbc6bSPrashanth Sreenivasa 		dmu_object_info_t doi;
7445cabbc6bSPrashanth Sreenivasa 		VERIFY0(dmu_object_info(spa->spa_meta_objset, prev_obj, &doi));
7455cabbc6bSPrashanth Sreenivasa 		if (doi.doi_bonus_size == sizeof (space_map_phys_t)) {
7465cabbc6bSPrashanth Sreenivasa 			return (1);
7475cabbc6bSPrashanth Sreenivasa 		}
7485cabbc6bSPrashanth Sreenivasa 	}
7495cabbc6bSPrashanth Sreenivasa 	return (0);
7505cabbc6bSPrashanth Sreenivasa }
7515cabbc6bSPrashanth Sreenivasa 
75286714001SSerapheim Dimitropoulos static int
75386714001SSerapheim Dimitropoulos get_checkpoint_refcount(vdev_t *vd)
75486714001SSerapheim Dimitropoulos {
75586714001SSerapheim Dimitropoulos 	int refcount = 0;
75686714001SSerapheim Dimitropoulos 
75786714001SSerapheim Dimitropoulos 	if (vd->vdev_top == vd && vd->vdev_top_zap != 0 &&
75886714001SSerapheim Dimitropoulos 	    zap_contains(spa_meta_objset(vd->vdev_spa),
75986714001SSerapheim Dimitropoulos 	    vd->vdev_top_zap, VDEV_TOP_ZAP_POOL_CHECKPOINT_SM) == 0)
76086714001SSerapheim Dimitropoulos 		refcount++;
76186714001SSerapheim Dimitropoulos 
76286714001SSerapheim Dimitropoulos 	for (uint64_t c = 0; c < vd->vdev_children; c++)
76386714001SSerapheim Dimitropoulos 		refcount += get_checkpoint_refcount(vd->vdev_child[c]);
76486714001SSerapheim Dimitropoulos 
76586714001SSerapheim Dimitropoulos 	return (refcount);
76686714001SSerapheim Dimitropoulos }
76786714001SSerapheim Dimitropoulos 
768814dcd43SSerapheim Dimitropoulos static int
769814dcd43SSerapheim Dimitropoulos get_log_spacemap_refcount(spa_t *spa)
770814dcd43SSerapheim Dimitropoulos {
771814dcd43SSerapheim Dimitropoulos 	return (avl_numnodes(&spa->spa_sm_logs_by_txg));
772814dcd43SSerapheim Dimitropoulos }
773814dcd43SSerapheim Dimitropoulos 
7740713e232SGeorge Wilson static int
7750713e232SGeorge Wilson verify_spacemap_refcounts(spa_t *spa)
7760713e232SGeorge Wilson {
7772acef22dSMatthew Ahrens 	uint64_t expected_refcount = 0;
7782acef22dSMatthew Ahrens 	uint64_t actual_refcount;
7790713e232SGeorge Wilson 
7802acef22dSMatthew Ahrens 	(void) feature_get_refcount(spa,
7812acef22dSMatthew Ahrens 	    &spa_feature_table[SPA_FEATURE_SPACEMAP_HISTOGRAM],
7822acef22dSMatthew Ahrens 	    &expected_refcount);
7830713e232SGeorge Wilson 	actual_refcount = get_dtl_refcount(spa->spa_root_vdev);
7840713e232SGeorge Wilson 	actual_refcount += get_metaslab_refcount(spa->spa_root_vdev);
7855cabbc6bSPrashanth Sreenivasa 	actual_refcount += get_obsolete_refcount(spa->spa_root_vdev);
7865cabbc6bSPrashanth Sreenivasa 	actual_refcount += get_prev_obsolete_spacemap_refcount(spa);
78786714001SSerapheim Dimitropoulos 	actual_refcount += get_checkpoint_refcount(spa->spa_root_vdev);
788814dcd43SSerapheim Dimitropoulos 	actual_refcount += get_log_spacemap_refcount(spa);
7890713e232SGeorge Wilson 
7900713e232SGeorge Wilson 	if (expected_refcount != actual_refcount) {
7912acef22dSMatthew Ahrens 		(void) printf("space map refcount mismatch: expected %lld != "
7922acef22dSMatthew Ahrens 		    "actual %lld\n",
7932acef22dSMatthew Ahrens 		    (longlong_t)expected_refcount,
7942acef22dSMatthew Ahrens 		    (longlong_t)actual_refcount);
7950713e232SGeorge Wilson 		return (2);
7960713e232SGeorge Wilson 	}
7970713e232SGeorge Wilson 	return (0);
7980713e232SGeorge Wilson }
7990713e232SGeorge Wilson 
800fa9e4066Sahrens static void
8010713e232SGeorge Wilson dump_spacemap(objset_t *os, space_map_t *sm)
802fa9e4066Sahrens {
8035cabbc6bSPrashanth Sreenivasa 	char *ddata[] = { "ALLOC", "FREE", "CONDENSE", "INVALID",
8045cabbc6bSPrashanth Sreenivasa 	    "INVALID", "INVALID", "INVALID", "INVALID" };
805fa9e4066Sahrens 
8060713e232SGeorge Wilson 	if (sm == NULL)
807fa9e4066Sahrens 		return;
808fa9e4066Sahrens 
8095cabbc6bSPrashanth Sreenivasa 	(void) printf("space map object %llu:\n",
810555d674dSSerapheim Dimitropoulos 	    (longlong_t)sm->sm_object);
811555d674dSSerapheim Dimitropoulos 	(void) printf("  smp_length = 0x%llx\n",
812555d674dSSerapheim Dimitropoulos 	    (longlong_t)sm->sm_phys->smp_length);
8135cabbc6bSPrashanth Sreenivasa 	(void) printf("  smp_alloc = 0x%llx\n",
8145cabbc6bSPrashanth Sreenivasa 	    (longlong_t)sm->sm_phys->smp_alloc);
8155cabbc6bSPrashanth Sreenivasa 
816555d674dSSerapheim Dimitropoulos 	if (dump_opt['d'] < 6 && dump_opt['m'] < 4)
817555d674dSSerapheim Dimitropoulos 		return;
818555d674dSSerapheim Dimitropoulos 
819fa9e4066Sahrens 	/*
820fa9e4066Sahrens 	 * Print out the freelist entries in both encoded and decoded form.
821fa9e4066Sahrens 	 */
82217f11284SSerapheim Dimitropoulos 	uint8_t mapshift = sm->sm_shift;
82317f11284SSerapheim Dimitropoulos 	int64_t alloc = 0;
824555d674dSSerapheim Dimitropoulos 	uint64_t word, entry_id = 0;
82517f11284SSerapheim Dimitropoulos 	for (uint64_t offset = 0; offset < space_map_length(sm);
82617f11284SSerapheim Dimitropoulos 	    offset += sizeof (word)) {
8270713e232SGeorge Wilson 
8280713e232SGeorge Wilson 		VERIFY0(dmu_read(os, space_map_object(sm), offset,
82917f11284SSerapheim Dimitropoulos 		    sizeof (word), &word, DMU_READ_PREFETCH));
8300713e232SGeorge Wilson 
83117f11284SSerapheim Dimitropoulos 		if (sm_entry_is_debug(word)) {
832555d674dSSerapheim Dimitropoulos 			(void) printf("\t    [%6llu] %s: txg %llu pass %llu\n",
833555d674dSSerapheim Dimitropoulos 			    (u_longlong_t)entry_id,
83417f11284SSerapheim Dimitropoulos 			    ddata[SM_DEBUG_ACTION_DECODE(word)],
83517f11284SSerapheim Dimitropoulos 			    (u_longlong_t)SM_DEBUG_TXG_DECODE(word),
83617f11284SSerapheim Dimitropoulos 			    (u_longlong_t)SM_DEBUG_SYNCPASS_DECODE(word));
837555d674dSSerapheim Dimitropoulos 			entry_id++;
83817f11284SSerapheim Dimitropoulos 			continue;
83917f11284SSerapheim Dimitropoulos 		}
84017f11284SSerapheim Dimitropoulos 
84117f11284SSerapheim Dimitropoulos 		uint8_t words;
84217f11284SSerapheim Dimitropoulos 		char entry_type;
84317f11284SSerapheim Dimitropoulos 		uint64_t entry_off, entry_run, entry_vdev = SM_NO_VDEVID;
84417f11284SSerapheim Dimitropoulos 
84517f11284SSerapheim Dimitropoulos 		if (sm_entry_is_single_word(word)) {
84617f11284SSerapheim Dimitropoulos 			entry_type = (SM_TYPE_DECODE(word) == SM_ALLOC) ?
84717f11284SSerapheim Dimitropoulos 			    'A' : 'F';
84817f11284SSerapheim Dimitropoulos 			entry_off = (SM_OFFSET_DECODE(word) << mapshift) +
84917f11284SSerapheim Dimitropoulos 			    sm->sm_start;
85017f11284SSerapheim Dimitropoulos 			entry_run = SM_RUN_DECODE(word) << mapshift;
85117f11284SSerapheim Dimitropoulos 			words = 1;
852fa9e4066Sahrens 		} else {
85317f11284SSerapheim Dimitropoulos 			/* it is a two-word entry so we read another word */
85417f11284SSerapheim Dimitropoulos 			ASSERT(sm_entry_is_double_word(word));
85517f11284SSerapheim Dimitropoulos 
85617f11284SSerapheim Dimitropoulos 			uint64_t extra_word;
85717f11284SSerapheim Dimitropoulos 			offset += sizeof (extra_word);
85817f11284SSerapheim Dimitropoulos 			VERIFY0(dmu_read(os, space_map_object(sm), offset,
85917f11284SSerapheim Dimitropoulos 			    sizeof (extra_word), &extra_word,
86017f11284SSerapheim Dimitropoulos 			    DMU_READ_PREFETCH));
86117f11284SSerapheim Dimitropoulos 
86217f11284SSerapheim Dimitropoulos 			ASSERT3U(offset, <=, space_map_length(sm));
86317f11284SSerapheim Dimitropoulos 
86417f11284SSerapheim Dimitropoulos 			entry_run = SM2_RUN_DECODE(word) << mapshift;
86517f11284SSerapheim Dimitropoulos 			entry_vdev = SM2_VDEV_DECODE(word);
86617f11284SSerapheim Dimitropoulos 			entry_type = (SM2_TYPE_DECODE(extra_word) == SM_ALLOC) ?
86717f11284SSerapheim Dimitropoulos 			    'A' : 'F';
86817f11284SSerapheim Dimitropoulos 			entry_off = (SM2_OFFSET_DECODE(extra_word) <<
86917f11284SSerapheim Dimitropoulos 			    mapshift) + sm->sm_start;
87017f11284SSerapheim Dimitropoulos 			words = 2;
871fa9e4066Sahrens 		}
87217f11284SSerapheim Dimitropoulos 
87317f11284SSerapheim Dimitropoulos 		(void) printf("\t    [%6llu]    %c  range:"
87417f11284SSerapheim Dimitropoulos 		    " %010llx-%010llx  size: %06llx vdev: %06llu words: %u\n",
875555d674dSSerapheim Dimitropoulos 		    (u_longlong_t)entry_id,
87617f11284SSerapheim Dimitropoulos 		    entry_type, (u_longlong_t)entry_off,
87717f11284SSerapheim Dimitropoulos 		    (u_longlong_t)(entry_off + entry_run),
87817f11284SSerapheim Dimitropoulos 		    (u_longlong_t)entry_run,
87917f11284SSerapheim Dimitropoulos 		    (u_longlong_t)entry_vdev, words);
88017f11284SSerapheim Dimitropoulos 
88117f11284SSerapheim Dimitropoulos 		if (entry_type == 'A')
88217f11284SSerapheim Dimitropoulos 			alloc += entry_run;
88317f11284SSerapheim Dimitropoulos 		else
88417f11284SSerapheim Dimitropoulos 			alloc -= entry_run;
885555d674dSSerapheim Dimitropoulos 		entry_id++;
886fa9e4066Sahrens 	}
887555d674dSSerapheim Dimitropoulos 	if (alloc != space_map_allocated(sm)) {
88817f11284SSerapheim Dimitropoulos 		(void) printf("space_map_object alloc (%lld) INCONSISTENT "
88917f11284SSerapheim Dimitropoulos 		    "with space map summary (%lld)\n",
89017f11284SSerapheim Dimitropoulos 		    (longlong_t)space_map_allocated(sm), (longlong_t)alloc);
891fa9e4066Sahrens 	}
892fa9e4066Sahrens }
893fa9e4066Sahrens 
894d6e555bdSGeorge Wilson static void
895d6e555bdSGeorge Wilson dump_metaslab_stats(metaslab_t *msp)
896d6e555bdSGeorge Wilson {
8973f9d6ad7SLin Ling 	char maxbuf[32];
89886714001SSerapheim Dimitropoulos 	range_tree_t *rt = msp->ms_allocatable;
89986714001SSerapheim Dimitropoulos 	avl_tree_t *t = &msp->ms_allocatable_by_size;
9000713e232SGeorge Wilson 	int free_pct = range_tree_space(rt) * 100 / msp->ms_size;
901d6e555bdSGeorge Wilson 
9020a055120SJason King 	/* max sure nicenum has enough space */
9030a055120SJason King 	CTASSERT(sizeof (maxbuf) >= NN_NUMBUF_SZ);
9040a055120SJason King 
905af1d63abSPaul Dagnelie 	zdb_nicenum(metaslab_largest_allocatable(msp), maxbuf, sizeof (maxbuf));
906d6e555bdSGeorge Wilson 
90787219db7SVictor Latushkin 	(void) printf("\t %25s %10lu   %7s  %6s   %4s %4d%%\n",
908d6e555bdSGeorge Wilson 	    "segments", avl_numnodes(t), "maxsize", maxbuf,
909d6e555bdSGeorge Wilson 	    "freepct", free_pct);
9100713e232SGeorge Wilson 	(void) printf("\tIn-memory histogram:\n");
9110713e232SGeorge Wilson 	dump_histogram(rt->rt_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
912d6e555bdSGeorge Wilson }
913d6e555bdSGeorge Wilson 
914fa9e4066Sahrens static void
915fa9e4066Sahrens dump_metaslab(metaslab_t *msp)
916fa9e4066Sahrens {
917fa9e4066Sahrens 	vdev_t *vd = msp->ms_group->mg_vd;
918fa9e4066Sahrens 	spa_t *spa = vd->vdev_spa;
9190713e232SGeorge Wilson 	space_map_t *sm = msp->ms_sm;
9203f9d6ad7SLin Ling 	char freebuf[32];
921fa9e4066Sahrens 
9220a055120SJason King 	zdb_nicenum(msp->ms_size - space_map_allocated(sm), freebuf,
9230a055120SJason King 	    sizeof (freebuf));
924fa9e4066Sahrens 
925fa9e4066Sahrens 	(void) printf(
92687219db7SVictor Latushkin 	    "\tmetaslab %6llu   offset %12llx   spacemap %6llu   free    %5s\n",
9270713e232SGeorge Wilson 	    (u_longlong_t)msp->ms_id, (u_longlong_t)msp->ms_start,
9280713e232SGeorge Wilson 	    (u_longlong_t)space_map_object(sm), freebuf);
929fa9e4066Sahrens 
9300713e232SGeorge Wilson 	if (dump_opt['m'] > 2 && !dump_opt['L']) {
931d6e555bdSGeorge Wilson 		mutex_enter(&msp->ms_lock);
932a0b03b16SSerapheim Dimitropoulos 		VERIFY0(metaslab_load(msp));
933a0b03b16SSerapheim Dimitropoulos 		range_tree_stat_verify(msp->ms_allocatable);
934bc3975b5SVictor Latushkin 		dump_metaslab_stats(msp);
9350713e232SGeorge Wilson 		metaslab_unload(msp);
936d6e555bdSGeorge Wilson 		mutex_exit(&msp->ms_lock);
937d6e555bdSGeorge Wilson 	}
938d6e555bdSGeorge Wilson 
9390713e232SGeorge Wilson 	if (dump_opt['m'] > 1 && sm != NULL &&
9402acef22dSMatthew Ahrens 	    spa_feature_is_active(spa, SPA_FEATURE_SPACEMAP_HISTOGRAM)) {
9410713e232SGeorge Wilson 		/*
9420713e232SGeorge Wilson 		 * The space map histogram represents free space in chunks
9430713e232SGeorge Wilson 		 * of sm_shift (i.e. bucket 0 refers to 2^sm_shift).
9440713e232SGeorge Wilson 		 */
9452e4c9986SGeorge Wilson 		(void) printf("\tOn-disk histogram:\t\tfragmentation %llu\n",
9462e4c9986SGeorge Wilson 		    (u_longlong_t)msp->ms_fragmentation);
9470713e232SGeorge Wilson 		dump_histogram(sm->sm_phys->smp_histogram,
9482e4c9986SGeorge Wilson 		    SPACE_MAP_HISTOGRAM_SIZE, sm->sm_shift);
9490713e232SGeorge Wilson 	}
9500713e232SGeorge Wilson 
951555d674dSSerapheim Dimitropoulos 	ASSERT(msp->ms_size == (1ULL << vd->vdev_ms_shift));
952555d674dSSerapheim Dimitropoulos 	dump_spacemap(spa->spa_meta_objset, msp->ms_sm);
953814dcd43SSerapheim Dimitropoulos 
954814dcd43SSerapheim Dimitropoulos 	if (spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP)) {
955814dcd43SSerapheim Dimitropoulos 		(void) printf("\tFlush data:\n\tunflushed txg=%llu\n\n",
956814dcd43SSerapheim Dimitropoulos 		    (u_longlong_t)metaslab_unflushed_txg(msp));
957814dcd43SSerapheim Dimitropoulos 	}
95887219db7SVictor Latushkin }
959fa9e4066Sahrens 
96087219db7SVictor Latushkin static void
96187219db7SVictor Latushkin print_vdev_metaslab_header(vdev_t *vd)
96287219db7SVictor Latushkin {
963663207adSDon Brady 	vdev_alloc_bias_t alloc_bias = vd->vdev_alloc_bias;
964814dcd43SSerapheim Dimitropoulos 	const char *bias_str = "";
965814dcd43SSerapheim Dimitropoulos 
966814dcd43SSerapheim Dimitropoulos 	if (alloc_bias == VDEV_BIAS_LOG || vd->vdev_islog) {
967814dcd43SSerapheim Dimitropoulos 		bias_str = VDEV_ALLOC_BIAS_LOG;
968814dcd43SSerapheim Dimitropoulos 	} else if (alloc_bias == VDEV_BIAS_SPECIAL) {
969814dcd43SSerapheim Dimitropoulos 		bias_str = VDEV_ALLOC_BIAS_SPECIAL;
970814dcd43SSerapheim Dimitropoulos 	} else if (alloc_bias == VDEV_BIAS_DEDUP) {
971814dcd43SSerapheim Dimitropoulos 		bias_str = VDEV_ALLOC_BIAS_DEDUP;
972814dcd43SSerapheim Dimitropoulos 	}
973814dcd43SSerapheim Dimitropoulos 
974814dcd43SSerapheim Dimitropoulos 	uint64_t ms_flush_data_obj = 0;
975814dcd43SSerapheim Dimitropoulos 	if (vd->vdev_top_zap != 0) {
976814dcd43SSerapheim Dimitropoulos 		int error = zap_lookup(spa_meta_objset(vd->vdev_spa),
977814dcd43SSerapheim Dimitropoulos 		    vd->vdev_top_zap, VDEV_TOP_ZAP_MS_UNFLUSHED_PHYS_TXGS,
978814dcd43SSerapheim Dimitropoulos 		    sizeof (uint64_t), 1, &ms_flush_data_obj);
979814dcd43SSerapheim Dimitropoulos 		if (error != ENOENT) {
980814dcd43SSerapheim Dimitropoulos 			ASSERT0(error);
981814dcd43SSerapheim Dimitropoulos 		}
982814dcd43SSerapheim Dimitropoulos 	}
983814dcd43SSerapheim Dimitropoulos 
984814dcd43SSerapheim Dimitropoulos 	(void) printf("\tvdev %10llu   %s",
985814dcd43SSerapheim Dimitropoulos 	    (u_longlong_t)vd->vdev_id, bias_str);
986663207adSDon Brady 
987814dcd43SSerapheim Dimitropoulos 	if (ms_flush_data_obj != 0) {
988814dcd43SSerapheim Dimitropoulos 		(void) printf("   ms_unflushed_phys object %llu",
989814dcd43SSerapheim Dimitropoulos 		    (u_longlong_t)ms_flush_data_obj);
990814dcd43SSerapheim Dimitropoulos 	}
991663207adSDon Brady 
992814dcd43SSerapheim Dimitropoulos 	(void) printf("\n\t%-10s%5llu   %-19s   %-15s   %-12s\n",
99387219db7SVictor Latushkin 	    "metaslabs", (u_longlong_t)vd->vdev_ms_count,
99487219db7SVictor Latushkin 	    "offset", "spacemap", "free");
995663207adSDon Brady 	(void) printf("\t%15s   %19s   %15s   %12s\n",
99687219db7SVictor Latushkin 	    "---------------", "-------------------",
997663207adSDon Brady 	    "---------------", "------------");
998fa9e4066Sahrens }
999fa9e4066Sahrens 
10002e4c9986SGeorge Wilson static void
10012e4c9986SGeorge Wilson dump_metaslab_groups(spa_t *spa)
10022e4c9986SGeorge Wilson {
10032e4c9986SGeorge Wilson 	vdev_t *rvd = spa->spa_root_vdev;
10042e4c9986SGeorge Wilson 	metaslab_class_t *mc = spa_normal_class(spa);
10052e4c9986SGeorge Wilson 	uint64_t fragmentation;
10062e4c9986SGeorge Wilson 
10072e4c9986SGeorge Wilson 	metaslab_class_histogram_verify(mc);
10082e4c9986SGeorge Wilson 
10093f7978d0SAlan Somers 	for (unsigned c = 0; c < rvd->vdev_children; c++) {
10102e4c9986SGeorge Wilson 		vdev_t *tvd = rvd->vdev_child[c];
10112e4c9986SGeorge Wilson 		metaslab_group_t *mg = tvd->vdev_mg;
10122e4c9986SGeorge Wilson 
1013663207adSDon Brady 		if (mg == NULL || mg->mg_class != mc)
10142e4c9986SGeorge Wilson 			continue;
10152e4c9986SGeorge Wilson 
10162e4c9986SGeorge Wilson 		metaslab_group_histogram_verify(mg);
10172e4c9986SGeorge Wilson 		mg->mg_fragmentation = metaslab_group_fragmentation(mg);
10182e4c9986SGeorge Wilson 
10192e4c9986SGeorge Wilson 		(void) printf("\tvdev %10llu\t\tmetaslabs%5llu\t\t"
10202e4c9986SGeorge Wilson 		    "fragmentation",
10212e4c9986SGeorge Wilson 		    (u_longlong_t)tvd->vdev_id,
10222e4c9986SGeorge Wilson 		    (u_longlong_t)tvd->vdev_ms_count);
10232e4c9986SGeorge Wilson 		if (mg->mg_fragmentation == ZFS_FRAG_INVALID) {
10242e4c9986SGeorge Wilson 			(void) printf("%3s\n", "-");
10252e4c9986SGeorge Wilson 		} else {
10262e4c9986SGeorge Wilson 			(void) printf("%3llu%%\n",
10272e4c9986SGeorge Wilson 			    (u_longlong_t)mg->mg_fragmentation);
10282e4c9986SGeorge Wilson 		}
10292e4c9986SGeorge Wilson 		dump_histogram(mg->mg_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
10302e4c9986SGeorge Wilson 	}
10312e4c9986SGeorge Wilson 
10322e4c9986SGeorge Wilson 	(void) printf("\tpool %s\tfragmentation", spa_name(spa));
10332e4c9986SGeorge Wilson 	fragmentation = metaslab_class_fragmentation(mc);
10342e4c9986SGeorge Wilson 	if (fragmentation == ZFS_FRAG_INVALID)
10352e4c9986SGeorge Wilson 		(void) printf("\t%3s\n", "-");
10362e4c9986SGeorge Wilson 	else
10372e4c9986SGeorge Wilson 		(void) printf("\t%3llu%%\n", (u_longlong_t)fragmentation);
10382e4c9986SGeorge Wilson 	dump_histogram(mc->mc_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
10392e4c9986SGeorge Wilson }
10402e4c9986SGeorge Wilson 
10415cabbc6bSPrashanth Sreenivasa static void
10425cabbc6bSPrashanth Sreenivasa print_vdev_indirect(vdev_t *vd)
10435cabbc6bSPrashanth Sreenivasa {
10445cabbc6bSPrashanth Sreenivasa 	vdev_indirect_config_t *vic = &vd->vdev_indirect_config;
10455cabbc6bSPrashanth Sreenivasa 	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
10465cabbc6bSPrashanth Sreenivasa 	vdev_indirect_births_t *vib = vd->vdev_indirect_births;
10475cabbc6bSPrashanth Sreenivasa 
10485cabbc6bSPrashanth Sreenivasa 	if (vim == NULL) {
10495cabbc6bSPrashanth Sreenivasa 		ASSERT3P(vib, ==, NULL);
10505cabbc6bSPrashanth Sreenivasa 		return;
10515cabbc6bSPrashanth Sreenivasa 	}
10525cabbc6bSPrashanth Sreenivasa 
10535cabbc6bSPrashanth Sreenivasa 	ASSERT3U(vdev_indirect_mapping_object(vim), ==,
10545cabbc6bSPrashanth Sreenivasa 	    vic->vic_mapping_object);
10555cabbc6bSPrashanth Sreenivasa 	ASSERT3U(vdev_indirect_births_object(vib), ==,
10565cabbc6bSPrashanth Sreenivasa 	    vic->vic_births_object);
10575cabbc6bSPrashanth Sreenivasa 
10585cabbc6bSPrashanth Sreenivasa 	(void) printf("indirect births obj %llu:\n",
10595cabbc6bSPrashanth Sreenivasa 	    (longlong_t)vic->vic_births_object);
10605cabbc6bSPrashanth Sreenivasa 	(void) printf("    vib_count = %llu\n",
10615cabbc6bSPrashanth Sreenivasa 	    (longlong_t)vdev_indirect_births_count(vib));
10625cabbc6bSPrashanth Sreenivasa 	for (uint64_t i = 0; i < vdev_indirect_births_count(vib); i++) {
10635cabbc6bSPrashanth Sreenivasa 		vdev_indirect_birth_entry_phys_t *cur_vibe =
10645cabbc6bSPrashanth Sreenivasa 		    &vib->vib_entries[i];
10655cabbc6bSPrashanth Sreenivasa 		(void) printf("\toffset %llx -> txg %llu\n",
10665cabbc6bSPrashanth Sreenivasa 		    (longlong_t)cur_vibe->vibe_offset,
10675cabbc6bSPrashanth Sreenivasa 		    (longlong_t)cur_vibe->vibe_phys_birth_txg);
10685cabbc6bSPrashanth Sreenivasa 	}
10695cabbc6bSPrashanth Sreenivasa 	(void) printf("\n");
10705cabbc6bSPrashanth Sreenivasa 
10715cabbc6bSPrashanth Sreenivasa 	(void) printf("indirect mapping obj %llu:\n",
10725cabbc6bSPrashanth Sreenivasa 	    (longlong_t)vic->vic_mapping_object);
10735cabbc6bSPrashanth Sreenivasa 	(void) printf("    vim_max_offset = 0x%llx\n",
10745cabbc6bSPrashanth Sreenivasa 	    (longlong_t)vdev_indirect_mapping_max_offset(vim));
10755cabbc6bSPrashanth Sreenivasa 	(void) printf("    vim_bytes_mapped = 0x%llx\n",
10765cabbc6bSPrashanth Sreenivasa 	    (longlong_t)vdev_indirect_mapping_bytes_mapped(vim));
10775cabbc6bSPrashanth Sreenivasa 	(void) printf("    vim_count = %llu\n",
10785cabbc6bSPrashanth Sreenivasa 	    (longlong_t)vdev_indirect_mapping_num_entries(vim));
10795cabbc6bSPrashanth Sreenivasa 
10805cabbc6bSPrashanth Sreenivasa 	if (dump_opt['d'] <= 5 && dump_opt['m'] <= 3)
10815cabbc6bSPrashanth Sreenivasa 		return;
10825cabbc6bSPrashanth Sreenivasa 
10835cabbc6bSPrashanth Sreenivasa 	uint32_t *counts = vdev_indirect_mapping_load_obsolete_counts(vim);
10845cabbc6bSPrashanth Sreenivasa 
10855cabbc6bSPrashanth Sreenivasa 	for (uint64_t i = 0; i < vdev_indirect_mapping_num_entries(vim); i++) {
10865cabbc6bSPrashanth Sreenivasa 		vdev_indirect_mapping_entry_phys_t *vimep =
10875cabbc6bSPrashanth Sreenivasa 		    &vim->vim_entries[i];
10885cabbc6bSPrashanth Sreenivasa 		(void) printf("\t<%llx:%llx:%llx> -> "
10895cabbc6bSPrashanth Sreenivasa 		    "<%llx:%llx:%llx> (%x obsolete)\n",
10905cabbc6bSPrashanth Sreenivasa 		    (longlong_t)vd->vdev_id,
10915cabbc6bSPrashanth Sreenivasa 		    (longlong_t)DVA_MAPPING_GET_SRC_OFFSET(vimep),
10925cabbc6bSPrashanth Sreenivasa 		    (longlong_t)DVA_GET_ASIZE(&vimep->vimep_dst),
10935cabbc6bSPrashanth Sreenivasa 		    (longlong_t)DVA_GET_VDEV(&vimep->vimep_dst),
10945cabbc6bSPrashanth Sreenivasa 		    (longlong_t)DVA_GET_OFFSET(&vimep->vimep_dst),
10955cabbc6bSPrashanth Sreenivasa 		    (longlong_t)DVA_GET_ASIZE(&vimep->vimep_dst),
10965cabbc6bSPrashanth Sreenivasa 		    counts[i]);
10975cabbc6bSPrashanth Sreenivasa 	}
10985cabbc6bSPrashanth Sreenivasa 	(void) printf("\n");
10995cabbc6bSPrashanth Sreenivasa 
11005cabbc6bSPrashanth Sreenivasa 	uint64_t obsolete_sm_object = vdev_obsolete_sm_object(vd);
11015cabbc6bSPrashanth Sreenivasa 	if (obsolete_sm_object != 0) {
11025cabbc6bSPrashanth Sreenivasa 		objset_t *mos = vd->vdev_spa->spa_meta_objset;
11035cabbc6bSPrashanth Sreenivasa 		(void) printf("obsolete space map object %llu:\n",
11045cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)obsolete_sm_object);
11055cabbc6bSPrashanth Sreenivasa 		ASSERT(vd->vdev_obsolete_sm != NULL);
11065cabbc6bSPrashanth Sreenivasa 		ASSERT3U(space_map_object(vd->vdev_obsolete_sm), ==,
11075cabbc6bSPrashanth Sreenivasa 		    obsolete_sm_object);
11085cabbc6bSPrashanth Sreenivasa 		dump_spacemap(mos, vd->vdev_obsolete_sm);
11095cabbc6bSPrashanth Sreenivasa 		(void) printf("\n");
11105cabbc6bSPrashanth Sreenivasa 	}
11115cabbc6bSPrashanth Sreenivasa }
11125cabbc6bSPrashanth Sreenivasa 
1113fa9e4066Sahrens static void
1114fa9e4066Sahrens dump_metaslabs(spa_t *spa)
1115fa9e4066Sahrens {
111687219db7SVictor Latushkin 	vdev_t *vd, *rvd = spa->spa_root_vdev;
111787219db7SVictor Latushkin 	uint64_t m, c = 0, children = rvd->vdev_children;
1118fa9e4066Sahrens 
1119fa9e4066Sahrens 	(void) printf("\nMetaslabs:\n");
1120fa9e4066Sahrens 
112187219db7SVictor Latushkin 	if (!dump_opt['d'] && zopt_objects > 0) {
112287219db7SVictor Latushkin 		c = zopt_object[0];
112387219db7SVictor Latushkin 
112487219db7SVictor Latushkin 		if (c >= children)
112587219db7SVictor Latushkin 			(void) fatal("bad vdev id: %llu", (u_longlong_t)c);
1126fa9e4066Sahrens 
112787219db7SVictor Latushkin 		if (zopt_objects > 1) {
112887219db7SVictor Latushkin 			vd = rvd->vdev_child[c];
112987219db7SVictor Latushkin 			print_vdev_metaslab_header(vd);
113087219db7SVictor Latushkin 
113187219db7SVictor Latushkin 			for (m = 1; m < zopt_objects; m++) {
113287219db7SVictor Latushkin 				if (zopt_object[m] < vd->vdev_ms_count)
113387219db7SVictor Latushkin 					dump_metaslab(
113487219db7SVictor Latushkin 					    vd->vdev_ms[zopt_object[m]]);
113587219db7SVictor Latushkin 				else
113687219db7SVictor Latushkin 					(void) fprintf(stderr, "bad metaslab "
113787219db7SVictor Latushkin 					    "number %llu\n",
113887219db7SVictor Latushkin 					    (u_longlong_t)zopt_object[m]);
113987219db7SVictor Latushkin 			}
114087219db7SVictor Latushkin 			(void) printf("\n");
114187219db7SVictor Latushkin 			return;
114287219db7SVictor Latushkin 		}
114387219db7SVictor Latushkin 		children = c + 1;
114487219db7SVictor Latushkin 	}
114587219db7SVictor Latushkin 	for (; c < children; c++) {
114687219db7SVictor Latushkin 		vd = rvd->vdev_child[c];
114787219db7SVictor Latushkin 		print_vdev_metaslab_header(vd);
1148fa9e4066Sahrens 
11495cabbc6bSPrashanth Sreenivasa 		print_vdev_indirect(vd);
11505cabbc6bSPrashanth Sreenivasa 
1151fa9e4066Sahrens 		for (m = 0; m < vd->vdev_ms_count; m++)
1152fa9e4066Sahrens 			dump_metaslab(vd->vdev_ms[m]);
1153fa9e4066Sahrens 		(void) printf("\n");
1154fa9e4066Sahrens 	}
1155fa9e4066Sahrens }
1156fa9e4066Sahrens 
1157814dcd43SSerapheim Dimitropoulos static void
1158814dcd43SSerapheim Dimitropoulos dump_log_spacemaps(spa_t *spa)
1159814dcd43SSerapheim Dimitropoulos {
1160814dcd43SSerapheim Dimitropoulos 	if (!spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP))
1161814dcd43SSerapheim Dimitropoulos 		return;
1162814dcd43SSerapheim Dimitropoulos 
1163814dcd43SSerapheim Dimitropoulos 	(void) printf("\nLog Space Maps in Pool:\n");
1164814dcd43SSerapheim Dimitropoulos 	for (spa_log_sm_t *sls = avl_first(&spa->spa_sm_logs_by_txg);
1165814dcd43SSerapheim Dimitropoulos 	    sls; sls = AVL_NEXT(&spa->spa_sm_logs_by_txg, sls)) {
1166814dcd43SSerapheim Dimitropoulos 		space_map_t *sm = NULL;
1167814dcd43SSerapheim Dimitropoulos 		VERIFY0(space_map_open(&sm, spa_meta_objset(spa),
1168814dcd43SSerapheim Dimitropoulos 		    sls->sls_sm_obj, 0, UINT64_MAX, SPA_MINBLOCKSHIFT));
1169814dcd43SSerapheim Dimitropoulos 
1170814dcd43SSerapheim Dimitropoulos 		(void) printf("Log Spacemap object %llu txg %llu\n",
1171814dcd43SSerapheim Dimitropoulos 		    (u_longlong_t)sls->sls_sm_obj, (u_longlong_t)sls->sls_txg);
1172814dcd43SSerapheim Dimitropoulos 		dump_spacemap(spa->spa_meta_objset, sm);
1173814dcd43SSerapheim Dimitropoulos 		space_map_close(sm);
1174814dcd43SSerapheim Dimitropoulos 	}
1175814dcd43SSerapheim Dimitropoulos 	(void) printf("\n");
1176814dcd43SSerapheim Dimitropoulos }
1177814dcd43SSerapheim Dimitropoulos 
1178b24ab676SJeff Bonwick static void
1179b24ab676SJeff Bonwick dump_dde(const ddt_t *ddt, const ddt_entry_t *dde, uint64_t index)
1180b24ab676SJeff Bonwick {
1181b24ab676SJeff Bonwick 	const ddt_phys_t *ddp = dde->dde_phys;
1182b24ab676SJeff Bonwick 	const ddt_key_t *ddk = &dde->dde_key;
11833f7978d0SAlan Somers 	const char *types[4] = { "ditto", "single", "double", "triple" };
1184b24ab676SJeff Bonwick 	char blkbuf[BP_SPRINTF_LEN];
1185b24ab676SJeff Bonwick 	blkptr_t blk;
1186b24ab676SJeff Bonwick 
1187b24ab676SJeff Bonwick 	for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
1188b24ab676SJeff Bonwick 		if (ddp->ddp_phys_birth == 0)
1189b24ab676SJeff Bonwick 			continue;
1190bbfd46c4SJeff Bonwick 		ddt_bp_create(ddt->ddt_checksum, ddk, ddp, &blk);
119143466aaeSMax Grossman 		snprintf_blkptr(blkbuf, sizeof (blkbuf), &blk);
1192b24ab676SJeff Bonwick 		(void) printf("index %llx refcnt %llu %s %s\n",
1193b24ab676SJeff Bonwick 		    (u_longlong_t)index, (u_longlong_t)ddp->ddp_refcnt,
1194b24ab676SJeff Bonwick 		    types[p], blkbuf);
1195b24ab676SJeff Bonwick 	}
1196b24ab676SJeff Bonwick }
1197b24ab676SJeff Bonwick 
1198b24ab676SJeff Bonwick static void
1199b24ab676SJeff Bonwick dump_dedup_ratio(const ddt_stat_t *dds)
1200b24ab676SJeff Bonwick {
1201b24ab676SJeff Bonwick 	double rL, rP, rD, D, dedup, compress, copies;
1202b24ab676SJeff Bonwick 
1203b24ab676SJeff Bonwick 	if (dds->dds_blocks == 0)
1204b24ab676SJeff Bonwick 		return;
1205b24ab676SJeff Bonwick 
1206b24ab676SJeff Bonwick 	rL = (double)dds->dds_ref_lsize;
1207b24ab676SJeff Bonwick 	rP = (double)dds->dds_ref_psize;
1208b24ab676SJeff Bonwick 	rD = (double)dds->dds_ref_dsize;
1209b24ab676SJeff Bonwick 	D = (double)dds->dds_dsize;
1210b24ab676SJeff Bonwick 
1211b24ab676SJeff Bonwick 	dedup = rD / D;
1212b24ab676SJeff Bonwick 	compress = rL / rP;
1213b24ab676SJeff Bonwick 	copies = rD / rP;
1214b24ab676SJeff Bonwick 
1215b24ab676SJeff Bonwick 	(void) printf("dedup = %.2f, compress = %.2f, copies = %.2f, "
1216b24ab676SJeff Bonwick 	    "dedup * compress / copies = %.2f\n\n",
1217b24ab676SJeff Bonwick 	    dedup, compress, copies, dedup * compress / copies);
1218b24ab676SJeff Bonwick }
1219b24ab676SJeff Bonwick 
1220b24ab676SJeff Bonwick static void
1221b24ab676SJeff Bonwick dump_ddt(ddt_t *ddt, enum ddt_type type, enum ddt_class class)
1222b24ab676SJeff Bonwick {
1223b24ab676SJeff Bonwick 	char name[DDT_NAMELEN];
1224b24ab676SJeff Bonwick 	ddt_entry_t dde;
1225b24ab676SJeff Bonwick 	uint64_t walk = 0;
1226b24ab676SJeff Bonwick 	dmu_object_info_t doi;
1227b24ab676SJeff Bonwick 	uint64_t count, dspace, mspace;
1228b24ab676SJeff Bonwick 	int error;
1229b24ab676SJeff Bonwick 
1230b24ab676SJeff Bonwick 	error = ddt_object_info(ddt, type, class, &doi);
1231b24ab676SJeff Bonwick 
1232b24ab676SJeff Bonwick 	if (error == ENOENT)
1233b24ab676SJeff Bonwick 		return;
1234b24ab676SJeff Bonwick 	ASSERT(error == 0);
1235b24ab676SJeff Bonwick 
12367448a079SGeorge Wilson 	if ((count = ddt_object_count(ddt, type, class)) == 0)
12377448a079SGeorge Wilson 		return;
12387448a079SGeorge Wilson 
1239b24ab676SJeff Bonwick 	dspace = doi.doi_physical_blocks_512 << 9;
1240b24ab676SJeff Bonwick 	mspace = doi.doi_fill_count * doi.doi_data_block_size;
1241b24ab676SJeff Bonwick 
1242b24ab676SJeff Bonwick 	ddt_object_name(ddt, type, class, name);
1243b24ab676SJeff Bonwick 
1244b24ab676SJeff Bonwick 	(void) printf("%s: %llu entries, size %llu on disk, %llu in core\n",
1245b24ab676SJeff Bonwick 	    name,
1246b24ab676SJeff Bonwick 	    (u_longlong_t)count,
1247b24ab676SJeff Bonwick 	    (u_longlong_t)(dspace / count),
1248b24ab676SJeff Bonwick 	    (u_longlong_t)(mspace / count));
1249b24ab676SJeff Bonwick 
1250b24ab676SJeff Bonwick 	if (dump_opt['D'] < 3)
1251b24ab676SJeff Bonwick 		return;
1252b24ab676SJeff Bonwick 
12539eb19f4dSGeorge Wilson 	zpool_dump_ddt(NULL, &ddt->ddt_histogram[type][class]);
1254b24ab676SJeff Bonwick 
1255b24ab676SJeff Bonwick 	if (dump_opt['D'] < 4)
1256b24ab676SJeff Bonwick 		return;
1257b24ab676SJeff Bonwick 
1258b24ab676SJeff Bonwick 	if (dump_opt['D'] < 5 && class == DDT_CLASS_UNIQUE)
1259b24ab676SJeff Bonwick 		return;
1260b24ab676SJeff Bonwick 
1261b24ab676SJeff Bonwick 	(void) printf("%s contents:\n\n", name);
1262b24ab676SJeff Bonwick 
1263bbfd46c4SJeff Bonwick 	while ((error = ddt_object_walk(ddt, type, class, &walk, &dde)) == 0)
1264b24ab676SJeff Bonwick 		dump_dde(ddt, &dde, walk);
1265b24ab676SJeff Bonwick 
126617f11284SSerapheim Dimitropoulos 	ASSERT3U(error, ==, ENOENT);
1267b24ab676SJeff Bonwick 
1268b24ab676SJeff Bonwick 	(void) printf("\n");
1269b24ab676SJeff Bonwick }
1270b24ab676SJeff Bonwick 
1271b24ab676SJeff Bonwick static void
1272b24ab676SJeff Bonwick dump_all_ddts(spa_t *spa)
1273b24ab676SJeff Bonwick {
12743f7978d0SAlan Somers 	ddt_histogram_t ddh_total;
12753f7978d0SAlan Somers 	ddt_stat_t dds_total;
12763f7978d0SAlan Somers 
12773f7978d0SAlan Somers 	bzero(&ddh_total, sizeof (ddh_total));
12783f7978d0SAlan Somers 	bzero(&dds_total, sizeof (dds_total));
1279b24ab676SJeff Bonwick 
1280b24ab676SJeff Bonwick 	for (enum zio_checksum c = 0; c < ZIO_CHECKSUM_FUNCTIONS; c++) {
1281b24ab676SJeff Bonwick 		ddt_t *ddt = spa->spa_ddt[c];
1282b24ab676SJeff Bonwick 		for (enum ddt_type type = 0; type < DDT_TYPES; type++) {
1283b24ab676SJeff Bonwick 			for (enum ddt_class class = 0; class < DDT_CLASSES;
1284b24ab676SJeff Bonwick 			    class++) {
1285b24ab676SJeff Bonwick 				dump_ddt(ddt, type, class);
1286b24ab676SJeff Bonwick 			}
1287b24ab676SJeff Bonwick 		}
1288b24ab676SJeff Bonwick 	}
1289b24ab676SJeff Bonwick 
12909eb19f4dSGeorge Wilson 	ddt_get_dedup_stats(spa, &dds_total);
1291b24ab676SJeff Bonwick 
1292b24ab676SJeff Bonwick 	if (dds_total.dds_blocks == 0) {
1293b24ab676SJeff Bonwick 		(void) printf("All DDTs are empty\n");
1294b24ab676SJeff Bonwick 		return;
1295b24ab676SJeff Bonwick 	}
1296b24ab676SJeff Bonwick 
1297b24ab676SJeff Bonwick 	(void) printf("\n");
1298b24ab676SJeff Bonwick 
1299b24ab676SJeff Bonwick 	if (dump_opt['D'] > 1) {
1300b24ab676SJeff Bonwick 		(void) printf("DDT histogram (aggregated over all DDTs):\n");
13019eb19f4dSGeorge Wilson 		ddt_get_dedup_histogram(spa, &ddh_total);
13029eb19f4dSGeorge Wilson 		zpool_dump_ddt(&dds_total, &ddh_total);
1303b24ab676SJeff Bonwick 	}
1304b24ab676SJeff Bonwick 
1305b24ab676SJeff Bonwick 	dump_dedup_ratio(&dds_total);
1306b24ab676SJeff Bonwick }
1307b24ab676SJeff Bonwick 
13088ad4d6ddSJeff Bonwick static void
13090713e232SGeorge Wilson dump_dtl_seg(void *arg, uint64_t start, uint64_t size)
13108ad4d6ddSJeff Bonwick {
13110713e232SGeorge Wilson 	char *prefix = arg;
13128ad4d6ddSJeff Bonwick 
13138ad4d6ddSJeff Bonwick 	(void) printf("%s [%llu,%llu) length %llu\n",
13148ad4d6ddSJeff Bonwick 	    prefix,
13158ad4d6ddSJeff Bonwick 	    (u_longlong_t)start,
13168ad4d6ddSJeff Bonwick 	    (u_longlong_t)(start + size),
13178ad4d6ddSJeff Bonwick 	    (u_longlong_t)(size));
13188ad4d6ddSJeff Bonwick }
13198ad4d6ddSJeff Bonwick 
1320fa9e4066Sahrens static void
1321fa9e4066Sahrens dump_dtl(vdev_t *vd, int indent)
1322fa9e4066Sahrens {
13238ad4d6ddSJeff Bonwick 	spa_t *spa = vd->vdev_spa;
13248ad4d6ddSJeff Bonwick 	boolean_t required;
13253f7978d0SAlan Somers 	const char *name[DTL_TYPES] = { "missing", "partial", "scrub",
13263f7978d0SAlan Somers 		"outage" };
13278ad4d6ddSJeff Bonwick 	char prefix[256];
13288ad4d6ddSJeff Bonwick 
13298f18d1faSGeorge Wilson 	spa_vdev_state_enter(spa, SCL_NONE);
13308ad4d6ddSJeff Bonwick 	required = vdev_dtl_required(vd);
13318ad4d6ddSJeff Bonwick 	(void) spa_vdev_state_exit(spa, NULL, 0);
1332fa9e4066Sahrens 
1333fa9e4066Sahrens 	if (indent == 0)
1334fa9e4066Sahrens 		(void) printf("\nDirty time logs:\n\n");
1335fa9e4066Sahrens 
13368ad4d6ddSJeff Bonwick 	(void) printf("\t%*s%s [%s]\n", indent, "",
1337e14bb325SJeff Bonwick 	    vd->vdev_path ? vd->vdev_path :
13388ad4d6ddSJeff Bonwick 	    vd->vdev_parent ? vd->vdev_ops->vdev_op_type : spa_name(spa),
13398ad4d6ddSJeff Bonwick 	    required ? "DTL-required" : "DTL-expendable");
1340fa9e4066Sahrens 
13418ad4d6ddSJeff Bonwick 	for (int t = 0; t < DTL_TYPES; t++) {
13420713e232SGeorge Wilson 		range_tree_t *rt = vd->vdev_dtl[t];
13430713e232SGeorge Wilson 		if (range_tree_space(rt) == 0)
13448ad4d6ddSJeff Bonwick 			continue;
13458ad4d6ddSJeff Bonwick 		(void) snprintf(prefix, sizeof (prefix), "\t%*s%s",
13468ad4d6ddSJeff Bonwick 		    indent + 2, "", name[t]);
13470713e232SGeorge Wilson 		range_tree_walk(rt, dump_dtl_seg, prefix);
13488ad4d6ddSJeff Bonwick 		if (dump_opt['d'] > 5 && vd->vdev_children == 0)
13490713e232SGeorge Wilson 			dump_spacemap(spa->spa_meta_objset, vd->vdev_dtl_sm);
1350fa9e4066Sahrens 	}
1351fa9e4066Sahrens 
13523f7978d0SAlan Somers 	for (unsigned c = 0; c < vd->vdev_children; c++)
1353fa9e4066Sahrens 		dump_dtl(vd->vdev_child[c], indent + 4);
1354fa9e4066Sahrens }
1355fa9e4066Sahrens 
13568f18d1faSGeorge Wilson static void
13578f18d1faSGeorge Wilson dump_history(spa_t *spa)
13588f18d1faSGeorge Wilson {
13598f18d1faSGeorge Wilson 	nvlist_t **events = NULL;
1360e4161df6SVictor Latushkin 	uint64_t resid, len, off = 0;
13618f18d1faSGeorge Wilson 	uint_t num = 0;
13628f18d1faSGeorge Wilson 	int error;
13638f18d1faSGeorge Wilson 	time_t tsec;
13648f18d1faSGeorge Wilson 	struct tm t;
13658f18d1faSGeorge Wilson 	char tbuf[30];
13668f18d1faSGeorge Wilson 	char internalstr[MAXPATHLEN];
13678f18d1faSGeorge Wilson 
13683f84190cSMatthew Ahrens 	char *buf = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
13698f18d1faSGeorge Wilson 	do {
13703f84190cSMatthew Ahrens 		len = SPA_MAXBLOCKSIZE;
1371e4161df6SVictor Latushkin 
13728f18d1faSGeorge Wilson 		if ((error = spa_history_get(spa, &off, &len, buf)) != 0) {
13738f18d1faSGeorge Wilson 			(void) fprintf(stderr, "Unable to read history: "
13748f18d1faSGeorge Wilson 			    "error %d\n", error);
13753f84190cSMatthew Ahrens 			umem_free(buf, SPA_MAXBLOCKSIZE);
13768f18d1faSGeorge Wilson 			return;
13778f18d1faSGeorge Wilson 		}
13788f18d1faSGeorge Wilson 
13798f18d1faSGeorge Wilson 		if (zpool_history_unpack(buf, len, &resid, &events, &num) != 0)
13808f18d1faSGeorge Wilson 			break;
13818f18d1faSGeorge Wilson 
13828f18d1faSGeorge Wilson 		off -= resid;
13838f18d1faSGeorge Wilson 	} while (len != 0);
13843f84190cSMatthew Ahrens 	umem_free(buf, SPA_MAXBLOCKSIZE);
13858f18d1faSGeorge Wilson 
13868f18d1faSGeorge Wilson 	(void) printf("\nHistory:\n");
13873f7978d0SAlan Somers 	for (unsigned i = 0; i < num; i++) {
13888f18d1faSGeorge Wilson 		uint64_t time, txg, ievent;
13898f18d1faSGeorge Wilson 		char *cmd, *intstr;
13904445fffbSMatthew Ahrens 		boolean_t printed = B_FALSE;
13918f18d1faSGeorge Wilson 
13928f18d1faSGeorge Wilson 		if (nvlist_lookup_uint64(events[i], ZPOOL_HIST_TIME,
13938f18d1faSGeorge Wilson 		    &time) != 0)
13944445fffbSMatthew Ahrens 			goto next;
13958f18d1faSGeorge Wilson 		if (nvlist_lookup_string(events[i], ZPOOL_HIST_CMD,
13968f18d1faSGeorge Wilson 		    &cmd) != 0) {
13978f18d1faSGeorge Wilson 			if (nvlist_lookup_uint64(events[i],
13988f18d1faSGeorge Wilson 			    ZPOOL_HIST_INT_EVENT, &ievent) != 0)
13994445fffbSMatthew Ahrens 				goto next;
14008f18d1faSGeorge Wilson 			verify(nvlist_lookup_uint64(events[i],
14018f18d1faSGeorge Wilson 			    ZPOOL_HIST_TXG, &txg) == 0);
14028f18d1faSGeorge Wilson 			verify(nvlist_lookup_string(events[i],
14038f18d1faSGeorge Wilson 			    ZPOOL_HIST_INT_STR, &intstr) == 0);
14044445fffbSMatthew Ahrens 			if (ievent >= ZFS_NUM_LEGACY_HISTORY_EVENTS)
14054445fffbSMatthew Ahrens 				goto next;
14068f18d1faSGeorge Wilson 
14078f18d1faSGeorge Wilson 			(void) snprintf(internalstr,
14088f18d1faSGeorge Wilson 			    sizeof (internalstr),
14093f7978d0SAlan Somers 			    "[internal %s txg:%ju] %s",
14103f7978d0SAlan Somers 			    zfs_history_event_names[ievent], (uintmax_t)txg,
14118f18d1faSGeorge Wilson 			    intstr);
14128f18d1faSGeorge Wilson 			cmd = internalstr;
14138f18d1faSGeorge Wilson 		}
14148f18d1faSGeorge Wilson 		tsec = time;
14158f18d1faSGeorge Wilson 		(void) localtime_r(&tsec, &t);
14168f18d1faSGeorge Wilson 		(void) strftime(tbuf, sizeof (tbuf), "%F.%T", &t);
14178f18d1faSGeorge Wilson 		(void) printf("%s %s\n", tbuf, cmd);
14184445fffbSMatthew Ahrens 		printed = B_TRUE;
14194445fffbSMatthew Ahrens 
14204445fffbSMatthew Ahrens next:
14214445fffbSMatthew Ahrens 		if (dump_opt['h'] > 1) {
14224445fffbSMatthew Ahrens 			if (!printed)
14234445fffbSMatthew Ahrens 				(void) printf("unrecognized record:\n");
14244445fffbSMatthew Ahrens 			dump_nvlist(events[i], 2);
14254445fffbSMatthew Ahrens 		}
14268f18d1faSGeorge Wilson 	}
14278f18d1faSGeorge Wilson }
14288f18d1faSGeorge Wilson 
1429fa9e4066Sahrens /*ARGSUSED*/
1430fa9e4066Sahrens static void
1431fa9e4066Sahrens dump_dnode(objset_t *os, uint64_t object, void *data, size_t size)
1432fa9e4066Sahrens {
1433fa9e4066Sahrens }
1434fa9e4066Sahrens 
1435fa9e4066Sahrens static uint64_t
14367802d7bfSMatthew Ahrens blkid2offset(const dnode_phys_t *dnp, const blkptr_t *bp,
14377802d7bfSMatthew Ahrens     const zbookmark_phys_t *zb)
1438fa9e4066Sahrens {
1439b24ab676SJeff Bonwick 	if (dnp == NULL) {
1440b24ab676SJeff Bonwick 		ASSERT(zb->zb_level < 0);
1441b24ab676SJeff Bonwick 		if (zb->zb_object == 0)
1442b24ab676SJeff Bonwick 			return (zb->zb_blkid);
1443b24ab676SJeff Bonwick 		return (zb->zb_blkid * BP_GET_LSIZE(bp));
1444b24ab676SJeff Bonwick 	}
1445b24ab676SJeff Bonwick 
1446b24ab676SJeff Bonwick 	ASSERT(zb->zb_level >= 0);
1447fa9e4066Sahrens 
1448b24ab676SJeff Bonwick 	return ((zb->zb_blkid <<
1449b24ab676SJeff Bonwick 	    (zb->zb_level * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT))) *
1450fa9e4066Sahrens 	    dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT);
1451fa9e4066Sahrens }
1452fa9e4066Sahrens 
145344cd46caSbillm static void
145443466aaeSMax Grossman snprintf_blkptr_compact(char *blkbuf, size_t buflen, const blkptr_t *bp)
145544cd46caSbillm {
1456cde58dbcSMatthew Ahrens 	const dva_t *dva = bp->blk_dva;
1457eb633035STom Caputi 	unsigned int ndvas = dump_opt['d'] > 5 ? BP_GET_NDVAS(bp) : 1;
1458b24ab676SJeff Bonwick 
1459490d05b9SMatthew Ahrens 	if (dump_opt['b'] >= 6) {
146043466aaeSMax Grossman 		snprintf_blkptr(blkbuf, buflen, bp);
1461b24ab676SJeff Bonwick 		return;
1462b24ab676SJeff Bonwick 	}
146344cd46caSbillm 
14645d7b4d43SMatthew Ahrens 	if (BP_IS_EMBEDDED(bp)) {
14655d7b4d43SMatthew Ahrens 		(void) sprintf(blkbuf,
14665d7b4d43SMatthew Ahrens 		    "EMBEDDED et=%u %llxL/%llxP B=%llu",
14675d7b4d43SMatthew Ahrens 		    (int)BPE_GET_ETYPE(bp),
14685d7b4d43SMatthew Ahrens 		    (u_longlong_t)BPE_GET_LSIZE(bp),
14695d7b4d43SMatthew Ahrens 		    (u_longlong_t)BPE_GET_PSIZE(bp),
14705d7b4d43SMatthew Ahrens 		    (u_longlong_t)bp->blk_birth);
14715d7b4d43SMatthew Ahrens 		return;
14725d7b4d43SMatthew Ahrens 	}
147344cd46caSbillm 
14745d7b4d43SMatthew Ahrens 	blkbuf[0] = '\0';
1475eb633035STom Caputi 	for (unsigned int i = 0; i < ndvas; i++)
147643466aaeSMax Grossman 		(void) snprintf(blkbuf + strlen(blkbuf),
147743466aaeSMax Grossman 		    buflen - strlen(blkbuf), "%llu:%llx:%llx ",
147844cd46caSbillm 		    (u_longlong_t)DVA_GET_VDEV(&dva[i]),
147944cd46caSbillm 		    (u_longlong_t)DVA_GET_OFFSET(&dva[i]),
148044cd46caSbillm 		    (u_longlong_t)DVA_GET_ASIZE(&dva[i]));
148144cd46caSbillm 
148243466aaeSMax Grossman 	if (BP_IS_HOLE(bp)) {
148343466aaeSMax Grossman 		(void) snprintf(blkbuf + strlen(blkbuf),
148470163ac5SPrakash Surya 		    buflen - strlen(blkbuf),
148570163ac5SPrakash Surya 		    "%llxL B=%llu",
148670163ac5SPrakash Surya 		    (u_longlong_t)BP_GET_LSIZE(bp),
148743466aaeSMax Grossman 		    (u_longlong_t)bp->blk_birth);
148843466aaeSMax Grossman 	} else {
148943466aaeSMax Grossman 		(void) snprintf(blkbuf + strlen(blkbuf),
149043466aaeSMax Grossman 		    buflen - strlen(blkbuf),
149143466aaeSMax Grossman 		    "%llxL/%llxP F=%llu B=%llu/%llu",
149243466aaeSMax Grossman 		    (u_longlong_t)BP_GET_LSIZE(bp),
149343466aaeSMax Grossman 		    (u_longlong_t)BP_GET_PSIZE(bp),
14945d7b4d43SMatthew Ahrens 		    (u_longlong_t)BP_GET_FILL(bp),
149543466aaeSMax Grossman 		    (u_longlong_t)bp->blk_birth,
149643466aaeSMax Grossman 		    (u_longlong_t)BP_PHYSICAL_BIRTH(bp));
149743466aaeSMax Grossman 	}
149844cd46caSbillm }
149944cd46caSbillm 
150088b7b0f2SMatthew Ahrens static void
15017802d7bfSMatthew Ahrens print_indirect(blkptr_t *bp, const zbookmark_phys_t *zb,
150288b7b0f2SMatthew Ahrens     const dnode_phys_t *dnp)
1503fa9e4066Sahrens {
150488b7b0f2SMatthew Ahrens 	char blkbuf[BP_SPRINTF_LEN];
1505fa9e4066Sahrens 	int l;
1506fa9e4066Sahrens 
15075d7b4d43SMatthew Ahrens 	if (!BP_IS_EMBEDDED(bp)) {
15085d7b4d43SMatthew Ahrens 		ASSERT3U(BP_GET_TYPE(bp), ==, dnp->dn_type);
15095d7b4d43SMatthew Ahrens 		ASSERT3U(BP_GET_LEVEL(bp), ==, zb->zb_level);
15105d7b4d43SMatthew Ahrens 	}
1511fa9e4066Sahrens 
1512b24ab676SJeff Bonwick 	(void) printf("%16llx ", (u_longlong_t)blkid2offset(dnp, bp, zb));
1513fa9e4066Sahrens 
1514fa9e4066Sahrens 	ASSERT(zb->zb_level >= 0);
1515fa9e4066Sahrens 
1516fa9e4066Sahrens 	for (l = dnp->dn_nlevels - 1; l >= -1; l--) {
1517fa9e4066Sahrens 		if (l == zb->zb_level) {
151888b7b0f2SMatthew Ahrens 			(void) printf("L%llx", (u_longlong_t)zb->zb_level);
1519fa9e4066Sahrens 		} else {
152088b7b0f2SMatthew Ahrens 			(void) printf(" ");
1521fa9e4066Sahrens 		}
1522fa9e4066Sahrens 	}
1523fa9e4066Sahrens 
152443466aaeSMax Grossman 	snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), bp);
152588b7b0f2SMatthew Ahrens 	(void) printf("%s\n", blkbuf);
152688b7b0f2SMatthew Ahrens }
152788b7b0f2SMatthew Ahrens 
152888b7b0f2SMatthew Ahrens static int
152988b7b0f2SMatthew Ahrens visit_indirect(spa_t *spa, const dnode_phys_t *dnp,
15307802d7bfSMatthew Ahrens     blkptr_t *bp, const zbookmark_phys_t *zb)
153188b7b0f2SMatthew Ahrens {
1532e4161df6SVictor Latushkin 	int err = 0;
153388b7b0f2SMatthew Ahrens 
153488b7b0f2SMatthew Ahrens 	if (bp->blk_birth == 0)
153588b7b0f2SMatthew Ahrens 		return (0);
153688b7b0f2SMatthew Ahrens 
153788b7b0f2SMatthew Ahrens 	print_indirect(bp, zb, dnp);
153888b7b0f2SMatthew Ahrens 
153943466aaeSMax Grossman 	if (BP_GET_LEVEL(bp) > 0 && !BP_IS_HOLE(bp)) {
15407adb730bSGeorge Wilson 		arc_flags_t flags = ARC_FLAG_WAIT;
154188b7b0f2SMatthew Ahrens 		int i;
154288b7b0f2SMatthew Ahrens 		blkptr_t *cbp;
154388b7b0f2SMatthew Ahrens 		int epb = BP_GET_LSIZE(bp) >> SPA_BLKPTRSHIFT;
154488b7b0f2SMatthew Ahrens 		arc_buf_t *buf;
154588b7b0f2SMatthew Ahrens 		uint64_t fill = 0;
154688b7b0f2SMatthew Ahrens 
15471b912ec7SGeorge Wilson 		err = arc_read(NULL, spa, bp, arc_getbuf_func, &buf,
154888b7b0f2SMatthew Ahrens 		    ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, zb);
154988b7b0f2SMatthew Ahrens 		if (err)
155088b7b0f2SMatthew Ahrens 			return (err);
15513f9d6ad7SLin Ling 		ASSERT(buf->b_data);
155288b7b0f2SMatthew Ahrens 
155388b7b0f2SMatthew Ahrens 		/* recursively visit blocks below this */
155488b7b0f2SMatthew Ahrens 		cbp = buf->b_data;
155588b7b0f2SMatthew Ahrens 		for (i = 0; i < epb; i++, cbp++) {
15567802d7bfSMatthew Ahrens 			zbookmark_phys_t czb;
155788b7b0f2SMatthew Ahrens 
155888b7b0f2SMatthew Ahrens 			SET_BOOKMARK(&czb, zb->zb_objset, zb->zb_object,
155988b7b0f2SMatthew Ahrens 			    zb->zb_level - 1,
156088b7b0f2SMatthew Ahrens 			    zb->zb_blkid * epb + i);
156188b7b0f2SMatthew Ahrens 			err = visit_indirect(spa, dnp, cbp, &czb);
156288b7b0f2SMatthew Ahrens 			if (err)
156388b7b0f2SMatthew Ahrens 				break;
15645d7b4d43SMatthew Ahrens 			fill += BP_GET_FILL(cbp);
156588b7b0f2SMatthew Ahrens 		}
15668ad4d6ddSJeff Bonwick 		if (!err)
15675d7b4d43SMatthew Ahrens 			ASSERT3U(fill, ==, BP_GET_FILL(bp));
1568dcbf3bd6SGeorge Wilson 		arc_buf_destroy(buf, &buf);
1569fa9e4066Sahrens 	}
1570fa9e4066Sahrens 
157188b7b0f2SMatthew Ahrens 	return (err);
1572fa9e4066Sahrens }
1573fa9e4066Sahrens 
1574fa9e4066Sahrens /*ARGSUSED*/
1575fa9e4066Sahrens static void
157688b7b0f2SMatthew Ahrens dump_indirect(dnode_t *dn)
1577fa9e4066Sahrens {
157888b7b0f2SMatthew Ahrens 	dnode_phys_t *dnp = dn->dn_phys;
157988b7b0f2SMatthew Ahrens 	int j;
15807802d7bfSMatthew Ahrens 	zbookmark_phys_t czb;
1581fa9e4066Sahrens 
1582fa9e4066Sahrens 	(void) printf("Indirect blocks:\n");
1583fa9e4066Sahrens 
1584503ad85cSMatthew Ahrens 	SET_BOOKMARK(&czb, dmu_objset_id(dn->dn_objset),
158588b7b0f2SMatthew Ahrens 	    dn->dn_object, dnp->dn_nlevels - 1, 0);
158688b7b0f2SMatthew Ahrens 	for (j = 0; j < dnp->dn_nblkptr; j++) {
158788b7b0f2SMatthew Ahrens 		czb.zb_blkid = j;
1588503ad85cSMatthew Ahrens 		(void) visit_indirect(dmu_objset_spa(dn->dn_objset), dnp,
158988b7b0f2SMatthew Ahrens 		    &dnp->dn_blkptr[j], &czb);
159088b7b0f2SMatthew Ahrens 	}
1591fa9e4066Sahrens 
1592fa9e4066Sahrens 	(void) printf("\n");
1593fa9e4066Sahrens }
1594fa9e4066Sahrens 
1595fa9e4066Sahrens /*ARGSUSED*/
1596fa9e4066Sahrens static void
1597fa9e4066Sahrens dump_dsl_dir(objset_t *os, uint64_t object, void *data, size_t size)
1598fa9e4066Sahrens {
1599fa9e4066Sahrens 	dsl_dir_phys_t *dd = data;
1600fa9e4066Sahrens 	time_t crtime;
16013f9d6ad7SLin Ling 	char nice[32];
1602fa9e4066Sahrens 
16030a055120SJason King 	/* make sure nicenum has enough space */
16040a055120SJason King 	CTASSERT(sizeof (nice) >= NN_NUMBUF_SZ);
16050a055120SJason King 
1606fa9e4066Sahrens 	if (dd == NULL)
1607fa9e4066Sahrens 		return;
1608fa9e4066Sahrens 
1609da6c28aaSamw 	ASSERT3U(size, >=, sizeof (dsl_dir_phys_t));
1610fa9e4066Sahrens 
1611fa9e4066Sahrens 	crtime = dd->dd_creation_time;
1612fa9e4066Sahrens 	(void) printf("\t\tcreation_time = %s", ctime(&crtime));
1613fa9e4066Sahrens 	(void) printf("\t\thead_dataset_obj = %llu\n",
1614fa9e4066Sahrens 	    (u_longlong_t)dd->dd_head_dataset_obj);
1615fa9e4066Sahrens 	(void) printf("\t\tparent_dir_obj = %llu\n",
1616fa9e4066Sahrens 	    (u_longlong_t)dd->dd_parent_obj);
16173cb34c60Sahrens 	(void) printf("\t\torigin_obj = %llu\n",
16183cb34c60Sahrens 	    (u_longlong_t)dd->dd_origin_obj);
1619fa9e4066Sahrens 	(void) printf("\t\tchild_dir_zapobj = %llu\n",
1620fa9e4066Sahrens 	    (u_longlong_t)dd->dd_child_dir_zapobj);
16210a055120SJason King 	zdb_nicenum(dd->dd_used_bytes, nice, sizeof (nice));
162274e7dc98SMatthew Ahrens 	(void) printf("\t\tused_bytes = %s\n", nice);
16230a055120SJason King 	zdb_nicenum(dd->dd_compressed_bytes, nice, sizeof (nice));
162474e7dc98SMatthew Ahrens 	(void) printf("\t\tcompressed_bytes = %s\n", nice);
16250a055120SJason King 	zdb_nicenum(dd->dd_uncompressed_bytes, nice, sizeof (nice));
162674e7dc98SMatthew Ahrens 	(void) printf("\t\tuncompressed_bytes = %s\n", nice);
16270a055120SJason King 	zdb_nicenum(dd->dd_quota, nice, sizeof (nice));
162874e7dc98SMatthew Ahrens 	(void) printf("\t\tquota = %s\n", nice);
16290a055120SJason King 	zdb_nicenum(dd->dd_reserved, nice, sizeof (nice));
163074e7dc98SMatthew Ahrens 	(void) printf("\t\treserved = %s\n", nice);
1631fa9e4066Sahrens 	(void) printf("\t\tprops_zapobj = %llu\n",
1632fa9e4066Sahrens 	    (u_longlong_t)dd->dd_props_zapobj);
1633ecd6cf80Smarks 	(void) printf("\t\tdeleg_zapobj = %llu\n",
1634ecd6cf80Smarks 	    (u_longlong_t)dd->dd_deleg_zapobj);
163574e7dc98SMatthew Ahrens 	(void) printf("\t\tflags = %llx\n",
163674e7dc98SMatthew Ahrens 	    (u_longlong_t)dd->dd_flags);
163774e7dc98SMatthew Ahrens 
163874e7dc98SMatthew Ahrens #define	DO(which) \
16390a055120SJason King 	zdb_nicenum(dd->dd_used_breakdown[DD_USED_ ## which], nice, \
16400a055120SJason King 	    sizeof (nice)); \
164174e7dc98SMatthew Ahrens 	(void) printf("\t\tused_breakdown[" #which "] = %s\n", nice)
164274e7dc98SMatthew Ahrens 	DO(HEAD);
164374e7dc98SMatthew Ahrens 	DO(SNAP);
164474e7dc98SMatthew Ahrens 	DO(CHILD);
164574e7dc98SMatthew Ahrens 	DO(CHILD_RSRV);
164674e7dc98SMatthew Ahrens 	DO(REFRSRV);
164774e7dc98SMatthew Ahrens #undef DO
164817fb938fSMatthew Ahrens 	(void) printf("\t\tclones = %llu\n",
164917fb938fSMatthew Ahrens 	    (u_longlong_t)dd->dd_clones);
1650fa9e4066Sahrens }
1651fa9e4066Sahrens 
1652fa9e4066Sahrens /*ARGSUSED*/
1653fa9e4066Sahrens static void
1654fa9e4066Sahrens dump_dsl_dataset(objset_t *os, uint64_t object, void *data, size_t size)
1655fa9e4066Sahrens {
1656fa9e4066Sahrens 	dsl_dataset_phys_t *ds = data;
1657fa9e4066Sahrens 	time_t crtime;
16583f9d6ad7SLin Ling 	char used[32], compressed[32], uncompressed[32], unique[32];
1659fbabab8fSmaybee 	char blkbuf[BP_SPRINTF_LEN];
1660fa9e4066Sahrens 
16610a055120SJason King 	/* make sure nicenum has enough space */
16620a055120SJason King 	CTASSERT(sizeof (used) >= NN_NUMBUF_SZ);
16630a055120SJason King 	CTASSERT(sizeof (compressed) >= NN_NUMBUF_SZ);
16640a055120SJason King 	CTASSERT(sizeof (uncompressed) >= NN_NUMBUF_SZ);
16650a055120SJason King 	CTASSERT(sizeof (unique) >= NN_NUMBUF_SZ);
16660a055120SJason King 
1667fa9e4066Sahrens 	if (ds == NULL)
1668fa9e4066Sahrens 		return;
1669fa9e4066Sahrens 
1670fa9e4066Sahrens 	ASSERT(size == sizeof (*ds));
1671fa9e4066Sahrens 	crtime = ds->ds_creation_time;
16720a055120SJason King 	zdb_nicenum(ds->ds_referenced_bytes, used, sizeof (used));
16730a055120SJason King 	zdb_nicenum(ds->ds_compressed_bytes, compressed, sizeof (compressed));
16740a055120SJason King 	zdb_nicenum(ds->ds_uncompressed_bytes, uncompressed,
16750a055120SJason King 	    sizeof (uncompressed));
16760a055120SJason King 	zdb_nicenum(ds->ds_unique_bytes, unique, sizeof (unique));
167743466aaeSMax Grossman 	snprintf_blkptr(blkbuf, sizeof (blkbuf), &ds->ds_bp);
1678fa9e4066Sahrens 
1679088f3894Sahrens 	(void) printf("\t\tdir_obj = %llu\n",
1680fa9e4066Sahrens 	    (u_longlong_t)ds->ds_dir_obj);
1681fa9e4066Sahrens 	(void) printf("\t\tprev_snap_obj = %llu\n",
1682fa9e4066Sahrens 	    (u_longlong_t)ds->ds_prev_snap_obj);
1683fa9e4066Sahrens 	(void) printf("\t\tprev_snap_txg = %llu\n",
1684fa9e4066Sahrens 	    (u_longlong_t)ds->ds_prev_snap_txg);
1685fa9e4066Sahrens 	(void) printf("\t\tnext_snap_obj = %llu\n",
1686fa9e4066Sahrens 	    (u_longlong_t)ds->ds_next_snap_obj);
1687fa9e4066Sahrens 	(void) printf("\t\tsnapnames_zapobj = %llu\n",
1688fa9e4066Sahrens 	    (u_longlong_t)ds->ds_snapnames_zapobj);
1689fa9e4066Sahrens 	(void) printf("\t\tnum_children = %llu\n",
1690fa9e4066Sahrens 	    (u_longlong_t)ds->ds_num_children);
1691842727c2SChris Kirby 	(void) printf("\t\tuserrefs_obj = %llu\n",
1692842727c2SChris Kirby 	    (u_longlong_t)ds->ds_userrefs_obj);
1693fa9e4066Sahrens 	(void) printf("\t\tcreation_time = %s", ctime(&crtime));
1694fa9e4066Sahrens 	(void) printf("\t\tcreation_txg = %llu\n",
1695fa9e4066Sahrens 	    (u_longlong_t)ds->ds_creation_txg);
1696fa9e4066Sahrens 	(void) printf("\t\tdeadlist_obj = %llu\n",
1697fa9e4066Sahrens 	    (u_longlong_t)ds->ds_deadlist_obj);
1698fa9e4066Sahrens 	(void) printf("\t\tused_bytes = %s\n", used);
1699fa9e4066Sahrens 	(void) printf("\t\tcompressed_bytes = %s\n", compressed);
1700fa9e4066Sahrens 	(void) printf("\t\tuncompressed_bytes = %s\n", uncompressed);
1701fa9e4066Sahrens 	(void) printf("\t\tunique = %s\n", unique);
1702fa9e4066Sahrens 	(void) printf("\t\tfsid_guid = %llu\n",
1703fa9e4066Sahrens 	    (u_longlong_t)ds->ds_fsid_guid);
1704fa9e4066Sahrens 	(void) printf("\t\tguid = %llu\n",
1705fa9e4066Sahrens 	    (u_longlong_t)ds->ds_guid);
170699653d4eSeschrock 	(void) printf("\t\tflags = %llx\n",
170799653d4eSeschrock 	    (u_longlong_t)ds->ds_flags);
1708088f3894Sahrens 	(void) printf("\t\tnext_clones_obj = %llu\n",
1709088f3894Sahrens 	    (u_longlong_t)ds->ds_next_clones_obj);
1710bb0ade09Sahrens 	(void) printf("\t\tprops_obj = %llu\n",
1711bb0ade09Sahrens 	    (u_longlong_t)ds->ds_props_obj);
1712fa9e4066Sahrens 	(void) printf("\t\tbp = %s\n", blkbuf);
1713fa9e4066Sahrens }
1714fa9e4066Sahrens 
1715ad135b5dSChristopher Siden /* ARGSUSED */
1716ad135b5dSChristopher Siden static int
1717ad135b5dSChristopher Siden dump_bptree_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
1718ad135b5dSChristopher Siden {
1719ad135b5dSChristopher Siden 	char blkbuf[BP_SPRINTF_LEN];
1720ad135b5dSChristopher Siden 
1721ad135b5dSChristopher Siden 	if (bp->blk_birth != 0) {
172243466aaeSMax Grossman 		snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
1723ad135b5dSChristopher Siden 		(void) printf("\t%s\n", blkbuf);
1724ad135b5dSChristopher Siden 	}
1725ad135b5dSChristopher Siden 	return (0);
1726ad135b5dSChristopher Siden }
1727ad135b5dSChristopher Siden 
1728ad135b5dSChristopher Siden static void
17293f7978d0SAlan Somers dump_bptree(objset_t *os, uint64_t obj, const char *name)
1730ad135b5dSChristopher Siden {
1731ad135b5dSChristopher Siden 	char bytes[32];
1732ad135b5dSChristopher Siden 	bptree_phys_t *bt;
1733ad135b5dSChristopher Siden 	dmu_buf_t *db;
1734ad135b5dSChristopher Siden 
17350a055120SJason King 	/* make sure nicenum has enough space */
17360a055120SJason King 	CTASSERT(sizeof (bytes) >= NN_NUMBUF_SZ);
17370a055120SJason King 
1738ad135b5dSChristopher Siden 	if (dump_opt['d'] < 3)
1739ad135b5dSChristopher Siden 		return;
1740ad135b5dSChristopher Siden 
1741b420f3adSRichard Lowe 	VERIFY3U(0, ==, dmu_bonus_hold(os, obj, FTAG, &db));
1742ad135b5dSChristopher Siden 	bt = db->db_data;
17430a055120SJason King 	zdb_nicenum(bt->bt_bytes, bytes, sizeof (bytes));
1744ad135b5dSChristopher Siden 	(void) printf("\n    %s: %llu datasets, %s\n",
1745ad135b5dSChristopher Siden 	    name, (unsigned long long)(bt->bt_end - bt->bt_begin), bytes);
1746ad135b5dSChristopher Siden 	dmu_buf_rele(db, FTAG);
1747ad135b5dSChristopher Siden 
1748ad135b5dSChristopher Siden 	if (dump_opt['d'] < 5)
1749ad135b5dSChristopher Siden 		return;
1750ad135b5dSChristopher Siden 
1751ad135b5dSChristopher Siden 	(void) printf("\n");
1752ad135b5dSChristopher Siden 
1753ad135b5dSChristopher Siden 	(void) bptree_iterate(os, obj, B_FALSE, dump_bptree_cb, NULL, NULL);
1754ad135b5dSChristopher Siden }
1755ad135b5dSChristopher Siden 
1756cde58dbcSMatthew Ahrens /* ARGSUSED */
1757cde58dbcSMatthew Ahrens static int
1758cde58dbcSMatthew Ahrens dump_bpobj_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
1759cde58dbcSMatthew Ahrens {
1760cde58dbcSMatthew Ahrens 	char blkbuf[BP_SPRINTF_LEN];
1761cde58dbcSMatthew Ahrens 
1762cde58dbcSMatthew Ahrens 	ASSERT(bp->blk_birth != 0);
176343466aaeSMax Grossman 	snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), bp);
1764cde58dbcSMatthew Ahrens 	(void) printf("\t%s\n", blkbuf);
1765cde58dbcSMatthew Ahrens 	return (0);
1766cde58dbcSMatthew Ahrens }
1767cde58dbcSMatthew Ahrens 
1768fa9e4066Sahrens static void
17693f7978d0SAlan Somers dump_full_bpobj(bpobj_t *bpo, const char *name, int indent)
1770fa9e4066Sahrens {
17713f9d6ad7SLin Ling 	char bytes[32];
17723f9d6ad7SLin Ling 	char comp[32];
17733f9d6ad7SLin Ling 	char uncomp[32];
1774fa9e4066Sahrens 
17750a055120SJason King 	/* make sure nicenum has enough space */
17760a055120SJason King 	CTASSERT(sizeof (bytes) >= NN_NUMBUF_SZ);
17770a055120SJason King 	CTASSERT(sizeof (comp) >= NN_NUMBUF_SZ);
17780a055120SJason King 	CTASSERT(sizeof (uncomp) >= NN_NUMBUF_SZ);
17790a055120SJason King 
1780fa9e4066Sahrens 	if (dump_opt['d'] < 3)
1781fa9e4066Sahrens 		return;
1782fa9e4066Sahrens 
17830a055120SJason King 	zdb_nicenum(bpo->bpo_phys->bpo_bytes, bytes, sizeof (bytes));
1784d0475637SMatthew Ahrens 	if (bpo->bpo_havesubobj && bpo->bpo_phys->bpo_subobjs != 0) {
17850a055120SJason King 		zdb_nicenum(bpo->bpo_phys->bpo_comp, comp, sizeof (comp));
17860a055120SJason King 		zdb_nicenum(bpo->bpo_phys->bpo_uncomp, uncomp, sizeof (uncomp));
1787d0475637SMatthew Ahrens 		(void) printf("    %*s: object %llu, %llu local blkptrs, "
1788732885fcSMatthew Ahrens 		    "%llu subobjs in object %llu, %s (%s/%s comp)\n",
1789d0475637SMatthew Ahrens 		    indent * 8, name,
1790d0475637SMatthew Ahrens 		    (u_longlong_t)bpo->bpo_object,
1791d0475637SMatthew Ahrens 		    (u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
1792cde58dbcSMatthew Ahrens 		    (u_longlong_t)bpo->bpo_phys->bpo_num_subobjs,
1793732885fcSMatthew Ahrens 		    (u_longlong_t)bpo->bpo_phys->bpo_subobjs,
179499653d4eSeschrock 		    bytes, comp, uncomp);
1795d0475637SMatthew Ahrens 
1796d0475637SMatthew Ahrens 		for (uint64_t i = 0; i < bpo->bpo_phys->bpo_num_subobjs; i++) {
1797d0475637SMatthew Ahrens 			uint64_t subobj;
1798d0475637SMatthew Ahrens 			bpobj_t subbpo;
1799d0475637SMatthew Ahrens 			int error;
1800d0475637SMatthew Ahrens 			VERIFY0(dmu_read(bpo->bpo_os,
1801d0475637SMatthew Ahrens 			    bpo->bpo_phys->bpo_subobjs,
1802d0475637SMatthew Ahrens 			    i * sizeof (subobj), sizeof (subobj), &subobj, 0));
1803d0475637SMatthew Ahrens 			error = bpobj_open(&subbpo, bpo->bpo_os, subobj);
1804d0475637SMatthew Ahrens 			if (error != 0) {
1805d0475637SMatthew Ahrens 				(void) printf("ERROR %u while trying to open "
1806d0475637SMatthew Ahrens 				    "subobj id %llu\n",
1807d0475637SMatthew Ahrens 				    error, (u_longlong_t)subobj);
1808d0475637SMatthew Ahrens 				continue;
1809d0475637SMatthew Ahrens 			}
1810732885fcSMatthew Ahrens 			dump_full_bpobj(&subbpo, "subobj", indent + 1);
181177061867SMatthew Ahrens 			bpobj_close(&subbpo);
1812d0475637SMatthew Ahrens 		}
181399653d4eSeschrock 	} else {
1814d0475637SMatthew Ahrens 		(void) printf("    %*s: object %llu, %llu blkptrs, %s\n",
1815d0475637SMatthew Ahrens 		    indent * 8, name,
1816d0475637SMatthew Ahrens 		    (u_longlong_t)bpo->bpo_object,
1817d0475637SMatthew Ahrens 		    (u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
1818d0475637SMatthew Ahrens 		    bytes);
181999653d4eSeschrock 	}
1820fa9e4066Sahrens 
1821cde58dbcSMatthew Ahrens 	if (dump_opt['d'] < 5)
1822fa9e4066Sahrens 		return;
1823fa9e4066Sahrens 
1824fa9e4066Sahrens 
1825d0475637SMatthew Ahrens 	if (indent == 0) {
1826d0475637SMatthew Ahrens 		(void) bpobj_iterate_nofree(bpo, dump_bpobj_cb, NULL, NULL);
1827d0475637SMatthew Ahrens 		(void) printf("\n");
1828d0475637SMatthew Ahrens 	}
1829cde58dbcSMatthew Ahrens }
183044cd46caSbillm 
183117fb938fSMatthew Ahrens static void
183217fb938fSMatthew Ahrens bpobj_count_refd(bpobj_t *bpo)
183317fb938fSMatthew Ahrens {
183417fb938fSMatthew Ahrens 	mos_obj_refd(bpo->bpo_object);
183517fb938fSMatthew Ahrens 
183617fb938fSMatthew Ahrens 	if (bpo->bpo_havesubobj && bpo->bpo_phys->bpo_subobjs != 0) {
183717fb938fSMatthew Ahrens 		mos_obj_refd(bpo->bpo_phys->bpo_subobjs);
183817fb938fSMatthew Ahrens 		for (uint64_t i = 0; i < bpo->bpo_phys->bpo_num_subobjs; i++) {
183917fb938fSMatthew Ahrens 			uint64_t subobj;
184017fb938fSMatthew Ahrens 			bpobj_t subbpo;
184117fb938fSMatthew Ahrens 			int error;
184217fb938fSMatthew Ahrens 			VERIFY0(dmu_read(bpo->bpo_os,
184317fb938fSMatthew Ahrens 			    bpo->bpo_phys->bpo_subobjs,
184417fb938fSMatthew Ahrens 			    i * sizeof (subobj), sizeof (subobj), &subobj, 0));
184517fb938fSMatthew Ahrens 			error = bpobj_open(&subbpo, bpo->bpo_os, subobj);
184617fb938fSMatthew Ahrens 			if (error != 0) {
184717fb938fSMatthew Ahrens 				(void) printf("ERROR %u while trying to open "
184817fb938fSMatthew Ahrens 				    "subobj id %llu\n",
184917fb938fSMatthew Ahrens 				    error, (u_longlong_t)subobj);
185017fb938fSMatthew Ahrens 				continue;
185117fb938fSMatthew Ahrens 			}
185217fb938fSMatthew Ahrens 			bpobj_count_refd(&subbpo);
185317fb938fSMatthew Ahrens 			bpobj_close(&subbpo);
185417fb938fSMatthew Ahrens 		}
185517fb938fSMatthew Ahrens 	}
185617fb938fSMatthew Ahrens }
185717fb938fSMatthew Ahrens 
1858cde58dbcSMatthew Ahrens static void
1859cde58dbcSMatthew Ahrens dump_deadlist(dsl_deadlist_t *dl)
1860cde58dbcSMatthew Ahrens {
1861cde58dbcSMatthew Ahrens 	dsl_deadlist_entry_t *dle;
1862d0475637SMatthew Ahrens 	uint64_t unused;
1863cde58dbcSMatthew Ahrens 	char bytes[32];
1864cde58dbcSMatthew Ahrens 	char comp[32];
1865cde58dbcSMatthew Ahrens 	char uncomp[32];
186617fb938fSMatthew Ahrens 	uint64_t empty_bpobj =
186717fb938fSMatthew Ahrens 	    dmu_objset_spa(dl->dl_os)->spa_dsl_pool->dp_empty_bpobj;
186817fb938fSMatthew Ahrens 
186917fb938fSMatthew Ahrens 	/* force the tree to be loaded */
187017fb938fSMatthew Ahrens 	dsl_deadlist_space_range(dl, 0, UINT64_MAX, &unused, &unused, &unused);
187117fb938fSMatthew Ahrens 
187217fb938fSMatthew Ahrens 	if (dl->dl_oldfmt) {
187317fb938fSMatthew Ahrens 		if (dl->dl_bpobj.bpo_object != empty_bpobj)
187417fb938fSMatthew Ahrens 			bpobj_count_refd(&dl->dl_bpobj);
187517fb938fSMatthew Ahrens 	} else {
187617fb938fSMatthew Ahrens 		mos_obj_refd(dl->dl_object);
187717fb938fSMatthew Ahrens 		for (dle = avl_first(&dl->dl_tree); dle;
187817fb938fSMatthew Ahrens 		    dle = AVL_NEXT(&dl->dl_tree, dle)) {
187917fb938fSMatthew Ahrens 			if (dle->dle_bpobj.bpo_object != empty_bpobj)
188017fb938fSMatthew Ahrens 				bpobj_count_refd(&dle->dle_bpobj);
188117fb938fSMatthew Ahrens 		}
188217fb938fSMatthew Ahrens 	}
1883cde58dbcSMatthew Ahrens 
18840a055120SJason King 	/* make sure nicenum has enough space */
18850a055120SJason King 	CTASSERT(sizeof (bytes) >= NN_NUMBUF_SZ);
18860a055120SJason King 	CTASSERT(sizeof (comp) >= NN_NUMBUF_SZ);
18870a055120SJason King 	CTASSERT(sizeof (uncomp) >= NN_NUMBUF_SZ);
18880a055120SJason King 
1889cde58dbcSMatthew Ahrens 	if (dump_opt['d'] < 3)
1890cde58dbcSMatthew Ahrens 		return;
1891cde58dbcSMatthew Ahrens 
189290c76c66SMatthew Ahrens 	if (dl->dl_oldfmt) {
1893732885fcSMatthew Ahrens 		dump_full_bpobj(&dl->dl_bpobj, "old-format deadlist", 0);
189490c76c66SMatthew Ahrens 		return;
189590c76c66SMatthew Ahrens 	}
189690c76c66SMatthew Ahrens 
18970a055120SJason King 	zdb_nicenum(dl->dl_phys->dl_used, bytes, sizeof (bytes));
18980a055120SJason King 	zdb_nicenum(dl->dl_phys->dl_comp, comp, sizeof (comp));
18990a055120SJason King 	zdb_nicenum(dl->dl_phys->dl_uncomp, uncomp, sizeof (uncomp));
1900cde58dbcSMatthew Ahrens 	(void) printf("\n    Deadlist: %s (%s/%s comp)\n",
1901cde58dbcSMatthew Ahrens 	    bytes, comp, uncomp);
1902cde58dbcSMatthew Ahrens 
1903cde58dbcSMatthew Ahrens 	if (dump_opt['d'] < 4)
1904cde58dbcSMatthew Ahrens 		return;
1905cde58dbcSMatthew Ahrens 
1906cde58dbcSMatthew Ahrens 	(void) printf("\n");
1907cde58dbcSMatthew Ahrens 
1908cde58dbcSMatthew Ahrens 	for (dle = avl_first(&dl->dl_tree); dle;
1909cde58dbcSMatthew Ahrens 	    dle = AVL_NEXT(&dl->dl_tree, dle)) {
1910d0475637SMatthew Ahrens 		if (dump_opt['d'] >= 5) {
1911d0475637SMatthew Ahrens 			char buf[128];
1912de05b588SRichard Yao 			(void) snprintf(buf, sizeof (buf),
1913de05b588SRichard Yao 			    "mintxg %llu -> obj %llu",
1914d0475637SMatthew Ahrens 			    (longlong_t)dle->dle_mintxg,
1915d0475637SMatthew Ahrens 			    (longlong_t)dle->dle_bpobj.bpo_object);
1916fa9e4066Sahrens 
1917732885fcSMatthew Ahrens 			dump_full_bpobj(&dle->dle_bpobj, buf, 0);
1918d0475637SMatthew Ahrens 		} else {
1919d0475637SMatthew Ahrens 			(void) printf("mintxg %llu -> obj %llu\n",
1920d0475637SMatthew Ahrens 			    (longlong_t)dle->dle_mintxg,
1921d0475637SMatthew Ahrens 			    (longlong_t)dle->dle_bpobj.bpo_object);
1922d0475637SMatthew Ahrens 		}
1923cde58dbcSMatthew Ahrens 	}
1924fa9e4066Sahrens }
1925fa9e4066Sahrens 
1926e0d35c44Smarks static avl_tree_t idx_tree;
1927e0d35c44Smarks static avl_tree_t domain_tree;
1928e0d35c44Smarks static boolean_t fuid_table_loaded;
1929ed61ec1dSYuri Pankov static objset_t *sa_os = NULL;
1930ed61ec1dSYuri Pankov static sa_attr_type_t *sa_attr_table = NULL;
1931ed61ec1dSYuri Pankov 
1932ed61ec1dSYuri Pankov static int
1933ed61ec1dSYuri Pankov open_objset(const char *path, dmu_objset_type_t type, void *tag, objset_t **osp)
1934ed61ec1dSYuri Pankov {
1935ed61ec1dSYuri Pankov 	int err;
1936ed61ec1dSYuri Pankov 	uint64_t sa_attrs = 0;
1937ed61ec1dSYuri Pankov 	uint64_t version = 0;
1938ed61ec1dSYuri Pankov 
1939ed61ec1dSYuri Pankov 	VERIFY3P(sa_os, ==, NULL);
1940eb633035STom Caputi 	err = dmu_objset_own(path, type, B_TRUE, B_FALSE, tag, osp);
1941ed61ec1dSYuri Pankov 	if (err != 0) {
1942ed61ec1dSYuri Pankov 		(void) fprintf(stderr, "failed to own dataset '%s': %s\n", path,
1943ed61ec1dSYuri Pankov 		    strerror(err));
1944ed61ec1dSYuri Pankov 		return (err);
1945ed61ec1dSYuri Pankov 	}
1946ed61ec1dSYuri Pankov 
1947eb633035STom Caputi 	if (dmu_objset_type(*osp) == DMU_OST_ZFS && !(*osp)->os_encrypted) {
1948ed61ec1dSYuri Pankov 		(void) zap_lookup(*osp, MASTER_NODE_OBJ, ZPL_VERSION_STR,
1949ed61ec1dSYuri Pankov 		    8, 1, &version);
1950ed61ec1dSYuri Pankov 		if (version >= ZPL_VERSION_SA) {
1951ed61ec1dSYuri Pankov 			(void) zap_lookup(*osp, MASTER_NODE_OBJ, ZFS_SA_ATTRS,
1952ed61ec1dSYuri Pankov 			    8, 1, &sa_attrs);
1953ed61ec1dSYuri Pankov 		}
1954ed61ec1dSYuri Pankov 		err = sa_setup(*osp, sa_attrs, zfs_attr_table, ZPL_END,
1955ed61ec1dSYuri Pankov 		    &sa_attr_table);
1956ed61ec1dSYuri Pankov 		if (err != 0) {
1957ed61ec1dSYuri Pankov 			(void) fprintf(stderr, "sa_setup failed: %s\n",
1958ed61ec1dSYuri Pankov 			    strerror(err));
1959eb633035STom Caputi 			dmu_objset_disown(*osp, B_FALSE, tag);
1960ed61ec1dSYuri Pankov 			*osp = NULL;
1961ed61ec1dSYuri Pankov 		}
1962ed61ec1dSYuri Pankov 	}
1963ed61ec1dSYuri Pankov 	sa_os = *osp;
1964ed61ec1dSYuri Pankov 
1965ed61ec1dSYuri Pankov 	return (0);
1966ed61ec1dSYuri Pankov }
1967ed61ec1dSYuri Pankov 
1968ed61ec1dSYuri Pankov static void
1969ed61ec1dSYuri Pankov close_objset(objset_t *os, void *tag)
1970ed61ec1dSYuri Pankov {
1971ed61ec1dSYuri Pankov 	VERIFY3P(os, ==, sa_os);
1972ed61ec1dSYuri Pankov 	if (os->os_sa != NULL)
1973ed61ec1dSYuri Pankov 		sa_tear_down(os);
1974eb633035STom Caputi 	dmu_objset_disown(os, B_FALSE, tag);
1975ed61ec1dSYuri Pankov 	sa_attr_table = NULL;
1976ed61ec1dSYuri Pankov 	sa_os = NULL;
1977ed61ec1dSYuri Pankov }
1978e0d35c44Smarks 
1979e0d35c44Smarks static void
1980e0d35c44Smarks fuid_table_destroy()
1981e0d35c44Smarks {
1982e0d35c44Smarks 	if (fuid_table_loaded) {
1983e0d35c44Smarks 		zfs_fuid_table_destroy(&idx_tree, &domain_tree);
1984e0d35c44Smarks 		fuid_table_loaded = B_FALSE;
1985e0d35c44Smarks 	}
1986e0d35c44Smarks }
1987e0d35c44Smarks 
1988e0d35c44Smarks /*
1989e0d35c44Smarks  * print uid or gid information.
1990e0d35c44Smarks  * For normal POSIX id just the id is printed in decimal format.
1991e0d35c44Smarks  * For CIFS files with FUID the fuid is printed in hex followed by
1992d0475637SMatthew Ahrens  * the domain-rid string.
1993e0d35c44Smarks  */
1994e0d35c44Smarks static void
1995e0d35c44Smarks print_idstr(uint64_t id, const char *id_type)
1996e0d35c44Smarks {
1997e0d35c44Smarks 	if (FUID_INDEX(id)) {
1998e0d35c44Smarks 		char *domain;
1999e0d35c44Smarks 
2000e0d35c44Smarks 		domain = zfs_fuid_idx_domain(&idx_tree, FUID_INDEX(id));
2001e0d35c44Smarks 		(void) printf("\t%s     %llx [%s-%d]\n", id_type,
2002e0d35c44Smarks 		    (u_longlong_t)id, domain, (int)FUID_RID(id));
2003e0d35c44Smarks 	} else {
2004e0d35c44Smarks 		(void) printf("\t%s     %llu\n", id_type, (u_longlong_t)id);
2005e0d35c44Smarks 	}
2006e0d35c44Smarks 
2007e0d35c44Smarks }
2008e0d35c44Smarks 
2009e0d35c44Smarks static void
20100a586ceaSMark Shellenbaum dump_uidgid(objset_t *os, uint64_t uid, uint64_t gid)
2011e0d35c44Smarks {
2012e0d35c44Smarks 	uint32_t uid_idx, gid_idx;
2013e0d35c44Smarks 
20140a586ceaSMark Shellenbaum 	uid_idx = FUID_INDEX(uid);
20150a586ceaSMark Shellenbaum 	gid_idx = FUID_INDEX(gid);
2016e0d35c44Smarks 
2017e0d35c44Smarks 	/* Load domain table, if not already loaded */
2018e0d35c44Smarks 	if (!fuid_table_loaded && (uid_idx || gid_idx)) {
2019e0d35c44Smarks 		uint64_t fuid_obj;
2020e0d35c44Smarks 
2021e0d35c44Smarks 		/* first find the fuid object.  It lives in the master node */
2022e0d35c44Smarks 		VERIFY(zap_lookup(os, MASTER_NODE_OBJ, ZFS_FUID_TABLES,
2023e0d35c44Smarks 		    8, 1, &fuid_obj) == 0);
202489459e17SMark Shellenbaum 		zfs_fuid_avl_tree_create(&idx_tree, &domain_tree);
2025e0d35c44Smarks 		(void) zfs_fuid_table_load(os, fuid_obj,
2026e0d35c44Smarks 		    &idx_tree, &domain_tree);
2027e0d35c44Smarks 		fuid_table_loaded = B_TRUE;
2028e0d35c44Smarks 	}
2029e0d35c44Smarks 
20300a586ceaSMark Shellenbaum 	print_idstr(uid, "uid");
20310a586ceaSMark Shellenbaum 	print_idstr(gid, "gid");
2032e0d35c44Smarks }
2033e0d35c44Smarks 
2034fa9e4066Sahrens /*ARGSUSED*/
2035fa9e4066Sahrens static void
2036fa9e4066Sahrens dump_znode(objset_t *os, uint64_t object, void *data, size_t size)
2037fa9e4066Sahrens {
2038fa9e4066Sahrens 	char path[MAXPATHLEN * 2];	/* allow for xattr and failure prefix */
20390a586ceaSMark Shellenbaum 	sa_handle_t *hdl;
20400a586ceaSMark Shellenbaum 	uint64_t xattr, rdev, gen;
20410a586ceaSMark Shellenbaum 	uint64_t uid, gid, mode, fsize, parent, links;
20428f2529deSMark Shellenbaum 	uint64_t pflags;
20430a586ceaSMark Shellenbaum 	uint64_t acctm[2], modtm[2], chgtm[2], crtm[2];
20440a586ceaSMark Shellenbaum 	time_t z_crtime, z_atime, z_mtime, z_ctime;
20458f2529deSMark Shellenbaum 	sa_bulk_attr_t bulk[12];
20460a586ceaSMark Shellenbaum 	int idx = 0;
204755434c77Sek 	int error;
2048fa9e4066Sahrens 
2049ed61ec1dSYuri Pankov 	VERIFY3P(os, ==, sa_os);
20500a586ceaSMark Shellenbaum 	if (sa_handle_get(os, object, NULL, SA_HDL_PRIVATE, &hdl)) {
20510a586ceaSMark Shellenbaum 		(void) printf("Failed to get handle for SA znode\n");
20520a586ceaSMark Shellenbaum 		return;
20530a586ceaSMark Shellenbaum 	}
20540a586ceaSMark Shellenbaum 
20550a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_UID], NULL, &uid, 8);
20560a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_GID], NULL, &gid, 8);
20570a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_LINKS], NULL,
20580a586ceaSMark Shellenbaum 	    &links, 8);
20590a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_GEN], NULL, &gen, 8);
20600a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_MODE], NULL,
20610a586ceaSMark Shellenbaum 	    &mode, 8);
20620a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_PARENT],
20630a586ceaSMark Shellenbaum 	    NULL, &parent, 8);
20640a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_SIZE], NULL,
20650a586ceaSMark Shellenbaum 	    &fsize, 8);
20660a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_ATIME], NULL,
20670a586ceaSMark Shellenbaum 	    acctm, 16);
20680a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_MTIME], NULL,
20690a586ceaSMark Shellenbaum 	    modtm, 16);
20700a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_CRTIME], NULL,
20710a586ceaSMark Shellenbaum 	    crtm, 16);
20720a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_CTIME], NULL,
20730a586ceaSMark Shellenbaum 	    chgtm, 16);
20748f2529deSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_FLAGS], NULL,
20758f2529deSMark Shellenbaum 	    &pflags, 8);
20760a586ceaSMark Shellenbaum 
20770a586ceaSMark Shellenbaum 	if (sa_bulk_lookup(hdl, bulk, idx)) {
20780a586ceaSMark Shellenbaum 		(void) sa_handle_destroy(hdl);
20790a586ceaSMark Shellenbaum 		return;
20800a586ceaSMark Shellenbaum 	}
2081fa9e4066Sahrens 
20820a586ceaSMark Shellenbaum 	z_crtime = (time_t)crtm[0];
20830a586ceaSMark Shellenbaum 	z_atime = (time_t)acctm[0];
20840a586ceaSMark Shellenbaum 	z_mtime = (time_t)modtm[0];
20850a586ceaSMark Shellenbaum 	z_ctime = (time_t)chgtm[0];
2086fa9e4066Sahrens 
2087e548d2faSAlan Somers 	if (dump_opt['d'] > 4) {
2088e548d2faSAlan Somers 		error = zfs_obj_to_path(os, object, path, sizeof (path));
208920b5dafbSPaul Dagnelie 		if (error == ESTALE) {
209020b5dafbSPaul Dagnelie 			(void) snprintf(path, sizeof (path), "on delete queue");
209120b5dafbSPaul Dagnelie 		} else if (error != 0) {
209220b5dafbSPaul Dagnelie 			leaked_objects++;
2093e548d2faSAlan Somers 			(void) snprintf(path, sizeof (path),
209420b5dafbSPaul Dagnelie 			    "path not found, possibly leaked");
2095e548d2faSAlan Somers 		}
2096e548d2faSAlan Somers 		(void) printf("\tpath	%s\n", path);
2097e548d2faSAlan Somers 	}
20980a586ceaSMark Shellenbaum 	dump_uidgid(os, uid, gid);
2099fa9e4066Sahrens 	(void) printf("\tatime	%s", ctime(&z_atime));
2100fa9e4066Sahrens 	(void) printf("\tmtime	%s", ctime(&z_mtime));
2101fa9e4066Sahrens 	(void) printf("\tctime	%s", ctime(&z_ctime));
2102fa9e4066Sahrens 	(void) printf("\tcrtime	%s", ctime(&z_crtime));
21030a586ceaSMark Shellenbaum 	(void) printf("\tgen	%llu\n", (u_longlong_t)gen);
21040a586ceaSMark Shellenbaum 	(void) printf("\tmode	%llo\n", (u_longlong_t)mode);
21050a586ceaSMark Shellenbaum 	(void) printf("\tsize	%llu\n", (u_longlong_t)fsize);
21060a586ceaSMark Shellenbaum 	(void) printf("\tparent	%llu\n", (u_longlong_t)parent);
21070a586ceaSMark Shellenbaum 	(void) printf("\tlinks	%llu\n", (u_longlong_t)links);
21088f2529deSMark Shellenbaum 	(void) printf("\tpflags	%llx\n", (u_longlong_t)pflags);
2109f67950b2SNasf-Fan 	if (dmu_objset_projectquota_enabled(os) && (pflags & ZFS_PROJID)) {
2110f67950b2SNasf-Fan 		uint64_t projid;
2111f67950b2SNasf-Fan 
2112f67950b2SNasf-Fan 		if (sa_lookup(hdl, sa_attr_table[ZPL_PROJID], &projid,
2113f67950b2SNasf-Fan 		    sizeof (uint64_t)) == 0)
2114f67950b2SNasf-Fan 			(void) printf("\tprojid	%llu\n", (u_longlong_t)projid);
2115f67950b2SNasf-Fan 	}
21160a586ceaSMark Shellenbaum 	if (sa_lookup(hdl, sa_attr_table[ZPL_XATTR], &xattr,
21170a586ceaSMark Shellenbaum 	    sizeof (uint64_t)) == 0)
21180a586ceaSMark Shellenbaum 		(void) printf("\txattr	%llu\n", (u_longlong_t)xattr);
21190a586ceaSMark Shellenbaum 	if (sa_lookup(hdl, sa_attr_table[ZPL_RDEV], &rdev,
21200a586ceaSMark Shellenbaum 	    sizeof (uint64_t)) == 0)
21210a586ceaSMark Shellenbaum 		(void) printf("\trdev	0x%016llx\n", (u_longlong_t)rdev);
21220a586ceaSMark Shellenbaum 	sa_handle_destroy(hdl);
2123fa9e4066Sahrens }
2124fa9e4066Sahrens 
2125fa9e4066Sahrens /*ARGSUSED*/
2126fa9e4066Sahrens static void
2127fa9e4066Sahrens dump_acl(objset_t *os, uint64_t object, void *data, size_t size)
2128fa9e4066Sahrens {
2129fa9e4066Sahrens }
2130fa9e4066Sahrens 
2131fa9e4066Sahrens /*ARGSUSED*/
2132fa9e4066Sahrens static void
2133fa9e4066Sahrens dump_dmu_objset(objset_t *os, uint64_t object, void *data, size_t size)
2134fa9e4066Sahrens {
2135fa9e4066Sahrens }
2136fa9e4066Sahrens 
2137eb633035STom Caputi 
21386de8f417SVictor Latushkin static object_viewer_t *object_viewer[DMU_OT_NUMTYPES + 1] = {
2139fa9e4066Sahrens 	dump_none,		/* unallocated			*/
2140fa9e4066Sahrens 	dump_zap,		/* object directory		*/
2141fa9e4066Sahrens 	dump_uint64,		/* object array			*/
2142fa9e4066Sahrens 	dump_none,		/* packed nvlist		*/
2143fa9e4066Sahrens 	dump_packed_nvlist,	/* packed nvlist size		*/
2144732885fcSMatthew Ahrens 	dump_none,		/* bpobj			*/
2145732885fcSMatthew Ahrens 	dump_bpobj,		/* bpobj header			*/
2146fa9e4066Sahrens 	dump_none,		/* SPA space map header		*/
2147fa9e4066Sahrens 	dump_none,		/* SPA space map		*/
2148fa9e4066Sahrens 	dump_none,		/* ZIL intent log		*/
2149fa9e4066Sahrens 	dump_dnode,		/* DMU dnode			*/
2150fa9e4066Sahrens 	dump_dmu_objset,	/* DMU objset			*/
2151ea8dc4b6Seschrock 	dump_dsl_dir,		/* DSL directory		*/
2152fa9e4066Sahrens 	dump_zap,		/* DSL directory child map	*/
2153fa9e4066Sahrens 	dump_zap,		/* DSL dataset snap map		*/
2154fa9e4066Sahrens 	dump_zap,		/* DSL props			*/
2155fa9e4066Sahrens 	dump_dsl_dataset,	/* DSL dataset			*/
2156fa9e4066Sahrens 	dump_znode,		/* ZFS znode			*/
2157da6c28aaSamw 	dump_acl,		/* ZFS V0 ACL			*/
2158fa9e4066Sahrens 	dump_uint8,		/* ZFS plain file		*/
2159e7437265Sahrens 	dump_zpldir,		/* ZFS directory		*/
2160fa9e4066Sahrens 	dump_zap,		/* ZFS master node		*/
2161fa9e4066Sahrens 	dump_zap,		/* ZFS delete queue		*/
2162fa9e4066Sahrens 	dump_uint8,		/* zvol object			*/
2163fa9e4066Sahrens 	dump_zap,		/* zvol prop			*/
2164fa9e4066Sahrens 	dump_uint8,		/* other uint8[]		*/
2165fa9e4066Sahrens 	dump_uint64,		/* other uint64[]		*/
2166fa9e4066Sahrens 	dump_zap,		/* other ZAP			*/
2167ea8dc4b6Seschrock 	dump_zap,		/* persistent error log		*/
216806eeb2adSek 	dump_uint8,		/* SPA history			*/
21694445fffbSMatthew Ahrens 	dump_history_offsets,	/* SPA history offsets		*/
2170b1b8ab34Slling 	dump_zap,		/* Pool properties		*/
2171ecd6cf80Smarks 	dump_zap,		/* DSL permissions		*/
2172da6c28aaSamw 	dump_acl,		/* ZFS ACL			*/
2173da6c28aaSamw 	dump_uint8,		/* ZFS SYSACL			*/
2174da6c28aaSamw 	dump_none,		/* FUID nvlist			*/
2175da6c28aaSamw 	dump_packed_nvlist,	/* FUID nvlist size		*/
2176088f3894Sahrens 	dump_zap,		/* DSL dataset next clones	*/
2177088f3894Sahrens 	dump_zap,		/* DSL scrub queue		*/
2178f67950b2SNasf-Fan 	dump_zap,		/* ZFS user/group/project used	*/
2179f67950b2SNasf-Fan 	dump_zap,		/* ZFS user/group/project quota	*/
2180842727c2SChris Kirby 	dump_zap,		/* snapshot refcount tags	*/
2181486ae710SMatthew Ahrens 	dump_ddt_zap,		/* DDT ZAP object		*/
2182b24ab676SJeff Bonwick 	dump_zap,		/* DDT statistics		*/
21830a586ceaSMark Shellenbaum 	dump_znode,		/* SA object			*/
21840a586ceaSMark Shellenbaum 	dump_zap,		/* SA Master Node		*/
21850a586ceaSMark Shellenbaum 	dump_sa_attrs,		/* SA attribute registration	*/
21860a586ceaSMark Shellenbaum 	dump_sa_layouts,	/* SA attribute layouts		*/
21873f9d6ad7SLin Ling 	dump_zap,		/* DSL scrub translations	*/
21883f9d6ad7SLin Ling 	dump_none,		/* fake dedup BP		*/
2189cde58dbcSMatthew Ahrens 	dump_zap,		/* deadlist			*/
2190cde58dbcSMatthew Ahrens 	dump_none,		/* deadlist hdr			*/
2191cde58dbcSMatthew Ahrens 	dump_zap,		/* dsl clones			*/
2192732885fcSMatthew Ahrens 	dump_bpobj_subobjs,	/* bpobj subobjs		*/
21930a586ceaSMark Shellenbaum 	dump_unknown,		/* Unknown type, must be last	*/
2194fa9e4066Sahrens };
2195fa9e4066Sahrens 
2196fa9e4066Sahrens static void
219754811da5SToomas Soome dump_object(objset_t *os, uint64_t object, int verbosity, int *print_header,
219854811da5SToomas Soome     uint64_t *dnode_slots_used)
2199fa9e4066Sahrens {
2200fa9e4066Sahrens 	dmu_buf_t *db = NULL;
2201fa9e4066Sahrens 	dmu_object_info_t doi;
2202fa9e4066Sahrens 	dnode_t *dn;
2203eb633035STom Caputi 	boolean_t dnode_held = B_FALSE;
2204fa9e4066Sahrens 	void *bonus = NULL;
2205fa9e4066Sahrens 	size_t bsize = 0;
220654811da5SToomas Soome 	char iblk[32], dblk[32], lsize[32], asize[32], fill[32], dnsize[32];
22073f9d6ad7SLin Ling 	char bonus_size[32];
2208fa9e4066Sahrens 	char aux[50];
2209fa9e4066Sahrens 	int error;
2210fa9e4066Sahrens 
22110a055120SJason King 	/* make sure nicenum has enough space */
22120a055120SJason King 	CTASSERT(sizeof (iblk) >= NN_NUMBUF_SZ);
22130a055120SJason King 	CTASSERT(sizeof (dblk) >= NN_NUMBUF_SZ);
22140a055120SJason King 	CTASSERT(sizeof (lsize) >= NN_NUMBUF_SZ);
22150a055120SJason King 	CTASSERT(sizeof (asize) >= NN_NUMBUF_SZ);
22160a055120SJason King 	CTASSERT(sizeof (bonus_size) >= NN_NUMBUF_SZ);
22170a055120SJason King 
2218fa9e4066Sahrens 	if (*print_header) {
221954811da5SToomas Soome 		(void) printf("\n%10s  %3s  %5s  %5s  %5s  %6s  %5s  %6s  %s\n",
222054811da5SToomas Soome 		    "Object", "lvl", "iblk", "dblk", "dsize", "dnsize",
222154811da5SToomas Soome 		    "lsize", "%full", "type");
2222fa9e4066Sahrens 		*print_header = 0;
2223fa9e4066Sahrens 	}
2224fa9e4066Sahrens 
2225fa9e4066Sahrens 	if (object == 0) {
2226744947dcSTom Erickson 		dn = DMU_META_DNODE(os);
2227eb633035STom Caputi 		dmu_object_info_from_dnode(dn, &doi);
2228fa9e4066Sahrens 	} else {
2229eb633035STom Caputi 		/*
2230eb633035STom Caputi 		 * Encrypted datasets will have sensitive bonus buffers
2231eb633035STom Caputi 		 * encrypted. Therefore we cannot hold the bonus buffer and
2232eb633035STom Caputi 		 * must hold the dnode itself instead.
2233eb633035STom Caputi 		 */
2234eb633035STom Caputi 		error = dmu_object_info(os, object, &doi);
2235ea8dc4b6Seschrock 		if (error)
2236eb633035STom Caputi 			fatal("dmu_object_info() failed, errno %u", error);
2237eb633035STom Caputi 
2238eb633035STom Caputi 		if (os->os_encrypted &&
2239eb633035STom Caputi 		    DMU_OT_IS_ENCRYPTED(doi.doi_bonus_type)) {
2240eb633035STom Caputi 			error = dnode_hold(os, object, FTAG, &dn);
2241eb633035STom Caputi 			if (error)
2242eb633035STom Caputi 				fatal("dnode_hold() failed, errno %u", error);
2243eb633035STom Caputi 			dnode_held = B_TRUE;
2244eb633035STom Caputi 		} else {
2245eb633035STom Caputi 			error = dmu_bonus_hold(os, object, FTAG, &db);
2246eb633035STom Caputi 			if (error)
2247eb633035STom Caputi 				fatal("dmu_bonus_hold(%llu) failed, errno %u",
2248eb633035STom Caputi 				    object, error);
2249eb633035STom Caputi 			bonus = db->db_data;
2250eb633035STom Caputi 			bsize = db->db_size;
2251eb633035STom Caputi 			dn = DB_DNODE((dmu_buf_impl_t *)db);
2252eb633035STom Caputi 		}
2253fa9e4066Sahrens 	}
2254fa9e4066Sahrens 
225554811da5SToomas Soome 	if (dnode_slots_used != NULL)
225654811da5SToomas Soome 		*dnode_slots_used = doi.doi_dnodesize / DNODE_MIN_SIZE;
225754811da5SToomas Soome 
22580a055120SJason King 	zdb_nicenum(doi.doi_metadata_block_size, iblk, sizeof (iblk));
22590a055120SJason King 	zdb_nicenum(doi.doi_data_block_size, dblk, sizeof (dblk));
22600a055120SJason King 	zdb_nicenum(doi.doi_max_offset, lsize, sizeof (lsize));
22610a055120SJason King 	zdb_nicenum(doi.doi_physical_blocks_512 << 9, asize, sizeof (asize));
22620a055120SJason King 	zdb_nicenum(doi.doi_bonus_size, bonus_size, sizeof (bonus_size));
226354811da5SToomas Soome 	zdb_nicenum(doi.doi_dnodesize, dnsize, sizeof (dnsize));
2264b24ab676SJeff Bonwick 	(void) sprintf(fill, "%6.2f", 100.0 * doi.doi_fill_count *
2265bbfd46c4SJeff Bonwick 	    doi.doi_data_block_size / (object == 0 ? DNODES_PER_BLOCK : 1) /
2266bbfd46c4SJeff Bonwick 	    doi.doi_max_offset);
2267fa9e4066Sahrens 
2268fa9e4066Sahrens 	aux[0] = '\0';
2269fa9e4066Sahrens 
2270e7437265Sahrens 	if (doi.doi_checksum != ZIO_CHECKSUM_INHERIT || verbosity >= 6) {
2271fa9e4066Sahrens 		(void) snprintf(aux + strlen(aux), sizeof (aux), " (K=%s)",
22726de8f417SVictor Latushkin 		    ZDB_CHECKSUM_NAME(doi.doi_checksum));
2273e7437265Sahrens 	}
2274fa9e4066Sahrens 
2275e7437265Sahrens 	if (doi.doi_compress != ZIO_COMPRESS_INHERIT || verbosity >= 6) {
2276fa9e4066Sahrens 		(void) snprintf(aux + strlen(aux), sizeof (aux), " (Z=%s)",
22776de8f417SVictor Latushkin 		    ZDB_COMPRESS_NAME(doi.doi_compress));
2278e7437265Sahrens 	}
2279fa9e4066Sahrens 
228054811da5SToomas Soome 	(void) printf("%10" PRIu64
228154811da5SToomas Soome 	    "  %3u  %5s  %5s  %5s  %5s  %5s  %6s  %s%s\n",
228254811da5SToomas Soome 	    object, doi.doi_indirection, iblk, dblk,
228354811da5SToomas Soome 	    asize, dnsize, lsize, fill, ZDB_OT_NAME(doi.doi_type), aux);
2284fa9e4066Sahrens 
2285fa9e4066Sahrens 	if (doi.doi_bonus_type != DMU_OT_NONE && verbosity > 3) {
228654811da5SToomas Soome 		(void) printf("%10s  %3s  %5s  %5s  %5s  %5s  %5s  %6s  %s\n",
228754811da5SToomas Soome 		    "", "", "", "", "", "", bonus_size, "bonus",
22886de8f417SVictor Latushkin 		    ZDB_OT_NAME(doi.doi_bonus_type));
2289fa9e4066Sahrens 	}
2290fa9e4066Sahrens 
2291fa9e4066Sahrens 	if (verbosity >= 4) {
2292f67950b2SNasf-Fan 		(void) printf("\tdnode flags: %s%s%s%s\n",
229314843421SMatthew Ahrens 		    (dn->dn_phys->dn_flags & DNODE_FLAG_USED_BYTES) ?
229414843421SMatthew Ahrens 		    "USED_BYTES " : "",
229514843421SMatthew Ahrens 		    (dn->dn_phys->dn_flags & DNODE_FLAG_USERUSED_ACCOUNTED) ?
22960a586ceaSMark Shellenbaum 		    "USERUSED_ACCOUNTED " : "",
2297f67950b2SNasf-Fan 		    (dn->dn_phys->dn_flags & DNODE_FLAG_USEROBJUSED_ACCOUNTED) ?
2298f67950b2SNasf-Fan 		    "USEROBJUSED_ACCOUNTED " : "",
22990a586ceaSMark Shellenbaum 		    (dn->dn_phys->dn_flags & DNODE_FLAG_SPILL_BLKPTR) ?
23000a586ceaSMark Shellenbaum 		    "SPILL_BLKPTR" : "");
230114843421SMatthew Ahrens 		(void) printf("\tdnode maxblkid: %llu\n",
230214843421SMatthew Ahrens 		    (longlong_t)dn->dn_phys->dn_maxblkid);
230314843421SMatthew Ahrens 
2304eb633035STom Caputi 		if (!dnode_held) {
2305eb633035STom Caputi 			object_viewer[ZDB_OT_TYPE(doi.doi_bonus_type)](os,
2306eb633035STom Caputi 			    object, bonus, bsize);
2307eb633035STom Caputi 		} else {
2308eb633035STom Caputi 			(void) printf("\t\t(bonus encrypted)\n");
2309eb633035STom Caputi 		}
2310eb633035STom Caputi 
2311eb633035STom Caputi 		if (!os->os_encrypted || !DMU_OT_IS_ENCRYPTED(doi.doi_type)) {
2312eb633035STom Caputi 			object_viewer[ZDB_OT_TYPE(doi.doi_type)](os, object,
2313eb633035STom Caputi 			    NULL, 0);
2314eb633035STom Caputi 		} else {
2315eb633035STom Caputi 			(void) printf("\t\t(object encrypted)\n");
2316eb633035STom Caputi 		}
2317eb633035STom Caputi 
2318fa9e4066Sahrens 		*print_header = 1;
2319fa9e4066Sahrens 	}
2320fa9e4066Sahrens 
2321fa9e4066Sahrens 	if (verbosity >= 5)
232288b7b0f2SMatthew Ahrens 		dump_indirect(dn);
2323fa9e4066Sahrens 
2324fa9e4066Sahrens 	if (verbosity >= 5) {
2325fa9e4066Sahrens 		/*
2326fa9e4066Sahrens 		 * Report the list of segments that comprise the object.
2327fa9e4066Sahrens 		 */
2328fa9e4066Sahrens 		uint64_t start = 0;
2329fa9e4066Sahrens 		uint64_t end;
2330fa9e4066Sahrens 		uint64_t blkfill = 1;
2331fa9e4066Sahrens 		int minlvl = 1;
2332fa9e4066Sahrens 
2333fa9e4066Sahrens 		if (dn->dn_type == DMU_OT_DNODE) {
2334fa9e4066Sahrens 			minlvl = 0;
2335fa9e4066Sahrens 			blkfill = DNODES_PER_BLOCK;
2336fa9e4066Sahrens 		}
2337fa9e4066Sahrens 
2338fa9e4066Sahrens 		for (;;) {
23393f9d6ad7SLin Ling 			char segsize[32];
23400a055120SJason King 			/* make sure nicenum has enough space */
23410a055120SJason King 			CTASSERT(sizeof (segsize) >= NN_NUMBUF_SZ);
2342cdb0ab79Smaybee 			error = dnode_next_offset(dn,
2343cdb0ab79Smaybee 			    0, &start, minlvl, blkfill, 0);
2344fa9e4066Sahrens 			if (error)
2345fa9e4066Sahrens 				break;
2346fa9e4066Sahrens 			end = start;
2347cdb0ab79Smaybee 			error = dnode_next_offset(dn,
2348cdb0ab79Smaybee 			    DNODE_FIND_HOLE, &end, minlvl, blkfill, 0);
23490a055120SJason King 			zdb_nicenum(end - start, segsize, sizeof (segsize));
2350fa9e4066Sahrens 			(void) printf("\t\tsegment [%016llx, %016llx)"
2351fa9e4066Sahrens 			    " size %5s\n", (u_longlong_t)start,
2352fa9e4066Sahrens 			    (u_longlong_t)end, segsize);
2353fa9e4066Sahrens 			if (error)
2354fa9e4066Sahrens 				break;
2355fa9e4066Sahrens 			start = end;
2356fa9e4066Sahrens 		}
2357fa9e4066Sahrens 	}
2358fa9e4066Sahrens 
2359fa9e4066Sahrens 	if (db != NULL)
2360ea8dc4b6Seschrock 		dmu_buf_rele(db, FTAG);
2361eb633035STom Caputi 	if (dnode_held)
2362eb633035STom Caputi 		dnode_rele(dn, FTAG);
2363fa9e4066Sahrens }
2364fa9e4066Sahrens 
236517fb938fSMatthew Ahrens static void
236617fb938fSMatthew Ahrens count_dir_mos_objects(dsl_dir_t *dd)
236717fb938fSMatthew Ahrens {
236817fb938fSMatthew Ahrens 	mos_obj_refd(dd->dd_object);
236917fb938fSMatthew Ahrens 	mos_obj_refd(dsl_dir_phys(dd)->dd_child_dir_zapobj);
237017fb938fSMatthew Ahrens 	mos_obj_refd(dsl_dir_phys(dd)->dd_deleg_zapobj);
237117fb938fSMatthew Ahrens 	mos_obj_refd(dsl_dir_phys(dd)->dd_props_zapobj);
237217fb938fSMatthew Ahrens 	mos_obj_refd(dsl_dir_phys(dd)->dd_clones);
237317fb938fSMatthew Ahrens }
237417fb938fSMatthew Ahrens 
237517fb938fSMatthew Ahrens static void
237617fb938fSMatthew Ahrens count_ds_mos_objects(dsl_dataset_t *ds)
237717fb938fSMatthew Ahrens {
237817fb938fSMatthew Ahrens 	mos_obj_refd(ds->ds_object);
237917fb938fSMatthew Ahrens 	mos_obj_refd(dsl_dataset_phys(ds)->ds_next_clones_obj);
238017fb938fSMatthew Ahrens 	mos_obj_refd(dsl_dataset_phys(ds)->ds_props_obj);
238117fb938fSMatthew Ahrens 	mos_obj_refd(dsl_dataset_phys(ds)->ds_userrefs_obj);
238217fb938fSMatthew Ahrens 	mos_obj_refd(dsl_dataset_phys(ds)->ds_snapnames_zapobj);
238317fb938fSMatthew Ahrens 
238417fb938fSMatthew Ahrens 	if (!dsl_dataset_is_snapshot(ds)) {
238517fb938fSMatthew Ahrens 		count_dir_mos_objects(ds->ds_dir);
238617fb938fSMatthew Ahrens 	}
238717fb938fSMatthew Ahrens }
238817fb938fSMatthew Ahrens 
23893f7978d0SAlan Somers static const char *objset_types[DMU_OST_NUMTYPES] = {
2390fa9e4066Sahrens 	"NONE", "META", "ZPL", "ZVOL", "OTHER", "ANY" };
2391fa9e4066Sahrens 
2392fa9e4066Sahrens static void
2393fa9e4066Sahrens dump_dir(objset_t *os)
2394fa9e4066Sahrens {
2395fa9e4066Sahrens 	dmu_objset_stats_t dds;
2396fa9e4066Sahrens 	uint64_t object, object_count;
2397a2eea2e1Sahrens 	uint64_t refdbytes, usedobjs, scratch;
23983f9d6ad7SLin Ling 	char numbuf[32];
239914843421SMatthew Ahrens 	char blkbuf[BP_SPRINTF_LEN + 20];
24009adfa60dSMatthew Ahrens 	char osname[ZFS_MAX_DATASET_NAME_LEN];
24013f7978d0SAlan Somers 	const char *type = "UNKNOWN";
2402fa9e4066Sahrens 	int verbosity = dump_opt['d'];
2403fa9e4066Sahrens 	int print_header = 1;
24043f7978d0SAlan Somers 	unsigned i;
24053f7978d0SAlan Somers 	int error;
240654811da5SToomas Soome 	uint64_t total_slots_used = 0;
240754811da5SToomas Soome 	uint64_t max_slot_used = 0;
240854811da5SToomas Soome 	uint64_t dnode_slots;
2409fa9e4066Sahrens 
24100a055120SJason King 	/* make sure nicenum has enough space */
24110a055120SJason King 	CTASSERT(sizeof (numbuf) >= NN_NUMBUF_SZ);
24120a055120SJason King 
24133b2aab18SMatthew Ahrens 	dsl_pool_config_enter(dmu_objset_pool(os), FTAG);
2414a2eea2e1Sahrens 	dmu_objset_fast_stat(os, &dds);
24153b2aab18SMatthew Ahrens 	dsl_pool_config_exit(dmu_objset_pool(os), FTAG);
2416fa9e4066Sahrens 
2417fa9e4066Sahrens 	if (dds.dds_type < DMU_OST_NUMTYPES)
2418fa9e4066Sahrens 		type = objset_types[dds.dds_type];
2419fa9e4066Sahrens 
2420fa9e4066Sahrens 	if (dds.dds_type == DMU_OST_META) {
2421fa9e4066Sahrens 		dds.dds_creation_txg = TXG_INITIAL;
24225d7b4d43SMatthew Ahrens 		usedobjs = BP_GET_FILL(os->os_rootbp);
2423c1379625SJustin T. Gibbs 		refdbytes = dsl_dir_phys(os->os_spa->spa_dsl_pool->dp_mos_dir)->
2424c1379625SJustin T. Gibbs 		    dd_used_bytes;
2425a2eea2e1Sahrens 	} else {
2426a2eea2e1Sahrens 		dmu_objset_space(os, &refdbytes, &scratch, &usedobjs, &scratch);
2427fa9e4066Sahrens 	}
2428fa9e4066Sahrens 
24295d7b4d43SMatthew Ahrens 	ASSERT3U(usedobjs, ==, BP_GET_FILL(os->os_rootbp));
2430fa9e4066Sahrens 
24310a055120SJason King 	zdb_nicenum(refdbytes, numbuf, sizeof (numbuf));
2432fa9e4066Sahrens 
2433fa9e4066Sahrens 	if (verbosity >= 4) {
243443466aaeSMax Grossman 		(void) snprintf(blkbuf, sizeof (blkbuf), ", rootbp ");
243543466aaeSMax Grossman 		(void) snprintf_blkptr(blkbuf + strlen(blkbuf),
243643466aaeSMax Grossman 		    sizeof (blkbuf) - strlen(blkbuf), os->os_rootbp);
2437fa9e4066Sahrens 	} else {
2438fa9e4066Sahrens 		blkbuf[0] = '\0';
2439fa9e4066Sahrens 	}
2440fa9e4066Sahrens 
2441fa9e4066Sahrens 	dmu_objset_name(os, osname);
2442fa9e4066Sahrens 
2443a2eea2e1Sahrens 	(void) printf("Dataset %s [%s], ID %llu, cr_txg %llu, "
2444ade2c828SSerapheim Dimitropoulos 	    "%s, %llu objects%s%s\n",
2445fa9e4066Sahrens 	    osname, type, (u_longlong_t)dmu_objset_id(os),
2446fa9e4066Sahrens 	    (u_longlong_t)dds.dds_creation_txg,
2447ade2c828SSerapheim Dimitropoulos 	    numbuf, (u_longlong_t)usedobjs, blkbuf,
2448ade2c828SSerapheim Dimitropoulos 	    (dds.dds_inconsistent) ? " (inconsistent)" : "");
2449fa9e4066Sahrens 
2450b24ab676SJeff Bonwick 	if (zopt_objects != 0) {
2451b24ab676SJeff Bonwick 		for (i = 0; i < zopt_objects; i++)
2452b24ab676SJeff Bonwick 			dump_object(os, zopt_object[i], verbosity,
245354811da5SToomas Soome 			    &print_header, NULL);
2454b24ab676SJeff Bonwick 		(void) printf("\n");
2455b24ab676SJeff Bonwick 		return;
2456b24ab676SJeff Bonwick 	}
2457b24ab676SJeff Bonwick 
2458b24ab676SJeff Bonwick 	if (dump_opt['i'] != 0 || verbosity >= 2)
2459b24ab676SJeff Bonwick 		dump_intent_log(dmu_objset_zil(os));
2460fa9e4066Sahrens 
24615cabbc6bSPrashanth Sreenivasa 	if (dmu_objset_ds(os) != NULL) {
24625cabbc6bSPrashanth Sreenivasa 		dsl_dataset_t *ds = dmu_objset_ds(os);
24635cabbc6bSPrashanth Sreenivasa 		dump_deadlist(&ds->ds_deadlist);
24645cabbc6bSPrashanth Sreenivasa 
24655cabbc6bSPrashanth Sreenivasa 		if (dsl_dataset_remap_deadlist_exists(ds)) {
24665cabbc6bSPrashanth Sreenivasa 			(void) printf("ds_remap_deadlist:\n");
24675cabbc6bSPrashanth Sreenivasa 			dump_deadlist(&ds->ds_remap_deadlist);
24685cabbc6bSPrashanth Sreenivasa 		}
246917fb938fSMatthew Ahrens 		count_ds_mos_objects(ds);
24705cabbc6bSPrashanth Sreenivasa 	}
2471fa9e4066Sahrens 
2472fa9e4066Sahrens 	if (verbosity < 2)
2473fa9e4066Sahrens 		return;
2474fa9e4066Sahrens 
247543466aaeSMax Grossman 	if (BP_IS_HOLE(os->os_rootbp))
2476088f3894Sahrens 		return;
2477088f3894Sahrens 
247854811da5SToomas Soome 	dump_object(os, 0, verbosity, &print_header, NULL);
247914843421SMatthew Ahrens 	object_count = 0;
2480744947dcSTom Erickson 	if (DMU_USERUSED_DNODE(os) != NULL &&
2481744947dcSTom Erickson 	    DMU_USERUSED_DNODE(os)->dn_type != 0) {
248254811da5SToomas Soome 		dump_object(os, DMU_USERUSED_OBJECT, verbosity, &print_header,
248354811da5SToomas Soome 		    NULL);
248454811da5SToomas Soome 		dump_object(os, DMU_GROUPUSED_OBJECT, verbosity, &print_header,
248554811da5SToomas Soome 		    NULL);
248614843421SMatthew Ahrens 	}
2487fa9e4066Sahrens 
2488f67950b2SNasf-Fan 	if (DMU_PROJECTUSED_DNODE(os) != NULL &&
2489f67950b2SNasf-Fan 	    DMU_PROJECTUSED_DNODE(os)->dn_type != 0)
2490f67950b2SNasf-Fan 		dump_object(os, DMU_PROJECTUSED_OBJECT, verbosity,
2491f67950b2SNasf-Fan 		    &print_header, NULL);
2492f67950b2SNasf-Fan 
2493fa9e4066Sahrens 	object = 0;
24946754306eSahrens 	while ((error = dmu_object_next(os, &object, B_FALSE, 0)) == 0) {
249554811da5SToomas Soome 		dump_object(os, object, verbosity, &print_header, &dnode_slots);
2496fa9e4066Sahrens 		object_count++;
249754811da5SToomas Soome 		total_slots_used += dnode_slots;
249854811da5SToomas Soome 		max_slot_used = object + dnode_slots - 1;
2499fa9e4066Sahrens 	}
2500fa9e4066Sahrens 
2501fa9e4066Sahrens 	(void) printf("\n");
2502fa9e4066Sahrens 
250354811da5SToomas Soome 	(void) printf("    Dnode slots:\n");
250454811da5SToomas Soome 	(void) printf("\tTotal used:    %10llu\n",
250554811da5SToomas Soome 	    (u_longlong_t)total_slots_used);
250654811da5SToomas Soome 	(void) printf("\tMax used:      %10llu\n",
250754811da5SToomas Soome 	    (u_longlong_t)max_slot_used);
250854811da5SToomas Soome 	(void) printf("\tPercent empty: %10lf\n",
250954811da5SToomas Soome 	    (double)(max_slot_used - total_slots_used)*100 /
251054811da5SToomas Soome 	    (double)max_slot_used);
251154811da5SToomas Soome 
251254811da5SToomas Soome 	(void) printf("\n");
251354811da5SToomas Soome 
2514ccba0801SRich Morris 	if (error != ESRCH) {
2515ccba0801SRich Morris 		(void) fprintf(stderr, "dmu_object_next() = %d\n", error);
2516ccba0801SRich Morris 		abort();
2517ccba0801SRich Morris 	}
251820b5dafbSPaul Dagnelie 	if (leaked_objects != 0) {
251920b5dafbSPaul Dagnelie 		(void) printf("%d potentially leaked objects detected\n",
252020b5dafbSPaul Dagnelie 		    leaked_objects);
252120b5dafbSPaul Dagnelie 		leaked_objects = 0;
252220b5dafbSPaul Dagnelie 	}
2523a3874b8bSToomas Soome 
2524a3874b8bSToomas Soome 	ASSERT3U(object_count, ==, usedobjs);
2525fa9e4066Sahrens }
2526fa9e4066Sahrens 
2527fa9e4066Sahrens static void
252853b9a4a9SVictor Latushkin dump_uberblock(uberblock_t *ub, const char *header, const char *footer)
2529fa9e4066Sahrens {
2530fa9e4066Sahrens 	time_t timestamp = ub->ub_timestamp;
2531fa9e4066Sahrens 
25323f7978d0SAlan Somers 	(void) printf("%s", header ? header : "");
2533fa9e4066Sahrens 	(void) printf("\tmagic = %016llx\n", (u_longlong_t)ub->ub_magic);
2534fa9e4066Sahrens 	(void) printf("\tversion = %llu\n", (u_longlong_t)ub->ub_version);
2535fa9e4066Sahrens 	(void) printf("\ttxg = %llu\n", (u_longlong_t)ub->ub_txg);
2536fa9e4066Sahrens 	(void) printf("\tguid_sum = %llu\n", (u_longlong_t)ub->ub_guid_sum);
2537fa9e4066Sahrens 	(void) printf("\ttimestamp = %llu UTC = %s",
2538fa9e4066Sahrens 	    (u_longlong_t)ub->ub_timestamp, asctime(localtime(&timestamp)));
2539e0f1c0afSOlaf Faaland 
2540e0f1c0afSOlaf Faaland 	(void) printf("\tmmp_magic = %016llx\n",
2541e0f1c0afSOlaf Faaland 	    (u_longlong_t)ub->ub_mmp_magic);
25424348eb90SOlaf Faaland 	if (MMP_VALID(ub)) {
2543e0f1c0afSOlaf Faaland 		(void) printf("\tmmp_delay = %0llu\n",
2544e0f1c0afSOlaf Faaland 		    (u_longlong_t)ub->ub_mmp_delay);
25454348eb90SOlaf Faaland 		if (MMP_SEQ_VALID(ub))
25464348eb90SOlaf Faaland 			(void) printf("\tmmp_seq = %u\n",
25474348eb90SOlaf Faaland 			    (unsigned int) MMP_SEQ(ub));
25484348eb90SOlaf Faaland 		if (MMP_FAIL_INT_VALID(ub))
25494348eb90SOlaf Faaland 			(void) printf("\tmmp_fail = %u\n",
25504348eb90SOlaf Faaland 			    (unsigned int) MMP_FAIL_INT(ub));
25514348eb90SOlaf Faaland 		if (MMP_INTERVAL_VALID(ub))
25524348eb90SOlaf Faaland 			(void) printf("\tmmp_write = %u\n",
25534348eb90SOlaf Faaland 			    (unsigned int) MMP_INTERVAL(ub));
25544348eb90SOlaf Faaland 		/* After MMP_* to make summarize_uberblock_mmp cleaner */
25554348eb90SOlaf Faaland 		(void) printf("\tmmp_valid = %x\n",
25564348eb90SOlaf Faaland 		    (unsigned int) ub->ub_mmp_config & 0xFF);
25574348eb90SOlaf Faaland 	}
2558e0f1c0afSOlaf Faaland 
2559fa9e4066Sahrens 	if (dump_opt['u'] >= 3) {
2560fbabab8fSmaybee 		char blkbuf[BP_SPRINTF_LEN];
256143466aaeSMax Grossman 		snprintf_blkptr(blkbuf, sizeof (blkbuf), &ub->ub_rootbp);
2562fa9e4066Sahrens 		(void) printf("\trootbp = %s\n", blkbuf);
2563fa9e4066Sahrens 	}
256486714001SSerapheim Dimitropoulos 	(void) printf("\tcheckpoint_txg = %llu\n",
256586714001SSerapheim Dimitropoulos 	    (u_longlong_t)ub->ub_checkpoint_txg);
25663f7978d0SAlan Somers 	(void) printf("%s", footer ? footer : "");
2567fa9e4066Sahrens }
2568fa9e4066Sahrens 
2569fa9e4066Sahrens static void
257007428bdfSVictor Latushkin dump_config(spa_t *spa)
2571fa9e4066Sahrens {
257207428bdfSVictor Latushkin 	dmu_buf_t *db;
257307428bdfSVictor Latushkin 	size_t nvsize = 0;
257407428bdfSVictor Latushkin 	int error = 0;
257507428bdfSVictor Latushkin 
2576fa9e4066Sahrens 
257707428bdfSVictor Latushkin 	error = dmu_bonus_hold(spa->spa_meta_objset,
257807428bdfSVictor Latushkin 	    spa->spa_config_object, FTAG, &db);
257907428bdfSVictor Latushkin 
258007428bdfSVictor Latushkin 	if (error == 0) {
258107428bdfSVictor Latushkin 		nvsize = *(uint64_t *)db->db_data;
258207428bdfSVictor Latushkin 		dmu_buf_rele(db, FTAG);
258307428bdfSVictor Latushkin 
258407428bdfSVictor Latushkin 		(void) printf("\nMOS Configuration:\n");
258507428bdfSVictor Latushkin 		dump_packed_nvlist(spa->spa_meta_objset,
258607428bdfSVictor Latushkin 		    spa->spa_config_object, (void *)&nvsize, 1);
258707428bdfSVictor Latushkin 	} else {
258807428bdfSVictor Latushkin 		(void) fprintf(stderr, "dmu_bonus_hold(%llu) failed, errno %d",
258907428bdfSVictor Latushkin 		    (u_longlong_t)spa->spa_config_object, error);
2590fa9e4066Sahrens 	}
2591fa9e4066Sahrens }
2592fa9e4066Sahrens 
2593c5904d13Seschrock static void
2594c5904d13Seschrock dump_cachefile(const char *cachefile)
2595c5904d13Seschrock {
2596c5904d13Seschrock 	int fd;
2597c5904d13Seschrock 	struct stat64 statbuf;
2598c5904d13Seschrock 	char *buf;
2599c5904d13Seschrock 	nvlist_t *config;
2600c5904d13Seschrock 
2601c5904d13Seschrock 	if ((fd = open64(cachefile, O_RDONLY)) < 0) {
2602c5904d13Seschrock 		(void) printf("cannot open '%s': %s\n", cachefile,
2603c5904d13Seschrock 		    strerror(errno));
2604c5904d13Seschrock 		exit(1);
2605c5904d13Seschrock 	}
2606c5904d13Seschrock 
2607c5904d13Seschrock 	if (fstat64(fd, &statbuf) != 0) {
2608c5904d13Seschrock 		(void) printf("failed to stat '%s': %s\n", cachefile,
2609c5904d13Seschrock 		    strerror(errno));
2610c5904d13Seschrock 		exit(1);
2611c5904d13Seschrock 	}
2612c5904d13Seschrock 
2613c5904d13Seschrock 	if ((buf = malloc(statbuf.st_size)) == NULL) {
2614c5904d13Seschrock 		(void) fprintf(stderr, "failed to allocate %llu bytes\n",
2615c5904d13Seschrock 		    (u_longlong_t)statbuf.st_size);
2616c5904d13Seschrock 		exit(1);
2617c5904d13Seschrock 	}
2618c5904d13Seschrock 
2619c5904d13Seschrock 	if (read(fd, buf, statbuf.st_size) != statbuf.st_size) {
2620c5904d13Seschrock 		(void) fprintf(stderr, "failed to read %llu bytes\n",
2621c5904d13Seschrock 		    (u_longlong_t)statbuf.st_size);
2622c5904d13Seschrock 		exit(1);
2623c5904d13Seschrock 	}
2624c5904d13Seschrock 
2625c5904d13Seschrock 	(void) close(fd);
2626c5904d13Seschrock 
2627c5904d13Seschrock 	if (nvlist_unpack(buf, statbuf.st_size, &config, 0) != 0) {
2628c5904d13Seschrock 		(void) fprintf(stderr, "failed to unpack nvlist\n");
2629c5904d13Seschrock 		exit(1);
2630c5904d13Seschrock 	}
2631c5904d13Seschrock 
2632c5904d13Seschrock 	free(buf);
2633c5904d13Seschrock 
2634c5904d13Seschrock 	dump_nvlist(config, 0);
2635c5904d13Seschrock 
2636c5904d13Seschrock 	nvlist_free(config);
2637c5904d13Seschrock }
2638c5904d13Seschrock 
263953b9a4a9SVictor Latushkin #define	ZDB_MAX_UB_HEADER_SIZE 32
264053b9a4a9SVictor Latushkin 
264153b9a4a9SVictor Latushkin static void
264253b9a4a9SVictor Latushkin dump_label_uberblocks(vdev_label_t *lbl, uint64_t ashift)
264353b9a4a9SVictor Latushkin {
264453b9a4a9SVictor Latushkin 	vdev_t vd;
264553b9a4a9SVictor Latushkin 	vdev_t *vdp = &vd;
264653b9a4a9SVictor Latushkin 	char header[ZDB_MAX_UB_HEADER_SIZE];
264753b9a4a9SVictor Latushkin 
264853b9a4a9SVictor Latushkin 	vd.vdev_ashift = ashift;
264953b9a4a9SVictor Latushkin 	vdp->vdev_top = vdp;
265053b9a4a9SVictor Latushkin 
265153b9a4a9SVictor Latushkin 	for (int i = 0; i < VDEV_UBERBLOCK_COUNT(vdp); i++) {
265253b9a4a9SVictor Latushkin 		uint64_t uoff = VDEV_UBERBLOCK_OFFSET(vdp, i);
265353b9a4a9SVictor Latushkin 		uberblock_t *ub = (void *)((char *)lbl + uoff);
265453b9a4a9SVictor Latushkin 
265553b9a4a9SVictor Latushkin 		if (uberblock_verify(ub))
265653b9a4a9SVictor Latushkin 			continue;
2657e0f1c0afSOlaf Faaland 
2658e0f1c0afSOlaf Faaland 		if ((dump_opt['u'] < 4) &&
2659e0f1c0afSOlaf Faaland 		    (ub->ub_mmp_magic == MMP_MAGIC) && ub->ub_mmp_delay &&
2660e0f1c0afSOlaf Faaland 		    (i >= VDEV_UBERBLOCK_COUNT(&vd) - MMP_BLOCKS_PER_LABEL))
2661e0f1c0afSOlaf Faaland 			continue;
2662e0f1c0afSOlaf Faaland 
266353b9a4a9SVictor Latushkin 		(void) snprintf(header, ZDB_MAX_UB_HEADER_SIZE,
266453b9a4a9SVictor Latushkin 		    "Uberblock[%d]\n", i);
266553b9a4a9SVictor Latushkin 		dump_uberblock(ub, header, "");
266653b9a4a9SVictor Latushkin 	}
266753b9a4a9SVictor Latushkin }
266853b9a4a9SVictor Latushkin 
2669ed61ec1dSYuri Pankov static char curpath[PATH_MAX];
2670ed61ec1dSYuri Pankov 
2671ed61ec1dSYuri Pankov /*
2672ed61ec1dSYuri Pankov  * Iterate through the path components, recursively passing
2673ed61ec1dSYuri Pankov  * current one's obj and remaining path until we find the obj
2674ed61ec1dSYuri Pankov  * for the last one.
2675ed61ec1dSYuri Pankov  */
2676ed61ec1dSYuri Pankov static int
2677ed61ec1dSYuri Pankov dump_path_impl(objset_t *os, uint64_t obj, char *name)
2678ed61ec1dSYuri Pankov {
2679ed61ec1dSYuri Pankov 	int err;
2680ed61ec1dSYuri Pankov 	int header = 1;
2681ed61ec1dSYuri Pankov 	uint64_t child_obj;
2682ed61ec1dSYuri Pankov 	char *s;
2683ed61ec1dSYuri Pankov 	dmu_buf_t *db;
2684ed61ec1dSYuri Pankov 	dmu_object_info_t doi;
2685ed61ec1dSYuri Pankov 
2686ed61ec1dSYuri Pankov 	if ((s = strchr(name, '/')) != NULL)
2687ed61ec1dSYuri Pankov 		*s = '\0';
2688ed61ec1dSYuri Pankov 	err = zap_lookup(os, obj, name, 8, 1, &child_obj);
2689ed61ec1dSYuri Pankov 
2690ed61ec1dSYuri Pankov 	(void) strlcat(curpath, name, sizeof (curpath));
2691ed61ec1dSYuri Pankov 
2692ed61ec1dSYuri Pankov 	if (err != 0) {
2693ed61ec1dSYuri Pankov 		(void) fprintf(stderr, "failed to lookup %s: %s\n",
2694ed61ec1dSYuri Pankov 		    curpath, strerror(err));
2695ed61ec1dSYuri Pankov 		return (err);
2696ed61ec1dSYuri Pankov 	}
2697ed61ec1dSYuri Pankov 
2698ed61ec1dSYuri Pankov 	child_obj = ZFS_DIRENT_OBJ(child_obj);
2699ed61ec1dSYuri Pankov 	err = sa_buf_hold(os, child_obj, FTAG, &db);
2700ed61ec1dSYuri Pankov 	if (err != 0) {
2701ed61ec1dSYuri Pankov 		(void) fprintf(stderr,
2702ed61ec1dSYuri Pankov 		    "failed to get SA dbuf for obj %llu: %s\n",
2703ed61ec1dSYuri Pankov 		    (u_longlong_t)child_obj, strerror(err));
2704ed61ec1dSYuri Pankov 		return (EINVAL);
2705ed61ec1dSYuri Pankov 	}
2706ed61ec1dSYuri Pankov 	dmu_object_info_from_db(db, &doi);
2707ed61ec1dSYuri Pankov 	sa_buf_rele(db, FTAG);
2708ed61ec1dSYuri Pankov 
2709ed61ec1dSYuri Pankov 	if (doi.doi_bonus_type != DMU_OT_SA &&
2710ed61ec1dSYuri Pankov 	    doi.doi_bonus_type != DMU_OT_ZNODE) {
2711ed61ec1dSYuri Pankov 		(void) fprintf(stderr, "invalid bonus type %d for obj %llu\n",
2712ed61ec1dSYuri Pankov 		    doi.doi_bonus_type, (u_longlong_t)child_obj);
2713ed61ec1dSYuri Pankov 		return (EINVAL);
2714ed61ec1dSYuri Pankov 	}
2715ed61ec1dSYuri Pankov 
2716ed61ec1dSYuri Pankov 	if (dump_opt['v'] > 6) {
2717ed61ec1dSYuri Pankov 		(void) printf("obj=%llu %s type=%d bonustype=%d\n",
2718ed61ec1dSYuri Pankov 		    (u_longlong_t)child_obj, curpath, doi.doi_type,
2719ed61ec1dSYuri Pankov 		    doi.doi_bonus_type);
2720ed61ec1dSYuri Pankov 	}
2721ed61ec1dSYuri Pankov 
2722ed61ec1dSYuri Pankov 	(void) strlcat(curpath, "/", sizeof (curpath));
2723ed61ec1dSYuri Pankov 
2724ed61ec1dSYuri Pankov 	switch (doi.doi_type) {
2725ed61ec1dSYuri Pankov 	case DMU_OT_DIRECTORY_CONTENTS:
2726ed61ec1dSYuri Pankov 		if (s != NULL && *(s + 1) != '\0')
2727ed61ec1dSYuri Pankov 			return (dump_path_impl(os, child_obj, s + 1));
2728ed61ec1dSYuri Pankov 		/*FALLTHROUGH*/
2729ed61ec1dSYuri Pankov 	case DMU_OT_PLAIN_FILE_CONTENTS:
273054811da5SToomas Soome 		dump_object(os, child_obj, dump_opt['v'], &header, NULL);
2731ed61ec1dSYuri Pankov 		return (0);
2732ed61ec1dSYuri Pankov 	default:
2733ed61ec1dSYuri Pankov 		(void) fprintf(stderr, "object %llu has non-file/directory "
2734ed61ec1dSYuri Pankov 		    "type %d\n", (u_longlong_t)obj, doi.doi_type);
2735ed61ec1dSYuri Pankov 		break;
2736ed61ec1dSYuri Pankov 	}
2737ed61ec1dSYuri Pankov 
2738ed61ec1dSYuri Pankov 	return (EINVAL);
2739ed61ec1dSYuri Pankov }
2740ed61ec1dSYuri Pankov 
2741ed61ec1dSYuri Pankov /*
2742ed61ec1dSYuri Pankov  * Dump the blocks for the object specified by path inside the dataset.
2743ed61ec1dSYuri Pankov  */
2744ed61ec1dSYuri Pankov static int
2745ed61ec1dSYuri Pankov dump_path(char *ds, char *path)
2746ed61ec1dSYuri Pankov {
2747ed61ec1dSYuri Pankov 	int err;
2748ed61ec1dSYuri Pankov 	objset_t *os;
2749ed61ec1dSYuri Pankov 	uint64_t root_obj;
2750ed61ec1dSYuri Pankov 
2751ed61ec1dSYuri Pankov 	err = open_objset(ds, DMU_OST_ZFS, FTAG, &os);
2752ed61ec1dSYuri Pankov 	if (err != 0)
2753ed61ec1dSYuri Pankov 		return (err);
2754ed61ec1dSYuri Pankov 
2755ed61ec1dSYuri Pankov 	err = zap_lookup(os, MASTER_NODE_OBJ, ZFS_ROOT_OBJ, 8, 1, &root_obj);
2756ed61ec1dSYuri Pankov 	if (err != 0) {
2757ed61ec1dSYuri Pankov 		(void) fprintf(stderr, "can't lookup root znode: %s\n",
2758ed61ec1dSYuri Pankov 		    strerror(err));
2759eb633035STom Caputi 		dmu_objset_disown(os, B_FALSE, FTAG);
2760ed61ec1dSYuri Pankov 		return (EINVAL);
2761ed61ec1dSYuri Pankov 	}
2762ed61ec1dSYuri Pankov 
2763ed61ec1dSYuri Pankov 	(void) snprintf(curpath, sizeof (curpath), "dataset=%s path=/", ds);
2764ed61ec1dSYuri Pankov 
2765ed61ec1dSYuri Pankov 	err = dump_path_impl(os, root_obj, path);
2766ed61ec1dSYuri Pankov 
2767ed61ec1dSYuri Pankov 	close_objset(os, FTAG);
2768ed61ec1dSYuri Pankov 	return (err);
2769ed61ec1dSYuri Pankov }
2770ed61ec1dSYuri Pankov 
277164723e36SYuri Pankov static int
2772fa9e4066Sahrens dump_label(const char *dev)
2773fa9e4066Sahrens {
2774fa9e4066Sahrens 	int fd;
2775fa9e4066Sahrens 	vdev_label_t label;
277664723e36SYuri Pankov 	char path[MAXPATHLEN];
277764723e36SYuri Pankov 	char *buf = label.vl_vdev_phys.vp_nvlist;
2778fa9e4066Sahrens 	size_t buflen = sizeof (label.vl_vdev_phys.vp_nvlist);
2779fa9e4066Sahrens 	struct stat64 statbuf;
278053b9a4a9SVictor Latushkin 	uint64_t psize, ashift;
278164723e36SYuri Pankov 	boolean_t label_found = B_FALSE;
278264723e36SYuri Pankov 
278364723e36SYuri Pankov 	(void) strlcpy(path, dev, sizeof (path));
278464723e36SYuri Pankov 	if (dev[0] == '/') {
278564723e36SYuri Pankov 		if (strncmp(dev, ZFS_DISK_ROOTD,
278664723e36SYuri Pankov 		    strlen(ZFS_DISK_ROOTD)) == 0) {
278764723e36SYuri Pankov 			(void) snprintf(path, sizeof (path), "%s%s",
278864723e36SYuri Pankov 			    ZFS_RDISK_ROOTD, dev + strlen(ZFS_DISK_ROOTD));
278964723e36SYuri Pankov 		}
279064723e36SYuri Pankov 	} else if (stat64(path, &statbuf) != 0) {
279164723e36SYuri Pankov 		char *s;
2792c6065d0fSGeorge Wilson 
279364723e36SYuri Pankov 		(void) snprintf(path, sizeof (path), "%s%s", ZFS_RDISK_ROOTD,
279464723e36SYuri Pankov 		    dev);
279522c8b958SYuri Pankov 		if (((s = strrchr(dev, 's')) == NULL &&
279622c8b958SYuri Pankov 		    (s = strchr(dev, 'p')) == NULL) ||
279722c8b958SYuri Pankov 		    !isdigit(*(s + 1)))
279864723e36SYuri Pankov 			(void) strlcat(path, "s0", sizeof (path));
2799fa9e4066Sahrens 	}
2800fa9e4066Sahrens 
280122c8b958SYuri Pankov 	if ((fd = open64(path, O_RDONLY)) < 0) {
280222c8b958SYuri Pankov 		(void) fprintf(stderr, "cannot open '%s': %s\n", path,
2803fa9e4066Sahrens 		    strerror(errno));
2804c6065d0fSGeorge Wilson 		exit(1);
2805c6065d0fSGeorge Wilson 	}
2806c6065d0fSGeorge Wilson 
280722c8b958SYuri Pankov 	if (fstat64(fd, &statbuf) != 0) {
280822c8b958SYuri Pankov 		(void) fprintf(stderr, "failed to stat '%s': %s\n", path,
280922c8b958SYuri Pankov 		    strerror(errno));
281022c8b958SYuri Pankov 		(void) close(fd);
281164723e36SYuri Pankov 		exit(1);
281264723e36SYuri Pankov 	}
281364723e36SYuri Pankov 
281422c8b958SYuri Pankov 	if (S_ISBLK(statbuf.st_mode)) {
281522c8b958SYuri Pankov 		(void) fprintf(stderr,
281622c8b958SYuri Pankov 		    "cannot use '%s': character device required\n", path);
281722c8b958SYuri Pankov 		(void) close(fd);
2818c6065d0fSGeorge Wilson 		exit(1);
2819fa9e4066Sahrens 	}
2820fa9e4066Sahrens 
2821fa9e4066Sahrens 	psize = statbuf.st_size;
2822fa9e4066Sahrens 	psize = P2ALIGN(psize, (uint64_t)sizeof (vdev_label_t));
2823fa9e4066Sahrens 
282453b9a4a9SVictor Latushkin 	for (int l = 0; l < VDEV_LABELS; l++) {
2825fa9e4066Sahrens 		nvlist_t *config = NULL;
2826fa9e4066Sahrens 
282764723e36SYuri Pankov 		if (!dump_opt['q']) {
282864723e36SYuri Pankov 			(void) printf("------------------------------------\n");
282964723e36SYuri Pankov 			(void) printf("LABEL %d\n", l);
283064723e36SYuri Pankov 			(void) printf("------------------------------------\n");
283164723e36SYuri Pankov 		}
2832fa9e4066Sahrens 
28330d981225Seschrock 		if (pread64(fd, &label, sizeof (label),
2834fa9e4066Sahrens 		    vdev_label_offset(psize, l, 0)) != sizeof (label)) {
283564723e36SYuri Pankov 			if (!dump_opt['q'])
283664723e36SYuri Pankov 				(void) printf("failed to read label %d\n", l);
2837fa9e4066Sahrens 			continue;
2838fa9e4066Sahrens 		}
2839fa9e4066Sahrens 
2840fa9e4066Sahrens 		if (nvlist_unpack(buf, buflen, &config, 0) != 0) {
284164723e36SYuri Pankov 			if (!dump_opt['q'])
284264723e36SYuri Pankov 				(void) printf("failed to unpack label %d\n", l);
284353b9a4a9SVictor Latushkin 			ashift = SPA_MINBLOCKSHIFT;
284453b9a4a9SVictor Latushkin 		} else {
284553b9a4a9SVictor Latushkin 			nvlist_t *vdev_tree = NULL;
284653b9a4a9SVictor Latushkin 
284764723e36SYuri Pankov 			if (!dump_opt['q'])
284864723e36SYuri Pankov 				dump_nvlist(config, 4);
284953b9a4a9SVictor Latushkin 			if ((nvlist_lookup_nvlist(config,
285053b9a4a9SVictor Latushkin 			    ZPOOL_CONFIG_VDEV_TREE, &vdev_tree) != 0) ||
285153b9a4a9SVictor Latushkin 			    (nvlist_lookup_uint64(vdev_tree,
285253b9a4a9SVictor Latushkin 			    ZPOOL_CONFIG_ASHIFT, &ashift) != 0))
285353b9a4a9SVictor Latushkin 				ashift = SPA_MINBLOCKSHIFT;
285453b9a4a9SVictor Latushkin 			nvlist_free(config);
285564723e36SYuri Pankov 			label_found = B_TRUE;
2856fa9e4066Sahrens 		}
285753b9a4a9SVictor Latushkin 		if (dump_opt['u'])
285853b9a4a9SVictor Latushkin 			dump_label_uberblocks(&label, ashift);
2859fa9e4066Sahrens 	}
2860c6065d0fSGeorge Wilson 
2861c6065d0fSGeorge Wilson 	(void) close(fd);
286264723e36SYuri Pankov 
286364723e36SYuri Pankov 	return (label_found ? 0 : 2);
2864fa9e4066Sahrens }
2865fa9e4066Sahrens 
2866ca0cc391SMatthew Ahrens static uint64_t dataset_feature_count[SPA_FEATURES];
28675cabbc6bSPrashanth Sreenivasa static uint64_t remap_deadlist_count = 0;
2868b5152584SMatthew Ahrens 
2869fa9e4066Sahrens /*ARGSUSED*/
28701d452cf5Sahrens static int
2871fd136879SMatthew Ahrens dump_one_dir(const char *dsname, void *arg)
2872fa9e4066Sahrens {
2873fa9e4066Sahrens 	int error;
2874fa9e4066Sahrens 	objset_t *os;
2875fa9e4066Sahrens 
2876ed61ec1dSYuri Pankov 	error = open_objset(dsname, DMU_OST_ANY, FTAG, &os);
2877ed61ec1dSYuri Pankov 	if (error != 0)
28781d452cf5Sahrens 		return (0);
2879ca0cc391SMatthew Ahrens 
2880ca0cc391SMatthew Ahrens 	for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
2881ca0cc391SMatthew Ahrens 		if (!dmu_objset_ds(os)->ds_feature_inuse[f])
2882ca0cc391SMatthew Ahrens 			continue;
2883ca0cc391SMatthew Ahrens 		ASSERT(spa_feature_table[f].fi_flags &
2884ca0cc391SMatthew Ahrens 		    ZFEATURE_FLAG_PER_DATASET);
2885ca0cc391SMatthew Ahrens 		dataset_feature_count[f]++;
2886ca0cc391SMatthew Ahrens 	}
2887ca0cc391SMatthew Ahrens 
28885cabbc6bSPrashanth Sreenivasa 	if (dsl_dataset_remap_deadlist_exists(dmu_objset_ds(os))) {
28895cabbc6bSPrashanth Sreenivasa 		remap_deadlist_count++;
28905cabbc6bSPrashanth Sreenivasa 	}
28915cabbc6bSPrashanth Sreenivasa 
2892fa9e4066Sahrens 	dump_dir(os);
2893ed61ec1dSYuri Pankov 	close_objset(os, FTAG);
2894e0d35c44Smarks 	fuid_table_destroy();
28951d452cf5Sahrens 	return (0);
2896fa9e4066Sahrens }
2897fa9e4066Sahrens 
2898fa9e4066Sahrens /*
2899b24ab676SJeff Bonwick  * Block statistics.
2900fa9e4066Sahrens  */
2901b5152584SMatthew Ahrens #define	PSIZE_HISTO_SIZE (SPA_OLD_MAXBLOCKSIZE / SPA_MINBLOCKSIZE + 2)
2902fa9e4066Sahrens typedef struct zdb_blkstats {
2903490d05b9SMatthew Ahrens 	uint64_t zb_asize;
2904490d05b9SMatthew Ahrens 	uint64_t zb_lsize;
2905490d05b9SMatthew Ahrens 	uint64_t zb_psize;
2906490d05b9SMatthew Ahrens 	uint64_t zb_count;
2907d5ee8a13SMatthew Ahrens 	uint64_t zb_gangs;
2908d5ee8a13SMatthew Ahrens 	uint64_t zb_ditto_samevdev;
2909663207adSDon Brady 	uint64_t zb_ditto_same_ms;
2910490d05b9SMatthew Ahrens 	uint64_t zb_psize_histogram[PSIZE_HISTO_SIZE];
2911fa9e4066Sahrens } zdb_blkstats_t;
2912fa9e4066Sahrens 
2913b24ab676SJeff Bonwick /*
2914b24ab676SJeff Bonwick  * Extended object types to report deferred frees and dedup auto-ditto blocks.
2915b24ab676SJeff Bonwick  */
2916b24ab676SJeff Bonwick #define	ZDB_OT_DEFERRED	(DMU_OT_NUMTYPES + 0)
2917b24ab676SJeff Bonwick #define	ZDB_OT_DITTO	(DMU_OT_NUMTYPES + 1)
2918ad135b5dSChristopher Siden #define	ZDB_OT_OTHER	(DMU_OT_NUMTYPES + 2)
2919ad135b5dSChristopher Siden #define	ZDB_OT_TOTAL	(DMU_OT_NUMTYPES + 3)
2920b24ab676SJeff Bonwick 
29213f7978d0SAlan Somers static const char *zdb_ot_extname[] = {
2922b24ab676SJeff Bonwick 	"deferred free",
2923b24ab676SJeff Bonwick 	"dedup ditto",
2924ad135b5dSChristopher Siden 	"other",
2925b24ab676SJeff Bonwick 	"Total",
2926b24ab676SJeff Bonwick };
2927fa9e4066Sahrens 
292888b7b0f2SMatthew Ahrens #define	ZB_TOTAL	DN_MAX_LEVELS
2929fa9e4066Sahrens 
2930fa9e4066Sahrens typedef struct zdb_cb {
2931b24ab676SJeff Bonwick 	zdb_blkstats_t	zcb_type[ZB_TOTAL + 1][ZDB_OT_TOTAL + 1];
29325cabbc6bSPrashanth Sreenivasa 	uint64_t	zcb_removing_size;
293386714001SSerapheim Dimitropoulos 	uint64_t	zcb_checkpoint_size;
2934b24ab676SJeff Bonwick 	uint64_t	zcb_dedup_asize;
2935b24ab676SJeff Bonwick 	uint64_t	zcb_dedup_blocks;
29365d7b4d43SMatthew Ahrens 	uint64_t	zcb_embedded_blocks[NUM_BP_EMBEDDED_TYPES];
29375d7b4d43SMatthew Ahrens 	uint64_t	zcb_embedded_histogram[NUM_BP_EMBEDDED_TYPES]
29385d7b4d43SMatthew Ahrens 	    [BPE_PAYLOAD_SIZE];
2939490d05b9SMatthew Ahrens 	uint64_t	zcb_start;
29403f7978d0SAlan Somers 	hrtime_t	zcb_lastprint;
2941490d05b9SMatthew Ahrens 	uint64_t	zcb_totalasize;
2942fa9e4066Sahrens 	uint64_t	zcb_errors[256];
2943fa9e4066Sahrens 	int		zcb_readfails;
2944fa9e4066Sahrens 	int		zcb_haderrors;
2945cde58dbcSMatthew Ahrens 	spa_t		*zcb_spa;
29465cabbc6bSPrashanth Sreenivasa 	uint32_t	**zcb_vd_obsolete_counts;
2947fa9e4066Sahrens } zdb_cb_t;
2948fa9e4066Sahrens 
2949663207adSDon Brady /* test if two DVA offsets from same vdev are within the same metaslab */
2950663207adSDon Brady static boolean_t
2951663207adSDon Brady same_metaslab(spa_t *spa, uint64_t vdev, uint64_t off1, uint64_t off2)
2952663207adSDon Brady {
2953663207adSDon Brady 	vdev_t *vd = vdev_lookup_top(spa, vdev);
2954663207adSDon Brady 	uint64_t ms_shift = vd->vdev_ms_shift;
2955663207adSDon Brady 
2956663207adSDon Brady 	return ((off1 >> ms_shift) == (off2 >> ms_shift));
2957663207adSDon Brady }
2958663207adSDon Brady 
2959fa9e4066Sahrens static void
2960cde58dbcSMatthew Ahrens zdb_count_block(zdb_cb_t *zcb, zilog_t *zilog, const blkptr_t *bp,
2961b24ab676SJeff Bonwick     dmu_object_type_t type)
2962fa9e4066Sahrens {
2963b24ab676SJeff Bonwick 	uint64_t refcnt = 0;
2964b24ab676SJeff Bonwick 
2965b24ab676SJeff Bonwick 	ASSERT(type < ZDB_OT_TOTAL);
2966b24ab676SJeff Bonwick 
2967b24ab676SJeff Bonwick 	if (zilog && zil_bp_tree_add(zilog, bp) != 0)
2968b24ab676SJeff Bonwick 		return;
2969b24ab676SJeff Bonwick 
2970663207adSDon Brady 	spa_config_enter(zcb->zcb_spa, SCL_CONFIG, FTAG, RW_READER);
2971663207adSDon Brady 
2972e14bb325SJeff Bonwick 	for (int i = 0; i < 4; i++) {
2973fa9e4066Sahrens 		int l = (i < 2) ? BP_GET_LEVEL(bp) : ZB_TOTAL;
2974b24ab676SJeff Bonwick 		int t = (i & 1) ? type : ZDB_OT_TOTAL;
2975d5ee8a13SMatthew Ahrens 		int equal;
2976fa9e4066Sahrens 		zdb_blkstats_t *zb = &zcb->zcb_type[l][t];
2977fa9e4066Sahrens 
2978fa9e4066Sahrens 		zb->zb_asize += BP_GET_ASIZE(bp);
2979fa9e4066Sahrens 		zb->zb_lsize += BP_GET_LSIZE(bp);
2980fa9e4066Sahrens 		zb->zb_psize += BP_GET_PSIZE(bp);
2981fa9e4066Sahrens 		zb->zb_count++;
2982b5152584SMatthew Ahrens 
2983b5152584SMatthew Ahrens 		/*
2984b5152584SMatthew Ahrens 		 * The histogram is only big enough to record blocks up to
2985b5152584SMatthew Ahrens 		 * SPA_OLD_MAXBLOCKSIZE; larger blocks go into the last,
2986b5152584SMatthew Ahrens 		 * "other", bucket.
2987b5152584SMatthew Ahrens 		 */
29883f7978d0SAlan Somers 		unsigned idx = BP_GET_PSIZE(bp) >> SPA_MINBLOCKSHIFT;
2989b5152584SMatthew Ahrens 		idx = MIN(idx, SPA_OLD_MAXBLOCKSIZE / SPA_MINBLOCKSIZE + 1);
2990b5152584SMatthew Ahrens 		zb->zb_psize_histogram[idx]++;
2991d5ee8a13SMatthew Ahrens 
2992d5ee8a13SMatthew Ahrens 		zb->zb_gangs += BP_COUNT_GANG(bp);
2993d5ee8a13SMatthew Ahrens 
2994d5ee8a13SMatthew Ahrens 		switch (BP_GET_NDVAS(bp)) {
2995d5ee8a13SMatthew Ahrens 		case 2:
2996d5ee8a13SMatthew Ahrens 			if (DVA_GET_VDEV(&bp->blk_dva[0]) ==
2997663207adSDon Brady 			    DVA_GET_VDEV(&bp->blk_dva[1])) {
2998d5ee8a13SMatthew Ahrens 				zb->zb_ditto_samevdev++;
2999663207adSDon Brady 
3000663207adSDon Brady 				if (same_metaslab(zcb->zcb_spa,
3001663207adSDon Brady 				    DVA_GET_VDEV(&bp->blk_dva[0]),
3002663207adSDon Brady 				    DVA_GET_OFFSET(&bp->blk_dva[0]),
3003663207adSDon Brady 				    DVA_GET_OFFSET(&bp->blk_dva[1])))
3004663207adSDon Brady 					zb->zb_ditto_same_ms++;
3005663207adSDon Brady 			}
3006d5ee8a13SMatthew Ahrens 			break;
3007d5ee8a13SMatthew Ahrens 		case 3:
3008d5ee8a13SMatthew Ahrens 			equal = (DVA_GET_VDEV(&bp->blk_dva[0]) ==
3009d5ee8a13SMatthew Ahrens 			    DVA_GET_VDEV(&bp->blk_dva[1])) +
3010d5ee8a13SMatthew Ahrens 			    (DVA_GET_VDEV(&bp->blk_dva[0]) ==
3011d5ee8a13SMatthew Ahrens 			    DVA_GET_VDEV(&bp->blk_dva[2])) +
3012d5ee8a13SMatthew Ahrens 			    (DVA_GET_VDEV(&bp->blk_dva[1]) ==
3013d5ee8a13SMatthew Ahrens 			    DVA_GET_VDEV(&bp->blk_dva[2]));
3014663207adSDon Brady 			if (equal != 0) {
3015d5ee8a13SMatthew Ahrens 				zb->zb_ditto_samevdev++;
3016663207adSDon Brady 
3017663207adSDon Brady 				if (DVA_GET_VDEV(&bp->blk_dva[0]) ==
3018663207adSDon Brady 				    DVA_GET_VDEV(&bp->blk_dva[1]) &&
3019663207adSDon Brady 				    same_metaslab(zcb->zcb_spa,
3020663207adSDon Brady 				    DVA_GET_VDEV(&bp->blk_dva[0]),
3021663207adSDon Brady 				    DVA_GET_OFFSET(&bp->blk_dva[0]),
3022663207adSDon Brady 				    DVA_GET_OFFSET(&bp->blk_dva[1])))
3023663207adSDon Brady 					zb->zb_ditto_same_ms++;
3024663207adSDon Brady 				else if (DVA_GET_VDEV(&bp->blk_dva[0]) ==
3025663207adSDon Brady 				    DVA_GET_VDEV(&bp->blk_dva[2]) &&
3026663207adSDon Brady 				    same_metaslab(zcb->zcb_spa,
3027663207adSDon Brady 				    DVA_GET_VDEV(&bp->blk_dva[0]),
3028663207adSDon Brady 				    DVA_GET_OFFSET(&bp->blk_dva[0]),
3029663207adSDon Brady 				    DVA_GET_OFFSET(&bp->blk_dva[2])))
3030663207adSDon Brady 					zb->zb_ditto_same_ms++;
3031663207adSDon Brady 				else if (DVA_GET_VDEV(&bp->blk_dva[1]) ==
3032663207adSDon Brady 				    DVA_GET_VDEV(&bp->blk_dva[2]) &&
3033663207adSDon Brady 				    same_metaslab(zcb->zcb_spa,
3034663207adSDon Brady 				    DVA_GET_VDEV(&bp->blk_dva[1]),
3035663207adSDon Brady 				    DVA_GET_OFFSET(&bp->blk_dva[1]),
3036663207adSDon Brady 				    DVA_GET_OFFSET(&bp->blk_dva[2])))
3037663207adSDon Brady 					zb->zb_ditto_same_ms++;
3038663207adSDon Brady 			}
3039d5ee8a13SMatthew Ahrens 			break;
3040d5ee8a13SMatthew Ahrens 		}
3041fa9e4066Sahrens 	}
3042fa9e4066Sahrens 
3043663207adSDon Brady 	spa_config_exit(zcb->zcb_spa, SCL_CONFIG, FTAG);
3044663207adSDon Brady 
30455d7b4d43SMatthew Ahrens 	if (BP_IS_EMBEDDED(bp)) {
30465d7b4d43SMatthew Ahrens 		zcb->zcb_embedded_blocks[BPE_GET_ETYPE(bp)]++;
30475d7b4d43SMatthew Ahrens 		zcb->zcb_embedded_histogram[BPE_GET_ETYPE(bp)]
30485d7b4d43SMatthew Ahrens 		    [BPE_GET_PSIZE(bp)]++;
30495d7b4d43SMatthew Ahrens 		return;
30505d7b4d43SMatthew Ahrens 	}
30515d7b4d43SMatthew Ahrens 
3052b24ab676SJeff Bonwick 	if (dump_opt['L'])
3053b24ab676SJeff Bonwick 		return;
3054b24ab676SJeff Bonwick 
3055b24ab676SJeff Bonwick 	if (BP_GET_DEDUP(bp)) {
3056b24ab676SJeff Bonwick 		ddt_t *ddt;
3057b24ab676SJeff Bonwick 		ddt_entry_t *dde;
3058b24ab676SJeff Bonwick 
3059cde58dbcSMatthew Ahrens 		ddt = ddt_select(zcb->zcb_spa, bp);
3060b24ab676SJeff Bonwick 		ddt_enter(ddt);
3061b24ab676SJeff Bonwick 		dde = ddt_lookup(ddt, bp, B_FALSE);
3062b24ab676SJeff Bonwick 
3063b24ab676SJeff Bonwick 		if (dde == NULL) {
3064b24ab676SJeff Bonwick 			refcnt = 0;
3065b24ab676SJeff Bonwick 		} else {
3066b24ab676SJeff Bonwick 			ddt_phys_t *ddp = ddt_phys_select(dde, bp);
3067b24ab676SJeff Bonwick 			ddt_phys_decref(ddp);
3068b24ab676SJeff Bonwick 			refcnt = ddp->ddp_refcnt;
3069b24ab676SJeff Bonwick 			if (ddt_phys_total_refcnt(dde) == 0)
3070b24ab676SJeff Bonwick 				ddt_remove(ddt, dde);
3071d41e7643Sek 		}
3072b24ab676SJeff Bonwick 		ddt_exit(ddt);
3073d41e7643Sek 	}
3074d41e7643Sek 
3075cde58dbcSMatthew Ahrens 	VERIFY3U(zio_wait(zio_claim(NULL, zcb->zcb_spa,
307686714001SSerapheim Dimitropoulos 	    refcnt ? 0 : spa_min_claim_txg(zcb->zcb_spa),
3077b24ab676SJeff Bonwick 	    bp, NULL, NULL, ZIO_FLAG_CANFAIL)), ==, 0);
3078fa9e4066Sahrens }
3079fa9e4066Sahrens 
308031d7e8faSGeorge Wilson static void
308131d7e8faSGeorge Wilson zdb_blkptr_done(zio_t *zio)
308231d7e8faSGeorge Wilson {
308331d7e8faSGeorge Wilson 	spa_t *spa = zio->io_spa;
308431d7e8faSGeorge Wilson 	blkptr_t *bp = zio->io_bp;
308531d7e8faSGeorge Wilson 	int ioerr = zio->io_error;
308631d7e8faSGeorge Wilson 	zdb_cb_t *zcb = zio->io_private;
30877802d7bfSMatthew Ahrens 	zbookmark_phys_t *zb = &zio->io_bookmark;
308831d7e8faSGeorge Wilson 
3089770499e1SDan Kimmel 	abd_free(zio->io_abd);
309031d7e8faSGeorge Wilson 
309131d7e8faSGeorge Wilson 	mutex_enter(&spa->spa_scrub_lock);
3092a3874b8bSToomas Soome 	spa->spa_load_verify_ios--;
309331d7e8faSGeorge Wilson 	cv_broadcast(&spa->spa_scrub_io_cv);
309431d7e8faSGeorge Wilson 
309531d7e8faSGeorge Wilson 	if (ioerr && !(zio->io_flags & ZIO_FLAG_SPECULATIVE)) {
309631d7e8faSGeorge Wilson 		char blkbuf[BP_SPRINTF_LEN];
309731d7e8faSGeorge Wilson 
309831d7e8faSGeorge Wilson 		zcb->zcb_haderrors = 1;
309931d7e8faSGeorge Wilson 		zcb->zcb_errors[ioerr]++;
310031d7e8faSGeorge Wilson 
310131d7e8faSGeorge Wilson 		if (dump_opt['b'] >= 2)
310243466aaeSMax Grossman 			snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
310331d7e8faSGeorge Wilson 		else
310431d7e8faSGeorge Wilson 			blkbuf[0] = '\0';
310531d7e8faSGeorge Wilson 
310631d7e8faSGeorge Wilson 		(void) printf("zdb_blkptr_cb: "
310731d7e8faSGeorge Wilson 		    "Got error %d reading "
310831d7e8faSGeorge Wilson 		    "<%llu, %llu, %lld, %llx> %s -- skipping\n",
310931d7e8faSGeorge Wilson 		    ioerr,
311031d7e8faSGeorge Wilson 		    (u_longlong_t)zb->zb_objset,
311131d7e8faSGeorge Wilson 		    (u_longlong_t)zb->zb_object,
311231d7e8faSGeorge Wilson 		    (u_longlong_t)zb->zb_level,
311331d7e8faSGeorge Wilson 		    (u_longlong_t)zb->zb_blkid,
311431d7e8faSGeorge Wilson 		    blkbuf);
311531d7e8faSGeorge Wilson 	}
311631d7e8faSGeorge Wilson 	mutex_exit(&spa->spa_scrub_lock);
311731d7e8faSGeorge Wilson }
311831d7e8faSGeorge Wilson 
3119fa9e4066Sahrens static int
31201b912ec7SGeorge Wilson zdb_blkptr_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
31217802d7bfSMatthew Ahrens     const zbookmark_phys_t *zb, const dnode_phys_t *dnp, void *arg)
3122fa9e4066Sahrens {
3123fa9e4066Sahrens 	zdb_cb_t *zcb = arg;
31246365109dSVictor Latushkin 	dmu_object_type_t type;
3125468c413aSTim Haley 	boolean_t is_metadata;
3126fa9e4066Sahrens 
3127a2cdcdd2SPaul Dagnelie 	if (bp == NULL)
3128a2cdcdd2SPaul Dagnelie 		return (0);
3129a2cdcdd2SPaul Dagnelie 
313043466aaeSMax Grossman 	if (dump_opt['b'] >= 5 && bp->blk_birth > 0) {
313143466aaeSMax Grossman 		char blkbuf[BP_SPRINTF_LEN];
313243466aaeSMax Grossman 		snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
313343466aaeSMax Grossman 		(void) printf("objset %llu object %llu "
313443466aaeSMax Grossman 		    "level %lld offset 0x%llx %s\n",
313543466aaeSMax Grossman 		    (u_longlong_t)zb->zb_objset,
313643466aaeSMax Grossman 		    (u_longlong_t)zb->zb_object,
313743466aaeSMax Grossman 		    (longlong_t)zb->zb_level,
313843466aaeSMax Grossman 		    (u_longlong_t)blkid2offset(dnp, bp, zb),
313943466aaeSMax Grossman 		    blkbuf);
314043466aaeSMax Grossman 	}
314143466aaeSMax Grossman 
314243466aaeSMax Grossman 	if (BP_IS_HOLE(bp))
314388b7b0f2SMatthew Ahrens 		return (0);
3144e14bb325SJeff Bonwick 
31456365109dSVictor Latushkin 	type = BP_GET_TYPE(bp);
3146e14bb325SJeff Bonwick 
3147ad135b5dSChristopher Siden 	zdb_count_block(zcb, zilog, bp,
3148ad135b5dSChristopher Siden 	    (type & DMU_OT_NEWTYPE) ? ZDB_OT_OTHER : type);
31496365109dSVictor Latushkin 
3150ad135b5dSChristopher Siden 	is_metadata = (BP_GET_LEVEL(bp) != 0 || DMU_OT_IS_METADATA(type));
31516365109dSVictor Latushkin 
31525d7b4d43SMatthew Ahrens 	if (!BP_IS_EMBEDDED(bp) &&
31535d7b4d43SMatthew Ahrens 	    (dump_opt['c'] > 1 || (dump_opt['c'] && is_metadata))) {
3154468c413aSTim Haley 		size_t size = BP_GET_PSIZE(bp);
3155770499e1SDan Kimmel 		abd_t *abd = abd_alloc(size, B_FALSE);
3156b24ab676SJeff Bonwick 		int flags = ZIO_FLAG_CANFAIL | ZIO_FLAG_SCRUB | ZIO_FLAG_RAW;
3157b24ab676SJeff Bonwick 
3158b24ab676SJeff Bonwick 		/* If it's an intent log block, failure is expected. */
3159b24ab676SJeff Bonwick 		if (zb->zb_level == ZB_ZIL_LEVEL)
3160b24ab676SJeff Bonwick 			flags |= ZIO_FLAG_SPECULATIVE;
3161b24ab676SJeff Bonwick 
316231d7e8faSGeorge Wilson 		mutex_enter(&spa->spa_scrub_lock);
3163a3874b8bSToomas Soome 		while (spa->spa_load_verify_ios > max_inflight)
316431d7e8faSGeorge Wilson 			cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock);
3165a3874b8bSToomas Soome 		spa->spa_load_verify_ios++;
316631d7e8faSGeorge Wilson 		mutex_exit(&spa->spa_scrub_lock);
3167b24ab676SJeff Bonwick 
3168770499e1SDan Kimmel 		zio_nowait(zio_read(NULL, spa, bp, abd, size,
316931d7e8faSGeorge Wilson 		    zdb_blkptr_done, zcb, ZIO_PRIORITY_ASYNC_READ, flags, zb));
3170fa9e4066Sahrens 	}
3171fa9e4066Sahrens 
3172fa9e4066Sahrens 	zcb->zcb_readfails = 0;
3173fa9e4066Sahrens 
3174f7950bf1SMatthew Ahrens 	/* only call gethrtime() every 100 blocks */
3175f7950bf1SMatthew Ahrens 	static int iters;
3176f7950bf1SMatthew Ahrens 	if (++iters > 100)
3177f7950bf1SMatthew Ahrens 		iters = 0;
3178f7950bf1SMatthew Ahrens 	else
3179f7950bf1SMatthew Ahrens 		return (0);
3180f7950bf1SMatthew Ahrens 
3181f7950bf1SMatthew Ahrens 	if (dump_opt['b'] < 5 && gethrtime() > zcb->zcb_lastprint + NANOSEC) {
3182490d05b9SMatthew Ahrens 		uint64_t now = gethrtime();
3183490d05b9SMatthew Ahrens 		char buf[10];
3184490d05b9SMatthew Ahrens 		uint64_t bytes = zcb->zcb_type[ZB_TOTAL][ZDB_OT_TOTAL].zb_asize;
3185490d05b9SMatthew Ahrens 		int kb_per_sec =
3186490d05b9SMatthew Ahrens 		    1 + bytes / (1 + ((now - zcb->zcb_start) / 1000 / 1000));
3187490d05b9SMatthew Ahrens 		int sec_remaining =
3188490d05b9SMatthew Ahrens 		    (zcb->zcb_totalasize - bytes) / 1024 / kb_per_sec;
3189490d05b9SMatthew Ahrens 
31900a055120SJason King 		/* make sure nicenum has enough space */
31910a055120SJason King 		CTASSERT(sizeof (buf) >= NN_NUMBUF_SZ);
31920a055120SJason King 
3193490d05b9SMatthew Ahrens 		zfs_nicenum(bytes, buf, sizeof (buf));
3194490d05b9SMatthew Ahrens 		(void) fprintf(stderr,
3195490d05b9SMatthew Ahrens 		    "\r%5s completed (%4dMB/s) "
3196490d05b9SMatthew Ahrens 		    "estimated time remaining: %uhr %02umin %02usec        ",
3197490d05b9SMatthew Ahrens 		    buf, kb_per_sec / 1024,
3198490d05b9SMatthew Ahrens 		    sec_remaining / 60 / 60,
3199490d05b9SMatthew Ahrens 		    sec_remaining / 60 % 60,
3200490d05b9SMatthew Ahrens 		    sec_remaining % 60);
3201490d05b9SMatthew Ahrens 
3202490d05b9SMatthew Ahrens 		zcb->zcb_lastprint = now;
3203490d05b9SMatthew Ahrens 	}
3204490d05b9SMatthew Ahrens 
3205fa9e4066Sahrens 	return (0);
3206fa9e4066Sahrens }
3207fa9e4066Sahrens 
3208b24ab676SJeff Bonwick static void
32090713e232SGeorge Wilson zdb_leak(void *arg, uint64_t start, uint64_t size)
3210b24ab676SJeff Bonwick {
32110713e232SGeorge Wilson 	vdev_t *vd = arg;
3212b24ab676SJeff Bonwick 
3213b24ab676SJeff Bonwick 	(void) printf("leaked space: vdev %llu, offset 0x%llx, size %llu\n",
3214b24ab676SJeff Bonwick 	    (u_longlong_t)vd->vdev_id, (u_longlong_t)start, (u_longlong_t)size);
3215b24ab676SJeff Bonwick }
3216b24ab676SJeff Bonwick 
32170713e232SGeorge Wilson static metaslab_ops_t zdb_metaslab_ops = {
32182e4c9986SGeorge Wilson 	NULL	/* alloc */
3219b24ab676SJeff Bonwick };
3220b24ab676SJeff Bonwick 
3221814dcd43SSerapheim Dimitropoulos typedef int (*zdb_log_sm_cb_t)(spa_t *spa, space_map_entry_t *sme,
3222814dcd43SSerapheim Dimitropoulos     uint64_t txg, void *arg);
3223814dcd43SSerapheim Dimitropoulos 
3224814dcd43SSerapheim Dimitropoulos typedef struct unflushed_iter_cb_arg {
3225814dcd43SSerapheim Dimitropoulos 	spa_t *uic_spa;
3226814dcd43SSerapheim Dimitropoulos 	uint64_t uic_txg;
3227814dcd43SSerapheim Dimitropoulos 	void *uic_arg;
3228814dcd43SSerapheim Dimitropoulos 	zdb_log_sm_cb_t uic_cb;
3229814dcd43SSerapheim Dimitropoulos } unflushed_iter_cb_arg_t;
3230814dcd43SSerapheim Dimitropoulos 
3231814dcd43SSerapheim Dimitropoulos static int
3232814dcd43SSerapheim Dimitropoulos iterate_through_spacemap_logs_cb(space_map_entry_t *sme, void *arg)
3233814dcd43SSerapheim Dimitropoulos {
3234814dcd43SSerapheim Dimitropoulos 	unflushed_iter_cb_arg_t *uic = arg;
3235814dcd43SSerapheim Dimitropoulos 
3236814dcd43SSerapheim Dimitropoulos 	return (uic->uic_cb(uic->uic_spa, sme, uic->uic_txg, uic->uic_arg));
3237814dcd43SSerapheim Dimitropoulos }
3238814dcd43SSerapheim Dimitropoulos 
3239814dcd43SSerapheim Dimitropoulos static void
3240814dcd43SSerapheim Dimitropoulos iterate_through_spacemap_logs(spa_t *spa, zdb_log_sm_cb_t cb, void *arg)
3241814dcd43SSerapheim Dimitropoulos {
3242814dcd43SSerapheim Dimitropoulos 	if (!spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP))
3243814dcd43SSerapheim Dimitropoulos 		return;
3244814dcd43SSerapheim Dimitropoulos 
3245814dcd43SSerapheim Dimitropoulos 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
3246814dcd43SSerapheim Dimitropoulos 	for (spa_log_sm_t *sls = avl_first(&spa->spa_sm_logs_by_txg);
3247814dcd43SSerapheim Dimitropoulos 	    sls; sls = AVL_NEXT(&spa->spa_sm_logs_by_txg, sls)) {
3248814dcd43SSerapheim Dimitropoulos 		space_map_t *sm = NULL;
3249814dcd43SSerapheim Dimitropoulos 		VERIFY0(space_map_open(&sm, spa_meta_objset(spa),
3250814dcd43SSerapheim Dimitropoulos 		    sls->sls_sm_obj, 0, UINT64_MAX, SPA_MINBLOCKSHIFT));
3251814dcd43SSerapheim Dimitropoulos 
3252814dcd43SSerapheim Dimitropoulos 		unflushed_iter_cb_arg_t uic = {
3253814dcd43SSerapheim Dimitropoulos 			.uic_spa = spa,
3254814dcd43SSerapheim Dimitropoulos 			.uic_txg = sls->sls_txg,
3255814dcd43SSerapheim Dimitropoulos 			.uic_arg = arg,
3256814dcd43SSerapheim Dimitropoulos 			.uic_cb = cb
3257814dcd43SSerapheim Dimitropoulos 		};
3258814dcd43SSerapheim Dimitropoulos 
3259814dcd43SSerapheim Dimitropoulos 		VERIFY0(space_map_iterate(sm, space_map_length(sm),
3260814dcd43SSerapheim Dimitropoulos 		    iterate_through_spacemap_logs_cb, &uic));
3261814dcd43SSerapheim Dimitropoulos 		space_map_close(sm);
3262814dcd43SSerapheim Dimitropoulos 	}
3263814dcd43SSerapheim Dimitropoulos 	spa_config_exit(spa, SCL_CONFIG, FTAG);
3264814dcd43SSerapheim Dimitropoulos }
3265814dcd43SSerapheim Dimitropoulos 
3266814dcd43SSerapheim Dimitropoulos /* ARGSUSED */
3267814dcd43SSerapheim Dimitropoulos static int
3268814dcd43SSerapheim Dimitropoulos load_unflushed_svr_segs_cb(spa_t *spa, space_map_entry_t *sme,
3269814dcd43SSerapheim Dimitropoulos     uint64_t txg, void *arg)
3270814dcd43SSerapheim Dimitropoulos {
3271814dcd43SSerapheim Dimitropoulos 	spa_vdev_removal_t *svr = arg;
3272814dcd43SSerapheim Dimitropoulos 
3273814dcd43SSerapheim Dimitropoulos 	uint64_t offset = sme->sme_offset;
3274814dcd43SSerapheim Dimitropoulos 	uint64_t size = sme->sme_run;
3275814dcd43SSerapheim Dimitropoulos 
3276814dcd43SSerapheim Dimitropoulos 	/* skip vdevs we don't care about */
3277814dcd43SSerapheim Dimitropoulos 	if (sme->sme_vdev != svr->svr_vdev_id)
3278814dcd43SSerapheim Dimitropoulos 		return (0);
3279814dcd43SSerapheim Dimitropoulos 
3280814dcd43SSerapheim Dimitropoulos 	vdev_t *vd = vdev_lookup_top(spa, sme->sme_vdev);
3281814dcd43SSerapheim Dimitropoulos 	metaslab_t *ms = vd->vdev_ms[offset >> vd->vdev_ms_shift];
3282814dcd43SSerapheim Dimitropoulos 	ASSERT(sme->sme_type == SM_ALLOC || sme->sme_type == SM_FREE);
3283814dcd43SSerapheim Dimitropoulos 
3284814dcd43SSerapheim Dimitropoulos 	if (txg < metaslab_unflushed_txg(ms))
3285814dcd43SSerapheim Dimitropoulos 		return (0);
3286814dcd43SSerapheim Dimitropoulos 
3287814dcd43SSerapheim Dimitropoulos 	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
3288814dcd43SSerapheim Dimitropoulos 	ASSERT(vim != NULL);
3289814dcd43SSerapheim Dimitropoulos 	if (offset >= vdev_indirect_mapping_max_offset(vim))
3290814dcd43SSerapheim Dimitropoulos 		return (0);
3291814dcd43SSerapheim Dimitropoulos 
3292814dcd43SSerapheim Dimitropoulos 	if (sme->sme_type == SM_ALLOC)
3293814dcd43SSerapheim Dimitropoulos 		range_tree_add(svr->svr_allocd_segs, offset, size);
3294814dcd43SSerapheim Dimitropoulos 	else
3295814dcd43SSerapheim Dimitropoulos 		range_tree_remove(svr->svr_allocd_segs, offset, size);
3296814dcd43SSerapheim Dimitropoulos 
3297814dcd43SSerapheim Dimitropoulos 	return (0);
3298814dcd43SSerapheim Dimitropoulos }
3299814dcd43SSerapheim Dimitropoulos 
3300b24ab676SJeff Bonwick static void
3301bbfd46c4SJeff Bonwick zdb_ddt_leak_init(spa_t *spa, zdb_cb_t *zcb)
3302b24ab676SJeff Bonwick {
33033f7978d0SAlan Somers 	ddt_bookmark_t ddb;
3304b24ab676SJeff Bonwick 	ddt_entry_t dde;
3305b24ab676SJeff Bonwick 	int error;
3306b24ab676SJeff Bonwick 
3307555d674dSSerapheim Dimitropoulos 	ASSERT(!dump_opt['L']);
3308555d674dSSerapheim Dimitropoulos 
33093f7978d0SAlan Somers 	bzero(&ddb, sizeof (ddb));
3310bbfd46c4SJeff Bonwick 	while ((error = ddt_walk(spa, &ddb, &dde)) == 0) {
3311b24ab676SJeff Bonwick 		blkptr_t blk;
3312b24ab676SJeff Bonwick 		ddt_phys_t *ddp = dde.dde_phys;
3313bbfd46c4SJeff Bonwick 
3314bbfd46c4SJeff Bonwick 		if (ddb.ddb_class == DDT_CLASS_UNIQUE)
3315bbfd46c4SJeff Bonwick 			return;
3316bbfd46c4SJeff Bonwick 
3317b24ab676SJeff Bonwick 		ASSERT(ddt_phys_total_refcnt(&dde) > 1);
3318bbfd46c4SJeff Bonwick 
3319b24ab676SJeff Bonwick 		for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
3320b24ab676SJeff Bonwick 			if (ddp->ddp_phys_birth == 0)
3321b24ab676SJeff Bonwick 				continue;
3322bbfd46c4SJeff Bonwick 			ddt_bp_create(ddb.ddb_checksum,
3323bbfd46c4SJeff Bonwick 			    &dde.dde_key, ddp, &blk);
3324b24ab676SJeff Bonwick 			if (p == DDT_PHYS_DITTO) {
3325cde58dbcSMatthew Ahrens 				zdb_count_block(zcb, NULL, &blk, ZDB_OT_DITTO);
3326b24ab676SJeff Bonwick 			} else {
3327b24ab676SJeff Bonwick 				zcb->zcb_dedup_asize +=
3328b24ab676SJeff Bonwick 				    BP_GET_ASIZE(&blk) * (ddp->ddp_refcnt - 1);
3329b24ab676SJeff Bonwick 				zcb->zcb_dedup_blocks++;
3330b24ab676SJeff Bonwick 			}
3331b24ab676SJeff Bonwick 		}
3332555d674dSSerapheim Dimitropoulos 		ddt_t *ddt = spa->spa_ddt[ddb.ddb_checksum];
3333555d674dSSerapheim Dimitropoulos 		ddt_enter(ddt);
3334555d674dSSerapheim Dimitropoulos 		VERIFY(ddt_lookup(ddt, &blk, B_TRUE) != NULL);
3335555d674dSSerapheim Dimitropoulos 		ddt_exit(ddt);
3336b24ab676SJeff Bonwick 	}
3337b24ab676SJeff Bonwick 
3338b24ab676SJeff Bonwick 	ASSERT(error == ENOENT);
3339b24ab676SJeff Bonwick }
3340b24ab676SJeff Bonwick 
33415cabbc6bSPrashanth Sreenivasa /* ARGSUSED */
33425cabbc6bSPrashanth Sreenivasa static void
33435cabbc6bSPrashanth Sreenivasa claim_segment_impl_cb(uint64_t inner_offset, vdev_t *vd, uint64_t offset,
33445cabbc6bSPrashanth Sreenivasa     uint64_t size, void *arg)
33455cabbc6bSPrashanth Sreenivasa {
33465cabbc6bSPrashanth Sreenivasa 	/*
33475cabbc6bSPrashanth Sreenivasa 	 * This callback was called through a remap from
33485cabbc6bSPrashanth Sreenivasa 	 * a device being removed. Therefore, the vdev that
33495cabbc6bSPrashanth Sreenivasa 	 * this callback is applied to is a concrete
33505cabbc6bSPrashanth Sreenivasa 	 * vdev.
33515cabbc6bSPrashanth Sreenivasa 	 */
33525cabbc6bSPrashanth Sreenivasa 	ASSERT(vdev_is_concrete(vd));
33535cabbc6bSPrashanth Sreenivasa 
33545cabbc6bSPrashanth Sreenivasa 	VERIFY0(metaslab_claim_impl(vd, offset, size,
335586714001SSerapheim Dimitropoulos 	    spa_min_claim_txg(vd->vdev_spa)));
33565cabbc6bSPrashanth Sreenivasa }
33575cabbc6bSPrashanth Sreenivasa 
33585cabbc6bSPrashanth Sreenivasa static void
33595cabbc6bSPrashanth Sreenivasa claim_segment_cb(void *arg, uint64_t offset, uint64_t size)
33605cabbc6bSPrashanth Sreenivasa {
33615cabbc6bSPrashanth Sreenivasa 	vdev_t *vd = arg;
33625cabbc6bSPrashanth Sreenivasa 
33635cabbc6bSPrashanth Sreenivasa 	vdev_indirect_ops.vdev_op_remap(vd, offset, size,
33645cabbc6bSPrashanth Sreenivasa 	    claim_segment_impl_cb, NULL);
33655cabbc6bSPrashanth Sreenivasa }
33665cabbc6bSPrashanth Sreenivasa 
33675cabbc6bSPrashanth Sreenivasa /*
33685cabbc6bSPrashanth Sreenivasa  * After accounting for all allocated blocks that are directly referenced,
33695cabbc6bSPrashanth Sreenivasa  * we might have missed a reference to a block from a partially complete
33705cabbc6bSPrashanth Sreenivasa  * (and thus unused) indirect mapping object. We perform a secondary pass
33715cabbc6bSPrashanth Sreenivasa  * through the metaslabs we have already mapped and claim the destination
33725cabbc6bSPrashanth Sreenivasa  * blocks.
33735cabbc6bSPrashanth Sreenivasa  */
33745cabbc6bSPrashanth Sreenivasa static void
33755cabbc6bSPrashanth Sreenivasa zdb_claim_removing(spa_t *spa, zdb_cb_t *zcb)
33765cabbc6bSPrashanth Sreenivasa {
3377555d674dSSerapheim Dimitropoulos 	if (dump_opt['L'])
3378555d674dSSerapheim Dimitropoulos 		return;
3379555d674dSSerapheim Dimitropoulos 
33805cabbc6bSPrashanth Sreenivasa 	if (spa->spa_vdev_removal == NULL)
33815cabbc6bSPrashanth Sreenivasa 		return;
33825cabbc6bSPrashanth Sreenivasa 
33835cabbc6bSPrashanth Sreenivasa 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
33845cabbc6bSPrashanth Sreenivasa 
33855cabbc6bSPrashanth Sreenivasa 	spa_vdev_removal_t *svr = spa->spa_vdev_removal;
33863a4b1be9SMatthew Ahrens 	vdev_t *vd = vdev_lookup_top(spa, svr->svr_vdev_id);
33875cabbc6bSPrashanth Sreenivasa 	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
33885cabbc6bSPrashanth Sreenivasa 
3389814dcd43SSerapheim Dimitropoulos 	ASSERT0(range_tree_space(svr->svr_allocd_segs));
3390814dcd43SSerapheim Dimitropoulos 
3391814dcd43SSerapheim Dimitropoulos 	range_tree_t *allocs = range_tree_create(NULL, NULL);
33925cabbc6bSPrashanth Sreenivasa 	for (uint64_t msi = 0; msi < vd->vdev_ms_count; msi++) {
33935cabbc6bSPrashanth Sreenivasa 		metaslab_t *msp = vd->vdev_ms[msi];
33945cabbc6bSPrashanth Sreenivasa 
33955cabbc6bSPrashanth Sreenivasa 		if (msp->ms_start >= vdev_indirect_mapping_max_offset(vim))
33965cabbc6bSPrashanth Sreenivasa 			break;
33975cabbc6bSPrashanth Sreenivasa 
3398814dcd43SSerapheim Dimitropoulos 		ASSERT0(range_tree_space(allocs));
3399814dcd43SSerapheim Dimitropoulos 		if (msp->ms_sm != NULL)
3400814dcd43SSerapheim Dimitropoulos 			VERIFY0(space_map_load(msp->ms_sm, allocs, SM_ALLOC));
3401814dcd43SSerapheim Dimitropoulos 		range_tree_vacate(allocs, range_tree_add, svr->svr_allocd_segs);
3402814dcd43SSerapheim Dimitropoulos 	}
3403814dcd43SSerapheim Dimitropoulos 	range_tree_destroy(allocs);
34045cabbc6bSPrashanth Sreenivasa 
3405814dcd43SSerapheim Dimitropoulos 	iterate_through_spacemap_logs(spa, load_unflushed_svr_segs_cb, svr);
34065cabbc6bSPrashanth Sreenivasa 
3407814dcd43SSerapheim Dimitropoulos 	/*
3408814dcd43SSerapheim Dimitropoulos 	 * Clear everything past what has been synced,
3409814dcd43SSerapheim Dimitropoulos 	 * because we have not allocated mappings for
3410814dcd43SSerapheim Dimitropoulos 	 * it yet.
3411814dcd43SSerapheim Dimitropoulos 	 */
3412814dcd43SSerapheim Dimitropoulos 	range_tree_clear(svr->svr_allocd_segs,
3413814dcd43SSerapheim Dimitropoulos 	    vdev_indirect_mapping_max_offset(vim),
3414814dcd43SSerapheim Dimitropoulos 	    vd->vdev_asize - vdev_indirect_mapping_max_offset(vim));
34155cabbc6bSPrashanth Sreenivasa 
3416814dcd43SSerapheim Dimitropoulos 	zcb->zcb_removing_size += range_tree_space(svr->svr_allocd_segs);
3417814dcd43SSerapheim Dimitropoulos 	range_tree_vacate(svr->svr_allocd_segs, claim_segment_cb, vd);
34185cabbc6bSPrashanth Sreenivasa 
34195cabbc6bSPrashanth Sreenivasa 	spa_config_exit(spa, SCL_CONFIG, FTAG);
34205cabbc6bSPrashanth Sreenivasa }
34215cabbc6bSPrashanth Sreenivasa 
34225cabbc6bSPrashanth Sreenivasa /* ARGSUSED */
34235cabbc6bSPrashanth Sreenivasa static int
34245cabbc6bSPrashanth Sreenivasa increment_indirect_mapping_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
34255cabbc6bSPrashanth Sreenivasa {
34265cabbc6bSPrashanth Sreenivasa 	zdb_cb_t *zcb = arg;
34275cabbc6bSPrashanth Sreenivasa 	spa_t *spa = zcb->zcb_spa;
34285cabbc6bSPrashanth Sreenivasa 	vdev_t *vd;
34295cabbc6bSPrashanth Sreenivasa 	const dva_t *dva = &bp->blk_dva[0];
34305cabbc6bSPrashanth Sreenivasa 
34315cabbc6bSPrashanth Sreenivasa 	ASSERT(!dump_opt['L']);
34325cabbc6bSPrashanth Sreenivasa 	ASSERT3U(BP_GET_NDVAS(bp), ==, 1);
34335cabbc6bSPrashanth Sreenivasa 
34345cabbc6bSPrashanth Sreenivasa 	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
34355cabbc6bSPrashanth Sreenivasa 	vd = vdev_lookup_top(zcb->zcb_spa, DVA_GET_VDEV(dva));
34365cabbc6bSPrashanth Sreenivasa 	ASSERT3P(vd, !=, NULL);
34375cabbc6bSPrashanth Sreenivasa 	spa_config_exit(spa, SCL_VDEV, FTAG);
34385cabbc6bSPrashanth Sreenivasa 
34395cabbc6bSPrashanth Sreenivasa 	ASSERT(vd->vdev_indirect_config.vic_mapping_object != 0);
34405cabbc6bSPrashanth Sreenivasa 	ASSERT3P(zcb->zcb_vd_obsolete_counts[vd->vdev_id], !=, NULL);
34415cabbc6bSPrashanth Sreenivasa 
34425cabbc6bSPrashanth Sreenivasa 	vdev_indirect_mapping_increment_obsolete_count(
34435cabbc6bSPrashanth Sreenivasa 	    vd->vdev_indirect_mapping,
34445cabbc6bSPrashanth Sreenivasa 	    DVA_GET_OFFSET(dva), DVA_GET_ASIZE(dva),
34455cabbc6bSPrashanth Sreenivasa 	    zcb->zcb_vd_obsolete_counts[vd->vdev_id]);
34465cabbc6bSPrashanth Sreenivasa 
34475cabbc6bSPrashanth Sreenivasa 	return (0);
34485cabbc6bSPrashanth Sreenivasa }
34495cabbc6bSPrashanth Sreenivasa 
34505cabbc6bSPrashanth Sreenivasa static uint32_t *
34515cabbc6bSPrashanth Sreenivasa zdb_load_obsolete_counts(vdev_t *vd)
34525cabbc6bSPrashanth Sreenivasa {
34535cabbc6bSPrashanth Sreenivasa 	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
34545cabbc6bSPrashanth Sreenivasa 	spa_t *spa = vd->vdev_spa;
34555cabbc6bSPrashanth Sreenivasa 	spa_condensing_indirect_phys_t *scip =
34565cabbc6bSPrashanth Sreenivasa 	    &spa->spa_condensing_indirect_phys;
34575cabbc6bSPrashanth Sreenivasa 	uint32_t *counts;
34585cabbc6bSPrashanth Sreenivasa 
34595cabbc6bSPrashanth Sreenivasa 	EQUIV(vdev_obsolete_sm_object(vd) != 0, vd->vdev_obsolete_sm != NULL);
34605cabbc6bSPrashanth Sreenivasa 	counts = vdev_indirect_mapping_load_obsolete_counts(vim);
34615cabbc6bSPrashanth Sreenivasa 	if (vd->vdev_obsolete_sm != NULL) {
34625cabbc6bSPrashanth Sreenivasa 		vdev_indirect_mapping_load_obsolete_spacemap(vim, counts,
34635cabbc6bSPrashanth Sreenivasa 		    vd->vdev_obsolete_sm);
34645cabbc6bSPrashanth Sreenivasa 	}
34655cabbc6bSPrashanth Sreenivasa 	if (scip->scip_vdev == vd->vdev_id &&
34665cabbc6bSPrashanth Sreenivasa 	    scip->scip_prev_obsolete_sm_object != 0) {
34675cabbc6bSPrashanth Sreenivasa 		space_map_t *prev_obsolete_sm = NULL;
34685cabbc6bSPrashanth Sreenivasa 		VERIFY0(space_map_open(&prev_obsolete_sm, spa->spa_meta_objset,
34695cabbc6bSPrashanth Sreenivasa 		    scip->scip_prev_obsolete_sm_object, 0, vd->vdev_asize, 0));
34705cabbc6bSPrashanth Sreenivasa 		vdev_indirect_mapping_load_obsolete_spacemap(vim, counts,
34715cabbc6bSPrashanth Sreenivasa 		    prev_obsolete_sm);
34725cabbc6bSPrashanth Sreenivasa 		space_map_close(prev_obsolete_sm);
34735cabbc6bSPrashanth Sreenivasa 	}
34745cabbc6bSPrashanth Sreenivasa 	return (counts);
34755cabbc6bSPrashanth Sreenivasa }
34765cabbc6bSPrashanth Sreenivasa 
347786714001SSerapheim Dimitropoulos typedef struct checkpoint_sm_exclude_entry_arg {
347886714001SSerapheim Dimitropoulos 	vdev_t *cseea_vd;
347986714001SSerapheim Dimitropoulos 	uint64_t cseea_checkpoint_size;
348086714001SSerapheim Dimitropoulos } checkpoint_sm_exclude_entry_arg_t;
348186714001SSerapheim Dimitropoulos 
348286714001SSerapheim Dimitropoulos static int
348317f11284SSerapheim Dimitropoulos checkpoint_sm_exclude_entry_cb(space_map_entry_t *sme, void *arg)
348486714001SSerapheim Dimitropoulos {
348586714001SSerapheim Dimitropoulos 	checkpoint_sm_exclude_entry_arg_t *cseea = arg;
348686714001SSerapheim Dimitropoulos 	vdev_t *vd = cseea->cseea_vd;
348717f11284SSerapheim Dimitropoulos 	metaslab_t *ms = vd->vdev_ms[sme->sme_offset >> vd->vdev_ms_shift];
348817f11284SSerapheim Dimitropoulos 	uint64_t end = sme->sme_offset + sme->sme_run;
348986714001SSerapheim Dimitropoulos 
349017f11284SSerapheim Dimitropoulos 	ASSERT(sme->sme_type == SM_FREE);
349186714001SSerapheim Dimitropoulos 
349286714001SSerapheim Dimitropoulos 	/*
349386714001SSerapheim Dimitropoulos 	 * Since the vdev_checkpoint_sm exists in the vdev level
349486714001SSerapheim Dimitropoulos 	 * and the ms_sm space maps exist in the metaslab level,
349586714001SSerapheim Dimitropoulos 	 * an entry in the checkpoint space map could theoretically
349686714001SSerapheim Dimitropoulos 	 * cross the boundaries of the metaslab that it belongs.
349786714001SSerapheim Dimitropoulos 	 *
349886714001SSerapheim Dimitropoulos 	 * In reality, because of the way that we populate and
349986714001SSerapheim Dimitropoulos 	 * manipulate the checkpoint's space maps currently,
350086714001SSerapheim Dimitropoulos 	 * there shouldn't be any entries that cross metaslabs.
350186714001SSerapheim Dimitropoulos 	 * Hence the assertion below.
350286714001SSerapheim Dimitropoulos 	 *
350386714001SSerapheim Dimitropoulos 	 * That said, there is no fundamental requirement that
350486714001SSerapheim Dimitropoulos 	 * the checkpoint's space map entries should not cross
350586714001SSerapheim Dimitropoulos 	 * metaslab boundaries. So if needed we could add code
350686714001SSerapheim Dimitropoulos 	 * that handles metaslab-crossing segments in the future.
350786714001SSerapheim Dimitropoulos 	 */
350817f11284SSerapheim Dimitropoulos 	VERIFY3U(sme->sme_offset, >=, ms->ms_start);
350986714001SSerapheim Dimitropoulos 	VERIFY3U(end, <=, ms->ms_start + ms->ms_size);
351086714001SSerapheim Dimitropoulos 
351186714001SSerapheim Dimitropoulos 	/*
351286714001SSerapheim Dimitropoulos 	 * By removing the entry from the allocated segments we
351386714001SSerapheim Dimitropoulos 	 * also verify that the entry is there to begin with.
351486714001SSerapheim Dimitropoulos 	 */
351586714001SSerapheim Dimitropoulos 	mutex_enter(&ms->ms_lock);
351617f11284SSerapheim Dimitropoulos 	range_tree_remove(ms->ms_allocatable, sme->sme_offset, sme->sme_run);
351786714001SSerapheim Dimitropoulos 	mutex_exit(&ms->ms_lock);
351886714001SSerapheim Dimitropoulos 
351917f11284SSerapheim Dimitropoulos 	cseea->cseea_checkpoint_size += sme->sme_run;
352086714001SSerapheim Dimitropoulos 	return (0);
352186714001SSerapheim Dimitropoulos }
352286714001SSerapheim Dimitropoulos 
352386714001SSerapheim Dimitropoulos static void
352486714001SSerapheim Dimitropoulos zdb_leak_init_vdev_exclude_checkpoint(vdev_t *vd, zdb_cb_t *zcb)
352586714001SSerapheim Dimitropoulos {
352686714001SSerapheim Dimitropoulos 	spa_t *spa = vd->vdev_spa;
352786714001SSerapheim Dimitropoulos 	space_map_t *checkpoint_sm = NULL;
352886714001SSerapheim Dimitropoulos 	uint64_t checkpoint_sm_obj;
352986714001SSerapheim Dimitropoulos 
353086714001SSerapheim Dimitropoulos 	/*
353186714001SSerapheim Dimitropoulos 	 * If there is no vdev_top_zap, we are in a pool whose
353286714001SSerapheim Dimitropoulos 	 * version predates the pool checkpoint feature.
353386714001SSerapheim Dimitropoulos 	 */
353486714001SSerapheim Dimitropoulos 	if (vd->vdev_top_zap == 0)
353586714001SSerapheim Dimitropoulos 		return;
353686714001SSerapheim Dimitropoulos 
353786714001SSerapheim Dimitropoulos 	/*
353886714001SSerapheim Dimitropoulos 	 * If there is no reference of the vdev_checkpoint_sm in
353986714001SSerapheim Dimitropoulos 	 * the vdev_top_zap, then one of the following scenarios
354086714001SSerapheim Dimitropoulos 	 * is true:
354186714001SSerapheim Dimitropoulos 	 *
354286714001SSerapheim Dimitropoulos 	 * 1] There is no checkpoint
354386714001SSerapheim Dimitropoulos 	 * 2] There is a checkpoint, but no checkpointed blocks
354486714001SSerapheim Dimitropoulos 	 *    have been freed yet
354586714001SSerapheim Dimitropoulos 	 * 3] The current vdev is indirect
354686714001SSerapheim Dimitropoulos 	 *
354786714001SSerapheim Dimitropoulos 	 * In these cases we return immediately.
354886714001SSerapheim Dimitropoulos 	 */
354986714001SSerapheim Dimitropoulos 	if (zap_contains(spa_meta_objset(spa), vd->vdev_top_zap,
355086714001SSerapheim Dimitropoulos 	    VDEV_TOP_ZAP_POOL_CHECKPOINT_SM) != 0)
355186714001SSerapheim Dimitropoulos 		return;
355286714001SSerapheim Dimitropoulos 
355386714001SSerapheim Dimitropoulos 	VERIFY0(zap_lookup(spa_meta_objset(spa), vd->vdev_top_zap,
355486714001SSerapheim Dimitropoulos 	    VDEV_TOP_ZAP_POOL_CHECKPOINT_SM, sizeof (uint64_t), 1,
355586714001SSerapheim Dimitropoulos 	    &checkpoint_sm_obj));
355686714001SSerapheim Dimitropoulos 
355786714001SSerapheim Dimitropoulos 	checkpoint_sm_exclude_entry_arg_t cseea;
355886714001SSerapheim Dimitropoulos 	cseea.cseea_vd = vd;
355986714001SSerapheim Dimitropoulos 	cseea.cseea_checkpoint_size = 0;
356086714001SSerapheim Dimitropoulos 
356186714001SSerapheim Dimitropoulos 	VERIFY0(space_map_open(&checkpoint_sm, spa_meta_objset(spa),
356286714001SSerapheim Dimitropoulos 	    checkpoint_sm_obj, 0, vd->vdev_asize, vd->vdev_ashift));
356386714001SSerapheim Dimitropoulos 
356486714001SSerapheim Dimitropoulos 	VERIFY0(space_map_iterate(checkpoint_sm,
3565555d674dSSerapheim Dimitropoulos 	    space_map_length(checkpoint_sm),
356686714001SSerapheim Dimitropoulos 	    checkpoint_sm_exclude_entry_cb, &cseea));
356786714001SSerapheim Dimitropoulos 	space_map_close(checkpoint_sm);
356886714001SSerapheim Dimitropoulos 
356986714001SSerapheim Dimitropoulos 	zcb->zcb_checkpoint_size += cseea.cseea_checkpoint_size;
357086714001SSerapheim Dimitropoulos }
357186714001SSerapheim Dimitropoulos 
357286714001SSerapheim Dimitropoulos static void
357386714001SSerapheim Dimitropoulos zdb_leak_init_exclude_checkpoint(spa_t *spa, zdb_cb_t *zcb)
357486714001SSerapheim Dimitropoulos {
3575555d674dSSerapheim Dimitropoulos 	ASSERT(!dump_opt['L']);
3576555d674dSSerapheim Dimitropoulos 
357786714001SSerapheim Dimitropoulos 	vdev_t *rvd = spa->spa_root_vdev;
357886714001SSerapheim Dimitropoulos 	for (uint64_t c = 0; c < rvd->vdev_children; c++) {
357986714001SSerapheim Dimitropoulos 		ASSERT3U(c, ==, rvd->vdev_child[c]->vdev_id);
358086714001SSerapheim Dimitropoulos 		zdb_leak_init_vdev_exclude_checkpoint(rvd->vdev_child[c], zcb);
358186714001SSerapheim Dimitropoulos 	}
358286714001SSerapheim Dimitropoulos }
358386714001SSerapheim Dimitropoulos 
3584814dcd43SSerapheim Dimitropoulos static int
3585814dcd43SSerapheim Dimitropoulos count_unflushed_space_cb(spa_t *spa, space_map_entry_t *sme,
3586814dcd43SSerapheim Dimitropoulos     uint64_t txg, void *arg)
3587814dcd43SSerapheim Dimitropoulos {
3588814dcd43SSerapheim Dimitropoulos 	int64_t *ualloc_space = arg;
3589814dcd43SSerapheim Dimitropoulos 	uint64_t offset = sme->sme_offset;
3590814dcd43SSerapheim Dimitropoulos 	uint64_t vdev_id = sme->sme_vdev;
3591814dcd43SSerapheim Dimitropoulos 
3592814dcd43SSerapheim Dimitropoulos 	vdev_t *vd = vdev_lookup_top(spa, vdev_id);
3593814dcd43SSerapheim Dimitropoulos 	if (!vdev_is_concrete(vd))
3594814dcd43SSerapheim Dimitropoulos 		return (0);
3595814dcd43SSerapheim Dimitropoulos 
3596814dcd43SSerapheim Dimitropoulos 	metaslab_t *ms = vd->vdev_ms[offset >> vd->vdev_ms_shift];
3597814dcd43SSerapheim Dimitropoulos 	ASSERT(sme->sme_type == SM_ALLOC || sme->sme_type == SM_FREE);
3598814dcd43SSerapheim Dimitropoulos 
3599814dcd43SSerapheim Dimitropoulos 	if (txg < metaslab_unflushed_txg(ms))
3600814dcd43SSerapheim Dimitropoulos 		return (0);
3601814dcd43SSerapheim Dimitropoulos 
3602814dcd43SSerapheim Dimitropoulos 	if (sme->sme_type == SM_ALLOC)
3603814dcd43SSerapheim Dimitropoulos 		*ualloc_space += sme->sme_run;
3604814dcd43SSerapheim Dimitropoulos 	else
3605814dcd43SSerapheim Dimitropoulos 		*ualloc_space -= sme->sme_run;
3606814dcd43SSerapheim Dimitropoulos 
3607814dcd43SSerapheim Dimitropoulos 	return (0);
3608814dcd43SSerapheim Dimitropoulos }
3609814dcd43SSerapheim Dimitropoulos 
3610814dcd43SSerapheim Dimitropoulos static int64_t
3611814dcd43SSerapheim Dimitropoulos get_unflushed_alloc_space(spa_t *spa)
3612814dcd43SSerapheim Dimitropoulos {
3613814dcd43SSerapheim Dimitropoulos 	if (dump_opt['L'])
3614814dcd43SSerapheim Dimitropoulos 		return (0);
3615814dcd43SSerapheim Dimitropoulos 
3616814dcd43SSerapheim Dimitropoulos 	int64_t ualloc_space = 0;
3617814dcd43SSerapheim Dimitropoulos 	iterate_through_spacemap_logs(spa, count_unflushed_space_cb,
3618814dcd43SSerapheim Dimitropoulos 	    &ualloc_space);
3619814dcd43SSerapheim Dimitropoulos 	return (ualloc_space);
3620814dcd43SSerapheim Dimitropoulos }
3621814dcd43SSerapheim Dimitropoulos 
3622814dcd43SSerapheim Dimitropoulos static int
3623814dcd43SSerapheim Dimitropoulos load_unflushed_cb(spa_t *spa, space_map_entry_t *sme, uint64_t txg, void *arg)
3624814dcd43SSerapheim Dimitropoulos {
3625814dcd43SSerapheim Dimitropoulos 	maptype_t *uic_maptype = arg;
3626814dcd43SSerapheim Dimitropoulos 	uint64_t offset = sme->sme_offset;
3627814dcd43SSerapheim Dimitropoulos 	uint64_t size = sme->sme_run;
3628814dcd43SSerapheim Dimitropoulos 	uint64_t vdev_id = sme->sme_vdev;
3629814dcd43SSerapheim Dimitropoulos 	vdev_t *vd = vdev_lookup_top(spa, vdev_id);
3630814dcd43SSerapheim Dimitropoulos 
3631814dcd43SSerapheim Dimitropoulos 	/* skip indirect vdevs */
3632814dcd43SSerapheim Dimitropoulos 	if (!vdev_is_concrete(vd))
3633814dcd43SSerapheim Dimitropoulos 		return (0);
3634814dcd43SSerapheim Dimitropoulos 
3635814dcd43SSerapheim Dimitropoulos 	metaslab_t *ms = vd->vdev_ms[offset >> vd->vdev_ms_shift];
3636814dcd43SSerapheim Dimitropoulos 
3637814dcd43SSerapheim Dimitropoulos 	ASSERT(sme->sme_type == SM_ALLOC || sme->sme_type == SM_FREE);
3638814dcd43SSerapheim Dimitropoulos 	ASSERT(*uic_maptype == SM_ALLOC || *uic_maptype == SM_FREE);
3639814dcd43SSerapheim Dimitropoulos 
3640814dcd43SSerapheim Dimitropoulos 	if (txg < metaslab_unflushed_txg(ms))
3641814dcd43SSerapheim Dimitropoulos 		return (0);
3642814dcd43SSerapheim Dimitropoulos 
3643814dcd43SSerapheim Dimitropoulos 	if (*uic_maptype == sme->sme_type)
3644814dcd43SSerapheim Dimitropoulos 		range_tree_add(ms->ms_allocatable, offset, size);
3645814dcd43SSerapheim Dimitropoulos 	else
3646814dcd43SSerapheim Dimitropoulos 		range_tree_remove(ms->ms_allocatable, offset, size);
3647814dcd43SSerapheim Dimitropoulos 
3648814dcd43SSerapheim Dimitropoulos 	return (0);
3649814dcd43SSerapheim Dimitropoulos }
3650814dcd43SSerapheim Dimitropoulos 
3651814dcd43SSerapheim Dimitropoulos static void
3652814dcd43SSerapheim Dimitropoulos load_unflushed_to_ms_allocatables(spa_t *spa, maptype_t maptype)
3653814dcd43SSerapheim Dimitropoulos {
3654814dcd43SSerapheim Dimitropoulos 	iterate_through_spacemap_logs(spa, load_unflushed_cb, &maptype);
3655814dcd43SSerapheim Dimitropoulos }
3656814dcd43SSerapheim Dimitropoulos 
365786714001SSerapheim Dimitropoulos static void
365886714001SSerapheim Dimitropoulos load_concrete_ms_allocatable_trees(spa_t *spa, maptype_t maptype)
365986714001SSerapheim Dimitropoulos {
366086714001SSerapheim Dimitropoulos 	vdev_t *rvd = spa->spa_root_vdev;
366186714001SSerapheim Dimitropoulos 	for (uint64_t i = 0; i < rvd->vdev_children; i++) {
366286714001SSerapheim Dimitropoulos 		vdev_t *vd = rvd->vdev_child[i];
366386714001SSerapheim Dimitropoulos 
366486714001SSerapheim Dimitropoulos 		ASSERT3U(i, ==, vd->vdev_id);
366586714001SSerapheim Dimitropoulos 
366686714001SSerapheim Dimitropoulos 		if (vd->vdev_ops == &vdev_indirect_ops)
366786714001SSerapheim Dimitropoulos 			continue;
366886714001SSerapheim Dimitropoulos 
366986714001SSerapheim Dimitropoulos 		for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
367086714001SSerapheim Dimitropoulos 			metaslab_t *msp = vd->vdev_ms[m];
367186714001SSerapheim Dimitropoulos 
367286714001SSerapheim Dimitropoulos 			(void) fprintf(stderr,
367386714001SSerapheim Dimitropoulos 			    "\rloading concrete vdev %llu, "
367486714001SSerapheim Dimitropoulos 			    "metaslab %llu of %llu ...",
367586714001SSerapheim Dimitropoulos 			    (longlong_t)vd->vdev_id,
367686714001SSerapheim Dimitropoulos 			    (longlong_t)msp->ms_id,
367786714001SSerapheim Dimitropoulos 			    (longlong_t)vd->vdev_ms_count);
367886714001SSerapheim Dimitropoulos 
367986714001SSerapheim Dimitropoulos 			mutex_enter(&msp->ms_lock);
3680814dcd43SSerapheim Dimitropoulos 			range_tree_vacate(msp->ms_allocatable, NULL, NULL);
368186714001SSerapheim Dimitropoulos 
368286714001SSerapheim Dimitropoulos 			/*
368386714001SSerapheim Dimitropoulos 			 * We don't want to spend the CPU manipulating the
368486714001SSerapheim Dimitropoulos 			 * size-ordered tree, so clear the range_tree ops.
368586714001SSerapheim Dimitropoulos 			 */
368686714001SSerapheim Dimitropoulos 			msp->ms_allocatable->rt_ops = NULL;
368786714001SSerapheim Dimitropoulos 
368886714001SSerapheim Dimitropoulos 			if (msp->ms_sm != NULL) {
368986714001SSerapheim Dimitropoulos 				VERIFY0(space_map_load(msp->ms_sm,
369086714001SSerapheim Dimitropoulos 				    msp->ms_allocatable, maptype));
369186714001SSerapheim Dimitropoulos 			}
369286714001SSerapheim Dimitropoulos 			if (!msp->ms_loaded)
369386714001SSerapheim Dimitropoulos 				msp->ms_loaded = B_TRUE;
369486714001SSerapheim Dimitropoulos 			mutex_exit(&msp->ms_lock);
369586714001SSerapheim Dimitropoulos 		}
369686714001SSerapheim Dimitropoulos 	}
3697814dcd43SSerapheim Dimitropoulos 
3698814dcd43SSerapheim Dimitropoulos 	load_unflushed_to_ms_allocatables(spa, maptype);
369986714001SSerapheim Dimitropoulos }
370086714001SSerapheim Dimitropoulos 
370186714001SSerapheim Dimitropoulos /*
370286714001SSerapheim Dimitropoulos  * vm_idxp is an in-out parameter which (for indirect vdevs) is the
370386714001SSerapheim Dimitropoulos  * index in vim_entries that has the first entry in this metaslab.
370486714001SSerapheim Dimitropoulos  * On return, it will be set to the first entry after this metaslab.
370586714001SSerapheim Dimitropoulos  */
370686714001SSerapheim Dimitropoulos static void
370786714001SSerapheim Dimitropoulos load_indirect_ms_allocatable_tree(vdev_t *vd, metaslab_t *msp,
370886714001SSerapheim Dimitropoulos     uint64_t *vim_idxp)
370986714001SSerapheim Dimitropoulos {
371086714001SSerapheim Dimitropoulos 	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
371186714001SSerapheim Dimitropoulos 
371286714001SSerapheim Dimitropoulos 	mutex_enter(&msp->ms_lock);
3713814dcd43SSerapheim Dimitropoulos 	range_tree_vacate(msp->ms_allocatable, NULL, NULL);
371486714001SSerapheim Dimitropoulos 
371586714001SSerapheim Dimitropoulos 	/*
371686714001SSerapheim Dimitropoulos 	 * We don't want to spend the CPU manipulating the
371786714001SSerapheim Dimitropoulos 	 * size-ordered tree, so clear the range_tree ops.
371886714001SSerapheim Dimitropoulos 	 */
371986714001SSerapheim Dimitropoulos 	msp->ms_allocatable->rt_ops = NULL;
372086714001SSerapheim Dimitropoulos 
372186714001SSerapheim Dimitropoulos 	for (; *vim_idxp < vdev_indirect_mapping_num_entries(vim);
372286714001SSerapheim Dimitropoulos 	    (*vim_idxp)++) {
372386714001SSerapheim Dimitropoulos 		vdev_indirect_mapping_entry_phys_t *vimep =
372486714001SSerapheim Dimitropoulos 		    &vim->vim_entries[*vim_idxp];
372586714001SSerapheim Dimitropoulos 		uint64_t ent_offset = DVA_MAPPING_GET_SRC_OFFSET(vimep);
372686714001SSerapheim Dimitropoulos 		uint64_t ent_len = DVA_GET_ASIZE(&vimep->vimep_dst);
372786714001SSerapheim Dimitropoulos 		ASSERT3U(ent_offset, >=, msp->ms_start);
372886714001SSerapheim Dimitropoulos 		if (ent_offset >= msp->ms_start + msp->ms_size)
372986714001SSerapheim Dimitropoulos 			break;
373086714001SSerapheim Dimitropoulos 
373186714001SSerapheim Dimitropoulos 		/*
373286714001SSerapheim Dimitropoulos 		 * Mappings do not cross metaslab boundaries,
373386714001SSerapheim Dimitropoulos 		 * because we create them by walking the metaslabs.
373486714001SSerapheim Dimitropoulos 		 */
373586714001SSerapheim Dimitropoulos 		ASSERT3U(ent_offset + ent_len, <=,
373686714001SSerapheim Dimitropoulos 		    msp->ms_start + msp->ms_size);
373786714001SSerapheim Dimitropoulos 		range_tree_add(msp->ms_allocatable, ent_offset, ent_len);
373886714001SSerapheim Dimitropoulos 	}
373986714001SSerapheim Dimitropoulos 
374086714001SSerapheim Dimitropoulos 	if (!msp->ms_loaded)
374186714001SSerapheim Dimitropoulos 		msp->ms_loaded = B_TRUE;
374286714001SSerapheim Dimitropoulos 	mutex_exit(&msp->ms_lock);
374386714001SSerapheim Dimitropoulos }
374486714001SSerapheim Dimitropoulos 
374586714001SSerapheim Dimitropoulos static void
374686714001SSerapheim Dimitropoulos zdb_leak_init_prepare_indirect_vdevs(spa_t *spa, zdb_cb_t *zcb)
374786714001SSerapheim Dimitropoulos {
3748555d674dSSerapheim Dimitropoulos 	ASSERT(!dump_opt['L']);
3749555d674dSSerapheim Dimitropoulos 
375086714001SSerapheim Dimitropoulos 	vdev_t *rvd = spa->spa_root_vdev;
375186714001SSerapheim Dimitropoulos 	for (uint64_t c = 0; c < rvd->vdev_children; c++) {
375286714001SSerapheim Dimitropoulos 		vdev_t *vd = rvd->vdev_child[c];
375386714001SSerapheim Dimitropoulos 
375486714001SSerapheim Dimitropoulos 		ASSERT3U(c, ==, vd->vdev_id);
375586714001SSerapheim Dimitropoulos 
375686714001SSerapheim Dimitropoulos 		if (vd->vdev_ops != &vdev_indirect_ops)
375786714001SSerapheim Dimitropoulos 			continue;
375886714001SSerapheim Dimitropoulos 
375986714001SSerapheim Dimitropoulos 		/*
376086714001SSerapheim Dimitropoulos 		 * Note: we don't check for mapping leaks on
376186714001SSerapheim Dimitropoulos 		 * removing vdevs because their ms_allocatable's
376286714001SSerapheim Dimitropoulos 		 * are used to look for leaks in allocated space.
376386714001SSerapheim Dimitropoulos 		 */
376486714001SSerapheim Dimitropoulos 		zcb->zcb_vd_obsolete_counts[c] = zdb_load_obsolete_counts(vd);
376586714001SSerapheim Dimitropoulos 
376686714001SSerapheim Dimitropoulos 		/*
376786714001SSerapheim Dimitropoulos 		 * Normally, indirect vdevs don't have any
376886714001SSerapheim Dimitropoulos 		 * metaslabs.  We want to set them up for
376986714001SSerapheim Dimitropoulos 		 * zio_claim().
377086714001SSerapheim Dimitropoulos 		 */
377186714001SSerapheim Dimitropoulos 		VERIFY0(vdev_metaslab_init(vd, 0));
377286714001SSerapheim Dimitropoulos 
377386714001SSerapheim Dimitropoulos 		vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
377486714001SSerapheim Dimitropoulos 		uint64_t vim_idx = 0;
377586714001SSerapheim Dimitropoulos 		for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
377686714001SSerapheim Dimitropoulos 
377786714001SSerapheim Dimitropoulos 			(void) fprintf(stderr,
377886714001SSerapheim Dimitropoulos 			    "\rloading indirect vdev %llu, "
377986714001SSerapheim Dimitropoulos 			    "metaslab %llu of %llu ...",
378086714001SSerapheim Dimitropoulos 			    (longlong_t)vd->vdev_id,
378186714001SSerapheim Dimitropoulos 			    (longlong_t)vd->vdev_ms[m]->ms_id,
378286714001SSerapheim Dimitropoulos 			    (longlong_t)vd->vdev_ms_count);
378386714001SSerapheim Dimitropoulos 
378486714001SSerapheim Dimitropoulos 			load_indirect_ms_allocatable_tree(vd, vd->vdev_ms[m],
378586714001SSerapheim Dimitropoulos 			    &vim_idx);
378686714001SSerapheim Dimitropoulos 		}
378786714001SSerapheim Dimitropoulos 		ASSERT3U(vim_idx, ==, vdev_indirect_mapping_num_entries(vim));
378886714001SSerapheim Dimitropoulos 	}
378986714001SSerapheim Dimitropoulos }
379086714001SSerapheim Dimitropoulos 
3791b24ab676SJeff Bonwick static void
3792b24ab676SJeff Bonwick zdb_leak_init(spa_t *spa, zdb_cb_t *zcb)
3793b24ab676SJeff Bonwick {
3794cde58dbcSMatthew Ahrens 	zcb->zcb_spa = spa;
3795cde58dbcSMatthew Ahrens 
3796555d674dSSerapheim Dimitropoulos 	if (dump_opt['L'])
3797555d674dSSerapheim Dimitropoulos 		return;
37988363e80aSGeorge Wilson 
3799555d674dSSerapheim Dimitropoulos 	dsl_pool_t *dp = spa->spa_dsl_pool;
3800555d674dSSerapheim Dimitropoulos 	vdev_t *rvd = spa->spa_root_vdev;
38018363e80aSGeorge Wilson 
3802555d674dSSerapheim Dimitropoulos 	/*
3803555d674dSSerapheim Dimitropoulos 	 * We are going to be changing the meaning of the metaslab's
3804555d674dSSerapheim Dimitropoulos 	 * ms_allocatable.  Ensure that the allocator doesn't try to
3805555d674dSSerapheim Dimitropoulos 	 * use the tree.
3806555d674dSSerapheim Dimitropoulos 	 */
3807555d674dSSerapheim Dimitropoulos 	spa->spa_normal_class->mc_ops = &zdb_metaslab_ops;
3808555d674dSSerapheim Dimitropoulos 	spa->spa_log_class->mc_ops = &zdb_metaslab_ops;
38095cabbc6bSPrashanth Sreenivasa 
3810555d674dSSerapheim Dimitropoulos 	zcb->zcb_vd_obsolete_counts =
3811555d674dSSerapheim Dimitropoulos 	    umem_zalloc(rvd->vdev_children * sizeof (uint32_t *),
3812555d674dSSerapheim Dimitropoulos 	    UMEM_NOFAIL);
38135cabbc6bSPrashanth Sreenivasa 
3814555d674dSSerapheim Dimitropoulos 	/*
3815555d674dSSerapheim Dimitropoulos 	 * For leak detection, we overload the ms_allocatable trees
3816555d674dSSerapheim Dimitropoulos 	 * to contain allocated segments instead of free segments.
3817555d674dSSerapheim Dimitropoulos 	 * As a result, we can't use the normal metaslab_load/unload
3818555d674dSSerapheim Dimitropoulos 	 * interfaces.
3819555d674dSSerapheim Dimitropoulos 	 */
3820555d674dSSerapheim Dimitropoulos 	zdb_leak_init_prepare_indirect_vdevs(spa, zcb);
3821555d674dSSerapheim Dimitropoulos 	load_concrete_ms_allocatable_trees(spa, SM_ALLOC);
38225cabbc6bSPrashanth Sreenivasa 
3823555d674dSSerapheim Dimitropoulos 	/*
3824555d674dSSerapheim Dimitropoulos 	 * On load_concrete_ms_allocatable_trees() we loaded all the
3825555d674dSSerapheim Dimitropoulos 	 * allocated entries from the ms_sm to the ms_allocatable for
3826555d674dSSerapheim Dimitropoulos 	 * each metaslab. If the pool has a checkpoint or is in the
3827555d674dSSerapheim Dimitropoulos 	 * middle of discarding a checkpoint, some of these blocks
3828555d674dSSerapheim Dimitropoulos 	 * may have been freed but their ms_sm may not have been
3829555d674dSSerapheim Dimitropoulos 	 * updated because they are referenced by the checkpoint. In
3830555d674dSSerapheim Dimitropoulos 	 * order to avoid false-positives during leak-detection, we
3831555d674dSSerapheim Dimitropoulos 	 * go through the vdev's checkpoint space map and exclude all
3832555d674dSSerapheim Dimitropoulos 	 * its entries from their relevant ms_allocatable.
3833555d674dSSerapheim Dimitropoulos 	 *
3834555d674dSSerapheim Dimitropoulos 	 * We also aggregate the space held by the checkpoint and add
3835555d674dSSerapheim Dimitropoulos 	 * it to zcb_checkpoint_size.
3836555d674dSSerapheim Dimitropoulos 	 *
3837555d674dSSerapheim Dimitropoulos 	 * Note that at this point we are also verifying that all the
3838555d674dSSerapheim Dimitropoulos 	 * entries on the checkpoint_sm are marked as allocated in
3839555d674dSSerapheim Dimitropoulos 	 * the ms_sm of their relevant metaslab.
3840555d674dSSerapheim Dimitropoulos 	 * [see comment in checkpoint_sm_exclude_entry_cb()]
3841555d674dSSerapheim Dimitropoulos 	 */
3842555d674dSSerapheim Dimitropoulos 	zdb_leak_init_exclude_checkpoint(spa, zcb);
3843555d674dSSerapheim Dimitropoulos 	ASSERT3U(zcb->zcb_checkpoint_size, ==, spa_get_checkpoint_space(spa));
38445cabbc6bSPrashanth Sreenivasa 
3845555d674dSSerapheim Dimitropoulos 	/* for cleaner progress output */
3846555d674dSSerapheim Dimitropoulos 	(void) fprintf(stderr, "\n");
3847555d674dSSerapheim Dimitropoulos 
3848555d674dSSerapheim Dimitropoulos 	if (bpobj_is_open(&dp->dp_obsolete_bpobj)) {
3849555d674dSSerapheim Dimitropoulos 		ASSERT(spa_feature_is_enabled(spa,
3850555d674dSSerapheim Dimitropoulos 		    SPA_FEATURE_DEVICE_REMOVAL));
3851555d674dSSerapheim Dimitropoulos 		(void) bpobj_iterate_nofree(&dp->dp_obsolete_bpobj,
3852555d674dSSerapheim Dimitropoulos 		    increment_indirect_mapping_cb, zcb, NULL);
3853b24ab676SJeff Bonwick 	}
3854b24ab676SJeff Bonwick 
3855b24ab676SJeff Bonwick 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
3856bbfd46c4SJeff Bonwick 	zdb_ddt_leak_init(spa, zcb);
3857b24ab676SJeff Bonwick 	spa_config_exit(spa, SCL_CONFIG, FTAG);
3858b24ab676SJeff Bonwick }
3859b24ab676SJeff Bonwick 
38605cabbc6bSPrashanth Sreenivasa static boolean_t
38615cabbc6bSPrashanth Sreenivasa zdb_check_for_obsolete_leaks(vdev_t *vd, zdb_cb_t *zcb)
38625cabbc6bSPrashanth Sreenivasa {
38635cabbc6bSPrashanth Sreenivasa 	boolean_t leaks = B_FALSE;
38645cabbc6bSPrashanth Sreenivasa 	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
38655cabbc6bSPrashanth Sreenivasa 	uint64_t total_leaked = 0;
38665cabbc6bSPrashanth Sreenivasa 
38675cabbc6bSPrashanth Sreenivasa 	ASSERT(vim != NULL);
38685cabbc6bSPrashanth Sreenivasa 
38695cabbc6bSPrashanth Sreenivasa 	for (uint64_t i = 0; i < vdev_indirect_mapping_num_entries(vim); i++) {
38705cabbc6bSPrashanth Sreenivasa 		vdev_indirect_mapping_entry_phys_t *vimep =
38715cabbc6bSPrashanth Sreenivasa 		    &vim->vim_entries[i];
38725cabbc6bSPrashanth Sreenivasa 		uint64_t obsolete_bytes = 0;
38735cabbc6bSPrashanth Sreenivasa 		uint64_t offset = DVA_MAPPING_GET_SRC_OFFSET(vimep);
38745cabbc6bSPrashanth Sreenivasa 		metaslab_t *msp = vd->vdev_ms[offset >> vd->vdev_ms_shift];
38755cabbc6bSPrashanth Sreenivasa 
38765cabbc6bSPrashanth Sreenivasa 		/*
38775cabbc6bSPrashanth Sreenivasa 		 * This is not very efficient but it's easy to
38785cabbc6bSPrashanth Sreenivasa 		 * verify correctness.
38795cabbc6bSPrashanth Sreenivasa 		 */
38805cabbc6bSPrashanth Sreenivasa 		for (uint64_t inner_offset = 0;
38815cabbc6bSPrashanth Sreenivasa 		    inner_offset < DVA_GET_ASIZE(&vimep->vimep_dst);
38825cabbc6bSPrashanth Sreenivasa 		    inner_offset += 1 << vd->vdev_ashift) {
388386714001SSerapheim Dimitropoulos 			if (range_tree_contains(msp->ms_allocatable,
38845cabbc6bSPrashanth Sreenivasa 			    offset + inner_offset, 1 << vd->vdev_ashift)) {
38855cabbc6bSPrashanth Sreenivasa 				obsolete_bytes += 1 << vd->vdev_ashift;
38865cabbc6bSPrashanth Sreenivasa 			}
38875cabbc6bSPrashanth Sreenivasa 		}
38885cabbc6bSPrashanth Sreenivasa 
38895cabbc6bSPrashanth Sreenivasa 		int64_t bytes_leaked = obsolete_bytes -
38905cabbc6bSPrashanth Sreenivasa 		    zcb->zcb_vd_obsolete_counts[vd->vdev_id][i];
38915cabbc6bSPrashanth Sreenivasa 		ASSERT3U(DVA_GET_ASIZE(&vimep->vimep_dst), >=,
38925cabbc6bSPrashanth Sreenivasa 		    zcb->zcb_vd_obsolete_counts[vd->vdev_id][i]);
38935cabbc6bSPrashanth Sreenivasa 		if (bytes_leaked != 0 &&
38945cabbc6bSPrashanth Sreenivasa 		    (vdev_obsolete_counts_are_precise(vd) ||
38955cabbc6bSPrashanth Sreenivasa 		    dump_opt['d'] >= 5)) {
38965cabbc6bSPrashanth Sreenivasa 			(void) printf("obsolete indirect mapping count "
38975cabbc6bSPrashanth Sreenivasa 			    "mismatch on %llu:%llx:%llx : %llx bytes leaked\n",
38985cabbc6bSPrashanth Sreenivasa 			    (u_longlong_t)vd->vdev_id,
38995cabbc6bSPrashanth Sreenivasa 			    (u_longlong_t)DVA_MAPPING_GET_SRC_OFFSET(vimep),
39005cabbc6bSPrashanth Sreenivasa 			    (u_longlong_t)DVA_GET_ASIZE(&vimep->vimep_dst),
39015cabbc6bSPrashanth Sreenivasa 			    (u_longlong_t)bytes_leaked);
39025cabbc6bSPrashanth Sreenivasa 		}
39035cabbc6bSPrashanth Sreenivasa 		total_leaked += ABS(bytes_leaked);
39045cabbc6bSPrashanth Sreenivasa 	}
39055cabbc6bSPrashanth Sreenivasa 
39065cabbc6bSPrashanth Sreenivasa 	if (!vdev_obsolete_counts_are_precise(vd) && total_leaked > 0) {
39075cabbc6bSPrashanth Sreenivasa 		int pct_leaked = total_leaked * 100 /
39085cabbc6bSPrashanth Sreenivasa 		    vdev_indirect_mapping_bytes_mapped(vim);
39095cabbc6bSPrashanth Sreenivasa 		(void) printf("cannot verify obsolete indirect mapping "
39105cabbc6bSPrashanth Sreenivasa 		    "counts of vdev %llu because precise feature was not "
39115cabbc6bSPrashanth Sreenivasa 		    "enabled when it was removed: %d%% (%llx bytes) of mapping"
39125cabbc6bSPrashanth Sreenivasa 		    "unreferenced\n",
39135cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)vd->vdev_id, pct_leaked,
39145cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)total_leaked);
39155cabbc6bSPrashanth Sreenivasa 	} else if (total_leaked > 0) {
39165cabbc6bSPrashanth Sreenivasa 		(void) printf("obsolete indirect mapping count mismatch "
39175cabbc6bSPrashanth Sreenivasa 		    "for vdev %llu -- %llx total bytes mismatched\n",
39185cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)vd->vdev_id,
39195cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)total_leaked);
39205cabbc6bSPrashanth Sreenivasa 		leaks |= B_TRUE;
39215cabbc6bSPrashanth Sreenivasa 	}
39225cabbc6bSPrashanth Sreenivasa 
39235cabbc6bSPrashanth Sreenivasa 	vdev_indirect_mapping_free_obsolete_counts(vim,
39245cabbc6bSPrashanth Sreenivasa 	    zcb->zcb_vd_obsolete_counts[vd->vdev_id]);
39255cabbc6bSPrashanth Sreenivasa 	zcb->zcb_vd_obsolete_counts[vd->vdev_id] = NULL;
39265cabbc6bSPrashanth Sreenivasa 
39275cabbc6bSPrashanth Sreenivasa 	return (leaks);
39285cabbc6bSPrashanth Sreenivasa }
39295cabbc6bSPrashanth Sreenivasa 
39305cabbc6bSPrashanth Sreenivasa static boolean_t
39315cabbc6bSPrashanth Sreenivasa zdb_leak_fini(spa_t *spa, zdb_cb_t *zcb)
3932b24ab676SJeff Bonwick {
3933555d674dSSerapheim Dimitropoulos 	if (dump_opt['L'])
3934555d674dSSerapheim Dimitropoulos 		return (B_FALSE);
3935555d674dSSerapheim Dimitropoulos 
39365cabbc6bSPrashanth Sreenivasa 	boolean_t leaks = B_FALSE;
39375cabbc6bSPrashanth Sreenivasa 
3938555d674dSSerapheim Dimitropoulos 	vdev_t *rvd = spa->spa_root_vdev;
3939555d674dSSerapheim Dimitropoulos 	for (unsigned c = 0; c < rvd->vdev_children; c++) {
3940555d674dSSerapheim Dimitropoulos 		vdev_t *vd = rvd->vdev_child[c];
3941555d674dSSerapheim Dimitropoulos #if DEBUG
3942555d674dSSerapheim Dimitropoulos 		metaslab_group_t *mg = vd->vdev_mg;
3943555d674dSSerapheim Dimitropoulos #endif
39448363e80aSGeorge Wilson 
3945555d674dSSerapheim Dimitropoulos 		if (zcb->zcb_vd_obsolete_counts[c] != NULL) {
3946555d674dSSerapheim Dimitropoulos 			leaks |= zdb_check_for_obsolete_leaks(vd, zcb);
3947555d674dSSerapheim Dimitropoulos 		}
3948555d674dSSerapheim Dimitropoulos 
3949555d674dSSerapheim Dimitropoulos 		for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
3950555d674dSSerapheim Dimitropoulos 			metaslab_t *msp = vd->vdev_ms[m];
3951555d674dSSerapheim Dimitropoulos 			ASSERT3P(mg, ==, msp->ms_group);
3952555d674dSSerapheim Dimitropoulos 
3953555d674dSSerapheim Dimitropoulos 			/*
3954555d674dSSerapheim Dimitropoulos 			 * ms_allocatable has been overloaded
3955555d674dSSerapheim Dimitropoulos 			 * to contain allocated segments. Now that
3956555d674dSSerapheim Dimitropoulos 			 * we finished traversing all blocks, any
3957555d674dSSerapheim Dimitropoulos 			 * block that remains in the ms_allocatable
3958555d674dSSerapheim Dimitropoulos 			 * represents an allocated block that we
3959555d674dSSerapheim Dimitropoulos 			 * did not claim during the traversal.
3960555d674dSSerapheim Dimitropoulos 			 * Claimed blocks would have been removed
3961555d674dSSerapheim Dimitropoulos 			 * from the ms_allocatable.  For indirect
3962555d674dSSerapheim Dimitropoulos 			 * vdevs, space remaining in the tree
3963555d674dSSerapheim Dimitropoulos 			 * represents parts of the mapping that are
3964555d674dSSerapheim Dimitropoulos 			 * not referenced, which is not a bug.
3965555d674dSSerapheim Dimitropoulos 			 */
3966555d674dSSerapheim Dimitropoulos 			if (vd->vdev_ops == &vdev_indirect_ops) {
3967555d674dSSerapheim Dimitropoulos 				range_tree_vacate(msp->ms_allocatable,
3968555d674dSSerapheim Dimitropoulos 				    NULL, NULL);
3969555d674dSSerapheim Dimitropoulos 			} else {
3970555d674dSSerapheim Dimitropoulos 				range_tree_vacate(msp->ms_allocatable,
3971555d674dSSerapheim Dimitropoulos 				    zdb_leak, vd);
3972555d674dSSerapheim Dimitropoulos 			}
3973555d674dSSerapheim Dimitropoulos 			if (msp->ms_loaded) {
3974555d674dSSerapheim Dimitropoulos 				msp->ms_loaded = B_FALSE;
3975b24ab676SJeff Bonwick 			}
3976b24ab676SJeff Bonwick 		}
39775cabbc6bSPrashanth Sreenivasa 
3978b24ab676SJeff Bonwick 	}
3979555d674dSSerapheim Dimitropoulos 
3980555d674dSSerapheim Dimitropoulos 	umem_free(zcb->zcb_vd_obsolete_counts,
3981555d674dSSerapheim Dimitropoulos 	    rvd->vdev_children * sizeof (uint32_t *));
3982555d674dSSerapheim Dimitropoulos 	zcb->zcb_vd_obsolete_counts = NULL;
3983555d674dSSerapheim Dimitropoulos 
39845cabbc6bSPrashanth Sreenivasa 	return (leaks);
3985b24ab676SJeff Bonwick }
3986b24ab676SJeff Bonwick 
3987cde58dbcSMatthew Ahrens /* ARGSUSED */
3988cde58dbcSMatthew Ahrens static int
3989cde58dbcSMatthew Ahrens count_block_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
3990cde58dbcSMatthew Ahrens {
3991cde58dbcSMatthew Ahrens 	zdb_cb_t *zcb = arg;
3992cde58dbcSMatthew Ahrens 
3993490d05b9SMatthew Ahrens 	if (dump_opt['b'] >= 5) {
3994cde58dbcSMatthew Ahrens 		char blkbuf[BP_SPRINTF_LEN];
399543466aaeSMax Grossman 		snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
3996cde58dbcSMatthew Ahrens 		(void) printf("[%s] %s\n",
3997cde58dbcSMatthew Ahrens 		    "deferred free", blkbuf);
3998cde58dbcSMatthew Ahrens 	}
3999cde58dbcSMatthew Ahrens 	zdb_count_block(zcb, NULL, bp, ZDB_OT_DEFERRED);
4000cde58dbcSMatthew Ahrens 	return (0);
4001cde58dbcSMatthew Ahrens }
4002cde58dbcSMatthew Ahrens 
4003fa9e4066Sahrens static int
4004fa9e4066Sahrens dump_block_stats(spa_t *spa)
4005fa9e4066Sahrens {
40063f7978d0SAlan Somers 	zdb_cb_t zcb;
4007fa9e4066Sahrens 	zdb_blkstats_t *zb, *tzb;
4008b24ab676SJeff Bonwick 	uint64_t norm_alloc, norm_space, total_alloc, total_found;
4009eb633035STom Caputi 	int flags = TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA |
4010eb633035STom Caputi 	    TRAVERSE_NO_DECRYPT | TRAVERSE_HARD;
40115d7b4d43SMatthew Ahrens 	boolean_t leaks = B_FALSE;
4012663207adSDon Brady 	int err;
4013fa9e4066Sahrens 
40143f7978d0SAlan Somers 	bzero(&zcb, sizeof (zcb));
4015490d05b9SMatthew Ahrens 	(void) printf("\nTraversing all blocks %s%s%s%s%s...\n\n",
4016b24ab676SJeff Bonwick 	    (dump_opt['c'] || !dump_opt['L']) ? "to verify " : "",
4017b24ab676SJeff Bonwick 	    (dump_opt['c'] == 1) ? "metadata " : "",
4018b24ab676SJeff Bonwick 	    dump_opt['c'] ? "checksums " : "",
4019b24ab676SJeff Bonwick 	    (dump_opt['c'] && !dump_opt['L']) ? "and verify " : "",
4020b24ab676SJeff Bonwick 	    !dump_opt['L'] ? "nothing leaked " : "");
4021fa9e4066Sahrens 
4022fa9e4066Sahrens 	/*
4023555d674dSSerapheim Dimitropoulos 	 * When leak detection is enabled we load all space maps as SM_ALLOC
4024555d674dSSerapheim Dimitropoulos 	 * maps, then traverse the pool claiming each block we discover. If
4025555d674dSSerapheim Dimitropoulos 	 * the pool is perfectly consistent, the segment trees will be empty
4026555d674dSSerapheim Dimitropoulos 	 * when we're done. Anything left over is a leak; any block we can't
4027555d674dSSerapheim Dimitropoulos 	 * claim (because it's not part of any space map) is a double
4028555d674dSSerapheim Dimitropoulos 	 * allocation, reference to a freed block, or an unclaimed log block.
4029555d674dSSerapheim Dimitropoulos 	 *
4030555d674dSSerapheim Dimitropoulos 	 * When leak detection is disabled (-L option) we still traverse the
4031555d674dSSerapheim Dimitropoulos 	 * pool claiming each block we discover, but we skip opening any space
4032555d674dSSerapheim Dimitropoulos 	 * maps.
4033fa9e4066Sahrens 	 */
4034555d674dSSerapheim Dimitropoulos 	bzero(&zcb, sizeof (zdb_cb_t));
4035b24ab676SJeff Bonwick 	zdb_leak_init(spa, &zcb);
4036fa9e4066Sahrens 
4037fa9e4066Sahrens 	/*
4038fa9e4066Sahrens 	 * If there's a deferred-free bplist, process that first.
4039fa9e4066Sahrens 	 */
4040cde58dbcSMatthew Ahrens 	(void) bpobj_iterate_nofree(&spa->spa_deferred_bpobj,
4041cde58dbcSMatthew Ahrens 	    count_block_cb, &zcb, NULL);
40425cabbc6bSPrashanth Sreenivasa 
40433b2aab18SMatthew Ahrens 	if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
40443b2aab18SMatthew Ahrens 		(void) bpobj_iterate_nofree(&spa->spa_dsl_pool->dp_free_bpobj,
40453b2aab18SMatthew Ahrens 		    count_block_cb, &zcb, NULL);
40463b2aab18SMatthew Ahrens 	}
40475cabbc6bSPrashanth Sreenivasa 
40485cabbc6bSPrashanth Sreenivasa 	zdb_claim_removing(spa, &zcb);
40495cabbc6bSPrashanth Sreenivasa 
40502acef22dSMatthew Ahrens 	if (spa_feature_is_active(spa, SPA_FEATURE_ASYNC_DESTROY)) {
4051b420f3adSRichard Lowe 		VERIFY3U(0, ==, bptree_iterate(spa->spa_meta_objset,
4052ad135b5dSChristopher Siden 		    spa->spa_dsl_pool->dp_bptree_obj, B_FALSE, count_block_cb,
4053ad135b5dSChristopher Siden 		    &zcb, NULL));
4054ad135b5dSChristopher Siden 	}
4055fa9e4066Sahrens 
4056bbfd46c4SJeff Bonwick 	if (dump_opt['c'] > 1)
4057bbfd46c4SJeff Bonwick 		flags |= TRAVERSE_PREFETCH_DATA;
4058bbfd46c4SJeff Bonwick 
4059490d05b9SMatthew Ahrens 	zcb.zcb_totalasize = metaslab_class_get_alloc(spa_normal_class(spa));
4060663207adSDon Brady 	zcb.zcb_totalasize += metaslab_class_get_alloc(spa_special_class(spa));
4061663207adSDon Brady 	zcb.zcb_totalasize += metaslab_class_get_alloc(spa_dedup_class(spa));
4062490d05b9SMatthew Ahrens 	zcb.zcb_start = zcb.zcb_lastprint = gethrtime();
4063663207adSDon Brady 	err = traverse_pool(spa, 0, flags, zdb_blkptr_cb, &zcb);
4064fa9e4066Sahrens 
406531d7e8faSGeorge Wilson 	/*
406631d7e8faSGeorge Wilson 	 * If we've traversed the data blocks then we need to wait for those
406731d7e8faSGeorge Wilson 	 * I/Os to complete. We leverage "The Godfather" zio to wait on
406831d7e8faSGeorge Wilson 	 * all async I/Os to complete.
406931d7e8faSGeorge Wilson 	 */
407031d7e8faSGeorge Wilson 	if (dump_opt['c']) {
40716f834bc1SMatthew Ahrens 		for (int i = 0; i < max_ncpus; i++) {
40726f834bc1SMatthew Ahrens 			(void) zio_wait(spa->spa_async_zio_root[i]);
40736f834bc1SMatthew Ahrens 			spa->spa_async_zio_root[i] = zio_root(spa, NULL, NULL,
40746f834bc1SMatthew Ahrens 			    ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE |
40756f834bc1SMatthew Ahrens 			    ZIO_FLAG_GODFATHER);
40766f834bc1SMatthew Ahrens 		}
407731d7e8faSGeorge Wilson 	}
407831d7e8faSGeorge Wilson 
4079663207adSDon Brady 	/*
4080663207adSDon Brady 	 * Done after zio_wait() since zcb_haderrors is modified in
4081663207adSDon Brady 	 * zdb_blkptr_done()
4082663207adSDon Brady 	 */
4083663207adSDon Brady 	zcb.zcb_haderrors |= err;
4084663207adSDon Brady 
4085b24ab676SJeff Bonwick 	if (zcb.zcb_haderrors) {
4086fa9e4066Sahrens 		(void) printf("\nError counts:\n\n");
4087fa9e4066Sahrens 		(void) printf("\t%5s  %s\n", "errno", "count");
4088b24ab676SJeff Bonwick 		for (int e = 0; e < 256; e++) {
4089fa9e4066Sahrens 			if (zcb.zcb_errors[e] != 0) {
4090fa9e4066Sahrens 				(void) printf("\t%5d  %llu\n",
4091fa9e4066Sahrens 				    e, (u_longlong_t)zcb.zcb_errors[e]);
4092fa9e4066Sahrens 			}
4093fa9e4066Sahrens 		}
4094fa9e4066Sahrens 	}
4095fa9e4066Sahrens 
4096fa9e4066Sahrens 	/*
4097fa9e4066Sahrens 	 * Report any leaked segments.
4098fa9e4066Sahrens 	 */
40995cabbc6bSPrashanth Sreenivasa 	leaks |= zdb_leak_fini(spa, &zcb);
4100fa9e4066Sahrens 
4101b24ab676SJeff Bonwick 	tzb = &zcb.zcb_type[ZB_TOTAL][ZDB_OT_TOTAL];
41028654d025Sperrin 
4103b24ab676SJeff Bonwick 	norm_alloc = metaslab_class_get_alloc(spa_normal_class(spa));
4104b24ab676SJeff Bonwick 	norm_space = metaslab_class_get_space(spa_normal_class(spa));
41058654d025Sperrin 
4106663207adSDon Brady 	total_alloc = norm_alloc +
4107663207adSDon Brady 	    metaslab_class_get_alloc(spa_log_class(spa)) +
4108663207adSDon Brady 	    metaslab_class_get_alloc(spa_special_class(spa)) +
4109814dcd43SSerapheim Dimitropoulos 	    metaslab_class_get_alloc(spa_dedup_class(spa)) +
4110814dcd43SSerapheim Dimitropoulos 	    get_unflushed_alloc_space(spa);
41115cabbc6bSPrashanth Sreenivasa 	total_found = tzb->zb_asize - zcb.zcb_dedup_asize +
411286714001SSerapheim Dimitropoulos 	    zcb.zcb_removing_size + zcb.zcb_checkpoint_size;
4113fa9e4066Sahrens 
4114555d674dSSerapheim Dimitropoulos 	if (total_found == total_alloc && !dump_opt['L']) {
4115555d674dSSerapheim Dimitropoulos 		(void) printf("\n\tNo leaks (block sum matches space"
4116555d674dSSerapheim Dimitropoulos 		    " maps exactly)\n");
4117555d674dSSerapheim Dimitropoulos 	} else if (!dump_opt['L']) {
4118fa9e4066Sahrens 		(void) printf("block traversal size %llu != alloc %llu "
411982a0a985SVictor Latushkin 		    "(%s %lld)\n",
4120b24ab676SJeff Bonwick 		    (u_longlong_t)total_found,
4121b24ab676SJeff Bonwick 		    (u_longlong_t)total_alloc,
412282a0a985SVictor Latushkin 		    (dump_opt['L']) ? "unreachable" : "leaked",
4123b24ab676SJeff Bonwick 		    (longlong_t)(total_alloc - total_found));
41245d7b4d43SMatthew Ahrens 		leaks = B_TRUE;
4125fa9e4066Sahrens 	}
4126fa9e4066Sahrens 
4127fa9e4066Sahrens 	if (tzb->zb_count == 0)
4128fa9e4066Sahrens 		return (2);
4129fa9e4066Sahrens 
4130fa9e4066Sahrens 	(void) printf("\n");
4131663207adSDon Brady 	(void) printf("\t%-16s %14llu\n", "bp count:",
4132fa9e4066Sahrens 	    (u_longlong_t)tzb->zb_count);
4133663207adSDon Brady 	(void) printf("\t%-16s %14llu\n", "ganged count:",
4134d5ee8a13SMatthew Ahrens 	    (longlong_t)tzb->zb_gangs);
4135663207adSDon Brady 	(void) printf("\t%-16s %14llu      avg: %6llu\n", "bp logical:",
4136fa9e4066Sahrens 	    (u_longlong_t)tzb->zb_lsize,
4137fa9e4066Sahrens 	    (u_longlong_t)(tzb->zb_lsize / tzb->zb_count));
4138663207adSDon Brady 	(void) printf("\t%-16s %14llu      avg: %6llu     compression: %6.2f\n",
4139663207adSDon Brady 	    "bp physical:", (u_longlong_t)tzb->zb_psize,
4140fa9e4066Sahrens 	    (u_longlong_t)(tzb->zb_psize / tzb->zb_count),
4141fa9e4066Sahrens 	    (double)tzb->zb_lsize / tzb->zb_psize);
4142663207adSDon Brady 	(void) printf("\t%-16s %14llu      avg: %6llu     compression: %6.2f\n",
4143663207adSDon Brady 	    "bp allocated:", (u_longlong_t)tzb->zb_asize,
4144fa9e4066Sahrens 	    (u_longlong_t)(tzb->zb_asize / tzb->zb_count),
4145fa9e4066Sahrens 	    (double)tzb->zb_lsize / tzb->zb_asize);
4146663207adSDon Brady 	(void) printf("\t%-16s %14llu    ref>1: %6llu   deduplication: %6.2f\n",
4147663207adSDon Brady 	    "bp deduped:", (u_longlong_t)zcb.zcb_dedup_asize,
4148b24ab676SJeff Bonwick 	    (u_longlong_t)zcb.zcb_dedup_blocks,
4149b24ab676SJeff Bonwick 	    (double)zcb.zcb_dedup_asize / tzb->zb_asize + 1.0);
4150663207adSDon Brady 	(void) printf("\t%-16s %14llu     used: %5.2f%%\n", "Normal class:",
4151b24ab676SJeff Bonwick 	    (u_longlong_t)norm_alloc, 100.0 * norm_alloc / norm_space);
4152fa9e4066Sahrens 
4153663207adSDon Brady 	if (spa_special_class(spa)->mc_rotor != NULL) {
4154663207adSDon Brady 		uint64_t alloc = metaslab_class_get_alloc(
4155663207adSDon Brady 		    spa_special_class(spa));
4156663207adSDon Brady 		uint64_t space = metaslab_class_get_space(
4157663207adSDon Brady 		    spa_special_class(spa));
4158663207adSDon Brady 
4159663207adSDon Brady 		(void) printf("\t%-16s %14llu     used: %5.2f%%\n",
4160663207adSDon Brady 		    "Special class", (u_longlong_t)alloc,
4161663207adSDon Brady 		    100.0 * alloc / space);
4162663207adSDon Brady 	}
4163663207adSDon Brady 
4164663207adSDon Brady 	if (spa_dedup_class(spa)->mc_rotor != NULL) {
4165663207adSDon Brady 		uint64_t alloc = metaslab_class_get_alloc(
4166663207adSDon Brady 		    spa_dedup_class(spa));
4167663207adSDon Brady 		uint64_t space = metaslab_class_get_space(
4168663207adSDon Brady 		    spa_dedup_class(spa));
4169663207adSDon Brady 
4170663207adSDon Brady 		(void) printf("\t%-16s %14llu     used: %5.2f%%\n",
4171663207adSDon Brady 		    "Dedup class", (u_longlong_t)alloc,
4172663207adSDon Brady 		    100.0 * alloc / space);
4173663207adSDon Brady 	}
4174663207adSDon Brady 
41755d7b4d43SMatthew Ahrens 	for (bp_embedded_type_t i = 0; i < NUM_BP_EMBEDDED_TYPES; i++) {
41765d7b4d43SMatthew Ahrens 		if (zcb.zcb_embedded_blocks[i] == 0)
41775d7b4d43SMatthew Ahrens 			continue;
41785d7b4d43SMatthew Ahrens 		(void) printf("\n");
41795d7b4d43SMatthew Ahrens 		(void) printf("\tadditional, non-pointer bps of type %u: "
41805d7b4d43SMatthew Ahrens 		    "%10llu\n",
41815d7b4d43SMatthew Ahrens 		    i, (u_longlong_t)zcb.zcb_embedded_blocks[i]);
41825d7b4d43SMatthew Ahrens 
41835d7b4d43SMatthew Ahrens 		if (dump_opt['b'] >= 3) {
41845d7b4d43SMatthew Ahrens 			(void) printf("\t number of (compressed) bytes:  "
41855d7b4d43SMatthew Ahrens 			    "number of bps\n");
41865d7b4d43SMatthew Ahrens 			dump_histogram(zcb.zcb_embedded_histogram[i],
41875d7b4d43SMatthew Ahrens 			    sizeof (zcb.zcb_embedded_histogram[i]) /
41885d7b4d43SMatthew Ahrens 			    sizeof (zcb.zcb_embedded_histogram[i][0]), 0);
41895d7b4d43SMatthew Ahrens 		}
41905d7b4d43SMatthew Ahrens 	}
41915d7b4d43SMatthew Ahrens 
4192d5ee8a13SMatthew Ahrens 	if (tzb->zb_ditto_samevdev != 0) {
4193d5ee8a13SMatthew Ahrens 		(void) printf("\tDittoed blocks on same vdev: %llu\n",
4194d5ee8a13SMatthew Ahrens 		    (longlong_t)tzb->zb_ditto_samevdev);
4195d5ee8a13SMatthew Ahrens 	}
4196663207adSDon Brady 	if (tzb->zb_ditto_same_ms != 0) {
4197663207adSDon Brady 		(void) printf("\tDittoed blocks in same metaslab: %llu\n",
4198663207adSDon Brady 		    (longlong_t)tzb->zb_ditto_same_ms);
4199663207adSDon Brady 	}
4200d5ee8a13SMatthew Ahrens 
42015cabbc6bSPrashanth Sreenivasa 	for (uint64_t v = 0; v < spa->spa_root_vdev->vdev_children; v++) {
42025cabbc6bSPrashanth Sreenivasa 		vdev_t *vd = spa->spa_root_vdev->vdev_child[v];
42035cabbc6bSPrashanth Sreenivasa 		vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
42045cabbc6bSPrashanth Sreenivasa 
42055cabbc6bSPrashanth Sreenivasa 		if (vim == NULL) {
42065cabbc6bSPrashanth Sreenivasa 			continue;
42075cabbc6bSPrashanth Sreenivasa 		}
42085cabbc6bSPrashanth Sreenivasa 
42095cabbc6bSPrashanth Sreenivasa 		char mem[32];
42105cabbc6bSPrashanth Sreenivasa 		zdb_nicenum(vdev_indirect_mapping_num_entries(vim),
42115cabbc6bSPrashanth Sreenivasa 		    mem, vdev_indirect_mapping_size(vim));
42125cabbc6bSPrashanth Sreenivasa 
42135cabbc6bSPrashanth Sreenivasa 		(void) printf("\tindirect vdev id %llu has %llu segments "
42145cabbc6bSPrashanth Sreenivasa 		    "(%s in memory)\n",
42155cabbc6bSPrashanth Sreenivasa 		    (longlong_t)vd->vdev_id,
42165cabbc6bSPrashanth Sreenivasa 		    (longlong_t)vdev_indirect_mapping_num_entries(vim), mem);
42175cabbc6bSPrashanth Sreenivasa 	}
42185cabbc6bSPrashanth Sreenivasa 
4219fa9e4066Sahrens 	if (dump_opt['b'] >= 2) {
4220fa9e4066Sahrens 		int l, t, level;
4221fa9e4066Sahrens 		(void) printf("\nBlocks\tLSIZE\tPSIZE\tASIZE"
4222fa9e4066Sahrens 		    "\t  avg\t comp\t%%Total\tType\n");
4223fa9e4066Sahrens 
4224b24ab676SJeff Bonwick 		for (t = 0; t <= ZDB_OT_TOTAL; t++) {
42253f9d6ad7SLin Ling 			char csize[32], lsize[32], psize[32], asize[32];
4226d5ee8a13SMatthew Ahrens 			char avg[32], gang[32];
42273f7978d0SAlan Somers 			const char *typename;
4228fa9e4066Sahrens 
42290a055120SJason King 			/* make sure nicenum has enough space */
42300a055120SJason King 			CTASSERT(sizeof (csize) >= NN_NUMBUF_SZ);
42310a055120SJason King 			CTASSERT(sizeof (lsize) >= NN_NUMBUF_SZ);
42320a055120SJason King 			CTASSERT(sizeof (psize) >= NN_NUMBUF_SZ);
42330a055120SJason King 			CTASSERT(sizeof (asize) >= NN_NUMBUF_SZ);
42340a055120SJason King 			CTASSERT(sizeof (avg) >= NN_NUMBUF_SZ);
42350a055120SJason King 			CTASSERT(sizeof (gang) >= NN_NUMBUF_SZ);
42360a055120SJason King 
4237b24ab676SJeff Bonwick 			if (t < DMU_OT_NUMTYPES)
4238b24ab676SJeff Bonwick 				typename = dmu_ot[t].ot_name;
4239b24ab676SJeff Bonwick 			else
4240b24ab676SJeff Bonwick 				typename = zdb_ot_extname[t - DMU_OT_NUMTYPES];
4241fa9e4066Sahrens 
4242fa9e4066Sahrens 			if (zcb.zcb_type[ZB_TOTAL][t].zb_asize == 0) {
4243fa9e4066Sahrens 				(void) printf("%6s\t%5s\t%5s\t%5s"
4244fa9e4066Sahrens 				    "\t%5s\t%5s\t%6s\t%s\n",
4245fa9e4066Sahrens 				    "-",
4246fa9e4066Sahrens 				    "-",
4247fa9e4066Sahrens 				    "-",
4248fa9e4066Sahrens 				    "-",
4249fa9e4066Sahrens 				    "-",
4250fa9e4066Sahrens 				    "-",
4251fa9e4066Sahrens 				    "-",
4252fa9e4066Sahrens 				    typename);
4253fa9e4066Sahrens 				continue;
4254fa9e4066Sahrens 			}
4255fa9e4066Sahrens 
4256fa9e4066Sahrens 			for (l = ZB_TOTAL - 1; l >= -1; l--) {
4257fa9e4066Sahrens 				level = (l == -1 ? ZB_TOTAL : l);
4258fa9e4066Sahrens 				zb = &zcb.zcb_type[level][t];
4259fa9e4066Sahrens 
4260fa9e4066Sahrens 				if (zb->zb_asize == 0)
4261fa9e4066Sahrens 					continue;
4262fa9e4066Sahrens 
4263fa9e4066Sahrens 				if (dump_opt['b'] < 3 && level != ZB_TOTAL)
4264fa9e4066Sahrens 					continue;
4265fa9e4066Sahrens 
4266fa9e4066Sahrens 				if (level == 0 && zb->zb_asize ==
4267fa9e4066Sahrens 				    zcb.zcb_type[ZB_TOTAL][t].zb_asize)
4268fa9e4066Sahrens 					continue;
4269fa9e4066Sahrens 
42700a055120SJason King 				zdb_nicenum(zb->zb_count, csize,
42710a055120SJason King 				    sizeof (csize));
42720a055120SJason King 				zdb_nicenum(zb->zb_lsize, lsize,
42730a055120SJason King 				    sizeof (lsize));
42740a055120SJason King 				zdb_nicenum(zb->zb_psize, psize,
42750a055120SJason King 				    sizeof (psize));
42760a055120SJason King 				zdb_nicenum(zb->zb_asize, asize,
42770a055120SJason King 				    sizeof (asize));
42780a055120SJason King 				zdb_nicenum(zb->zb_asize / zb->zb_count, avg,
42790a055120SJason King 				    sizeof (avg));
42800a055120SJason King 				zdb_nicenum(zb->zb_gangs, gang, sizeof (gang));
4281fa9e4066Sahrens 
4282fa9e4066Sahrens 				(void) printf("%6s\t%5s\t%5s\t%5s\t%5s"
4283fa9e4066Sahrens 				    "\t%5.2f\t%6.2f\t",
4284fa9e4066Sahrens 				    csize, lsize, psize, asize, avg,
4285fa9e4066Sahrens 				    (double)zb->zb_lsize / zb->zb_psize,
4286fa9e4066Sahrens 				    100.0 * zb->zb_asize / tzb->zb_asize);
4287fa9e4066Sahrens 
4288fa9e4066Sahrens 				if (level == ZB_TOTAL)
4289fa9e4066Sahrens 					(void) printf("%s\n", typename);
4290fa9e4066Sahrens 				else
4291fa9e4066Sahrens 					(void) printf("    L%d %s\n",
4292fa9e4066Sahrens 					    level, typename);
4293490d05b9SMatthew Ahrens 
4294d5ee8a13SMatthew Ahrens 				if (dump_opt['b'] >= 3 && zb->zb_gangs > 0) {
4295d5ee8a13SMatthew Ahrens 					(void) printf("\t number of ganged "
4296d5ee8a13SMatthew Ahrens 					    "blocks: %s\n", gang);
4297d5ee8a13SMatthew Ahrens 				}
4298d5ee8a13SMatthew Ahrens 
4299490d05b9SMatthew Ahrens 				if (dump_opt['b'] >= 4) {
4300490d05b9SMatthew Ahrens 					(void) printf("psize "
4301490d05b9SMatthew Ahrens 					    "(in 512-byte sectors): "
4302490d05b9SMatthew Ahrens 					    "number of blocks\n");
4303490d05b9SMatthew Ahrens 					dump_histogram(zb->zb_psize_histogram,
43040713e232SGeorge Wilson 					    PSIZE_HISTO_SIZE, 0);
4305490d05b9SMatthew Ahrens 				}
4306fa9e4066Sahrens 			}
4307fa9e4066Sahrens 		}
4308fa9e4066Sahrens 	}
4309fa9e4066Sahrens 
4310fa9e4066Sahrens 	(void) printf("\n");
4311fa9e4066Sahrens 
4312fa9e4066Sahrens 	if (leaks)
4313fa9e4066Sahrens 		return (2);
4314fa9e4066Sahrens 
4315fa9e4066Sahrens 	if (zcb.zcb_haderrors)
4316fa9e4066Sahrens 		return (3);
4317fa9e4066Sahrens 
4318fa9e4066Sahrens 	return (0);
4319fa9e4066Sahrens }
4320fa9e4066Sahrens 
4321b24ab676SJeff Bonwick typedef struct zdb_ddt_entry {
4322b24ab676SJeff Bonwick 	ddt_key_t	zdde_key;
4323b24ab676SJeff Bonwick 	uint64_t	zdde_ref_blocks;
4324b24ab676SJeff Bonwick 	uint64_t	zdde_ref_lsize;
4325b24ab676SJeff Bonwick 	uint64_t	zdde_ref_psize;
4326b24ab676SJeff Bonwick 	uint64_t	zdde_ref_dsize;
4327b24ab676SJeff Bonwick 	avl_node_t	zdde_node;
4328b24ab676SJeff Bonwick } zdb_ddt_entry_t;
4329b24ab676SJeff Bonwick 
4330b24ab676SJeff Bonwick /* ARGSUSED */
4331b24ab676SJeff Bonwick static int
4332b24ab676SJeff Bonwick zdb_ddt_add_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
43337802d7bfSMatthew Ahrens     const zbookmark_phys_t *zb, const dnode_phys_t *dnp, void *arg)
4334b24ab676SJeff Bonwick {
4335b24ab676SJeff Bonwick 	avl_tree_t *t = arg;
4336b24ab676SJeff Bonwick 	avl_index_t where;
4337b24ab676SJeff Bonwick 	zdb_ddt_entry_t *zdde, zdde_search;
4338b24ab676SJeff Bonwick 
4339a2cdcdd2SPaul Dagnelie 	if (bp == NULL || BP_IS_HOLE(bp) || BP_IS_EMBEDDED(bp))
4340b24ab676SJeff Bonwick 		return (0);
4341b24ab676SJeff Bonwick 
4342b24ab676SJeff Bonwick 	if (dump_opt['S'] > 1 && zb->zb_level == ZB_ROOT_LEVEL) {
4343b24ab676SJeff Bonwick 		(void) printf("traversing objset %llu, %llu objects, "
4344b24ab676SJeff Bonwick 		    "%lu blocks so far\n",
4345b24ab676SJeff Bonwick 		    (u_longlong_t)zb->zb_objset,
43465d7b4d43SMatthew Ahrens 		    (u_longlong_t)BP_GET_FILL(bp),
4347b24ab676SJeff Bonwick 		    avl_numnodes(t));
4348b24ab676SJeff Bonwick 	}
4349b24ab676SJeff Bonwick 
4350bbfd46c4SJeff Bonwick 	if (BP_IS_HOLE(bp) || BP_GET_CHECKSUM(bp) == ZIO_CHECKSUM_OFF ||
4351ad135b5dSChristopher Siden 	    BP_GET_LEVEL(bp) > 0 || DMU_OT_IS_METADATA(BP_GET_TYPE(bp)))
4352b24ab676SJeff Bonwick 		return (0);
4353b24ab676SJeff Bonwick 
4354b24ab676SJeff Bonwick 	ddt_key_fill(&zdde_search.zdde_key, bp);
4355b24ab676SJeff Bonwick 
4356b24ab676SJeff Bonwick 	zdde = avl_find(t, &zdde_search, &where);
4357b24ab676SJeff Bonwick 
4358b24ab676SJeff Bonwick 	if (zdde == NULL) {
4359b24ab676SJeff Bonwick 		zdde = umem_zalloc(sizeof (*zdde), UMEM_NOFAIL);
4360b24ab676SJeff Bonwick 		zdde->zdde_key = zdde_search.zdde_key;
4361b24ab676SJeff Bonwick 		avl_insert(t, zdde, where);
4362b24ab676SJeff Bonwick 	}
4363b24ab676SJeff Bonwick 
4364b24ab676SJeff Bonwick 	zdde->zdde_ref_blocks += 1;
4365b24ab676SJeff Bonwick 	zdde->zdde_ref_lsize += BP_GET_LSIZE(bp);
4366b24ab676SJeff Bonwick 	zdde->zdde_ref_psize += BP_GET_PSIZE(bp);
4367b24ab676SJeff Bonwick 	zdde->zdde_ref_dsize += bp_get_dsize_sync(spa, bp);
4368b24ab676SJeff Bonwick 
4369b24ab676SJeff Bonwick 	return (0);
4370b24ab676SJeff Bonwick }
4371b24ab676SJeff Bonwick 
4372b24ab676SJeff Bonwick static void
4373b24ab676SJeff Bonwick dump_simulated_ddt(spa_t *spa)
4374b24ab676SJeff Bonwick {
4375b24ab676SJeff Bonwick 	avl_tree_t t;
4376b24ab676SJeff Bonwick 	void *cookie = NULL;
4377b24ab676SJeff Bonwick 	zdb_ddt_entry_t *zdde;
43783f7978d0SAlan Somers 	ddt_histogram_t ddh_total;
43793f7978d0SAlan Somers 	ddt_stat_t dds_total;
4380b24ab676SJeff Bonwick 
43813f7978d0SAlan Somers 	bzero(&ddh_total, sizeof (ddh_total));
43823f7978d0SAlan Somers 	bzero(&dds_total, sizeof (dds_total));
4383b24ab676SJeff Bonwick 	avl_create(&t, ddt_entry_compare,
4384b24ab676SJeff Bonwick 	    sizeof (zdb_ddt_entry_t), offsetof(zdb_ddt_entry_t, zdde_node));
4385b24ab676SJeff Bonwick 
4386b24ab676SJeff Bonwick 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
4387b24ab676SJeff Bonwick 
4388eb633035STom Caputi 	(void) traverse_pool(spa, 0, TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA |
4389eb633035STom Caputi 	    TRAVERSE_NO_DECRYPT, zdb_ddt_add_cb, &t);
4390b24ab676SJeff Bonwick 
4391b24ab676SJeff Bonwick 	spa_config_exit(spa, SCL_CONFIG, FTAG);
4392b24ab676SJeff Bonwick 
4393b24ab676SJeff Bonwick 	while ((zdde = avl_destroy_nodes(&t, &cookie)) != NULL) {
4394b24ab676SJeff Bonwick 		ddt_stat_t dds;
4395b24ab676SJeff Bonwick 		uint64_t refcnt = zdde->zdde_ref_blocks;
4396b24ab676SJeff Bonwick 		ASSERT(refcnt != 0);
4397b24ab676SJeff Bonwick 
4398b24ab676SJeff Bonwick 		dds.dds_blocks = zdde->zdde_ref_blocks / refcnt;
4399b24ab676SJeff Bonwick 		dds.dds_lsize = zdde->zdde_ref_lsize / refcnt;
4400b24ab676SJeff Bonwick 		dds.dds_psize = zdde->zdde_ref_psize / refcnt;
4401b24ab676SJeff Bonwick 		dds.dds_dsize = zdde->zdde_ref_dsize / refcnt;
4402b24ab676SJeff Bonwick 
4403b24ab676SJeff Bonwick 		dds.dds_ref_blocks = zdde->zdde_ref_blocks;
4404b24ab676SJeff Bonwick 		dds.dds_ref_lsize = zdde->zdde_ref_lsize;
4405b24ab676SJeff Bonwick 		dds.dds_ref_psize = zdde->zdde_ref_psize;
4406b24ab676SJeff Bonwick 		dds.dds_ref_dsize = zdde->zdde_ref_dsize;
4407b24ab676SJeff Bonwick 
4408bf16b11eSMatthew Ahrens 		ddt_stat_add(&ddh_total.ddh_stat[highbit64(refcnt) - 1],
4409bf16b11eSMatthew Ahrens 		    &dds, 0);
4410b24ab676SJeff Bonwick 
4411b24ab676SJeff Bonwick 		umem_free(zdde, sizeof (*zdde));
4412b24ab676SJeff Bonwick 	}
4413b24ab676SJeff Bonwick 
4414b24ab676SJeff Bonwick 	avl_destroy(&t);
4415b24ab676SJeff Bonwick 
4416b24ab676SJeff Bonwick 	ddt_histogram_stat(&dds_total, &ddh_total);
4417b24ab676SJeff Bonwick 
4418b24ab676SJeff Bonwick 	(void) printf("Simulated DDT histogram:\n");
4419b24ab676SJeff Bonwick 
44209eb19f4dSGeorge Wilson 	zpool_dump_ddt(&dds_total, &ddh_total);
4421b24ab676SJeff Bonwick 
4422b24ab676SJeff Bonwick 	dump_dedup_ratio(&dds_total);
4423b24ab676SJeff Bonwick }
4424b24ab676SJeff Bonwick 
44255cabbc6bSPrashanth Sreenivasa static int
44265cabbc6bSPrashanth Sreenivasa verify_device_removal_feature_counts(spa_t *spa)
44275cabbc6bSPrashanth Sreenivasa {
44285cabbc6bSPrashanth Sreenivasa 	uint64_t dr_feature_refcount = 0;
44295cabbc6bSPrashanth Sreenivasa 	uint64_t oc_feature_refcount = 0;
44305cabbc6bSPrashanth Sreenivasa 	uint64_t indirect_vdev_count = 0;
44315cabbc6bSPrashanth Sreenivasa 	uint64_t precise_vdev_count = 0;
44325cabbc6bSPrashanth Sreenivasa 	uint64_t obsolete_counts_object_count = 0;
44335cabbc6bSPrashanth Sreenivasa 	uint64_t obsolete_sm_count = 0;
44345cabbc6bSPrashanth Sreenivasa 	uint64_t obsolete_counts_count = 0;
44355cabbc6bSPrashanth Sreenivasa 	uint64_t scip_count = 0;
44365cabbc6bSPrashanth Sreenivasa 	uint64_t obsolete_bpobj_count = 0;
44375cabbc6bSPrashanth Sreenivasa 	int ret = 0;
44385cabbc6bSPrashanth Sreenivasa 
44395cabbc6bSPrashanth Sreenivasa 	spa_condensing_indirect_phys_t *scip =
44405cabbc6bSPrashanth Sreenivasa 	    &spa->spa_condensing_indirect_phys;
44415cabbc6bSPrashanth Sreenivasa 	if (scip->scip_next_mapping_object != 0) {
44425cabbc6bSPrashanth Sreenivasa 		vdev_t *vd = spa->spa_root_vdev->vdev_child[scip->scip_vdev];
44435cabbc6bSPrashanth Sreenivasa 		ASSERT(scip->scip_prev_obsolete_sm_object != 0);
44445cabbc6bSPrashanth Sreenivasa 		ASSERT3P(vd->vdev_ops, ==, &vdev_indirect_ops);
44455cabbc6bSPrashanth Sreenivasa 
44465cabbc6bSPrashanth Sreenivasa 		(void) printf("Condensing indirect vdev %llu: new mapping "
44475cabbc6bSPrashanth Sreenivasa 		    "object %llu, prev obsolete sm %llu\n",
44485cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)scip->scip_vdev,
44495cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)scip->scip_next_mapping_object,
44505cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)scip->scip_prev_obsolete_sm_object);
44515cabbc6bSPrashanth Sreenivasa 		if (scip->scip_prev_obsolete_sm_object != 0) {
44525cabbc6bSPrashanth Sreenivasa 			space_map_t *prev_obsolete_sm = NULL;
44535cabbc6bSPrashanth Sreenivasa 			VERIFY0(space_map_open(&prev_obsolete_sm,
44545cabbc6bSPrashanth Sreenivasa 			    spa->spa_meta_objset,
44555cabbc6bSPrashanth Sreenivasa 			    scip->scip_prev_obsolete_sm_object,
44565cabbc6bSPrashanth Sreenivasa 			    0, vd->vdev_asize, 0));
44575cabbc6bSPrashanth Sreenivasa 			dump_spacemap(spa->spa_meta_objset, prev_obsolete_sm);
44585cabbc6bSPrashanth Sreenivasa 			(void) printf("\n");
44595cabbc6bSPrashanth Sreenivasa 			space_map_close(prev_obsolete_sm);
44605cabbc6bSPrashanth Sreenivasa 		}
44615cabbc6bSPrashanth Sreenivasa 
44625cabbc6bSPrashanth Sreenivasa 		scip_count += 2;
44635cabbc6bSPrashanth Sreenivasa 	}
44645cabbc6bSPrashanth Sreenivasa 
44655cabbc6bSPrashanth Sreenivasa 	for (uint64_t i = 0; i < spa->spa_root_vdev->vdev_children; i++) {
44665cabbc6bSPrashanth Sreenivasa 		vdev_t *vd = spa->spa_root_vdev->vdev_child[i];
44675cabbc6bSPrashanth Sreenivasa 		vdev_indirect_config_t *vic = &vd->vdev_indirect_config;
44685cabbc6bSPrashanth Sreenivasa 
44695cabbc6bSPrashanth Sreenivasa 		if (vic->vic_mapping_object != 0) {
44705cabbc6bSPrashanth Sreenivasa 			ASSERT(vd->vdev_ops == &vdev_indirect_ops ||
44715cabbc6bSPrashanth Sreenivasa 			    vd->vdev_removing);
44725cabbc6bSPrashanth Sreenivasa 			indirect_vdev_count++;
44735cabbc6bSPrashanth Sreenivasa 
44745cabbc6bSPrashanth Sreenivasa 			if (vd->vdev_indirect_mapping->vim_havecounts) {
44755cabbc6bSPrashanth Sreenivasa 				obsolete_counts_count++;
44765cabbc6bSPrashanth Sreenivasa 			}
44775cabbc6bSPrashanth Sreenivasa 		}
44785cabbc6bSPrashanth Sreenivasa 		if (vdev_obsolete_counts_are_precise(vd)) {
44795cabbc6bSPrashanth Sreenivasa 			ASSERT(vic->vic_mapping_object != 0);
44805cabbc6bSPrashanth Sreenivasa 			precise_vdev_count++;
44815cabbc6bSPrashanth Sreenivasa 		}
44825cabbc6bSPrashanth Sreenivasa 		if (vdev_obsolete_sm_object(vd) != 0) {
44835cabbc6bSPrashanth Sreenivasa 			ASSERT(vic->vic_mapping_object != 0);
44845cabbc6bSPrashanth Sreenivasa 			obsolete_sm_count++;
44855cabbc6bSPrashanth Sreenivasa 		}
44865cabbc6bSPrashanth Sreenivasa 	}
44875cabbc6bSPrashanth Sreenivasa 
44885cabbc6bSPrashanth Sreenivasa 	(void) feature_get_refcount(spa,
44895cabbc6bSPrashanth Sreenivasa 	    &spa_feature_table[SPA_FEATURE_DEVICE_REMOVAL],
44905cabbc6bSPrashanth Sreenivasa 	    &dr_feature_refcount);
44915cabbc6bSPrashanth Sreenivasa 	(void) feature_get_refcount(spa,
44925cabbc6bSPrashanth Sreenivasa 	    &spa_feature_table[SPA_FEATURE_OBSOLETE_COUNTS],
44935cabbc6bSPrashanth Sreenivasa 	    &oc_feature_refcount);
44945cabbc6bSPrashanth Sreenivasa 
44955cabbc6bSPrashanth Sreenivasa 	if (dr_feature_refcount != indirect_vdev_count) {
44965cabbc6bSPrashanth Sreenivasa 		ret = 1;
44975cabbc6bSPrashanth Sreenivasa 		(void) printf("Number of indirect vdevs (%llu) " \
44985cabbc6bSPrashanth Sreenivasa 		    "does not match feature count (%llu)\n",
44995cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)indirect_vdev_count,
45005cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)dr_feature_refcount);
45015cabbc6bSPrashanth Sreenivasa 	} else {
45025cabbc6bSPrashanth Sreenivasa 		(void) printf("Verified device_removal feature refcount " \
45035cabbc6bSPrashanth Sreenivasa 		    "of %llu is correct\n",
45045cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)dr_feature_refcount);
45055cabbc6bSPrashanth Sreenivasa 	}
45065cabbc6bSPrashanth Sreenivasa 
45075cabbc6bSPrashanth Sreenivasa 	if (zap_contains(spa_meta_objset(spa), DMU_POOL_DIRECTORY_OBJECT,
45085cabbc6bSPrashanth Sreenivasa 	    DMU_POOL_OBSOLETE_BPOBJ) == 0) {
45095cabbc6bSPrashanth Sreenivasa 		obsolete_bpobj_count++;
45105cabbc6bSPrashanth Sreenivasa 	}
45115cabbc6bSPrashanth Sreenivasa 
45125cabbc6bSPrashanth Sreenivasa 
45135cabbc6bSPrashanth Sreenivasa 	obsolete_counts_object_count = precise_vdev_count;
45145cabbc6bSPrashanth Sreenivasa 	obsolete_counts_object_count += obsolete_sm_count;
45155cabbc6bSPrashanth Sreenivasa 	obsolete_counts_object_count += obsolete_counts_count;
45165cabbc6bSPrashanth Sreenivasa 	obsolete_counts_object_count += scip_count;
45175cabbc6bSPrashanth Sreenivasa 	obsolete_counts_object_count += obsolete_bpobj_count;
45185cabbc6bSPrashanth Sreenivasa 	obsolete_counts_object_count += remap_deadlist_count;
45195cabbc6bSPrashanth Sreenivasa 
45205cabbc6bSPrashanth Sreenivasa 	if (oc_feature_refcount != obsolete_counts_object_count) {
45215cabbc6bSPrashanth Sreenivasa 		ret = 1;
45225cabbc6bSPrashanth Sreenivasa 		(void) printf("Number of obsolete counts objects (%llu) " \
45235cabbc6bSPrashanth Sreenivasa 		    "does not match feature count (%llu)\n",
45245cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)obsolete_counts_object_count,
45255cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)oc_feature_refcount);
45265cabbc6bSPrashanth Sreenivasa 		(void) printf("pv:%llu os:%llu oc:%llu sc:%llu "
45275cabbc6bSPrashanth Sreenivasa 		    "ob:%llu rd:%llu\n",
45285cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)precise_vdev_count,
45295cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)obsolete_sm_count,
45305cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)obsolete_counts_count,
45315cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)scip_count,
45325cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)obsolete_bpobj_count,
45335cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)remap_deadlist_count);
45345cabbc6bSPrashanth Sreenivasa 	} else {
45355cabbc6bSPrashanth Sreenivasa 		(void) printf("Verified indirect_refcount feature refcount " \
45365cabbc6bSPrashanth Sreenivasa 		    "of %llu is correct\n",
45375cabbc6bSPrashanth Sreenivasa 		    (u_longlong_t)oc_feature_refcount);
45385cabbc6bSPrashanth Sreenivasa 	}
45395cabbc6bSPrashanth Sreenivasa 	return (ret);
45405cabbc6bSPrashanth Sreenivasa }
45415cabbc6bSPrashanth Sreenivasa 
4542e0f1c0afSOlaf Faaland static void
4543e0f1c0afSOlaf Faaland zdb_set_skip_mmp(char *target)
4544e0f1c0afSOlaf Faaland {
4545e0f1c0afSOlaf Faaland 	spa_t *spa;
4546e0f1c0afSOlaf Faaland 
4547e0f1c0afSOlaf Faaland 	/*
4548e0f1c0afSOlaf Faaland 	 * Disable the activity check to allow examination of
4549e0f1c0afSOlaf Faaland 	 * active pools.
4550e0f1c0afSOlaf Faaland 	 */
4551e0f1c0afSOlaf Faaland 	mutex_enter(&spa_namespace_lock);
4552e0f1c0afSOlaf Faaland 	if ((spa = spa_lookup(target)) != NULL) {
4553e0f1c0afSOlaf Faaland 		spa->spa_import_flags |= ZFS_IMPORT_SKIP_MMP;
4554e0f1c0afSOlaf Faaland 	}
4555e0f1c0afSOlaf Faaland 	mutex_exit(&spa_namespace_lock);
4556e0f1c0afSOlaf Faaland }
4557e0f1c0afSOlaf Faaland 
455886714001SSerapheim Dimitropoulos #define	BOGUS_SUFFIX "_CHECKPOINTED_UNIVERSE"
455986714001SSerapheim Dimitropoulos /*
456086714001SSerapheim Dimitropoulos  * Import the checkpointed state of the pool specified by the target
456186714001SSerapheim Dimitropoulos  * parameter as readonly. The function also accepts a pool config
456286714001SSerapheim Dimitropoulos  * as an optional parameter, else it attempts to infer the config by
456386714001SSerapheim Dimitropoulos  * the name of the target pool.
456486714001SSerapheim Dimitropoulos  *
456586714001SSerapheim Dimitropoulos  * Note that the checkpointed state's pool name will be the name of
456686714001SSerapheim Dimitropoulos  * the original pool with the above suffix appened to it. In addition,
456786714001SSerapheim Dimitropoulos  * if the target is not a pool name (e.g. a path to a dataset) then
456886714001SSerapheim Dimitropoulos  * the new_path parameter is populated with the updated path to
456986714001SSerapheim Dimitropoulos  * reflect the fact that we are looking into the checkpointed state.
457086714001SSerapheim Dimitropoulos  *
457186714001SSerapheim Dimitropoulos  * The function returns a newly-allocated copy of the name of the
457286714001SSerapheim Dimitropoulos  * pool containing the checkpointed state. When this copy is no
457386714001SSerapheim Dimitropoulos  * longer needed it should be freed with free(3C). Same thing
457486714001SSerapheim Dimitropoulos  * applies to the new_path parameter if allocated.
457586714001SSerapheim Dimitropoulos  */
457686714001SSerapheim Dimitropoulos static char *
457786714001SSerapheim Dimitropoulos import_checkpointed_state(char *target, nvlist_t *cfg, char **new_path)
457886714001SSerapheim Dimitropoulos {
457986714001SSerapheim Dimitropoulos 	int error = 0;
458086714001SSerapheim Dimitropoulos 	char *poolname, *bogus_name;
458186714001SSerapheim Dimitropoulos 
458286714001SSerapheim Dimitropoulos 	/* If the target is not a pool, the extract the pool name */
458386714001SSerapheim Dimitropoulos 	char *path_start = strchr(target, '/');
458486714001SSerapheim Dimitropoulos 	if (path_start != NULL) {
458586714001SSerapheim Dimitropoulos 		size_t poolname_len = path_start - target;
458686714001SSerapheim Dimitropoulos 		poolname = strndup(target, poolname_len);
458786714001SSerapheim Dimitropoulos 	} else {
458886714001SSerapheim Dimitropoulos 		poolname = target;
458986714001SSerapheim Dimitropoulos 	}
459086714001SSerapheim Dimitropoulos 
459186714001SSerapheim Dimitropoulos 	if (cfg == NULL) {
4592e0f1c0afSOlaf Faaland 		zdb_set_skip_mmp(poolname);
459386714001SSerapheim Dimitropoulos 		error = spa_get_stats(poolname, &cfg, NULL, 0);
459486714001SSerapheim Dimitropoulos 		if (error != 0) {
459586714001SSerapheim Dimitropoulos 			fatal("Tried to read config of pool \"%s\" but "
459686714001SSerapheim Dimitropoulos 			    "spa_get_stats() failed with error %d\n",
459786714001SSerapheim Dimitropoulos 			    poolname, error);
459886714001SSerapheim Dimitropoulos 		}
459986714001SSerapheim Dimitropoulos 	}
460086714001SSerapheim Dimitropoulos 
460186714001SSerapheim Dimitropoulos 	(void) asprintf(&bogus_name, "%s%s", poolname, BOGUS_SUFFIX);
460286714001SSerapheim Dimitropoulos 	fnvlist_add_string(cfg, ZPOOL_CONFIG_POOL_NAME, bogus_name);
460386714001SSerapheim Dimitropoulos 
460486714001SSerapheim Dimitropoulos 	error = spa_import(bogus_name, cfg, NULL,
4605e0f1c0afSOlaf Faaland 	    ZFS_IMPORT_MISSING_LOG | ZFS_IMPORT_CHECKPOINT |
4606e0f1c0afSOlaf Faaland 	    ZFS_IMPORT_SKIP_MMP);
460786714001SSerapheim Dimitropoulos 	if (error != 0) {
460886714001SSerapheim Dimitropoulos 		fatal("Tried to import pool \"%s\" but spa_import() failed "
460986714001SSerapheim Dimitropoulos 		    "with error %d\n", bogus_name, error);
461086714001SSerapheim Dimitropoulos 	}
461186714001SSerapheim Dimitropoulos 
461286714001SSerapheim Dimitropoulos 	if (new_path != NULL && path_start != NULL)
461386714001SSerapheim Dimitropoulos 		(void) asprintf(new_path, "%s%s", bogus_name, path_start);
461486714001SSerapheim Dimitropoulos 
461586714001SSerapheim Dimitropoulos 	if (target != poolname)
461686714001SSerapheim Dimitropoulos 		free(poolname);
461786714001SSerapheim Dimitropoulos 
461886714001SSerapheim Dimitropoulos 	return (bogus_name);
461986714001SSerapheim Dimitropoulos }
462086714001SSerapheim Dimitropoulos 
462186714001SSerapheim Dimitropoulos typedef struct verify_checkpoint_sm_entry_cb_arg {
462286714001SSerapheim Dimitropoulos 	vdev_t *vcsec_vd;
462386714001SSerapheim Dimitropoulos 
462486714001SSerapheim Dimitropoulos 	/* the following fields are only used for printing progress */
462586714001SSerapheim Dimitropoulos 	uint64_t vcsec_entryid;
462686714001SSerapheim Dimitropoulos 	uint64_t vcsec_num_entries;
462786714001SSerapheim Dimitropoulos } verify_checkpoint_sm_entry_cb_arg_t;
462886714001SSerapheim Dimitropoulos 
462986714001SSerapheim Dimitropoulos #define	ENTRIES_PER_PROGRESS_UPDATE 10000
463086714001SSerapheim Dimitropoulos 
463186714001SSerapheim Dimitropoulos static int
463217f11284SSerapheim Dimitropoulos verify_checkpoint_sm_entry_cb(space_map_entry_t *sme, void *arg)
463386714001SSerapheim Dimitropoulos {
463486714001SSerapheim Dimitropoulos 	verify_checkpoint_sm_entry_cb_arg_t *vcsec = arg;
463586714001SSerapheim Dimitropoulos 	vdev_t *vd = vcsec->vcsec_vd;
463617f11284SSerapheim Dimitropoulos 	metaslab_t *ms = vd->vdev_ms[sme->sme_offset >> vd->vdev_ms_shift];
463717f11284SSerapheim Dimitropoulos 	uint64_t end = sme->sme_offset + sme->sme_run;
463886714001SSerapheim Dimitropoulos 
463917f11284SSerapheim Dimitropoulos 	ASSERT(sme->sme_type == SM_FREE);
464086714001SSerapheim Dimitropoulos 
464186714001SSerapheim Dimitropoulos 	if ((vcsec->vcsec_entryid % ENTRIES_PER_PROGRESS_UPDATE) == 0) {
464286714001SSerapheim Dimitropoulos 		(void) fprintf(stderr,
464386714001SSerapheim Dimitropoulos 		    "\rverifying vdev %llu, space map entry %llu of %llu ...",
464486714001SSerapheim Dimitropoulos 		    (longlong_t)vd->vdev_id,
464586714001SSerapheim Dimitropoulos 		    (longlong_t)vcsec->vcsec_entryid,
464686714001SSerapheim Dimitropoulos 		    (longlong_t)vcsec->vcsec_num_entries);
464786714001SSerapheim Dimitropoulos 	}
464886714001SSerapheim Dimitropoulos 	vcsec->vcsec_entryid++;
464986714001SSerapheim Dimitropoulos 
465086714001SSerapheim Dimitropoulos 	/*
465186714001SSerapheim Dimitropoulos 	 * See comment in checkpoint_sm_exclude_entry_cb()
465286714001SSerapheim Dimitropoulos 	 */
465317f11284SSerapheim Dimitropoulos 	VERIFY3U(sme->sme_offset, >=, ms->ms_start);
465486714001SSerapheim Dimitropoulos 	VERIFY3U(end, <=, ms->ms_start + ms->ms_size);
465586714001SSerapheim Dimitropoulos 
465686714001SSerapheim Dimitropoulos 	/*
465786714001SSerapheim Dimitropoulos 	 * The entries in the vdev_checkpoint_sm should be marked as
465886714001SSerapheim Dimitropoulos 	 * allocated in the checkpointed state of the pool, therefore
465986714001SSerapheim Dimitropoulos 	 * their respective ms_allocateable trees should not contain them.
466086714001SSerapheim Dimitropoulos 	 */
466186714001SSerapheim Dimitropoulos 	mutex_enter(&ms->ms_lock);
4662555d674dSSerapheim Dimitropoulos 	range_tree_verify_not_present(ms->ms_allocatable,
4663555d674dSSerapheim Dimitropoulos 	    sme->sme_offset, sme->sme_run);
466486714001SSerapheim Dimitropoulos 	mutex_exit(&ms->ms_lock);
466586714001SSerapheim Dimitropoulos 
466686714001SSerapheim Dimitropoulos 	return (0);
466786714001SSerapheim Dimitropoulos }
466886714001SSerapheim Dimitropoulos 
466986714001SSerapheim Dimitropoulos /*
467086714001SSerapheim Dimitropoulos  * Verify that all segments in the vdev_checkpoint_sm are allocated
467186714001SSerapheim Dimitropoulos  * according to the checkpoint's ms_sm (i.e. are not in the checkpoint's
467286714001SSerapheim Dimitropoulos  * ms_allocatable).
467386714001SSerapheim Dimitropoulos  *
467486714001SSerapheim Dimitropoulos  * Do so by comparing the checkpoint space maps (vdev_checkpoint_sm) of
467586714001SSerapheim Dimitropoulos  * each vdev in the current state of the pool to the metaslab space maps
467686714001SSerapheim Dimitropoulos  * (ms_sm) of the checkpointed state of the pool.
467786714001SSerapheim Dimitropoulos  *
467886714001SSerapheim Dimitropoulos  * Note that the function changes the state of the ms_allocatable
467986714001SSerapheim Dimitropoulos  * trees of the current spa_t. The entries of these ms_allocatable
468086714001SSerapheim Dimitropoulos  * trees are cleared out and then repopulated from with the free
468186714001SSerapheim Dimitropoulos  * entries of their respective ms_sm space maps.
468286714001SSerapheim Dimitropoulos  */
468386714001SSerapheim Dimitropoulos static void
468486714001SSerapheim Dimitropoulos verify_checkpoint_vdev_spacemaps(spa_t *checkpoint, spa_t *current)
468586714001SSerapheim Dimitropoulos {
468686714001SSerapheim Dimitropoulos 	vdev_t *ckpoint_rvd = checkpoint->spa_root_vdev;
468786714001SSerapheim Dimitropoulos 	vdev_t *current_rvd = current->spa_root_vdev;
468886714001SSerapheim Dimitropoulos 
468986714001SSerapheim Dimitropoulos 	load_concrete_ms_allocatable_trees(checkpoint, SM_FREE);
469086714001SSerapheim Dimitropoulos 
469186714001SSerapheim Dimitropoulos 	for (uint64_t c = 0; c < ckpoint_rvd->vdev_children; c++) {
469286714001SSerapheim Dimitropoulos 		vdev_t *ckpoint_vd = ckpoint_rvd->vdev_child[c];
469386714001SSerapheim Dimitropoulos 		vdev_t *current_vd = current_rvd->vdev_child[c];
469486714001SSerapheim Dimitropoulos 
469586714001SSerapheim Dimitropoulos 		space_map_t *checkpoint_sm = NULL;
469686714001SSerapheim Dimitropoulos 		uint64_t checkpoint_sm_obj;
469786714001SSerapheim Dimitropoulos 
469886714001SSerapheim Dimitropoulos 		if (ckpoint_vd->vdev_ops == &vdev_indirect_ops) {
469986714001SSerapheim Dimitropoulos 			/*
470086714001SSerapheim Dimitropoulos 			 * Since we don't allow device removal in a pool
470186714001SSerapheim Dimitropoulos 			 * that has a checkpoint, we expect that all removed
470286714001SSerapheim Dimitropoulos 			 * vdevs were removed from the pool before the
470386714001SSerapheim Dimitropoulos 			 * checkpoint.
470486714001SSerapheim Dimitropoulos 			 */
470586714001SSerapheim Dimitropoulos 			ASSERT3P(current_vd->vdev_ops, ==, &vdev_indirect_ops);
470686714001SSerapheim Dimitropoulos 			continue;
470786714001SSerapheim Dimitropoulos 		}
470886714001SSerapheim Dimitropoulos 
470986714001SSerapheim Dimitropoulos 		/*
471086714001SSerapheim Dimitropoulos 		 * If the checkpoint space map doesn't exist, then nothing
471186714001SSerapheim Dimitropoulos 		 * here is checkpointed so there's nothing to verify.
471286714001SSerapheim Dimitropoulos 		 */
471386714001SSerapheim Dimitropoulos 		if (current_vd->vdev_top_zap == 0 ||
471486714001SSerapheim Dimitropoulos 		    zap_contains(spa_meta_objset(current),
471586714001SSerapheim Dimitropoulos 		    current_vd->vdev_top_zap,
471686714001SSerapheim Dimitropoulos 		    VDEV_TOP_ZAP_POOL_CHECKPOINT_SM) != 0)
471786714001SSerapheim Dimitropoulos 			continue;
471886714001SSerapheim Dimitropoulos 
471986714001SSerapheim Dimitropoulos 		VERIFY0(zap_lookup(spa_meta_objset(current),
472086714001SSerapheim Dimitropoulos 		    current_vd->vdev_top_zap, VDEV_TOP_ZAP_POOL_CHECKPOINT_SM,
472186714001SSerapheim Dimitropoulos 		    sizeof (uint64_t), 1, &checkpoint_sm_obj));
472286714001SSerapheim Dimitropoulos 
472386714001SSerapheim Dimitropoulos 		VERIFY0(space_map_open(&checkpoint_sm, spa_meta_objset(current),
472486714001SSerapheim Dimitropoulos 		    checkpoint_sm_obj, 0, current_vd->vdev_asize,
472586714001SSerapheim Dimitropoulos 		    current_vd->vdev_ashift));
472686714001SSerapheim Dimitropoulos 
472786714001SSerapheim Dimitropoulos 		verify_checkpoint_sm_entry_cb_arg_t vcsec;
472886714001SSerapheim Dimitropoulos 		vcsec.vcsec_vd = ckpoint_vd;
472986714001SSerapheim Dimitropoulos 		vcsec.vcsec_entryid = 0;
473086714001SSerapheim Dimitropoulos 		vcsec.vcsec_num_entries =
473186714001SSerapheim Dimitropoulos 		    space_map_length(checkpoint_sm) / sizeof (uint64_t);
473286714001SSerapheim Dimitropoulos 		VERIFY0(space_map_iterate(checkpoint_sm,
4733555d674dSSerapheim Dimitropoulos 		    space_map_length(checkpoint_sm),
473486714001SSerapheim Dimitropoulos 		    verify_checkpoint_sm_entry_cb, &vcsec));
473586714001SSerapheim Dimitropoulos 		dump_spacemap(current->spa_meta_objset, checkpoint_sm);
473686714001SSerapheim Dimitropoulos 		space_map_close(checkpoint_sm);
473786714001SSerapheim Dimitropoulos 	}
473886714001SSerapheim Dimitropoulos 
473986714001SSerapheim Dimitropoulos 	/*
474086714001SSerapheim Dimitropoulos 	 * If we've added vdevs since we took the checkpoint, ensure
474186714001SSerapheim Dimitropoulos 	 * that their checkpoint space maps are empty.
474286714001SSerapheim Dimitropoulos 	 */
474386714001SSerapheim Dimitropoulos 	if (ckpoint_rvd->vdev_children < current_rvd->vdev_children) {
474486714001SSerapheim Dimitropoulos 		for (uint64_t c = ckpoint_rvd->vdev_children;
474586714001SSerapheim Dimitropoulos 		    c < current_rvd->vdev_children; c++) {
474686714001SSerapheim Dimitropoulos 			vdev_t *current_vd = current_rvd->vdev_child[c];
474786714001SSerapheim Dimitropoulos 			ASSERT3P(current_vd->vdev_checkpoint_sm, ==, NULL);
474886714001SSerapheim Dimitropoulos 		}
474986714001SSerapheim Dimitropoulos 	}
475086714001SSerapheim Dimitropoulos 
475186714001SSerapheim Dimitropoulos 	/* for cleaner progress output */
475286714001SSerapheim Dimitropoulos 	(void) fprintf(stderr, "\n");
475386714001SSerapheim Dimitropoulos }
475486714001SSerapheim Dimitropoulos 
475586714001SSerapheim Dimitropoulos /*
475686714001SSerapheim Dimitropoulos  * Verifies that all space that's allocated in the checkpoint is
475786714001SSerapheim Dimitropoulos  * still allocated in the current version, by checking that everything
475886714001SSerapheim Dimitropoulos  * in checkpoint's ms_allocatable (which is actually allocated, not
475986714001SSerapheim Dimitropoulos  * allocatable/free) is not present in current's ms_allocatable.
476086714001SSerapheim Dimitropoulos  *
476186714001SSerapheim Dimitropoulos  * Note that the function changes the state of the ms_allocatable
476286714001SSerapheim Dimitropoulos  * trees of both spas when called. The entries of all ms_allocatable
476386714001SSerapheim Dimitropoulos  * trees are cleared out and then repopulated from their respective
476486714001SSerapheim Dimitropoulos  * ms_sm space maps. In the checkpointed state we load the allocated
476586714001SSerapheim Dimitropoulos  * entries, and in the current state we load the free entries.
476686714001SSerapheim Dimitropoulos  */
476786714001SSerapheim Dimitropoulos static void
476886714001SSerapheim Dimitropoulos verify_checkpoint_ms_spacemaps(spa_t *checkpoint, spa_t *current)
476986714001SSerapheim Dimitropoulos {
477086714001SSerapheim Dimitropoulos 	vdev_t *ckpoint_rvd = checkpoint->spa_root_vdev;
477186714001SSerapheim Dimitropoulos 	vdev_t *current_rvd = current->spa_root_vdev;
477286714001SSerapheim Dimitropoulos 
477386714001SSerapheim Dimitropoulos 	load_concrete_ms_allocatable_trees(checkpoint, SM_ALLOC);
477486714001SSerapheim Dimitropoulos 	load_concrete_ms_allocatable_trees(current, SM_FREE);
477586714001SSerapheim Dimitropoulos 
477686714001SSerapheim Dimitropoulos 	for (uint64_t i = 0; i < ckpoint_rvd->vdev_children; i++) {
477786714001SSerapheim Dimitropoulos 		vdev_t *ckpoint_vd = ckpoint_rvd->vdev_child[i];
477886714001SSerapheim Dimitropoulos 		vdev_t *current_vd = current_rvd->vdev_child[i];
477986714001SSerapheim Dimitropoulos 
478086714001SSerapheim Dimitropoulos 		if (ckpoint_vd->vdev_ops == &vdev_indirect_ops) {
478186714001SSerapheim Dimitropoulos 			/*
478286714001SSerapheim Dimitropoulos 			 * See comment in verify_checkpoint_vdev_spacemaps()
478386714001SSerapheim Dimitropoulos 			 */
478486714001SSerapheim Dimitropoulos 			ASSERT3P(current_vd->vdev_ops, ==, &vdev_indirect_ops);
478586714001SSerapheim Dimitropoulos 			continue;
478686714001SSerapheim Dimitropoulos 		}
478786714001SSerapheim Dimitropoulos 
478886714001SSerapheim Dimitropoulos 		for (uint64_t m = 0; m < ckpoint_vd->vdev_ms_count; m++) {
478986714001SSerapheim Dimitropoulos 			metaslab_t *ckpoint_msp = ckpoint_vd->vdev_ms[m];
479086714001SSerapheim Dimitropoulos 			metaslab_t *current_msp = current_vd->vdev_ms[m];
479186714001SSerapheim Dimitropoulos 
479286714001SSerapheim Dimitropoulos 			(void) fprintf(stderr,
479386714001SSerapheim Dimitropoulos 			    "\rverifying vdev %llu of %llu, "
479486714001SSerapheim Dimitropoulos 			    "metaslab %llu of %llu ...",
479586714001SSerapheim Dimitropoulos 			    (longlong_t)current_vd->vdev_id,
479686714001SSerapheim Dimitropoulos 			    (longlong_t)current_rvd->vdev_children,
479786714001SSerapheim Dimitropoulos 			    (longlong_t)current_vd->vdev_ms[m]->ms_id,
479886714001SSerapheim Dimitropoulos 			    (longlong_t)current_vd->vdev_ms_count);
479986714001SSerapheim Dimitropoulos 
480086714001SSerapheim Dimitropoulos 			/*
480186714001SSerapheim Dimitropoulos 			 * We walk through the ms_allocatable trees that
480286714001SSerapheim Dimitropoulos 			 * are loaded with the allocated blocks from the
480386714001SSerapheim Dimitropoulos 			 * ms_sm spacemaps of the checkpoint. For each
480486714001SSerapheim Dimitropoulos 			 * one of these ranges we ensure that none of them
480586714001SSerapheim Dimitropoulos 			 * exists in the ms_allocatable trees of the
480686714001SSerapheim Dimitropoulos 			 * current state which are loaded with the ranges
480786714001SSerapheim Dimitropoulos 			 * that are currently free.
480886714001SSerapheim Dimitropoulos 			 *
480986714001SSerapheim Dimitropoulos 			 * This way we ensure that none of the blocks that
481086714001SSerapheim Dimitropoulos 			 * are part of the checkpoint were freed by mistake.
481186714001SSerapheim Dimitropoulos 			 */
481286714001SSerapheim Dimitropoulos 			range_tree_walk(ckpoint_msp->ms_allocatable,
4813555d674dSSerapheim Dimitropoulos 			    (range_tree_func_t *)range_tree_verify_not_present,
481486714001SSerapheim Dimitropoulos 			    current_msp->ms_allocatable);
481586714001SSerapheim Dimitropoulos 		}
481686714001SSerapheim Dimitropoulos 	}
481786714001SSerapheim Dimitropoulos 
481886714001SSerapheim Dimitropoulos 	/* for cleaner progress output */
481986714001SSerapheim Dimitropoulos 	(void) fprintf(stderr, "\n");
482086714001SSerapheim Dimitropoulos }
482186714001SSerapheim Dimitropoulos 
482286714001SSerapheim Dimitropoulos static void
482386714001SSerapheim Dimitropoulos verify_checkpoint_blocks(spa_t *spa)
482486714001SSerapheim Dimitropoulos {
4825555d674dSSerapheim Dimitropoulos 	ASSERT(!dump_opt['L']);
4826555d674dSSerapheim Dimitropoulos 
482786714001SSerapheim Dimitropoulos 	spa_t *checkpoint_spa;
482886714001SSerapheim Dimitropoulos 	char *checkpoint_pool;
482986714001SSerapheim Dimitropoulos 	nvlist_t *config = NULL;
483086714001SSerapheim Dimitropoulos 	int error = 0;
483186714001SSerapheim Dimitropoulos 
483286714001SSerapheim Dimitropoulos 	/*
483386714001SSerapheim Dimitropoulos 	 * We import the checkpointed state of the pool (under a different
483486714001SSerapheim Dimitropoulos 	 * name) so we can do verification on it against the current state
483586714001SSerapheim Dimitropoulos 	 * of the pool.
483686714001SSerapheim Dimitropoulos 	 */
483786714001SSerapheim Dimitropoulos 	checkpoint_pool = import_checkpointed_state(spa->spa_name, config,
483886714001SSerapheim Dimitropoulos 	    NULL);
483986714001SSerapheim Dimitropoulos 	ASSERT(strcmp(spa->spa_name, checkpoint_pool) != 0);
484086714001SSerapheim Dimitropoulos 
484186714001SSerapheim Dimitropoulos 	error = spa_open(checkpoint_pool, &checkpoint_spa, FTAG);
484286714001SSerapheim Dimitropoulos 	if (error != 0) {
484386714001SSerapheim Dimitropoulos 		fatal("Tried to open pool \"%s\" but spa_open() failed with "
484486714001SSerapheim Dimitropoulos 		    "error %d\n", checkpoint_pool, error);
484586714001SSerapheim Dimitropoulos 	}
484686714001SSerapheim Dimitropoulos 
484786714001SSerapheim Dimitropoulos 	/*
484886714001SSerapheim Dimitropoulos 	 * Ensure that ranges in the checkpoint space maps of each vdev
484986714001SSerapheim Dimitropoulos 	 * are allocated according to the checkpointed state's metaslab
485086714001SSerapheim Dimitropoulos 	 * space maps.
485186714001SSerapheim Dimitropoulos 	 */
485286714001SSerapheim Dimitropoulos 	verify_checkpoint_vdev_spacemaps(checkpoint_spa, spa);
485386714001SSerapheim Dimitropoulos 
485486714001SSerapheim Dimitropoulos 	/*
485586714001SSerapheim Dimitropoulos 	 * Ensure that allocated ranges in the checkpoint's metaslab
485686714001SSerapheim Dimitropoulos 	 * space maps remain allocated in the metaslab space maps of
485786714001SSerapheim Dimitropoulos 	 * the current state.
485886714001SSerapheim Dimitropoulos 	 */
485986714001SSerapheim Dimitropoulos 	verify_checkpoint_ms_spacemaps(checkpoint_spa, spa);
486086714001SSerapheim Dimitropoulos 
486186714001SSerapheim Dimitropoulos 	/*
486286714001SSerapheim Dimitropoulos 	 * Once we are done, we get rid of the checkpointed state.
486386714001SSerapheim Dimitropoulos 	 */
486486714001SSerapheim Dimitropoulos 	spa_close(checkpoint_spa, FTAG);
486586714001SSerapheim Dimitropoulos 	free(checkpoint_pool);
486686714001SSerapheim Dimitropoulos }
486786714001SSerapheim Dimitropoulos 
486886714001SSerapheim Dimitropoulos static void
486986714001SSerapheim Dimitropoulos dump_leftover_checkpoint_blocks(spa_t *spa)
487086714001SSerapheim Dimitropoulos {
487186714001SSerapheim Dimitropoulos 	vdev_t *rvd = spa->spa_root_vdev;
487286714001SSerapheim Dimitropoulos 
487386714001SSerapheim Dimitropoulos 	for (uint64_t i = 0; i < rvd->vdev_children; i++) {
487486714001SSerapheim Dimitropoulos 		vdev_t *vd = rvd->vdev_child[i];
487586714001SSerapheim Dimitropoulos 
487686714001SSerapheim Dimitropoulos 		space_map_t *checkpoint_sm = NULL;
487786714001SSerapheim Dimitropoulos 		uint64_t checkpoint_sm_obj;
487886714001SSerapheim Dimitropoulos 
487986714001SSerapheim Dimitropoulos 		if (vd->vdev_top_zap == 0)
488086714001SSerapheim Dimitropoulos 			continue;
488186714001SSerapheim Dimitropoulos 
488286714001SSerapheim Dimitropoulos 		if (zap_contains(spa_meta_objset(spa), vd->vdev_top_zap,
488386714001SSerapheim Dimitropoulos 		    VDEV_TOP_ZAP_POOL_CHECKPOINT_SM) != 0)
488486714001SSerapheim Dimitropoulos 			continue;
488586714001SSerapheim Dimitropoulos 
488686714001SSerapheim Dimitropoulos 		VERIFY0(zap_lookup(spa_meta_objset(spa), vd->vdev_top_zap,
488786714001SSerapheim Dimitropoulos 		    VDEV_TOP_ZAP_POOL_CHECKPOINT_SM,
488886714001SSerapheim Dimitropoulos 		    sizeof (uint64_t), 1, &checkpoint_sm_obj));
488986714001SSerapheim Dimitropoulos 
489086714001SSerapheim Dimitropoulos 		VERIFY0(space_map_open(&checkpoint_sm, spa_meta_objset(spa),
489186714001SSerapheim Dimitropoulos 		    checkpoint_sm_obj, 0, vd->vdev_asize, vd->vdev_ashift));
489286714001SSerapheim Dimitropoulos 		dump_spacemap(spa->spa_meta_objset, checkpoint_sm);
489386714001SSerapheim Dimitropoulos 		space_map_close(checkpoint_sm);
489486714001SSerapheim Dimitropoulos 	}
489586714001SSerapheim Dimitropoulos }
489686714001SSerapheim Dimitropoulos 
489786714001SSerapheim Dimitropoulos static int
489886714001SSerapheim Dimitropoulos verify_checkpoint(spa_t *spa)
489986714001SSerapheim Dimitropoulos {
490086714001SSerapheim Dimitropoulos 	uberblock_t checkpoint;
490186714001SSerapheim Dimitropoulos 	int error;
490286714001SSerapheim Dimitropoulos 
490386714001SSerapheim Dimitropoulos 	if (!spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT))
490486714001SSerapheim Dimitropoulos 		return (0);
490586714001SSerapheim Dimitropoulos 
490686714001SSerapheim Dimitropoulos 	error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
490786714001SSerapheim Dimitropoulos 	    DMU_POOL_ZPOOL_CHECKPOINT, sizeof (uint64_t),
490886714001SSerapheim Dimitropoulos 	    sizeof (uberblock_t) / sizeof (uint64_t), &checkpoint);
490986714001SSerapheim Dimitropoulos 
491017f11284SSerapheim Dimitropoulos 	if (error == ENOENT && !dump_opt['L']) {
491186714001SSerapheim Dimitropoulos 		/*
491286714001SSerapheim Dimitropoulos 		 * If the feature is active but the uberblock is missing
491386714001SSerapheim Dimitropoulos 		 * then we must be in the middle of discarding the
491486714001SSerapheim Dimitropoulos 		 * checkpoint.
491586714001SSerapheim Dimitropoulos 		 */
491686714001SSerapheim Dimitropoulos 		(void) printf("\nPartially discarded checkpoint "
491786714001SSerapheim Dimitropoulos 		    "state found:\n");
491886714001SSerapheim Dimitropoulos 		dump_leftover_checkpoint_blocks(spa);
491986714001SSerapheim Dimitropoulos 		return (0);
492086714001SSerapheim Dimitropoulos 	} else if (error != 0) {
492186714001SSerapheim Dimitropoulos 		(void) printf("lookup error %d when looking for "
492286714001SSerapheim Dimitropoulos 		    "checkpointed uberblock in MOS\n", error);
492386714001SSerapheim Dimitropoulos 		return (error);
492486714001SSerapheim Dimitropoulos 	}
492586714001SSerapheim Dimitropoulos 	dump_uberblock(&checkpoint, "\nCheckpointed uberblock found:\n", "\n");
492686714001SSerapheim Dimitropoulos 
492786714001SSerapheim Dimitropoulos 	if (checkpoint.ub_checkpoint_txg == 0) {
492886714001SSerapheim Dimitropoulos 		(void) printf("\nub_checkpoint_txg not set in checkpointed "
492986714001SSerapheim Dimitropoulos 		    "uberblock\n");
493086714001SSerapheim Dimitropoulos 		error = 3;
493186714001SSerapheim Dimitropoulos 	}
493286714001SSerapheim Dimitropoulos 
493317f11284SSerapheim Dimitropoulos 	if (error == 0 && !dump_opt['L'])
493486714001SSerapheim Dimitropoulos 		verify_checkpoint_blocks(spa);
493586714001SSerapheim Dimitropoulos 
493686714001SSerapheim Dimitropoulos 	return (error);
493786714001SSerapheim Dimitropoulos }
493886714001SSerapheim Dimitropoulos 
493917fb938fSMatthew Ahrens /* ARGSUSED */
494017fb938fSMatthew Ahrens static void
494117fb938fSMatthew Ahrens mos_leaks_cb(void *arg, uint64_t start, uint64_t size)
494217fb938fSMatthew Ahrens {
494317fb938fSMatthew Ahrens 	for (uint64_t i = start; i < size; i++) {
494417fb938fSMatthew Ahrens 		(void) printf("MOS object %llu referenced but not allocated\n",
494517fb938fSMatthew Ahrens 		    (u_longlong_t)i);
494617fb938fSMatthew Ahrens 	}
494717fb938fSMatthew Ahrens }
494817fb938fSMatthew Ahrens 
494917fb938fSMatthew Ahrens static range_tree_t *mos_refd_objs;
495017fb938fSMatthew Ahrens 
495117fb938fSMatthew Ahrens static void
495217fb938fSMatthew Ahrens mos_obj_refd(uint64_t obj)
495317fb938fSMatthew Ahrens {
495417fb938fSMatthew Ahrens 	if (obj != 0 && mos_refd_objs != NULL)
495517fb938fSMatthew Ahrens 		range_tree_add(mos_refd_objs, obj, 1);
495617fb938fSMatthew Ahrens }
495717fb938fSMatthew Ahrens 
4958814dcd43SSerapheim Dimitropoulos static void
4959814dcd43SSerapheim Dimitropoulos mos_leak_vdev_top_zap(vdev_t *vd)
4960814dcd43SSerapheim Dimitropoulos {
4961814dcd43SSerapheim Dimitropoulos 	uint64_t ms_flush_data_obj;
4962814dcd43SSerapheim Dimitropoulos 
4963814dcd43SSerapheim Dimitropoulos 	int error = zap_lookup(spa_meta_objset(vd->vdev_spa),
4964814dcd43SSerapheim Dimitropoulos 	    vd->vdev_top_zap, VDEV_TOP_ZAP_MS_UNFLUSHED_PHYS_TXGS,
4965814dcd43SSerapheim Dimitropoulos 	    sizeof (ms_flush_data_obj), 1, &ms_flush_data_obj);
4966814dcd43SSerapheim Dimitropoulos 	if (error == ENOENT)
4967814dcd43SSerapheim Dimitropoulos 		return;
4968814dcd43SSerapheim Dimitropoulos 	ASSERT0(error);
4969814dcd43SSerapheim Dimitropoulos 
4970814dcd43SSerapheim Dimitropoulos 	mos_obj_refd(ms_flush_data_obj);
4971814dcd43SSerapheim Dimitropoulos }
4972814dcd43SSerapheim Dimitropoulos 
497317fb938fSMatthew Ahrens static void
497417fb938fSMatthew Ahrens mos_leak_vdev(vdev_t *vd)
497517fb938fSMatthew Ahrens {
497617fb938fSMatthew Ahrens 	mos_obj_refd(vd->vdev_dtl_object);
497717fb938fSMatthew Ahrens 	mos_obj_refd(vd->vdev_ms_array);
497817fb938fSMatthew Ahrens 	mos_obj_refd(vd->vdev_indirect_config.vic_births_object);
497917fb938fSMatthew Ahrens 	mos_obj_refd(vd->vdev_indirect_config.vic_mapping_object);
498017fb938fSMatthew Ahrens 	mos_obj_refd(vd->vdev_leaf_zap);
498117fb938fSMatthew Ahrens 	if (vd->vdev_checkpoint_sm != NULL)
498217fb938fSMatthew Ahrens 		mos_obj_refd(vd->vdev_checkpoint_sm->sm_object);
498317fb938fSMatthew Ahrens 	if (vd->vdev_indirect_mapping != NULL) {
498417fb938fSMatthew Ahrens 		mos_obj_refd(vd->vdev_indirect_mapping->
498517fb938fSMatthew Ahrens 		    vim_phys->vimp_counts_object);
498617fb938fSMatthew Ahrens 	}
498717fb938fSMatthew Ahrens 	if (vd->vdev_obsolete_sm != NULL)
498817fb938fSMatthew Ahrens 		mos_obj_refd(vd->vdev_obsolete_sm->sm_object);
498917fb938fSMatthew Ahrens 
499017fb938fSMatthew Ahrens 	for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
499117fb938fSMatthew Ahrens 		metaslab_t *ms = vd->vdev_ms[m];
499217fb938fSMatthew Ahrens 		mos_obj_refd(space_map_object(ms->ms_sm));
499317fb938fSMatthew Ahrens 	}
499417fb938fSMatthew Ahrens 
4995814dcd43SSerapheim Dimitropoulos 	if (vd->vdev_top_zap != 0) {
4996814dcd43SSerapheim Dimitropoulos 		mos_obj_refd(vd->vdev_top_zap);
4997814dcd43SSerapheim Dimitropoulos 		mos_leak_vdev_top_zap(vd);
4998814dcd43SSerapheim Dimitropoulos 	}
4999814dcd43SSerapheim Dimitropoulos 
500017fb938fSMatthew Ahrens 	for (uint64_t c = 0; c < vd->vdev_children; c++) {
500117fb938fSMatthew Ahrens 		mos_leak_vdev(vd->vdev_child[c]);
500217fb938fSMatthew Ahrens 	}
500317fb938fSMatthew Ahrens }
500417fb938fSMatthew Ahrens 
5005814dcd43SSerapheim Dimitropoulos static void
5006814dcd43SSerapheim Dimitropoulos mos_leak_log_spacemaps(spa_t *spa)
5007814dcd43SSerapheim Dimitropoulos {
5008814dcd43SSerapheim Dimitropoulos 	uint64_t spacemap_zap;
5009814dcd43SSerapheim Dimitropoulos 
5010814dcd43SSerapheim Dimitropoulos 	int error = zap_lookup(spa_meta_objset(spa),
5011814dcd43SSerapheim Dimitropoulos 	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_LOG_SPACEMAP_ZAP,
5012814dcd43SSerapheim Dimitropoulos 	    sizeof (spacemap_zap), 1, &spacemap_zap);
5013814dcd43SSerapheim Dimitropoulos 	if (error == ENOENT)
5014814dcd43SSerapheim Dimitropoulos 		return;
5015814dcd43SSerapheim Dimitropoulos 	ASSERT0(error);
5016814dcd43SSerapheim Dimitropoulos 
5017814dcd43SSerapheim Dimitropoulos 	mos_obj_refd(spacemap_zap);
5018814dcd43SSerapheim Dimitropoulos 	for (spa_log_sm_t *sls = avl_first(&spa->spa_sm_logs_by_txg);
5019814dcd43SSerapheim Dimitropoulos 	    sls; sls = AVL_NEXT(&spa->spa_sm_logs_by_txg, sls))
5020814dcd43SSerapheim Dimitropoulos 		mos_obj_refd(sls->sls_sm_obj);
5021814dcd43SSerapheim Dimitropoulos }
5022814dcd43SSerapheim Dimitropoulos 
502317fb938fSMatthew Ahrens static int
502417fb938fSMatthew Ahrens dump_mos_leaks(spa_t *spa)
502517fb938fSMatthew Ahrens {
502617fb938fSMatthew Ahrens 	int rv = 0;
502717fb938fSMatthew Ahrens 	objset_t *mos = spa->spa_meta_objset;
502817fb938fSMatthew Ahrens 	dsl_pool_t *dp = spa->spa_dsl_pool;
502917fb938fSMatthew Ahrens 
503017fb938fSMatthew Ahrens 	/* Visit and mark all referenced objects in the MOS */
503117fb938fSMatthew Ahrens 
503217fb938fSMatthew Ahrens 	mos_obj_refd(DMU_POOL_DIRECTORY_OBJECT);
503317fb938fSMatthew Ahrens 	mos_obj_refd(spa->spa_pool_props_object);
503417fb938fSMatthew Ahrens 	mos_obj_refd(spa->spa_config_object);
503517fb938fSMatthew Ahrens 	mos_obj_refd(spa->spa_ddt_stat_object);
503617fb938fSMatthew Ahrens 	mos_obj_refd(spa->spa_feat_desc_obj);
503717fb938fSMatthew Ahrens 	mos_obj_refd(spa->spa_feat_enabled_txg_obj);
503817fb938fSMatthew Ahrens 	mos_obj_refd(spa->spa_feat_for_read_obj);
503917fb938fSMatthew Ahrens 	mos_obj_refd(spa->spa_feat_for_write_obj);
504017fb938fSMatthew Ahrens 	mos_obj_refd(spa->spa_history);
504117fb938fSMatthew Ahrens 	mos_obj_refd(spa->spa_errlog_last);
504217fb938fSMatthew Ahrens 	mos_obj_refd(spa->spa_errlog_scrub);
504317fb938fSMatthew Ahrens 	mos_obj_refd(spa->spa_all_vdev_zaps);
504417fb938fSMatthew Ahrens 	mos_obj_refd(spa->spa_dsl_pool->dp_bptree_obj);
504517fb938fSMatthew Ahrens 	mos_obj_refd(spa->spa_dsl_pool->dp_tmp_userrefs_obj);
504617fb938fSMatthew Ahrens 	mos_obj_refd(spa->spa_dsl_pool->dp_scan->scn_phys.scn_queue_obj);
504717fb938fSMatthew Ahrens 	bpobj_count_refd(&spa->spa_deferred_bpobj);
504817fb938fSMatthew Ahrens 	mos_obj_refd(dp->dp_empty_bpobj);
504917fb938fSMatthew Ahrens 	bpobj_count_refd(&dp->dp_obsolete_bpobj);
505017fb938fSMatthew Ahrens 	bpobj_count_refd(&dp->dp_free_bpobj);
505117fb938fSMatthew Ahrens 	mos_obj_refd(spa->spa_l2cache.sav_object);
505217fb938fSMatthew Ahrens 	mos_obj_refd(spa->spa_spares.sav_object);
505317fb938fSMatthew Ahrens 
5054814dcd43SSerapheim Dimitropoulos 	if (spa->spa_syncing_log_sm != NULL)
5055814dcd43SSerapheim Dimitropoulos 		mos_obj_refd(spa->spa_syncing_log_sm->sm_object);
5056814dcd43SSerapheim Dimitropoulos 	mos_leak_log_spacemaps(spa);
5057814dcd43SSerapheim Dimitropoulos 
505817fb938fSMatthew Ahrens 	mos_obj_refd(spa->spa_condensing_indirect_phys.
505917fb938fSMatthew Ahrens 	    scip_next_mapping_object);
506017fb938fSMatthew Ahrens 	mos_obj_refd(spa->spa_condensing_indirect_phys.
506117fb938fSMatthew Ahrens 	    scip_prev_obsolete_sm_object);
506217fb938fSMatthew Ahrens 	if (spa->spa_condensing_indirect_phys.scip_next_mapping_object != 0) {
506317fb938fSMatthew Ahrens 		vdev_indirect_mapping_t *vim =
506417fb938fSMatthew Ahrens 		    vdev_indirect_mapping_open(mos,
506517fb938fSMatthew Ahrens 		    spa->spa_condensing_indirect_phys.scip_next_mapping_object);
506617fb938fSMatthew Ahrens 		mos_obj_refd(vim->vim_phys->vimp_counts_object);
506717fb938fSMatthew Ahrens 		vdev_indirect_mapping_close(vim);
506817fb938fSMatthew Ahrens 	}
506917fb938fSMatthew Ahrens 
507017fb938fSMatthew Ahrens 	if (dp->dp_origin_snap != NULL) {
507117fb938fSMatthew Ahrens 		dsl_dataset_t *ds;
507217fb938fSMatthew Ahrens 
507317fb938fSMatthew Ahrens 		dsl_pool_config_enter(dp, FTAG);
507417fb938fSMatthew Ahrens 		VERIFY0(dsl_dataset_hold_obj(dp,
507517fb938fSMatthew Ahrens 		    dsl_dataset_phys(dp->dp_origin_snap)->ds_next_snap_obj,
507617fb938fSMatthew Ahrens 		    FTAG, &ds));
507717fb938fSMatthew Ahrens 		count_ds_mos_objects(ds);
507817fb938fSMatthew Ahrens 		dump_deadlist(&ds->ds_deadlist);
507917fb938fSMatthew Ahrens 		dsl_dataset_rele(ds, FTAG);
508017fb938fSMatthew Ahrens 		dsl_pool_config_exit(dp, FTAG);
508117fb938fSMatthew Ahrens 
508217fb938fSMatthew Ahrens 		count_ds_mos_objects(dp->dp_origin_snap);
508317fb938fSMatthew Ahrens 		dump_deadlist(&dp->dp_origin_snap->ds_deadlist);
508417fb938fSMatthew Ahrens 	}
508517fb938fSMatthew Ahrens 	count_dir_mos_objects(dp->dp_mos_dir);
508617fb938fSMatthew Ahrens 	if (dp->dp_free_dir != NULL)
508717fb938fSMatthew Ahrens 		count_dir_mos_objects(dp->dp_free_dir);
508817fb938fSMatthew Ahrens 	if (dp->dp_leak_dir != NULL)
508917fb938fSMatthew Ahrens 		count_dir_mos_objects(dp->dp_leak_dir);
509017fb938fSMatthew Ahrens 
509117fb938fSMatthew Ahrens 	mos_leak_vdev(spa->spa_root_vdev);
509217fb938fSMatthew Ahrens 
509317fb938fSMatthew Ahrens 	for (uint64_t class = 0; class < DDT_CLASSES; class++) {
509417fb938fSMatthew Ahrens 		for (uint64_t type = 0; type < DDT_TYPES; type++) {
509517fb938fSMatthew Ahrens 			for (uint64_t cksum = 0;
509617fb938fSMatthew Ahrens 			    cksum < ZIO_CHECKSUM_FUNCTIONS; cksum++) {
509717fb938fSMatthew Ahrens 				ddt_t *ddt = spa->spa_ddt[cksum];
509817fb938fSMatthew Ahrens 				mos_obj_refd(ddt->ddt_object[type][class]);
509917fb938fSMatthew Ahrens 			}
510017fb938fSMatthew Ahrens 		}
510117fb938fSMatthew Ahrens 	}
510217fb938fSMatthew Ahrens 
510317fb938fSMatthew Ahrens 	/*
510417fb938fSMatthew Ahrens 	 * Visit all allocated objects and make sure they are referenced.
510517fb938fSMatthew Ahrens 	 */
510617fb938fSMatthew Ahrens 	uint64_t object = 0;
510717fb938fSMatthew Ahrens 	while (dmu_object_next(mos, &object, B_FALSE, 0) == 0) {
510817fb938fSMatthew Ahrens 		if (range_tree_contains(mos_refd_objs, object, 1)) {
510917fb938fSMatthew Ahrens 			range_tree_remove(mos_refd_objs, object, 1);
511017fb938fSMatthew Ahrens 		} else {
511117fb938fSMatthew Ahrens 			dmu_object_info_t doi;
511217fb938fSMatthew Ahrens 			const char *name;
511317fb938fSMatthew Ahrens 			dmu_object_info(mos, object, &doi);
511417fb938fSMatthew Ahrens 			if (doi.doi_type & DMU_OT_NEWTYPE) {
511517fb938fSMatthew Ahrens 				dmu_object_byteswap_t bswap =
511617fb938fSMatthew Ahrens 				    DMU_OT_BYTESWAP(doi.doi_type);
511717fb938fSMatthew Ahrens 				name = dmu_ot_byteswap[bswap].ob_name;
511817fb938fSMatthew Ahrens 			} else {
511917fb938fSMatthew Ahrens 				name = dmu_ot[doi.doi_type].ot_name;
512017fb938fSMatthew Ahrens 			}
512117fb938fSMatthew Ahrens 
512217fb938fSMatthew Ahrens 			(void) printf("MOS object %llu (%s) leaked\n",
512317fb938fSMatthew Ahrens 			    (u_longlong_t)object, name);
512417fb938fSMatthew Ahrens 			rv = 2;
512517fb938fSMatthew Ahrens 		}
512617fb938fSMatthew Ahrens 	}
512717fb938fSMatthew Ahrens 	(void) range_tree_walk(mos_refd_objs, mos_leaks_cb, NULL);
512817fb938fSMatthew Ahrens 	if (!range_tree_is_empty(mos_refd_objs))
512917fb938fSMatthew Ahrens 		rv = 2;
513017fb938fSMatthew Ahrens 	range_tree_vacate(mos_refd_objs, NULL, NULL);
513117fb938fSMatthew Ahrens 	range_tree_destroy(mos_refd_objs);
513217fb938fSMatthew Ahrens 	return (rv);
513317fb938fSMatthew Ahrens }
513417fb938fSMatthew Ahrens 
5135814dcd43SSerapheim Dimitropoulos typedef struct log_sm_obsolete_stats_arg {
5136814dcd43SSerapheim Dimitropoulos 	uint64_t lsos_current_txg;
5137814dcd43SSerapheim Dimitropoulos 
5138814dcd43SSerapheim Dimitropoulos 	uint64_t lsos_total_entries;
5139814dcd43SSerapheim Dimitropoulos 	uint64_t lsos_valid_entries;
5140814dcd43SSerapheim Dimitropoulos 
5141814dcd43SSerapheim Dimitropoulos 	uint64_t lsos_sm_entries;
5142814dcd43SSerapheim Dimitropoulos 	uint64_t lsos_valid_sm_entries;
5143814dcd43SSerapheim Dimitropoulos } log_sm_obsolete_stats_arg_t;
5144814dcd43SSerapheim Dimitropoulos 
5145814dcd43SSerapheim Dimitropoulos static int
5146814dcd43SSerapheim Dimitropoulos log_spacemap_obsolete_stats_cb(spa_t *spa, space_map_entry_t *sme,
5147814dcd43SSerapheim Dimitropoulos     uint64_t txg, void *arg)
5148814dcd43SSerapheim Dimitropoulos {
5149814dcd43SSerapheim Dimitropoulos 	log_sm_obsolete_stats_arg_t *lsos = arg;
5150814dcd43SSerapheim Dimitropoulos 	uint64_t offset = sme->sme_offset;
5151814dcd43SSerapheim Dimitropoulos 	uint64_t vdev_id = sme->sme_vdev;
5152814dcd43SSerapheim Dimitropoulos 
5153814dcd43SSerapheim Dimitropoulos 	if (lsos->lsos_current_txg == 0) {
5154814dcd43SSerapheim Dimitropoulos 		/* this is the first log */
5155814dcd43SSerapheim Dimitropoulos 		lsos->lsos_current_txg = txg;
5156814dcd43SSerapheim Dimitropoulos 	} else if (lsos->lsos_current_txg < txg) {
5157814dcd43SSerapheim Dimitropoulos 		/* we just changed log - print stats and reset */
5158814dcd43SSerapheim Dimitropoulos 		(void) printf("%-8llu valid entries out of %-8llu - txg %llu\n",
5159814dcd43SSerapheim Dimitropoulos 		    (u_longlong_t)lsos->lsos_valid_sm_entries,
5160814dcd43SSerapheim Dimitropoulos 		    (u_longlong_t)lsos->lsos_sm_entries,
5161814dcd43SSerapheim Dimitropoulos 		    (u_longlong_t)lsos->lsos_current_txg);
5162814dcd43SSerapheim Dimitropoulos 		lsos->lsos_valid_sm_entries = 0;
5163814dcd43SSerapheim Dimitropoulos 		lsos->lsos_sm_entries = 0;
5164814dcd43SSerapheim Dimitropoulos 		lsos->lsos_current_txg = txg;
5165814dcd43SSerapheim Dimitropoulos 	}
5166814dcd43SSerapheim Dimitropoulos 	ASSERT3U(lsos->lsos_current_txg, ==, txg);
5167814dcd43SSerapheim Dimitropoulos 
5168814dcd43SSerapheim Dimitropoulos 	lsos->lsos_sm_entries++;
5169814dcd43SSerapheim Dimitropoulos 	lsos->lsos_total_entries++;
5170814dcd43SSerapheim Dimitropoulos 
5171814dcd43SSerapheim Dimitropoulos 	vdev_t *vd = vdev_lookup_top(spa, vdev_id);
5172814dcd43SSerapheim Dimitropoulos 	if (!vdev_is_concrete(vd))
5173814dcd43SSerapheim Dimitropoulos 		return (0);
5174814dcd43SSerapheim Dimitropoulos 
5175814dcd43SSerapheim Dimitropoulos 	metaslab_t *ms = vd->vdev_ms[offset >> vd->vdev_ms_shift];
5176814dcd43SSerapheim Dimitropoulos 	ASSERT(sme->sme_type == SM_ALLOC || sme->sme_type == SM_FREE);
5177814dcd43SSerapheim Dimitropoulos 
5178814dcd43SSerapheim Dimitropoulos 	if (txg < metaslab_unflushed_txg(ms))
5179814dcd43SSerapheim Dimitropoulos 		return (0);
5180814dcd43SSerapheim Dimitropoulos 	lsos->lsos_valid_sm_entries++;
5181814dcd43SSerapheim Dimitropoulos 	lsos->lsos_valid_entries++;
5182814dcd43SSerapheim Dimitropoulos 	return (0);
5183814dcd43SSerapheim Dimitropoulos }
5184814dcd43SSerapheim Dimitropoulos 
5185814dcd43SSerapheim Dimitropoulos static void
5186814dcd43SSerapheim Dimitropoulos dump_log_spacemap_obsolete_stats(spa_t *spa)
5187814dcd43SSerapheim Dimitropoulos {
5188814dcd43SSerapheim Dimitropoulos 	if (!spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP))
5189814dcd43SSerapheim Dimitropoulos 		return;
5190814dcd43SSerapheim Dimitropoulos 
5191814dcd43SSerapheim Dimitropoulos 	log_sm_obsolete_stats_arg_t lsos;
5192814dcd43SSerapheim Dimitropoulos 	bzero(&lsos, sizeof (lsos));
5193814dcd43SSerapheim Dimitropoulos 
5194814dcd43SSerapheim Dimitropoulos 	(void) printf("Log Space Map Obsolete Entry Statistics:\n");
5195814dcd43SSerapheim Dimitropoulos 
5196814dcd43SSerapheim Dimitropoulos 	iterate_through_spacemap_logs(spa,
5197814dcd43SSerapheim Dimitropoulos 	    log_spacemap_obsolete_stats_cb, &lsos);
5198814dcd43SSerapheim Dimitropoulos 
5199814dcd43SSerapheim Dimitropoulos 	/* print stats for latest log */
5200814dcd43SSerapheim Dimitropoulos 	(void) printf("%-8llu valid entries out of %-8llu - txg %llu\n",
5201814dcd43SSerapheim Dimitropoulos 	    (u_longlong_t)lsos.lsos_valid_sm_entries,
5202814dcd43SSerapheim Dimitropoulos 	    (u_longlong_t)lsos.lsos_sm_entries,
5203814dcd43SSerapheim Dimitropoulos 	    (u_longlong_t)lsos.lsos_current_txg);
5204814dcd43SSerapheim Dimitropoulos 
5205814dcd43SSerapheim Dimitropoulos 	(void) printf("%-8llu valid entries out of %-8llu - total\n\n",
5206814dcd43SSerapheim Dimitropoulos 	    (u_longlong_t)lsos.lsos_valid_entries,
5207814dcd43SSerapheim Dimitropoulos 	    (u_longlong_t)lsos.lsos_total_entries);
5208814dcd43SSerapheim Dimitropoulos }
5209814dcd43SSerapheim Dimitropoulos 
5210fa9e4066Sahrens static void
5211fa9e4066Sahrens dump_zpool(spa_t *spa)
5212fa9e4066Sahrens {
5213fa9e4066Sahrens 	dsl_pool_t *dp = spa_get_dsl(spa);
5214fa9e4066Sahrens 	int rc = 0;
5215fa9e4066Sahrens 
5216b24ab676SJeff Bonwick 	if (dump_opt['S']) {
5217b24ab676SJeff Bonwick 		dump_simulated_ddt(spa);
5218b24ab676SJeff Bonwick 		return;
5219b24ab676SJeff Bonwick 	}
5220b24ab676SJeff Bonwick 
522107428bdfSVictor Latushkin 	if (!dump_opt['e'] && dump_opt['C'] > 1) {
522207428bdfSVictor Latushkin 		(void) printf("\nCached configuration:\n");
522307428bdfSVictor Latushkin 		dump_nvlist(spa->spa_config, 8);
522407428bdfSVictor Latushkin 	}
522507428bdfSVictor Latushkin 
522607428bdfSVictor Latushkin 	if (dump_opt['C'])
522707428bdfSVictor Latushkin 		dump_config(spa);
522807428bdfSVictor Latushkin 
5229fa9e4066Sahrens 	if (dump_opt['u'])
523053b9a4a9SVictor Latushkin 		dump_uberblock(&spa->spa_uberblock, "\nUberblock:\n", "\n");
5231fa9e4066Sahrens 
5232b24ab676SJeff Bonwick 	if (dump_opt['D'])
5233b24ab676SJeff Bonwick 		dump_all_ddts(spa);
5234b24ab676SJeff Bonwick 
523587219db7SVictor Latushkin 	if (dump_opt['d'] > 2 || dump_opt['m'])
523687219db7SVictor Latushkin 		dump_metaslabs(spa);
52372e4c9986SGeorge Wilson 	if (dump_opt['M'])
52382e4c9986SGeorge Wilson 		dump_metaslab_groups(spa);
5239814dcd43SSerapheim Dimitropoulos 	if (dump_opt['d'] > 2 || dump_opt['m']) {
5240814dcd43SSerapheim Dimitropoulos 		dump_log_spacemaps(spa);
5241814dcd43SSerapheim Dimitropoulos 		dump_log_spacemap_obsolete_stats(spa);
5242814dcd43SSerapheim Dimitropoulos 	}
524387219db7SVictor Latushkin 
524487219db7SVictor Latushkin 	if (dump_opt['d'] || dump_opt['i']) {
524517fb938fSMatthew Ahrens 		mos_refd_objs = range_tree_create(NULL, NULL);
5246fa9e4066Sahrens 		dump_dir(dp->dp_meta_objset);
524717fb938fSMatthew Ahrens 
5248fa9e4066Sahrens 		if (dump_opt['d'] >= 3) {
52495cabbc6bSPrashanth Sreenivasa 			dsl_pool_t *dp = spa->spa_dsl_pool;
5250732885fcSMatthew Ahrens 			dump_full_bpobj(&spa->spa_deferred_bpobj,
5251d0475637SMatthew Ahrens 			    "Deferred frees", 0);
5252cde58dbcSMatthew Ahrens 			if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
52535cabbc6bSPrashanth Sreenivasa 				dump_full_bpobj(&dp->dp_free_bpobj,
5254d0475637SMatthew Ahrens 				    "Pool snapshot frees", 0);
5255ad135b5dSChristopher Siden 			}
52565cabbc6bSPrashanth Sreenivasa 			if (bpobj_is_open(&dp->dp_obsolete_bpobj)) {
52575cabbc6bSPrashanth Sreenivasa 				ASSERT(spa_feature_is_enabled(spa,
52585cabbc6bSPrashanth Sreenivasa 				    SPA_FEATURE_DEVICE_REMOVAL));
52595cabbc6bSPrashanth Sreenivasa 				dump_full_bpobj(&dp->dp_obsolete_bpobj,
52605cabbc6bSPrashanth Sreenivasa 				    "Pool obsolete blocks", 0);
52615cabbc6bSPrashanth Sreenivasa 			}
5262ad135b5dSChristopher Siden 
5263ad135b5dSChristopher Siden 			if (spa_feature_is_active(spa,
52642acef22dSMatthew Ahrens 			    SPA_FEATURE_ASYNC_DESTROY)) {
5265ad135b5dSChristopher Siden 				dump_bptree(spa->spa_meta_objset,
52665cabbc6bSPrashanth Sreenivasa 				    dp->dp_bptree_obj,
5267ad135b5dSChristopher Siden 				    "Pool dataset frees");
5268cde58dbcSMatthew Ahrens 			}
5269fa9e4066Sahrens 			dump_dtl(spa->spa_root_vdev, 0);
5270fa9e4066Sahrens 		}
527107428bdfSVictor Latushkin 		(void) dmu_objset_find(spa_name(spa), dump_one_dir,
527207428bdfSVictor Latushkin 		    NULL, DS_FIND_SNAPSHOTS | DS_FIND_CHILDREN);
5273b5152584SMatthew Ahrens 
527417fb938fSMatthew Ahrens 		if (rc == 0 && !dump_opt['L'])
527517fb938fSMatthew Ahrens 			rc = dump_mos_leaks(spa);
527617fb938fSMatthew Ahrens 
5277ca0cc391SMatthew Ahrens 		for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
5278ca0cc391SMatthew Ahrens 			uint64_t refcount;
5279ca0cc391SMatthew Ahrens 
5280ca0cc391SMatthew Ahrens 			if (!(spa_feature_table[f].fi_flags &
5281c5d1600cSMatthew Ahrens 			    ZFEATURE_FLAG_PER_DATASET) ||
5282c5d1600cSMatthew Ahrens 			    !spa_feature_is_enabled(spa, f)) {
5283ca0cc391SMatthew Ahrens 				ASSERT0(dataset_feature_count[f]);
5284ca0cc391SMatthew Ahrens 				continue;
5285ca0cc391SMatthew Ahrens 			}
5286ca0cc391SMatthew Ahrens 			(void) feature_get_refcount(spa,
5287ca0cc391SMatthew Ahrens 			    &spa_feature_table[f], &refcount);
5288ca0cc391SMatthew Ahrens 			if (dataset_feature_count[f] != refcount) {
5289ca0cc391SMatthew Ahrens 				(void) printf("%s feature refcount mismatch: "
5290ca0cc391SMatthew Ahrens 				    "%lld datasets != %lld refcount\n",
5291ca0cc391SMatthew Ahrens 				    spa_feature_table[f].fi_uname,
5292ca0cc391SMatthew Ahrens 				    (longlong_t)dataset_feature_count[f],
5293ca0cc391SMatthew Ahrens 				    (longlong_t)refcount);
5294ca0cc391SMatthew Ahrens 				rc = 2;
5295ca0cc391SMatthew Ahrens 			} else {
5296ca0cc391SMatthew Ahrens 				(void) printf("Verified %s feature refcount "
5297ca0cc391SMatthew Ahrens 				    "of %llu is correct\n",
5298ca0cc391SMatthew Ahrens 				    spa_feature_table[f].fi_uname,
5299ca0cc391SMatthew Ahrens 				    (longlong_t)refcount);
5300ca0cc391SMatthew Ahrens 			}
5301b5152584SMatthew Ahrens 		}
53025cabbc6bSPrashanth Sreenivasa 
5303814dcd43SSerapheim Dimitropoulos 		if (rc == 0)
53045cabbc6bSPrashanth Sreenivasa 			rc = verify_device_removal_feature_counts(spa);
5305fa9e4066Sahrens 	}
530617fb938fSMatthew Ahrens 
5307b5152584SMatthew Ahrens 	if (rc == 0 && (dump_opt['b'] || dump_opt['c']))
5308fa9e4066Sahrens 		rc = dump_block_stats(spa);
5309fa9e4066Sahrens 
53100713e232SGeorge Wilson 	if (rc == 0)
53110713e232SGeorge Wilson 		rc = verify_spacemap_refcounts(spa);
53120713e232SGeorge Wilson 
5313fa9e4066Sahrens 	if (dump_opt['s'])
5314fa9e4066Sahrens 		show_pool_stats(spa);
5315fa9e4066Sahrens 
53168f18d1faSGeorge Wilson 	if (dump_opt['h'])
53178f18d1faSGeorge Wilson 		dump_history(spa);
53188f18d1faSGeorge Wilson 
531917f11284SSerapheim Dimitropoulos 	if (rc == 0)
532086714001SSerapheim Dimitropoulos 		rc = verify_checkpoint(spa);
532186714001SSerapheim Dimitropoulos 
532229bdd2f9SPavel Zakharov 	if (rc != 0) {
532329bdd2f9SPavel Zakharov 		dump_debug_buffer();
5324fa9e4066Sahrens 		exit(rc);
532529bdd2f9SPavel Zakharov 	}
5326fa9e4066Sahrens }
5327fa9e4066Sahrens 
532844cd46caSbillm #define	ZDB_FLAG_CHECKSUM	0x0001
532944cd46caSbillm #define	ZDB_FLAG_DECOMPRESS	0x0002
533044cd46caSbillm #define	ZDB_FLAG_BSWAP		0x0004
533144cd46caSbillm #define	ZDB_FLAG_GBH		0x0008
533244cd46caSbillm #define	ZDB_FLAG_INDIRECT	0x0010
533344cd46caSbillm #define	ZDB_FLAG_PHYS		0x0020
533444cd46caSbillm #define	ZDB_FLAG_RAW		0x0040
533544cd46caSbillm #define	ZDB_FLAG_PRINT_BLKPTR	0x0080
533644cd46caSbillm 
53373f7978d0SAlan Somers static int flagbits[256];
533844cd46caSbillm 
533944cd46caSbillm static void
534044cd46caSbillm zdb_print_blkptr(blkptr_t *bp, int flags)
534144cd46caSbillm {
5342b24ab676SJeff Bonwick 	char blkbuf[BP_SPRINTF_LEN];
534344cd46caSbillm 
534444cd46caSbillm 	if (flags & ZDB_FLAG_BSWAP)
534544cd46caSbillm 		byteswap_uint64_array((void *)bp, sizeof (blkptr_t));
5346b24ab676SJeff Bonwick 
534743466aaeSMax Grossman 	snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
5348b24ab676SJeff Bonwick 	(void) printf("%s\n", blkbuf);
534944cd46caSbillm }
535044cd46caSbillm 
535144cd46caSbillm static void
535244cd46caSbillm zdb_dump_indirect(blkptr_t *bp, int nbps, int flags)
535344cd46caSbillm {
535444cd46caSbillm 	int i;
535544cd46caSbillm 
535644cd46caSbillm 	for (i = 0; i < nbps; i++)
535744cd46caSbillm 		zdb_print_blkptr(&bp[i], flags);
535844cd46caSbillm }
535944cd46caSbillm 
536044cd46caSbillm static void
536144cd46caSbillm zdb_dump_gbh(void *buf, int flags)
536244cd46caSbillm {
536344cd46caSbillm 	zdb_dump_indirect((blkptr_t *)buf, SPA_GBH_NBLKPTRS, flags);
536444cd46caSbillm }
536544cd46caSbillm 
536644cd46caSbillm static void
536744cd46caSbillm zdb_dump_block_raw(void *buf, uint64_t size, int flags)
536844cd46caSbillm {
536944cd46caSbillm 	if (flags & ZDB_FLAG_BSWAP)
537044cd46caSbillm 		byteswap_uint64_array(buf, size);
5371b24ab676SJeff Bonwick 	(void) write(1, buf, size);
537244cd46caSbillm }
537344cd46caSbillm 
537444cd46caSbillm static void
537544cd46caSbillm zdb_dump_block(char *label, void *buf, uint64_t size, int flags)
537644cd46caSbillm {
537744cd46caSbillm 	uint64_t *d = (uint64_t *)buf;
53783f7978d0SAlan Somers 	unsigned nwords = size / sizeof (uint64_t);
537944cd46caSbillm 	int do_bswap = !!(flags & ZDB_FLAG_BSWAP);
53803f7978d0SAlan Somers 	unsigned i, j;
53813f7978d0SAlan Somers 	const char *hdr;
53823f7978d0SAlan Somers 	char *c;
538344cd46caSbillm 
538444cd46caSbillm 
538544cd46caSbillm 	if (do_bswap)
538644cd46caSbillm 		hdr = " 7 6 5 4 3 2 1 0   f e d c b a 9 8";
538744cd46caSbillm 	else
538844cd46caSbillm 		hdr = " 0 1 2 3 4 5 6 7   8 9 a b c d e f";
538944cd46caSbillm 
539044cd46caSbillm 	(void) printf("\n%s\n%6s   %s  0123456789abcdef\n", label, "", hdr);
539144cd46caSbillm 
539244cd46caSbillm 	for (i = 0; i < nwords; i += 2) {
539344cd46caSbillm 		(void) printf("%06llx:  %016llx  %016llx  ",
539444cd46caSbillm 		    (u_longlong_t)(i * sizeof (uint64_t)),
539544cd46caSbillm 		    (u_longlong_t)(do_bswap ? BSWAP_64(d[i]) : d[i]),
539644cd46caSbillm 		    (u_longlong_t)(do_bswap ? BSWAP_64(d[i + 1]) : d[i + 1]));
539744cd46caSbillm 
539844cd46caSbillm 		c = (char *)&d[i];
539944cd46caSbillm 		for (j = 0; j < 2 * sizeof (uint64_t); j++)
540044cd46caSbillm 			(void) printf("%c", isprint(c[j]) ? c[j] : '.');
540144cd46caSbillm 		(void) printf("\n");
540244cd46caSbillm 	}
540344cd46caSbillm }
540444cd46caSbillm 
540544cd46caSbillm /*
540644cd46caSbillm  * There are two acceptable formats:
540744cd46caSbillm  *	leaf_name	  - For example: c1t0d0 or /tmp/ztest.0a
540844cd46caSbillm  *	child[.child]*    - For example: 0.1.1
540944cd46caSbillm  *
541044cd46caSbillm  * The second form can be used to specify arbitrary vdevs anywhere
541144cd46caSbillm  * in the heirarchy.  For example, in a pool with a mirror of
541244cd46caSbillm  * RAID-Zs, you can specify either RAID-Z vdev with 0.0 or 0.1 .
541344cd46caSbillm  */
541444cd46caSbillm static vdev_t *
54153f7978d0SAlan Somers zdb_vdev_lookup(vdev_t *vdev, const char *path)
541644cd46caSbillm {
541744cd46caSbillm 	char *s, *p, *q;
54183f7978d0SAlan Somers 	unsigned i;
541944cd46caSbillm 
542044cd46caSbillm 	if (vdev == NULL)
542144cd46caSbillm 		return (NULL);
542244cd46caSbillm 
542344cd46caSbillm 	/* First, assume the x.x.x.x format */
54243f7978d0SAlan Somers 	i = strtoul(path, &s, 10);
542544cd46caSbillm 	if (s == path || (s && *s != '.' && *s != '\0'))
542644cd46caSbillm 		goto name;
54273f7978d0SAlan Somers 	if (i >= vdev->vdev_children)
542844cd46caSbillm 		return (NULL);
542944cd46caSbillm 
543044cd46caSbillm 	vdev = vdev->vdev_child[i];
543144cd46caSbillm 	if (*s == '\0')
543244cd46caSbillm 		return (vdev);
543344cd46caSbillm 	return (zdb_vdev_lookup(vdev, s+1));
543444cd46caSbillm 
543544cd46caSbillm name:
543644cd46caSbillm 	for (i = 0; i < vdev->vdev_children; i++) {
543744cd46caSbillm 		vdev_t *vc = vdev->vdev_child[i];
543844cd46caSbillm 
543944cd46caSbillm 		if (vc->vdev_path == NULL) {
544044cd46caSbillm 			vc = zdb_vdev_lookup(vc, path);
544144cd46caSbillm 			if (vc == NULL)
544244cd46caSbillm 				continue;
544344cd46caSbillm 			else
544444cd46caSbillm 				return (vc);
544544cd46caSbillm 		}
544644cd46caSbillm 
544744cd46caSbillm 		p = strrchr(vc->vdev_path, '/');
544844cd46caSbillm 		p = p ? p + 1 : vc->vdev_path;
544944cd46caSbillm 		q = &vc->vdev_path[strlen(vc->vdev_path) - 2];
545044cd46caSbillm 
545144cd46caSbillm 		if (strcmp(vc->vdev_path, path) == 0)
545244cd46caSbillm 			return (vc);
545344cd46caSbillm 		if (strcmp(p, path) == 0)
545444cd46caSbillm 			return (vc);
545544cd46caSbillm 		if (strcmp(q, "s0") == 0 && strncmp(p, path, q - p) == 0)
545644cd46caSbillm 			return (vc);
545744cd46caSbillm 	}
545844cd46caSbillm 
545944cd46caSbillm 	return (NULL);
546044cd46caSbillm }
546144cd46caSbillm 
5462770499e1SDan Kimmel /* ARGSUSED */
5463770499e1SDan Kimmel static int
5464770499e1SDan Kimmel random_get_pseudo_bytes_cb(void *buf, size_t len, void *unused)
5465770499e1SDan Kimmel {
5466770499e1SDan Kimmel 	return (random_get_pseudo_bytes(buf, len));
5467770499e1SDan Kimmel }
5468770499e1SDan Kimmel 
546944cd46caSbillm /*
547044cd46caSbillm  * Read a block from a pool and print it out.  The syntax of the
547144cd46caSbillm  * block descriptor is:
547244cd46caSbillm  *
547344cd46caSbillm  *	pool:vdev_specifier:offset:size[:flags]
547444cd46caSbillm  *
547544cd46caSbillm  *	pool           - The name of the pool you wish to read from
547644cd46caSbillm  *	vdev_specifier - Which vdev (see comment for zdb_vdev_lookup)
547744cd46caSbillm  *	offset         - offset, in hex, in bytes
547844cd46caSbillm  *	size           - Amount of data to read, in hex, in bytes
547944cd46caSbillm  *	flags          - A string of characters specifying options
548044cd46caSbillm  *		 b: Decode a blkptr at given offset within block
548144cd46caSbillm  *		*c: Calculate and display checksums
5482b24ab676SJeff Bonwick  *		 d: Decompress data before dumping
548344cd46caSbillm  *		 e: Byteswap data before dumping
5484b24ab676SJeff Bonwick  *		 g: Display data as a gang block header
5485b24ab676SJeff Bonwick  *		 i: Display as an indirect block
548644cd46caSbillm  *		 p: Do I/O to physical offset
548744cd46caSbillm  *		 r: Dump raw data to stdout
548844cd46caSbillm  *
548944cd46caSbillm  *              * = not yet implemented
549044cd46caSbillm  */
549144cd46caSbillm static void
549207428bdfSVictor Latushkin zdb_read_block(char *thing, spa_t *spa)
549344cd46caSbillm {
5494b24ab676SJeff Bonwick 	blkptr_t blk, *bp = &blk;
5495b24ab676SJeff Bonwick 	dva_t *dva = bp->blk_dva;
549644cd46caSbillm 	int flags = 0;
5497b24ab676SJeff Bonwick 	uint64_t offset = 0, size = 0, psize = 0, lsize = 0, blkptr_offset = 0;
549844cd46caSbillm 	zio_t *zio;
549944cd46caSbillm 	vdev_t *vd;
5500770499e1SDan Kimmel 	abd_t *pabd;
5501770499e1SDan Kimmel 	void *lbuf, *buf;
55023f7978d0SAlan Somers 	const char *s, *vdev;
55033f7978d0SAlan Somers 	char *p, *dup, *flagstr;
5504b24ab676SJeff Bonwick 	int i, error;
550544cd46caSbillm 
550644cd46caSbillm 	dup = strdup(thing);
550744cd46caSbillm 	s = strtok(dup, ":");
550844cd46caSbillm 	vdev = s ? s : "";
550944cd46caSbillm 	s = strtok(NULL, ":");
551044cd46caSbillm 	offset = strtoull(s ? s : "", NULL, 16);
551144cd46caSbillm 	s = strtok(NULL, ":");
551244cd46caSbillm 	size = strtoull(s ? s : "", NULL, 16);
551344cd46caSbillm 	s = strtok(NULL, ":");
55143f7978d0SAlan Somers 	if (s)
55153f7978d0SAlan Somers 		flagstr = strdup(s);
55163f7978d0SAlan Somers 	else
55173f7978d0SAlan Somers 		flagstr = strdup("");
551844cd46caSbillm 
551944cd46caSbillm 	s = NULL;
552044cd46caSbillm 	if (size == 0)
552144cd46caSbillm 		s = "size must not be zero";
552244cd46caSbillm 	if (!IS_P2ALIGNED(size, DEV_BSIZE))
552344cd46caSbillm 		s = "size must be a multiple of sector size";
552444cd46caSbillm 	if (!IS_P2ALIGNED(offset, DEV_BSIZE))
552544cd46caSbillm 		s = "offset must be a multiple of sector size";
552644cd46caSbillm 	if (s) {
552744cd46caSbillm 		(void) printf("Invalid block specifier: %s  - %s\n", thing, s);
552844cd46caSbillm 		free(dup);
552944cd46caSbillm 		return;
553044cd46caSbillm 	}
553144cd46caSbillm 
553244cd46caSbillm 	for (s = strtok(flagstr, ":"); s; s = strtok(NULL, ":")) {
553344cd46caSbillm 		for (i = 0; flagstr[i]; i++) {
55345ad82045Snd 			int bit = flagbits[(uchar_t)flagstr[i]];
553544cd46caSbillm 
553644cd46caSbillm 			if (bit == 0) {
553744cd46caSbillm 				(void) printf("***Invalid flag: %c\n",
553844cd46caSbillm 				    flagstr[i]);
553944cd46caSbillm 				continue;
554044cd46caSbillm 			}
554144cd46caSbillm 			flags |= bit;
554244cd46caSbillm 
554344cd46caSbillm 			/* If it's not something with an argument, keep going */
5544b24ab676SJeff Bonwick 			if ((bit & (ZDB_FLAG_CHECKSUM |
554544cd46caSbillm 			    ZDB_FLAG_PRINT_BLKPTR)) == 0)
554644cd46caSbillm 				continue;
554744cd46caSbillm 
554844cd46caSbillm 			p = &flagstr[i + 1];
554944cd46caSbillm 			if (bit == ZDB_FLAG_PRINT_BLKPTR)
555044cd46caSbillm 				blkptr_offset = strtoull(p, &p, 16);
555144cd46caSbillm 			if (*p != ':' && *p != '\0') {
555244cd46caSbillm 				(void) printf("***Invalid flag arg: '%s'\n", s);
555344cd46caSbillm 				free(dup);
555444cd46caSbillm 				return;
555544cd46caSbillm 			}
555644cd46caSbillm 		}
555744cd46caSbillm 	}
55583f7978d0SAlan Somers 	free(flagstr);
555944cd46caSbillm 
556044cd46caSbillm 	vd = zdb_vdev_lookup(spa->spa_root_vdev, vdev);
556144cd46caSbillm 	if (vd == NULL) {
556244cd46caSbillm 		(void) printf("***Invalid vdev: %s\n", vdev);
556344cd46caSbillm 		free(dup);
556444cd46caSbillm 		return;
556544cd46caSbillm 	} else {
556644cd46caSbillm 		if (vd->vdev_path)
5567b24ab676SJeff Bonwick 			(void) fprintf(stderr, "Found vdev: %s\n",
5568b24ab676SJeff Bonwick 			    vd->vdev_path);
556944cd46caSbillm 		else
5570b24ab676SJeff Bonwick 			(void) fprintf(stderr, "Found vdev type: %s\n",
557144cd46caSbillm 			    vd->vdev_ops->vdev_op_type);
557244cd46caSbillm 	}
557344cd46caSbillm 
5574b24ab676SJeff Bonwick 	psize = size;
5575b24ab676SJeff Bonwick 	lsize = size;
557644cd46caSbillm 
5577770499e1SDan Kimmel 	pabd = abd_alloc_linear(SPA_MAXBLOCKSIZE, B_FALSE);
5578b24ab676SJeff Bonwick 	lbuf = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
5579b24ab676SJeff Bonwick 
5580b24ab676SJeff Bonwick 	BP_ZERO(bp);
5581b24ab676SJeff Bonwick 
5582b24ab676SJeff Bonwick 	DVA_SET_VDEV(&dva[0], vd->vdev_id);
5583b24ab676SJeff Bonwick 	DVA_SET_OFFSET(&dva[0], offset);
5584b24ab676SJeff Bonwick 	DVA_SET_GANG(&dva[0], !!(flags & ZDB_FLAG_GBH));
5585b24ab676SJeff Bonwick 	DVA_SET_ASIZE(&dva[0], vdev_psize_to_asize(vd, psize));
5586b24ab676SJeff Bonwick 
5587b24ab676SJeff Bonwick 	BP_SET_BIRTH(bp, TXG_INITIAL, TXG_INITIAL);
5588b24ab676SJeff Bonwick 
5589b24ab676SJeff Bonwick 	BP_SET_LSIZE(bp, lsize);
5590b24ab676SJeff Bonwick 	BP_SET_PSIZE(bp, psize);
5591b24ab676SJeff Bonwick 	BP_SET_COMPRESS(bp, ZIO_COMPRESS_OFF);
5592b24ab676SJeff Bonwick 	BP_SET_CHECKSUM(bp, ZIO_CHECKSUM_OFF);
5593b24ab676SJeff Bonwick 	BP_SET_TYPE(bp, DMU_OT_NONE);
5594b24ab676SJeff Bonwick 	BP_SET_LEVEL(bp, 0);
5595b24ab676SJeff Bonwick 	BP_SET_DEDUP(bp, 0);
5596b24ab676SJeff Bonwick 	BP_SET_BYTEORDER(bp, ZFS_HOST_BYTEORDER);
559744cd46caSbillm 
5598e14bb325SJeff Bonwick 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
559944cd46caSbillm 	zio = zio_root(spa, NULL, NULL, 0);
5600b24ab676SJeff Bonwick 
5601b24ab676SJeff Bonwick 	if (vd == vd->vdev_top) {
5602b24ab676SJeff Bonwick 		/*
5603b24ab676SJeff Bonwick 		 * Treat this as a normal block read.
5604b24ab676SJeff Bonwick 		 */
5605770499e1SDan Kimmel 		zio_nowait(zio_read(zio, spa, bp, pabd, psize, NULL, NULL,
5606b24ab676SJeff Bonwick 		    ZIO_PRIORITY_SYNC_READ,
5607b24ab676SJeff Bonwick 		    ZIO_FLAG_CANFAIL | ZIO_FLAG_RAW, NULL));
5608b24ab676SJeff Bonwick 	} else {
5609b24ab676SJeff Bonwick 		/*
5610b24ab676SJeff Bonwick 		 * Treat this as a vdev child I/O.
5611b24ab676SJeff Bonwick 		 */
5612770499e1SDan Kimmel 		zio_nowait(zio_vdev_child_io(zio, bp, vd, offset, pabd,
5613770499e1SDan Kimmel 		    psize, ZIO_TYPE_READ, ZIO_PRIORITY_SYNC_READ,
5614b24ab676SJeff Bonwick 		    ZIO_FLAG_DONT_CACHE | ZIO_FLAG_DONT_QUEUE |
5615b24ab676SJeff Bonwick 		    ZIO_FLAG_DONT_PROPAGATE | ZIO_FLAG_DONT_RETRY |
56165cabbc6bSPrashanth Sreenivasa 		    ZIO_FLAG_CANFAIL | ZIO_FLAG_RAW | ZIO_FLAG_OPTIONAL,
56175cabbc6bSPrashanth Sreenivasa 		    NULL, NULL));
5618b24ab676SJeff Bonwick 	}
5619b24ab676SJeff Bonwick 
562044cd46caSbillm 	error = zio_wait(zio);
5621e14bb325SJeff Bonwick 	spa_config_exit(spa, SCL_STATE, FTAG);
562244cd46caSbillm 
562344cd46caSbillm 	if (error) {
562444cd46caSbillm 		(void) printf("Read of %s failed, error: %d\n", thing, error);
562544cd46caSbillm 		goto out;
562644cd46caSbillm 	}
562744cd46caSbillm 
5628b24ab676SJeff Bonwick 	if (flags & ZDB_FLAG_DECOMPRESS) {
5629b24ab676SJeff Bonwick 		/*
5630b24ab676SJeff Bonwick 		 * We don't know how the data was compressed, so just try
5631b24ab676SJeff Bonwick 		 * every decompress function at every inflated blocksize.
5632b24ab676SJeff Bonwick 		 */
5633b24ab676SJeff Bonwick 		enum zio_compress c;
5634b24ab676SJeff Bonwick 		void *pbuf2 = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
5635b24ab676SJeff Bonwick 		void *lbuf2 = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
5636b24ab676SJeff Bonwick 
5637770499e1SDan Kimmel 		abd_copy_to_buf(pbuf2, pabd, psize);
5638b24ab676SJeff Bonwick 
5639770499e1SDan Kimmel 		VERIFY0(abd_iterate_func(pabd, psize, SPA_MAXBLOCKSIZE - psize,
5640770499e1SDan Kimmel 		    random_get_pseudo_bytes_cb, NULL));
5641b24ab676SJeff Bonwick 
5642770499e1SDan Kimmel 		VERIFY0(random_get_pseudo_bytes((uint8_t *)pbuf2 + psize,
5643770499e1SDan Kimmel 		    SPA_MAXBLOCKSIZE - psize));
5644b24ab676SJeff Bonwick 
5645b24ab676SJeff Bonwick 		for (lsize = SPA_MAXBLOCKSIZE; lsize > psize;
5646b24ab676SJeff Bonwick 		    lsize -= SPA_MINBLOCKSIZE) {
5647b24ab676SJeff Bonwick 			for (c = 0; c < ZIO_COMPRESS_FUNCTIONS; c++) {
5648770499e1SDan Kimmel 				if (zio_decompress_data(c, pabd,
5649770499e1SDan Kimmel 				    lbuf, psize, lsize) == 0 &&
5650770499e1SDan Kimmel 				    zio_decompress_data_buf(c, pbuf2,
5651770499e1SDan Kimmel 				    lbuf2, psize, lsize) == 0 &&
5652b24ab676SJeff Bonwick 				    bcmp(lbuf, lbuf2, lsize) == 0)
5653b24ab676SJeff Bonwick 					break;
5654b24ab676SJeff Bonwick 			}
5655b24ab676SJeff Bonwick 			if (c != ZIO_COMPRESS_FUNCTIONS)
5656b24ab676SJeff Bonwick 				break;
5657b24ab676SJeff Bonwick 			lsize -= SPA_MINBLOCKSIZE;
5658b24ab676SJeff Bonwick 		}
5659b24ab676SJeff Bonwick 
5660b24ab676SJeff Bonwick 		umem_free(pbuf2, SPA_MAXBLOCKSIZE);
5661b24ab676SJeff Bonwick 		umem_free(lbuf2, SPA_MAXBLOCKSIZE);
5662b24ab676SJeff Bonwick 
5663b24ab676SJeff Bonwick 		if (lsize <= psize) {
5664b24ab676SJeff Bonwick 			(void) printf("Decompress of %s failed\n", thing);
5665b24ab676SJeff Bonwick 			goto out;
5666b24ab676SJeff Bonwick 		}
5667b24ab676SJeff Bonwick 		buf = lbuf;
5668b24ab676SJeff Bonwick 		size = lsize;
5669b24ab676SJeff Bonwick 	} else {
5670770499e1SDan Kimmel 		buf = abd_to_buf(pabd);
5671b24ab676SJeff Bonwick 		size = psize;
5672b24ab676SJeff Bonwick 	}
5673b24ab676SJeff Bonwick 
567444cd46caSbillm 	if (flags & ZDB_FLAG_PRINT_BLKPTR)
567544cd46caSbillm 		zdb_print_blkptr((blkptr_t *)(void *)
567644cd46caSbillm 		    ((uintptr_t)buf + (uintptr_t)blkptr_offset), flags);
567744cd46caSbillm 	else if (flags & ZDB_FLAG_RAW)
567844cd46caSbillm 		zdb_dump_block_raw(buf, size, flags);
567944cd46caSbillm 	else if (flags & ZDB_FLAG_INDIRECT)
568044cd46caSbillm 		zdb_dump_indirect((blkptr_t *)buf, size / sizeof (blkptr_t),
568144cd46caSbillm 		    flags);
568244cd46caSbillm 	else if (flags & ZDB_FLAG_GBH)
568344cd46caSbillm 		zdb_dump_gbh(buf, flags);
568444cd46caSbillm 	else
568544cd46caSbillm 		zdb_dump_block(thing, buf, size, flags);
568644cd46caSbillm 
568744cd46caSbillm out:
5688770499e1SDan Kimmel 	abd_free(pabd);
5689b24ab676SJeff Bonwick 	umem_free(lbuf, SPA_MAXBLOCKSIZE);
569044cd46caSbillm 	free(dup);
569144cd46caSbillm }
569244cd46caSbillm 
56934923c69fSMatthew Ahrens static void
56944923c69fSMatthew Ahrens zdb_embedded_block(char *thing)
56954923c69fSMatthew Ahrens {
56963f7978d0SAlan Somers 	blkptr_t bp;
56974923c69fSMatthew Ahrens 	unsigned long long *words = (void *)&bp;
569803a4c2f4SJorgen Lundman 	char *buf;
56994923c69fSMatthew Ahrens 	int err;
57004923c69fSMatthew Ahrens 
57013f7978d0SAlan Somers 	bzero(&bp, sizeof (bp));
57024923c69fSMatthew Ahrens 	err = sscanf(thing, "%llx:%llx:%llx:%llx:%llx:%llx:%llx:%llx:"
57034923c69fSMatthew Ahrens 	    "%llx:%llx:%llx:%llx:%llx:%llx:%llx:%llx",
57044923c69fSMatthew Ahrens 	    words + 0, words + 1, words + 2, words + 3,
57054923c69fSMatthew Ahrens 	    words + 4, words + 5, words + 6, words + 7,
57064923c69fSMatthew Ahrens 	    words + 8, words + 9, words + 10, words + 11,
57074923c69fSMatthew Ahrens 	    words + 12, words + 13, words + 14, words + 15);
57084923c69fSMatthew Ahrens 	if (err != 16) {
570903a4c2f4SJorgen Lundman 		(void) fprintf(stderr, "invalid input format\n");
57104923c69fSMatthew Ahrens 		exit(1);
57114923c69fSMatthew Ahrens 	}
57124923c69fSMatthew Ahrens 	ASSERT3U(BPE_GET_LSIZE(&bp), <=, SPA_MAXBLOCKSIZE);
571303a4c2f4SJorgen Lundman 	buf = malloc(SPA_MAXBLOCKSIZE);
571403a4c2f4SJorgen Lundman 	if (buf == NULL) {
571503a4c2f4SJorgen Lundman 		(void) fprintf(stderr, "out of memory\n");
571603a4c2f4SJorgen Lundman 		exit(1);
571703a4c2f4SJorgen Lundman 	}
57184923c69fSMatthew Ahrens 	err = decode_embedded_bp(&bp, buf, BPE_GET_LSIZE(&bp));
57194923c69fSMatthew Ahrens 	if (err != 0) {
572003a4c2f4SJorgen Lundman 		(void) fprintf(stderr, "decode failed: %u\n", err);
57214923c69fSMatthew Ahrens 		exit(1);
57224923c69fSMatthew Ahrens 	}
57234923c69fSMatthew Ahrens 	zdb_dump_block_raw(buf, BPE_GET_LSIZE(&bp), 0);
572403a4c2f4SJorgen Lundman 	free(buf);
57254923c69fSMatthew Ahrens }
57264923c69fSMatthew Ahrens 
5727fa9e4066Sahrens int
5728fa9e4066Sahrens main(int argc, char **argv)
5729fa9e4066Sahrens {
57303f7978d0SAlan Somers 	int c;
5731fa9e4066Sahrens 	struct rlimit rl = { 1024, 1024 };
57323ad6c7f9SVictor Latushkin 	spa_t *spa = NULL;
5733fa9e4066Sahrens 	objset_t *os = NULL;
5734fa9e4066Sahrens 	int dump_all = 1;
5735fa9e4066Sahrens 	int verbose = 0;
5736c8ee1847SVictor Latushkin 	int error = 0;
57373ad6c7f9SVictor Latushkin 	char **searchdirs = NULL;
57383ad6c7f9SVictor Latushkin 	int nsearch = 0;
5739e0f1c0afSOlaf Faaland 	char *target, *target_pool;
5740468c413aSTim Haley 	nvlist_t *policy = NULL;
5741468c413aSTim Haley 	uint64_t max_txg = UINT64_MAX;
5742dfd5965fSRichard Yao 	int flags = ZFS_IMPORT_MISSING_LOG;
5743c8ee1847SVictor Latushkin 	int rewind = ZPOOL_NEVER_REWIND;
5744ae24175bSCyril Plisko 	char *spa_config_path_env;
5745b702644aSTim Chase 	boolean_t target_is_spa = B_TRUE;
574686714001SSerapheim Dimitropoulos 	nvlist_t *cfg = NULL;
5747fa9e4066Sahrens 
5748fa9e4066Sahrens 	(void) setrlimit(RLIMIT_NOFILE, &rl);
5749004388ebScasper 	(void) enable_extended_FILE_stdio(-1, -1);
5750fa9e4066Sahrens 
5751fa9e4066Sahrens 	dprintf_setup(&argc, argv);
5752fa9e4066Sahrens 
5753ae24175bSCyril Plisko 	/*
5754ae24175bSCyril Plisko 	 * If there is an environment variable SPA_CONFIG_PATH it overrides
5755ae24175bSCyril Plisko 	 * default spa_config_path setting. If -U flag is specified it will
5756ae24175bSCyril Plisko 	 * override this environment variable settings once again.
5757ae24175bSCyril Plisko 	 */
5758ae24175bSCyril Plisko 	spa_config_path_env = getenv("SPA_CONFIG_PATH");
5759ae24175bSCyril Plisko 	if (spa_config_path_env != NULL)
5760ae24175bSCyril Plisko 		spa_config_path = spa_config_path_env;
5761ae24175bSCyril Plisko 
5762df15e419SMatthew Ahrens 	while ((c = getopt(argc, argv,
576386714001SSerapheim Dimitropoulos 	    "AbcCdDeEFGhiI:klLmMo:Op:PqRsSt:uU:vVx:X")) != -1) {
5764fa9e4066Sahrens 		switch (c) {
5765fa9e4066Sahrens 		case 'b':
5766fa9e4066Sahrens 		case 'c':
5767ed61ec1dSYuri Pankov 		case 'C':
5768b24ab676SJeff Bonwick 		case 'd':
5769ed61ec1dSYuri Pankov 		case 'D':
57704923c69fSMatthew Ahrens 		case 'E':
5771ed61ec1dSYuri Pankov 		case 'G':
5772b24ab676SJeff Bonwick 		case 'h':
5773b24ab676SJeff Bonwick 		case 'i':
5774b24ab676SJeff Bonwick 		case 'l':
5775d6e555bdSGeorge Wilson 		case 'm':
57762e4c9986SGeorge Wilson 		case 'M':
5777ed61ec1dSYuri Pankov 		case 'O':
577844cd46caSbillm 		case 'R':
5779ed61ec1dSYuri Pankov 		case 's':
5780b24ab676SJeff Bonwick 		case 'S':
5781ed61ec1dSYuri Pankov 		case 'u':
5782fa9e4066Sahrens 			dump_opt[c]++;
5783fa9e4066Sahrens 			dump_all = 0;
5784fa9e4066Sahrens 			break;
5785feef89cfSVictor Latushkin 		case 'A':
5786ed61ec1dSYuri Pankov 		case 'e':
5787c8ee1847SVictor Latushkin 		case 'F':
578886714001SSerapheim Dimitropoulos 		case 'k':
578982a0a985SVictor Latushkin 		case 'L':
57903f9d6ad7SLin Ling 		case 'P':
579164723e36SYuri Pankov 		case 'q':
5792ed61ec1dSYuri Pankov 		case 'X':
579382a0a985SVictor Latushkin 			dump_opt[c]++;
579482a0a985SVictor Latushkin 			break;
5795ed61ec1dSYuri Pankov 		/* NB: Sort single match options below. */
57962e4c9986SGeorge Wilson 		case 'I':
579731d7e8faSGeorge Wilson 			max_inflight = strtoull(optarg, NULL, 0);
579831d7e8faSGeorge Wilson 			if (max_inflight == 0) {
579931d7e8faSGeorge Wilson 				(void) fprintf(stderr, "maximum number "
580031d7e8faSGeorge Wilson 				    "of inflight I/Os must be greater "
580131d7e8faSGeorge Wilson 				    "than 0\n");
580231d7e8faSGeorge Wilson 				usage();
580331d7e8faSGeorge Wilson 			}
580431d7e8faSGeorge Wilson 			break;
5805ed61ec1dSYuri Pankov 		case 'o':
5806ed61ec1dSYuri Pankov 			error = set_global_var(optarg);
5807ed61ec1dSYuri Pankov 			if (error != 0)
5808ed61ec1dSYuri Pankov 				usage();
5809ed61ec1dSYuri Pankov 			break;
5810de6628f0Sck 		case 'p':
58113ad6c7f9SVictor Latushkin 			if (searchdirs == NULL) {
58123ad6c7f9SVictor Latushkin 				searchdirs = umem_alloc(sizeof (char *),
58133ad6c7f9SVictor Latushkin 				    UMEM_NOFAIL);
58143ad6c7f9SVictor Latushkin 			} else {
58153ad6c7f9SVictor Latushkin 				char **tmp = umem_alloc((nsearch + 1) *
58163ad6c7f9SVictor Latushkin 				    sizeof (char *), UMEM_NOFAIL);
58173ad6c7f9SVictor Latushkin 				bcopy(searchdirs, tmp, nsearch *
58183ad6c7f9SVictor Latushkin 				    sizeof (char *));
58193ad6c7f9SVictor Latushkin 				umem_free(searchdirs,
58203ad6c7f9SVictor Latushkin 				    nsearch * sizeof (char *));
58213ad6c7f9SVictor Latushkin 				searchdirs = tmp;
58223ad6c7f9SVictor Latushkin 			}
58233ad6c7f9SVictor Latushkin 			searchdirs[nsearch++] = optarg;
5824de6628f0Sck 			break;
58252e551927SVictor Latushkin 		case 't':
5826468c413aSTim Haley 			max_txg = strtoull(optarg, NULL, 0);
5827468c413aSTim Haley 			if (max_txg < TXG_INITIAL) {
58282e551927SVictor Latushkin 				(void) fprintf(stderr, "incorrect txg "
58292e551927SVictor Latushkin 				    "specified: %s\n", optarg);
58302e551927SVictor Latushkin 				usage();
58312e551927SVictor Latushkin 			}
58322e551927SVictor Latushkin 			break;
5833b24ab676SJeff Bonwick 		case 'U':
5834b24ab676SJeff Bonwick 			spa_config_path = optarg;
58354923c69fSMatthew Ahrens 			if (spa_config_path[0] != '/') {
58364923c69fSMatthew Ahrens 				(void) fprintf(stderr,
58374923c69fSMatthew Ahrens 				    "cachefile must be an absolute path "
58384923c69fSMatthew Ahrens 				    "(i.e. start with a slash)\n");
58394923c69fSMatthew Ahrens 				usage();
58404923c69fSMatthew Ahrens 			}
5841b24ab676SJeff Bonwick 			break;
58422e4c9986SGeorge Wilson 		case 'v':
58432e4c9986SGeorge Wilson 			verbose++;
58442e4c9986SGeorge Wilson 			break;
5845dfd5965fSRichard Yao 		case 'V':
5846dfd5965fSRichard Yao 			flags = ZFS_IMPORT_VERBATIM;
5847dfd5965fSRichard Yao 			break;
58482e4c9986SGeorge Wilson 		case 'x':
58492e4c9986SGeorge Wilson 			vn_dumpdir = optarg;
58502e4c9986SGeorge Wilson 			break;
5851fa9e4066Sahrens 		default:
5852fa9e4066Sahrens 			usage();
5853fa9e4066Sahrens 			break;
5854fa9e4066Sahrens 		}
5855fa9e4066Sahrens 	}
5856fa9e4066Sahrens 
58573ad6c7f9SVictor Latushkin 	if (!dump_opt['e'] && searchdirs != NULL) {
585888b7b0f2SMatthew Ahrens 		(void) fprintf(stderr, "-p option requires use of -e\n");
585988b7b0f2SMatthew Ahrens 		usage();
586088b7b0f2SMatthew Ahrens 	}
5861de6628f0Sck 
586206be9802SMatthew Ahrens 	/*
586306be9802SMatthew Ahrens 	 * ZDB does not typically re-read blocks; therefore limit the ARC
586406be9802SMatthew Ahrens 	 * to 256 MB, which can be used entirely for metadata.
586506be9802SMatthew Ahrens 	 */
586606be9802SMatthew Ahrens 	zfs_arc_max = zfs_arc_meta_limit = 256 * 1024 * 1024;
586706be9802SMatthew Ahrens 
5868f7950bf1SMatthew Ahrens 	/*
5869f7950bf1SMatthew Ahrens 	 * "zdb -c" uses checksum-verifying scrub i/os which are async reads.
5870f7950bf1SMatthew Ahrens 	 * "zdb -b" uses traversal prefetch which uses async reads.
5871f7950bf1SMatthew Ahrens 	 * For good performance, let several of them be active at once.
5872f7950bf1SMatthew Ahrens 	 */
5873f7950bf1SMatthew Ahrens 	zfs_vdev_async_read_max_active = 10;
5874f7950bf1SMatthew Ahrens 
58754dd77f9eSMatthew Ahrens 	/*
58764dd77f9eSMatthew Ahrens 	 * Disable reference tracking for better performance.
58774dd77f9eSMatthew Ahrens 	 */
58784dd77f9eSMatthew Ahrens 	reference_tracking_enable = B_FALSE;
58794dd77f9eSMatthew Ahrens 
5880e144c4e6SPavel Zakharov 	/*
5881e144c4e6SPavel Zakharov 	 * Do not fail spa_load when spa_load_verify fails. This is needed
5882e144c4e6SPavel Zakharov 	 * to load non-idle pools.
5883e144c4e6SPavel Zakharov 	 */
5884e144c4e6SPavel Zakharov 	spa_load_verify_dryrun = B_TRUE;
5885e144c4e6SPavel Zakharov 
5886fa9e4066Sahrens 	kernel_init(FREAD);
5887de6628f0Sck 	g_zfs = libzfs_init();
588891ebeef5Sahrens 	ASSERT(g_zfs != NULL);
5889fa9e4066Sahrens 
5890b24ab676SJeff Bonwick 	if (dump_all)
5891b24ab676SJeff Bonwick 		verbose = MAX(verbose, 1);
5892b24ab676SJeff Bonwick 
5893fa9e4066Sahrens 	for (c = 0; c < 256; c++) {
589486714001SSerapheim Dimitropoulos 		if (dump_all && strchr("AeEFklLOPRSX", c) == NULL)
5895fa9e4066Sahrens 			dump_opt[c] = 1;
5896fa9e4066Sahrens 		if (dump_opt[c])
5897fa9e4066Sahrens 			dump_opt[c] += verbose;
5898fa9e4066Sahrens 	}
5899fa9e4066Sahrens 
5900feef89cfSVictor Latushkin 	aok = (dump_opt['A'] == 1) || (dump_opt['A'] > 2);
5901feef89cfSVictor Latushkin 	zfs_recover = (dump_opt['A'] > 1);
5902feef89cfSVictor Latushkin 
5903fa9e4066Sahrens 	argc -= optind;
5904fa9e4066Sahrens 	argv += optind;
5905fa9e4066Sahrens 
590607428bdfSVictor Latushkin 	if (argc < 2 && dump_opt['R'])
590707428bdfSVictor Latushkin 		usage();
59084923c69fSMatthew Ahrens 
59094923c69fSMatthew Ahrens 	if (dump_opt['E']) {
59104923c69fSMatthew Ahrens 		if (argc != 1)
59114923c69fSMatthew Ahrens 			usage();
59124923c69fSMatthew Ahrens 		zdb_embedded_block(argv[0]);
59134923c69fSMatthew Ahrens 		return (0);
59144923c69fSMatthew Ahrens 	}
59154923c69fSMatthew Ahrens 
5916fa9e4066Sahrens 	if (argc < 1) {
59173ad6c7f9SVictor Latushkin 		if (!dump_opt['e'] && dump_opt['C']) {
5918e829d913Sck 			dump_cachefile(spa_config_path);
5919fa9e4066Sahrens 			return (0);
5920fa9e4066Sahrens 		}
5921fa9e4066Sahrens 		usage();
5922fa9e4066Sahrens 	}
5923fa9e4066Sahrens 
592464723e36SYuri Pankov 	if (dump_opt['l'])
592564723e36SYuri Pankov 		return (dump_label(argv[0]));
5926fa9e4066Sahrens 
5927ed61ec1dSYuri Pankov 	if (dump_opt['O']) {
5928ed61ec1dSYuri Pankov 		if (argc != 2)
5929ed61ec1dSYuri Pankov 			usage();
5930ed61ec1dSYuri Pankov 		dump_opt['v'] = verbose + 3;
5931ed61ec1dSYuri Pankov 		return (dump_path(argv[0], argv[1]));
5932ed61ec1dSYuri Pankov 	}
5933ed61ec1dSYuri Pankov 
5934c8ee1847SVictor Latushkin 	if (dump_opt['X'] || dump_opt['F'])
5935c8ee1847SVictor Latushkin 		rewind = ZPOOL_DO_REWIND |
5936c8ee1847SVictor Latushkin 		    (dump_opt['X'] ? ZPOOL_EXTREME_REWIND : 0);
5937c8ee1847SVictor Latushkin 
5938c8ee1847SVictor Latushkin 	if (nvlist_alloc(&policy, NV_UNIQUE_NAME_TYPE, 0) != 0 ||
59395dafeea3SPavel Zakharov 	    nvlist_add_uint64(policy, ZPOOL_LOAD_REQUEST_TXG, max_txg) != 0 ||
59405dafeea3SPavel Zakharov 	    nvlist_add_uint32(policy, ZPOOL_LOAD_REWIND_POLICY, rewind) != 0)
5941c8ee1847SVictor Latushkin 		fatal("internal error: %s", strerror(ENOMEM));
5942c8ee1847SVictor Latushkin 
5943c5904d13Seschrock 	error = 0;
59443ad6c7f9SVictor Latushkin 	target = argv[0];
5945990b4856Slling 
5946e0f1c0afSOlaf Faaland 	if (strpbrk(target, "/@") != NULL) {
5947e0f1c0afSOlaf Faaland 		size_t targetlen;
5948e0f1c0afSOlaf Faaland 
5949e0f1c0afSOlaf Faaland 		target_pool = strdup(target);
5950e0f1c0afSOlaf Faaland 		*strpbrk(target_pool, "/@") = '\0';
5951e0f1c0afSOlaf Faaland 
5952e0f1c0afSOlaf Faaland 		target_is_spa = B_FALSE;
5953e0f1c0afSOlaf Faaland 		targetlen = strlen(target);
5954e0f1c0afSOlaf Faaland 		if (targetlen && target[targetlen - 1] == '/')
5955e0f1c0afSOlaf Faaland 			target[targetlen - 1] = '\0';
5956e0f1c0afSOlaf Faaland 	} else {
5957e0f1c0afSOlaf Faaland 		target_pool = target;
5958e0f1c0afSOlaf Faaland 	}
5959e0f1c0afSOlaf Faaland 
59603ad6c7f9SVictor Latushkin 	if (dump_opt['e']) {
5961e0f1c0afSOlaf Faaland 		importargs_t args = { 0 };
5962990b4856Slling 
5963e0f1c0afSOlaf Faaland 		args.paths = nsearch;
5964e0f1c0afSOlaf Faaland 		args.path = searchdirs;
5965e0f1c0afSOlaf Faaland 		args.can_be_active = B_TRUE;
5966e0f1c0afSOlaf Faaland 
5967e0f1c0afSOlaf Faaland 		error = zpool_tryimport(g_zfs, target_pool, &cfg, &args);
5968e0f1c0afSOlaf Faaland 
5969e0f1c0afSOlaf Faaland 		if (error == 0) {
597086714001SSerapheim Dimitropoulos 
5971c8ee1847SVictor Latushkin 			if (nvlist_add_nvlist(cfg,
59725dafeea3SPavel Zakharov 			    ZPOOL_LOAD_POLICY, policy) != 0) {
5973468c413aSTim Haley 				fatal("can't open '%s': %s",
5974468c413aSTim Haley 				    target, strerror(ENOMEM));
5975468c413aSTim Haley 			}
5976e0f1c0afSOlaf Faaland 
5977e0f1c0afSOlaf Faaland 			if (dump_opt['C'] > 1) {
5978e0f1c0afSOlaf Faaland 				(void) printf("\nConfiguration for import:\n");
5979e0f1c0afSOlaf Faaland 				dump_nvlist(cfg, 8);
5980e0f1c0afSOlaf Faaland 			}
5981e0f1c0afSOlaf Faaland 
5982e0f1c0afSOlaf Faaland 			/*
5983e0f1c0afSOlaf Faaland 			 * Disable the activity check to allow examination of
5984e0f1c0afSOlaf Faaland 			 * active pools.
5985e0f1c0afSOlaf Faaland 			 */
5986e0f1c0afSOlaf Faaland 			error = spa_import(target_pool, cfg, NULL,
5987e0f1c0afSOlaf Faaland 			    flags | ZFS_IMPORT_SKIP_MMP);
5988de6628f0Sck 		}
5989c5904d13Seschrock 	}
5990c5904d13Seschrock 
599186714001SSerapheim Dimitropoulos 	char *checkpoint_pool = NULL;
599286714001SSerapheim Dimitropoulos 	char *checkpoint_target = NULL;
599386714001SSerapheim Dimitropoulos 	if (dump_opt['k']) {
599486714001SSerapheim Dimitropoulos 		checkpoint_pool = import_checkpointed_state(target, cfg,
599586714001SSerapheim Dimitropoulos 		    &checkpoint_target);
599686714001SSerapheim Dimitropoulos 
599786714001SSerapheim Dimitropoulos 		if (checkpoint_target != NULL)
599886714001SSerapheim Dimitropoulos 			target = checkpoint_target;
599986714001SSerapheim Dimitropoulos 
600086714001SSerapheim Dimitropoulos 	}
600186714001SSerapheim Dimitropoulos 
6002c5904d13Seschrock 	if (error == 0) {
600386714001SSerapheim Dimitropoulos 		if (dump_opt['k'] && (target_is_spa || dump_opt['R'])) {
600486714001SSerapheim Dimitropoulos 			ASSERT(checkpoint_pool != NULL);
600586714001SSerapheim Dimitropoulos 			ASSERT(checkpoint_target == NULL);
600686714001SSerapheim Dimitropoulos 
600786714001SSerapheim Dimitropoulos 			error = spa_open(checkpoint_pool, &spa, FTAG);
600886714001SSerapheim Dimitropoulos 			if (error != 0) {
600986714001SSerapheim Dimitropoulos 				fatal("Tried to open pool \"%s\" but "
601086714001SSerapheim Dimitropoulos 				    "spa_open() failed with error %d\n",
601186714001SSerapheim Dimitropoulos 				    checkpoint_pool, error);
601286714001SSerapheim Dimitropoulos 			}
601386714001SSerapheim Dimitropoulos 
601486714001SSerapheim Dimitropoulos 		} else if (target_is_spa || dump_opt['R']) {
6015e0f1c0afSOlaf Faaland 			zdb_set_skip_mmp(target);
601680eb36f2SGeorge Wilson 			error = spa_open_rewind(target, &spa, FTAG, policy,
601780eb36f2SGeorge Wilson 			    NULL);
60188f18d1faSGeorge Wilson 			if (error) {
60198f18d1faSGeorge Wilson 				/*
60208f18d1faSGeorge Wilson 				 * If we're missing the log device then
60218f18d1faSGeorge Wilson 				 * try opening the pool after clearing the
60228f18d1faSGeorge Wilson 				 * log state.
60238f18d1faSGeorge Wilson 				 */
60248f18d1faSGeorge Wilson 				mutex_enter(&spa_namespace_lock);
60253ad6c7f9SVictor Latushkin 				if ((spa = spa_lookup(target)) != NULL &&
60268f18d1faSGeorge Wilson 				    spa->spa_log_state == SPA_LOG_MISSING) {
60278f18d1faSGeorge Wilson 					spa->spa_log_state = SPA_LOG_CLEAR;
60288f18d1faSGeorge Wilson 					error = 0;
60298f18d1faSGeorge Wilson 				}
60308f18d1faSGeorge Wilson 				mutex_exit(&spa_namespace_lock);
60318f18d1faSGeorge Wilson 
603280eb36f2SGeorge Wilson 				if (!error) {
603380eb36f2SGeorge Wilson 					error = spa_open_rewind(target, &spa,
603480eb36f2SGeorge Wilson 					    FTAG, policy, NULL);
603580eb36f2SGeorge Wilson 				}
60368f18d1faSGeorge Wilson 			}
603707428bdfSVictor Latushkin 		} else {
6038e0f1c0afSOlaf Faaland 			zdb_set_skip_mmp(target);
6039ed61ec1dSYuri Pankov 			error = open_objset(target, DMU_OST_ANY, FTAG, &os);
6040c5904d13Seschrock 		}
6041fa9e4066Sahrens 	}
604280eb36f2SGeorge Wilson 	nvlist_free(policy);
604380eb36f2SGeorge Wilson 
6044fa9e4066Sahrens 	if (error)
60453ad6c7f9SVictor Latushkin 		fatal("can't open '%s': %s", target, strerror(error));
6046fa9e4066Sahrens 
6047fa9e4066Sahrens 	argv++;
604807428bdfSVictor Latushkin 	argc--;
604907428bdfSVictor Latushkin 	if (!dump_opt['R']) {
605007428bdfSVictor Latushkin 		if (argc > 0) {
605107428bdfSVictor Latushkin 			zopt_objects = argc;
605207428bdfSVictor Latushkin 			zopt_object = calloc(zopt_objects, sizeof (uint64_t));
60533f7978d0SAlan Somers 			for (unsigned i = 0; i < zopt_objects; i++) {
605407428bdfSVictor Latushkin 				errno = 0;
605507428bdfSVictor Latushkin 				zopt_object[i] = strtoull(argv[i], NULL, 0);
605607428bdfSVictor Latushkin 				if (zopt_object[i] == 0 && errno != 0)
605787219db7SVictor Latushkin 					fatal("bad number %s: %s",
605807428bdfSVictor Latushkin 					    argv[i], strerror(errno));
605907428bdfSVictor Latushkin 			}
6060fa9e4066Sahrens 		}
6061e690fb27SChristopher Siden 		if (os != NULL) {
6062e690fb27SChristopher Siden 			dump_dir(os);
6063e690fb27SChristopher Siden 		} else if (zopt_objects > 0 && !dump_opt['m']) {
6064e690fb27SChristopher Siden 			dump_dir(spa->spa_meta_objset);
6065e690fb27SChristopher Siden 		} else {
6066e690fb27SChristopher Siden 			dump_zpool(spa);
6067e690fb27SChristopher Siden 		}
6068fa9e4066Sahrens 	} else {
606907428bdfSVictor Latushkin 		flagbits['b'] = ZDB_FLAG_PRINT_BLKPTR;
607007428bdfSVictor Latushkin 		flagbits['c'] = ZDB_FLAG_CHECKSUM;
607107428bdfSVictor Latushkin 		flagbits['d'] = ZDB_FLAG_DECOMPRESS;
607207428bdfSVictor Latushkin 		flagbits['e'] = ZDB_FLAG_BSWAP;
607307428bdfSVictor Latushkin 		flagbits['g'] = ZDB_FLAG_GBH;
607407428bdfSVictor Latushkin 		flagbits['i'] = ZDB_FLAG_INDIRECT;
607507428bdfSVictor Latushkin 		flagbits['p'] = ZDB_FLAG_PHYS;
607607428bdfSVictor Latushkin 		flagbits['r'] = ZDB_FLAG_RAW;
607707428bdfSVictor Latushkin 
60783f7978d0SAlan Somers 		for (int i = 0; i < argc; i++)
607907428bdfSVictor Latushkin 			zdb_read_block(argv[i], spa);
6080fa9e4066Sahrens 	}
6081fa9e4066Sahrens 
608286714001SSerapheim Dimitropoulos 	if (dump_opt['k']) {
608386714001SSerapheim Dimitropoulos 		free(checkpoint_pool);
608486714001SSerapheim Dimitropoulos 		if (!target_is_spa)
608586714001SSerapheim Dimitropoulos 			free(checkpoint_target);
608686714001SSerapheim Dimitropoulos 	}
608786714001SSerapheim Dimitropoulos 
6088ed61ec1dSYuri Pankov 	if (os != NULL)
6089ed61ec1dSYuri Pankov 		close_objset(os, FTAG);
6090ed61ec1dSYuri Pankov 	else
6091ed61ec1dSYuri Pankov 		spa_close(spa, FTAG);
609207428bdfSVictor Latushkin 
6093e0d35c44Smarks 	fuid_table_destroy();
6094e0d35c44Smarks 
609529bdd2f9SPavel Zakharov 	dump_debug_buffer();
609629bdd2f9SPavel Zakharov 
6097de6628f0Sck 	libzfs_fini(g_zfs);
6098fa9e4066Sahrens 	kernel_fini();
6099fa9e4066Sahrens 
610020b5dafbSPaul Dagnelie 	return (error);
6101fa9e4066Sahrens }
6102