xref: /illumos-gate/usr/src/cmd/zdb/zdb.c (revision 4923c69fddc0887da5604a262585af3efd82ee20)
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.
2429bdd2f9SPavel Zakharov  * Copyright (c) 2011, 2016 by Delphix. All rights reserved.
25c3d26abcSMatthew Ahrens  * Copyright (c) 2014 Integros [integros.com]
26ed61ec1dSYuri Pankov  * Copyright 2017 Nexenta Systems, Inc.
27fa9e4066Sahrens  */
28fa9e4066Sahrens 
29fa9e4066Sahrens #include <stdio.h>
30490d05b9SMatthew Ahrens #include <unistd.h>
31004388ebScasper #include <stdio_ext.h>
32fa9e4066Sahrens #include <stdlib.h>
3344cd46caSbillm #include <ctype.h>
34fa9e4066Sahrens #include <sys/zfs_context.h>
35fa9e4066Sahrens #include <sys/spa.h>
36fa9e4066Sahrens #include <sys/spa_impl.h>
37fa9e4066Sahrens #include <sys/dmu.h>
38fa9e4066Sahrens #include <sys/zap.h>
39fa9e4066Sahrens #include <sys/fs/zfs.h>
40fa9e4066Sahrens #include <sys/zfs_znode.h>
410a586ceaSMark Shellenbaum #include <sys/zfs_sa.h>
420a586ceaSMark Shellenbaum #include <sys/sa.h>
430a586ceaSMark Shellenbaum #include <sys/sa_impl.h>
44fa9e4066Sahrens #include <sys/vdev.h>
45fa9e4066Sahrens #include <sys/vdev_impl.h>
46fa9e4066Sahrens #include <sys/metaslab_impl.h>
47fa9e4066Sahrens #include <sys/dmu_objset.h>
48fa9e4066Sahrens #include <sys/dsl_dir.h>
49fa9e4066Sahrens #include <sys/dsl_dataset.h>
50fa9e4066Sahrens #include <sys/dsl_pool.h>
51fa9e4066Sahrens #include <sys/dbuf.h>
52fa9e4066Sahrens #include <sys/zil.h>
53fa9e4066Sahrens #include <sys/zil_impl.h>
54fa9e4066Sahrens #include <sys/stat.h>
55fa9e4066Sahrens #include <sys/resource.h>
56fa9e4066Sahrens #include <sys/dmu_traverse.h>
57fa9e4066Sahrens #include <sys/zio_checksum.h>
58fa9e4066Sahrens #include <sys/zio_compress.h>
59e0d35c44Smarks #include <sys/zfs_fuid.h>
6088b7b0f2SMatthew Ahrens #include <sys/arc.h>
61b24ab676SJeff Bonwick #include <sys/ddt.h>
62ad135b5dSChristopher Siden #include <sys/zfeature.h>
63770499e1SDan Kimmel #include <sys/abd.h>
64*4923c69fSMatthew Ahrens #include <sys/blkptr.h>
654445fffbSMatthew Ahrens #include <zfs_comutil.h>
66de6628f0Sck #undef verify
67de6628f0Sck #include <libzfs.h>
68fa9e4066Sahrens 
69e690fb27SChristopher Siden #define	ZDB_COMPRESS_NAME(idx) ((idx) < ZIO_COMPRESS_FUNCTIONS ?	\
70e690fb27SChristopher Siden 	zio_compress_table[(idx)].ci_name : "UNKNOWN")
71e690fb27SChristopher Siden #define	ZDB_CHECKSUM_NAME(idx) ((idx) < ZIO_CHECKSUM_FUNCTIONS ?	\
72e690fb27SChristopher Siden 	zio_checksum_table[(idx)].ci_name : "UNKNOWN")
73e690fb27SChristopher Siden #define	ZDB_OT_NAME(idx) ((idx) < DMU_OT_NUMTYPES ?	\
74e690fb27SChristopher Siden 	dmu_ot[(idx)].ot_name : DMU_OT_IS_VALID(idx) ?	\
75e690fb27SChristopher Siden 	dmu_ot_byteswap[DMU_OT_BYTESWAP(idx)].ob_name : "UNKNOWN")
76e690fb27SChristopher Siden #define	ZDB_OT_TYPE(idx) ((idx) < DMU_OT_NUMTYPES ? (idx) :		\
77e690fb27SChristopher Siden 	(((idx) == DMU_OTN_ZAP_DATA || (idx) == DMU_OTN_ZAP_METADATA) ?	\
78e690fb27SChristopher Siden 	DMU_OT_ZAP_OTHER : DMU_OT_NUMTYPES))
796de8f417SVictor Latushkin 
80feef89cfSVictor Latushkin #ifndef lint
814dd77f9eSMatthew Ahrens extern int reference_tracking_enable;
827fd05ac4SMatthew Ahrens extern boolean_t zfs_recover;
8306be9802SMatthew Ahrens extern uint64_t zfs_arc_max, zfs_arc_meta_limit;
84f7950bf1SMatthew Ahrens extern int zfs_vdev_async_read_max_active;
85feef89cfSVictor Latushkin #else
864dd77f9eSMatthew Ahrens int reference_tracking_enable;
877fd05ac4SMatthew Ahrens boolean_t zfs_recover;
8806be9802SMatthew Ahrens uint64_t zfs_arc_max, zfs_arc_meta_limit;
89f7950bf1SMatthew Ahrens int zfs_vdev_async_read_max_active;
90feef89cfSVictor Latushkin #endif
91feef89cfSVictor Latushkin 
92fa9e4066Sahrens const char cmdname[] = "zdb";
93fa9e4066Sahrens uint8_t dump_opt[256];
94fa9e4066Sahrens 
95fa9e4066Sahrens typedef void object_viewer_t(objset_t *, uint64_t, void *data, size_t size);
96fa9e4066Sahrens 
97fa9e4066Sahrens extern void dump_intent_log(zilog_t *);
98fa9e4066Sahrens uint64_t *zopt_object = NULL;
99fa9e4066Sahrens int zopt_objects = 0;
100de6628f0Sck libzfs_handle_t *g_zfs;
10106be9802SMatthew Ahrens uint64_t max_inflight = 1000;
102fa9e4066Sahrens 
103732885fcSMatthew Ahrens static void snprintf_blkptr_compact(char *, size_t, const blkptr_t *);
104732885fcSMatthew Ahrens 
105fa9e4066Sahrens /*
106fa9e4066Sahrens  * These libumem hooks provide a reasonable set of defaults for the allocator's
107fa9e4066Sahrens  * debugging facilities.
108fa9e4066Sahrens  */
109fa9e4066Sahrens const char *
110fa9e4066Sahrens _umem_debug_init()
111fa9e4066Sahrens {
112fa9e4066Sahrens 	return ("default,verbose"); /* $UMEM_DEBUG setting */
113fa9e4066Sahrens }
114fa9e4066Sahrens 
115fa9e4066Sahrens const char *
116fa9e4066Sahrens _umem_logging_init(void)
117fa9e4066Sahrens {
118fa9e4066Sahrens 	return ("fail,contents"); /* $UMEM_LOGGING setting */
119fa9e4066Sahrens }
120fa9e4066Sahrens 
121fa9e4066Sahrens static void
122fa9e4066Sahrens usage(void)
123fa9e4066Sahrens {
124fa9e4066Sahrens 	(void) fprintf(stderr,
125dfd5965fSRichard Yao 	    "Usage:\t%s [-AbcdDFGhiLMPsvX] [-e [-V] [-p <path> ...]] "
126ed61ec1dSYuri Pankov 	    "[-I <inflight I/Os>]\n"
127ed61ec1dSYuri Pankov 	    "\t\t[-o <var>=<value>]... [-t <txg>] [-U <cache>] [-x <dumpdir>]\n"
128ed61ec1dSYuri Pankov 	    "\t\t[<poolname> [<object> ...]]\n"
129dfd5965fSRichard Yao 	    "\t%s [-AdiPv] [-e [-V] [-p <path> ...]] [-U <cache>] <dataset> "
130ed61ec1dSYuri Pankov 	    "[<object> ...]\n"
131ed61ec1dSYuri Pankov 	    "\t%s -C [-A] [-U <cache>]\n"
132ed61ec1dSYuri Pankov 	    "\t%s -l [-Aqu] <device>\n"
133dfd5965fSRichard Yao 	    "\t%s -m [-AFLPX] [-e [-V] [-p <path> ...]] [-t <txg>] "
134dfd5965fSRichard Yao 	    "[-U <cache>]\n\t\t<poolname> [<vdev> [<metaslab> ...]]\n"
135ed61ec1dSYuri Pankov 	    "\t%s -O <dataset> <path>\n"
136dfd5965fSRichard Yao 	    "\t%s -R [-A] [-e [-V] [-p <path> ...]] [-U <cache>]\n"
137ed61ec1dSYuri Pankov 	    "\t\t<poolname> <vdev>:<offset>:<size>[:<flags>]\n"
138*4923c69fSMatthew Ahrens 	    "\t%s -E [-A] word0:word1:...:word15\n"
139dfd5965fSRichard Yao 	    "\t%s -S [-AP] [-e [-V] [-p <path> ...]] [-U <cache>] "
140dfd5965fSRichard Yao 	    "<poolname>\n\n",
141ed61ec1dSYuri Pankov 	    cmdname, cmdname, cmdname, cmdname, cmdname, cmdname, cmdname,
142*4923c69fSMatthew Ahrens 	    cmdname, cmdname);
1433ad6c7f9SVictor Latushkin 
1443ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    Dataset name must include at least one "
1453ad6c7f9SVictor Latushkin 	    "separator character '/' or '@'\n");
1463ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    If dataset name is specified, only that "
1473ad6c7f9SVictor Latushkin 	    "dataset is dumped\n");
1483ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    If object numbers are specified, only "
1493ad6c7f9SVictor Latushkin 	    "those objects are dumped\n\n");
1503ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    Options to control amount of output:\n");
1513ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -b block statistics\n");
1523ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -c checksum all metadata (twice for "
1536365109dSVictor Latushkin 	    "all data) blocks\n");
154ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -C config (or cachefile if alone)\n");
155ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -d dataset(s)\n");
156f0ba89beSJeff Bonwick 	(void) fprintf(stderr, "        -D dedup statistics\n");
157*4923c69fSMatthew Ahrens 	(void) fprintf(stderr, "        -E decode and display block from an "
158*4923c69fSMatthew Ahrens 	    "embedded block pointer\n");
159ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -h pool history\n");
160ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -i intent logs\n");
16164723e36SYuri Pankov 	(void) fprintf(stderr, "        -l read label contents\n");
16282a0a985SVictor Latushkin 	(void) fprintf(stderr, "        -L disable leak tracking (do not "
16382a0a985SVictor Latushkin 	    "load spacemaps)\n");
164ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -m metaslabs\n");
165ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -M metaslab groups\n");
166ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -O perform object lookups by path\n");
167d41e7643Sek 	(void) fprintf(stderr, "        -R read and display block from a "
168ed61ec1dSYuri Pankov 	    "device\n");
169ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -s report stats on zdb's I/O\n");
170ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -S simulate dedup to measure effect\n");
171ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -v verbose (applies to all "
172ed61ec1dSYuri Pankov 	    "others)\n\n");
1733ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    Below options are intended for use "
174df15e419SMatthew Ahrens 	    "with other options:\n");
175feef89cfSVictor Latushkin 	(void) fprintf(stderr, "        -A ignore assertions (-A), enable "
176feef89cfSVictor Latushkin 	    "panic recovery (-AA) or both (-AAA)\n");
1773ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -e pool is exported/destroyed/"
1783ad6c7f9SVictor Latushkin 	    "has altroot/not in a cachefile\n");
179ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -F attempt automatic rewind within "
180ed61ec1dSYuri Pankov 	    "safe range of transaction groups\n");
181ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -G dump zfs_dbgmsg buffer before "
182ed61ec1dSYuri Pankov 	    "exiting\n");
1832e4c9986SGeorge Wilson 	(void) fprintf(stderr, "        -I <number of inflight I/Os> -- "
184df15e419SMatthew Ahrens 	    "specify the maximum number of "
185df15e419SMatthew Ahrens 	    "checksumming I/Os [default is 200]\n");
1860e60744cSPavel Zakharov 	(void) fprintf(stderr, "        -o <variable>=<value> set global "
1870e60744cSPavel Zakharov 	    "variable to an unsigned 32-bit integer value\n");
188ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -p <path> -- use one or more with "
189ed61ec1dSYuri Pankov 	    "-e to specify path to vdev dir\n");
190ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -P print numbers in parseable form\n");
19164723e36SYuri Pankov 	(void) fprintf(stderr, "        -q don't print label contents\n");
192ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -t <txg> -- highest txg to use when "
193ed61ec1dSYuri Pankov 	    "searching for uberblocks\n");
19464723e36SYuri Pankov 	(void) fprintf(stderr, "        -u uberblock\n");
195ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -U <cachefile_path> -- use alternate "
196ed61ec1dSYuri Pankov 	    "cachefile\n");
197dfd5965fSRichard Yao 	(void) fprintf(stderr, "        -V do verbatim import\n");
198ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -x <dumpdir> -- "
199ed61ec1dSYuri Pankov 	    "dump all read blocks into specified directory\n");
200ed61ec1dSYuri Pankov 	(void) fprintf(stderr, "        -X attempt extreme rewind (does not "
201ed61ec1dSYuri Pankov 	    "work with dataset)\n\n");
202fa9e4066Sahrens 	(void) fprintf(stderr, "Specify an option more than once (e.g. -bb) "
203fa9e4066Sahrens 	    "to make only that option verbose\n");
204fa9e4066Sahrens 	(void) fprintf(stderr, "Default is to dump everything non-verbosely\n");
205fa9e4066Sahrens 	exit(1);
206fa9e4066Sahrens }
207fa9e4066Sahrens 
20829bdd2f9SPavel Zakharov static void
20929bdd2f9SPavel Zakharov dump_debug_buffer()
21029bdd2f9SPavel Zakharov {
21129bdd2f9SPavel Zakharov 	if (dump_opt['G']) {
21229bdd2f9SPavel Zakharov 		(void) printf("\n");
21329bdd2f9SPavel Zakharov 		zfs_dbgmsg_print("zdb");
21429bdd2f9SPavel Zakharov 	}
21529bdd2f9SPavel Zakharov }
21629bdd2f9SPavel Zakharov 
217ccba0801SRich Morris /*
218ccba0801SRich Morris  * Called for usage errors that are discovered after a call to spa_open(),
219ccba0801SRich Morris  * dmu_bonus_hold(), or pool_match().  abort() is called for other errors.
220ccba0801SRich Morris  */
221ccba0801SRich Morris 
222fa9e4066Sahrens static void
223fa9e4066Sahrens fatal(const char *fmt, ...)
224fa9e4066Sahrens {
225fa9e4066Sahrens 	va_list ap;
226fa9e4066Sahrens 
227fa9e4066Sahrens 	va_start(ap, fmt);
228fa9e4066Sahrens 	(void) fprintf(stderr, "%s: ", cmdname);
229fa9e4066Sahrens 	(void) vfprintf(stderr, fmt, ap);
230fa9e4066Sahrens 	va_end(ap);
231fa9e4066Sahrens 	(void) fprintf(stderr, "\n");
232fa9e4066Sahrens 
23329bdd2f9SPavel Zakharov 	dump_debug_buffer();
23429bdd2f9SPavel Zakharov 
235ccba0801SRich Morris 	exit(1);
236fa9e4066Sahrens }
237fa9e4066Sahrens 
238fa9e4066Sahrens /* ARGSUSED */
239fa9e4066Sahrens static void
240fa9e4066Sahrens dump_packed_nvlist(objset_t *os, uint64_t object, void *data, size_t size)
241fa9e4066Sahrens {
242fa9e4066Sahrens 	nvlist_t *nv;
243fa9e4066Sahrens 	size_t nvsize = *(uint64_t *)data;
244fa9e4066Sahrens 	char *packed = umem_alloc(nvsize, UMEM_NOFAIL);
245fa9e4066Sahrens 
2467bfdf011SNeil Perrin 	VERIFY(0 == dmu_read(os, object, 0, nvsize, packed, DMU_READ_PREFETCH));
247fa9e4066Sahrens 
248fa9e4066Sahrens 	VERIFY(nvlist_unpack(packed, nvsize, &nv, 0) == 0);
249fa9e4066Sahrens 
250fa9e4066Sahrens 	umem_free(packed, nvsize);
251fa9e4066Sahrens 
252fa9e4066Sahrens 	dump_nvlist(nv, 8);
253fa9e4066Sahrens 
254fa9e4066Sahrens 	nvlist_free(nv);
255fa9e4066Sahrens }
256fa9e4066Sahrens 
2574445fffbSMatthew Ahrens /* ARGSUSED */
2584445fffbSMatthew Ahrens static void
2594445fffbSMatthew Ahrens dump_history_offsets(objset_t *os, uint64_t object, void *data, size_t size)
2604445fffbSMatthew Ahrens {
2614445fffbSMatthew Ahrens 	spa_history_phys_t *shp = data;
2624445fffbSMatthew Ahrens 
2634445fffbSMatthew Ahrens 	if (shp == NULL)
2644445fffbSMatthew Ahrens 		return;
2654445fffbSMatthew Ahrens 
2664445fffbSMatthew Ahrens 	(void) printf("\t\tpool_create_len = %llu\n",
2674445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_pool_create_len);
2684445fffbSMatthew Ahrens 	(void) printf("\t\tphys_max_off = %llu\n",
2694445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_phys_max_off);
2704445fffbSMatthew Ahrens 	(void) printf("\t\tbof = %llu\n",
2714445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_bof);
2724445fffbSMatthew Ahrens 	(void) printf("\t\teof = %llu\n",
2734445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_eof);
2744445fffbSMatthew Ahrens 	(void) printf("\t\trecords_lost = %llu\n",
2754445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_records_lost);
2764445fffbSMatthew Ahrens }
2774445fffbSMatthew Ahrens 
2783f9d6ad7SLin Ling static void
2793f9d6ad7SLin Ling zdb_nicenum(uint64_t num, char *buf)
2803f9d6ad7SLin Ling {
2813f9d6ad7SLin Ling 	if (dump_opt['P'])
2823f9d6ad7SLin Ling 		(void) sprintf(buf, "%llu", (longlong_t)num);
2833f9d6ad7SLin Ling 	else
2843f9d6ad7SLin Ling 		nicenum(num, buf);
2853f9d6ad7SLin Ling }
2863f9d6ad7SLin Ling 
287490d05b9SMatthew Ahrens const char histo_stars[] = "****************************************";
288490d05b9SMatthew Ahrens const int histo_width = sizeof (histo_stars) - 1;
289fa9e4066Sahrens 
290fa9e4066Sahrens static void
2910713e232SGeorge Wilson dump_histogram(const uint64_t *histo, int size, int offset)
292fa9e4066Sahrens {
293fa9e4066Sahrens 	int i;
294490d05b9SMatthew Ahrens 	int minidx = size - 1;
295fa9e4066Sahrens 	int maxidx = 0;
296fa9e4066Sahrens 	uint64_t max = 0;
297fa9e4066Sahrens 
298490d05b9SMatthew Ahrens 	for (i = 0; i < size; i++) {
299fa9e4066Sahrens 		if (histo[i] > max)
300fa9e4066Sahrens 			max = histo[i];
301fa9e4066Sahrens 		if (histo[i] > 0 && i > maxidx)
302fa9e4066Sahrens 			maxidx = i;
303fa9e4066Sahrens 		if (histo[i] > 0 && i < minidx)
304fa9e4066Sahrens 			minidx = i;
305fa9e4066Sahrens 	}
306fa9e4066Sahrens 
307490d05b9SMatthew Ahrens 	if (max < histo_width)
308490d05b9SMatthew Ahrens 		max = histo_width;
309fa9e4066Sahrens 
310490d05b9SMatthew Ahrens 	for (i = minidx; i <= maxidx; i++) {
311490d05b9SMatthew Ahrens 		(void) printf("\t\t\t%3u: %6llu %s\n",
3120713e232SGeorge Wilson 		    i + offset, (u_longlong_t)histo[i],
313490d05b9SMatthew Ahrens 		    &histo_stars[(max - histo[i]) * histo_width / max]);
314490d05b9SMatthew Ahrens 	}
315fa9e4066Sahrens }
316fa9e4066Sahrens 
317fa9e4066Sahrens static void
318fa9e4066Sahrens dump_zap_stats(objset_t *os, uint64_t object)
319fa9e4066Sahrens {
320fa9e4066Sahrens 	int error;
321fa9e4066Sahrens 	zap_stats_t zs;
322fa9e4066Sahrens 
323fa9e4066Sahrens 	error = zap_get_stats(os, object, &zs);
324fa9e4066Sahrens 	if (error)
325fa9e4066Sahrens 		return;
326fa9e4066Sahrens 
327fa9e4066Sahrens 	if (zs.zs_ptrtbl_len == 0) {
328fa9e4066Sahrens 		ASSERT(zs.zs_num_blocks == 1);
329fa9e4066Sahrens 		(void) printf("\tmicrozap: %llu bytes, %llu entries\n",
330fa9e4066Sahrens 		    (u_longlong_t)zs.zs_blocksize,
331fa9e4066Sahrens 		    (u_longlong_t)zs.zs_num_entries);
332fa9e4066Sahrens 		return;
333fa9e4066Sahrens 	}
334fa9e4066Sahrens 
335fa9e4066Sahrens 	(void) printf("\tFat ZAP stats:\n");
3368248818dSnd 
3378248818dSnd 	(void) printf("\t\tPointer table:\n");
3388248818dSnd 	(void) printf("\t\t\t%llu elements\n",
339fa9e4066Sahrens 	    (u_longlong_t)zs.zs_ptrtbl_len);
3408248818dSnd 	(void) printf("\t\t\tzt_blk: %llu\n",
3418248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_zt_blk);
3428248818dSnd 	(void) printf("\t\t\tzt_numblks: %llu\n",
3438248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_zt_numblks);
3448248818dSnd 	(void) printf("\t\t\tzt_shift: %llu\n",
3458248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_zt_shift);
3468248818dSnd 	(void) printf("\t\t\tzt_blks_copied: %llu\n",
3478248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_blks_copied);
3488248818dSnd 	(void) printf("\t\t\tzt_nextblk: %llu\n",
3498248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_nextblk);
3508248818dSnd 
351fa9e4066Sahrens 	(void) printf("\t\tZAP entries: %llu\n",
352fa9e4066Sahrens 	    (u_longlong_t)zs.zs_num_entries);
353fa9e4066Sahrens 	(void) printf("\t\tLeaf blocks: %llu\n",
354fa9e4066Sahrens 	    (u_longlong_t)zs.zs_num_leafs);
355fa9e4066Sahrens 	(void) printf("\t\tTotal blocks: %llu\n",
356fa9e4066Sahrens 	    (u_longlong_t)zs.zs_num_blocks);
3578248818dSnd 	(void) printf("\t\tzap_block_type: 0x%llx\n",
3588248818dSnd 	    (u_longlong_t)zs.zs_block_type);
3598248818dSnd 	(void) printf("\t\tzap_magic: 0x%llx\n",
3608248818dSnd 	    (u_longlong_t)zs.zs_magic);
3618248818dSnd 	(void) printf("\t\tzap_salt: 0x%llx\n",
3628248818dSnd 	    (u_longlong_t)zs.zs_salt);
363fa9e4066Sahrens 
364fa9e4066Sahrens 	(void) printf("\t\tLeafs with 2^n pointers:\n");
3650713e232SGeorge Wilson 	dump_histogram(zs.zs_leafs_with_2n_pointers, ZAP_HISTOGRAM_SIZE, 0);
366fa9e4066Sahrens 
367fa9e4066Sahrens 	(void) printf("\t\tBlocks with n*5 entries:\n");
3680713e232SGeorge Wilson 	dump_histogram(zs.zs_blocks_with_n5_entries, ZAP_HISTOGRAM_SIZE, 0);
369fa9e4066Sahrens 
370fa9e4066Sahrens 	(void) printf("\t\tBlocks n/10 full:\n");
3710713e232SGeorge Wilson 	dump_histogram(zs.zs_blocks_n_tenths_full, ZAP_HISTOGRAM_SIZE, 0);
372fa9e4066Sahrens 
373fa9e4066Sahrens 	(void) printf("\t\tEntries with n chunks:\n");
3740713e232SGeorge Wilson 	dump_histogram(zs.zs_entries_using_n_chunks, ZAP_HISTOGRAM_SIZE, 0);
375fa9e4066Sahrens 
376fa9e4066Sahrens 	(void) printf("\t\tBuckets with n entries:\n");
3770713e232SGeorge Wilson 	dump_histogram(zs.zs_buckets_with_n_entries, ZAP_HISTOGRAM_SIZE, 0);
378fa9e4066Sahrens }
379fa9e4066Sahrens 
380fa9e4066Sahrens /*ARGSUSED*/
381fa9e4066Sahrens static void
382fa9e4066Sahrens dump_none(objset_t *os, uint64_t object, void *data, size_t size)
383fa9e4066Sahrens {
384fa9e4066Sahrens }
385fa9e4066Sahrens 
3866de8f417SVictor Latushkin /*ARGSUSED*/
3876de8f417SVictor Latushkin static void
3886de8f417SVictor Latushkin dump_unknown(objset_t *os, uint64_t object, void *data, size_t size)
3896de8f417SVictor Latushkin {
3906de8f417SVictor Latushkin 	(void) printf("\tUNKNOWN OBJECT TYPE\n");
3916de8f417SVictor Latushkin }
3926de8f417SVictor Latushkin 
393fa9e4066Sahrens /*ARGSUSED*/
394fa9e4066Sahrens void
395fa9e4066Sahrens dump_uint8(objset_t *os, uint64_t object, void *data, size_t size)
396fa9e4066Sahrens {
397fa9e4066Sahrens }
398fa9e4066Sahrens 
399fa9e4066Sahrens /*ARGSUSED*/
400fa9e4066Sahrens static void
401fa9e4066Sahrens dump_uint64(objset_t *os, uint64_t object, void *data, size_t size)
402fa9e4066Sahrens {
403fa9e4066Sahrens }
404fa9e4066Sahrens 
405fa9e4066Sahrens /*ARGSUSED*/
406fa9e4066Sahrens static void
407fa9e4066Sahrens dump_zap(objset_t *os, uint64_t object, void *data, size_t size)
408fa9e4066Sahrens {
409fa9e4066Sahrens 	zap_cursor_t zc;
410fa9e4066Sahrens 	zap_attribute_t attr;
411fa9e4066Sahrens 	void *prop;
412fa9e4066Sahrens 	int i;
413fa9e4066Sahrens 
414fa9e4066Sahrens 	dump_zap_stats(os, object);
415fa9e4066Sahrens 	(void) printf("\n");
416fa9e4066Sahrens 
417fa9e4066Sahrens 	for (zap_cursor_init(&zc, os, object);
418fa9e4066Sahrens 	    zap_cursor_retrieve(&zc, &attr) == 0;
419fa9e4066Sahrens 	    zap_cursor_advance(&zc)) {
420fa9e4066Sahrens 		(void) printf("\t\t%s = ", attr.za_name);
421fa9e4066Sahrens 		if (attr.za_num_integers == 0) {
422fa9e4066Sahrens 			(void) printf("\n");
423fa9e4066Sahrens 			continue;
424fa9e4066Sahrens 		}
425fa9e4066Sahrens 		prop = umem_zalloc(attr.za_num_integers *
426fa9e4066Sahrens 		    attr.za_integer_length, UMEM_NOFAIL);
427fa9e4066Sahrens 		(void) zap_lookup(os, object, attr.za_name,
428fa9e4066Sahrens 		    attr.za_integer_length, attr.za_num_integers, prop);
429fa9e4066Sahrens 		if (attr.za_integer_length == 1) {
430fa9e4066Sahrens 			(void) printf("%s", (char *)prop);
431fa9e4066Sahrens 		} else {
432fa9e4066Sahrens 			for (i = 0; i < attr.za_num_integers; i++) {
433fa9e4066Sahrens 				switch (attr.za_integer_length) {
434fa9e4066Sahrens 				case 2:
435fa9e4066Sahrens 					(void) printf("%u ",
436fa9e4066Sahrens 					    ((uint16_t *)prop)[i]);
437fa9e4066Sahrens 					break;
438fa9e4066Sahrens 				case 4:
439fa9e4066Sahrens 					(void) printf("%u ",
440fa9e4066Sahrens 					    ((uint32_t *)prop)[i]);
441fa9e4066Sahrens 					break;
442fa9e4066Sahrens 				case 8:
443fa9e4066Sahrens 					(void) printf("%lld ",
444fa9e4066Sahrens 					    (u_longlong_t)((int64_t *)prop)[i]);
445fa9e4066Sahrens 					break;
446fa9e4066Sahrens 				}
447fa9e4066Sahrens 			}
448fa9e4066Sahrens 		}
449fa9e4066Sahrens 		(void) printf("\n");
450fa9e4066Sahrens 		umem_free(prop, attr.za_num_integers * attr.za_integer_length);
451fa9e4066Sahrens 	}
45287e5029aSahrens 	zap_cursor_fini(&zc);
453fa9e4066Sahrens }
454fa9e4066Sahrens 
455732885fcSMatthew Ahrens static void
456732885fcSMatthew Ahrens dump_bpobj(objset_t *os, uint64_t object, void *data, size_t size)
457732885fcSMatthew Ahrens {
458732885fcSMatthew Ahrens 	bpobj_phys_t *bpop = data;
459732885fcSMatthew Ahrens 	char bytes[32], comp[32], uncomp[32];
460732885fcSMatthew Ahrens 
461732885fcSMatthew Ahrens 	if (bpop == NULL)
462732885fcSMatthew Ahrens 		return;
463732885fcSMatthew Ahrens 
464732885fcSMatthew Ahrens 	zdb_nicenum(bpop->bpo_bytes, bytes);
465732885fcSMatthew Ahrens 	zdb_nicenum(bpop->bpo_comp, comp);
466732885fcSMatthew Ahrens 	zdb_nicenum(bpop->bpo_uncomp, uncomp);
467732885fcSMatthew Ahrens 
468732885fcSMatthew Ahrens 	(void) printf("\t\tnum_blkptrs = %llu\n",
469732885fcSMatthew Ahrens 	    (u_longlong_t)bpop->bpo_num_blkptrs);
470732885fcSMatthew Ahrens 	(void) printf("\t\tbytes = %s\n", bytes);
471732885fcSMatthew Ahrens 	if (size >= BPOBJ_SIZE_V1) {
472732885fcSMatthew Ahrens 		(void) printf("\t\tcomp = %s\n", comp);
473732885fcSMatthew Ahrens 		(void) printf("\t\tuncomp = %s\n", uncomp);
474732885fcSMatthew Ahrens 	}
475732885fcSMatthew Ahrens 	if (size >= sizeof (*bpop)) {
476732885fcSMatthew Ahrens 		(void) printf("\t\tsubobjs = %llu\n",
477732885fcSMatthew Ahrens 		    (u_longlong_t)bpop->bpo_subobjs);
478732885fcSMatthew Ahrens 		(void) printf("\t\tnum_subobjs = %llu\n",
479732885fcSMatthew Ahrens 		    (u_longlong_t)bpop->bpo_num_subobjs);
480732885fcSMatthew Ahrens 	}
481732885fcSMatthew Ahrens 
482732885fcSMatthew Ahrens 	if (dump_opt['d'] < 5)
483732885fcSMatthew Ahrens 		return;
484732885fcSMatthew Ahrens 
485732885fcSMatthew Ahrens 	for (uint64_t i = 0; i < bpop->bpo_num_blkptrs; i++) {
486732885fcSMatthew Ahrens 		char blkbuf[BP_SPRINTF_LEN];
487732885fcSMatthew Ahrens 		blkptr_t bp;
488732885fcSMatthew Ahrens 
489732885fcSMatthew Ahrens 		int err = dmu_read(os, object,
490732885fcSMatthew Ahrens 		    i * sizeof (bp), sizeof (bp), &bp, 0);
491732885fcSMatthew Ahrens 		if (err != 0) {
492732885fcSMatthew Ahrens 			(void) printf("got error %u from dmu_read\n", err);
493732885fcSMatthew Ahrens 			break;
494732885fcSMatthew Ahrens 		}
495732885fcSMatthew Ahrens 		snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), &bp);
496732885fcSMatthew Ahrens 		(void) printf("\t%s\n", blkbuf);
497732885fcSMatthew Ahrens 	}
498732885fcSMatthew Ahrens }
499732885fcSMatthew Ahrens 
500732885fcSMatthew Ahrens /* ARGSUSED */
501732885fcSMatthew Ahrens static void
502732885fcSMatthew Ahrens dump_bpobj_subobjs(objset_t *os, uint64_t object, void *data, size_t size)
503732885fcSMatthew Ahrens {
504732885fcSMatthew Ahrens 	dmu_object_info_t doi;
505732885fcSMatthew Ahrens 
506732885fcSMatthew Ahrens 	VERIFY0(dmu_object_info(os, object, &doi));
507732885fcSMatthew Ahrens 	uint64_t *subobjs = kmem_alloc(doi.doi_max_offset, KM_SLEEP);
508732885fcSMatthew Ahrens 
509732885fcSMatthew Ahrens 	int err = dmu_read(os, object, 0, doi.doi_max_offset, subobjs, 0);
510732885fcSMatthew Ahrens 	if (err != 0) {
511732885fcSMatthew Ahrens 		(void) printf("got error %u from dmu_read\n", err);
512732885fcSMatthew Ahrens 		kmem_free(subobjs, doi.doi_max_offset);
513732885fcSMatthew Ahrens 		return;
514732885fcSMatthew Ahrens 	}
515732885fcSMatthew Ahrens 
516732885fcSMatthew Ahrens 	int64_t last_nonzero = -1;
517732885fcSMatthew Ahrens 	for (uint64_t i = 0; i < doi.doi_max_offset / 8; i++) {
518732885fcSMatthew Ahrens 		if (subobjs[i] != 0)
519732885fcSMatthew Ahrens 			last_nonzero = i;
520732885fcSMatthew Ahrens 	}
521732885fcSMatthew Ahrens 
522732885fcSMatthew Ahrens 	for (int64_t i = 0; i <= last_nonzero; i++) {
523732885fcSMatthew Ahrens 		(void) printf("\t%llu\n", (longlong_t)subobjs[i]);
524732885fcSMatthew Ahrens 	}
525732885fcSMatthew Ahrens 	kmem_free(subobjs, doi.doi_max_offset);
526732885fcSMatthew Ahrens }
527732885fcSMatthew Ahrens 
528486ae710SMatthew Ahrens /*ARGSUSED*/
529486ae710SMatthew Ahrens static void
530486ae710SMatthew Ahrens dump_ddt_zap(objset_t *os, uint64_t object, void *data, size_t size)
531486ae710SMatthew Ahrens {
532486ae710SMatthew Ahrens 	dump_zap_stats(os, object);
533486ae710SMatthew Ahrens 	/* contents are printed elsewhere, properly decoded */
534486ae710SMatthew Ahrens }
535486ae710SMatthew Ahrens 
5360a586ceaSMark Shellenbaum /*ARGSUSED*/
5370a586ceaSMark Shellenbaum static void
5380a586ceaSMark Shellenbaum dump_sa_attrs(objset_t *os, uint64_t object, void *data, size_t size)
5390a586ceaSMark Shellenbaum {
5400a586ceaSMark Shellenbaum 	zap_cursor_t zc;
5410a586ceaSMark Shellenbaum 	zap_attribute_t attr;
5420a586ceaSMark Shellenbaum 
5430a586ceaSMark Shellenbaum 	dump_zap_stats(os, object);
5440a586ceaSMark Shellenbaum 	(void) printf("\n");
5450a586ceaSMark Shellenbaum 
5460a586ceaSMark Shellenbaum 	for (zap_cursor_init(&zc, os, object);
5470a586ceaSMark Shellenbaum 	    zap_cursor_retrieve(&zc, &attr) == 0;
5480a586ceaSMark Shellenbaum 	    zap_cursor_advance(&zc)) {
5490a586ceaSMark Shellenbaum 		(void) printf("\t\t%s = ", attr.za_name);
5500a586ceaSMark Shellenbaum 		if (attr.za_num_integers == 0) {
5510a586ceaSMark Shellenbaum 			(void) printf("\n");
5520a586ceaSMark Shellenbaum 			continue;
5530a586ceaSMark Shellenbaum 		}
5540a586ceaSMark Shellenbaum 		(void) printf(" %llx : [%d:%d:%d]\n",
5550a586ceaSMark Shellenbaum 		    (u_longlong_t)attr.za_first_integer,
5560a586ceaSMark Shellenbaum 		    (int)ATTR_LENGTH(attr.za_first_integer),
5570a586ceaSMark Shellenbaum 		    (int)ATTR_BSWAP(attr.za_first_integer),
5580a586ceaSMark Shellenbaum 		    (int)ATTR_NUM(attr.za_first_integer));
5590a586ceaSMark Shellenbaum 	}
5600a586ceaSMark Shellenbaum 	zap_cursor_fini(&zc);
5610a586ceaSMark Shellenbaum }
5620a586ceaSMark Shellenbaum 
5630a586ceaSMark Shellenbaum /*ARGSUSED*/
5640a586ceaSMark Shellenbaum static void
5650a586ceaSMark Shellenbaum dump_sa_layouts(objset_t *os, uint64_t object, void *data, size_t size)
5660a586ceaSMark Shellenbaum {
5670a586ceaSMark Shellenbaum 	zap_cursor_t zc;
5680a586ceaSMark Shellenbaum 	zap_attribute_t attr;
5690a586ceaSMark Shellenbaum 	uint16_t *layout_attrs;
5700a586ceaSMark Shellenbaum 	int i;
5710a586ceaSMark Shellenbaum 
5720a586ceaSMark Shellenbaum 	dump_zap_stats(os, object);
5730a586ceaSMark Shellenbaum 	(void) printf("\n");
5740a586ceaSMark Shellenbaum 
5750a586ceaSMark Shellenbaum 	for (zap_cursor_init(&zc, os, object);
5760a586ceaSMark Shellenbaum 	    zap_cursor_retrieve(&zc, &attr) == 0;
5770a586ceaSMark Shellenbaum 	    zap_cursor_advance(&zc)) {
5780a586ceaSMark Shellenbaum 		(void) printf("\t\t%s = [", attr.za_name);
5790a586ceaSMark Shellenbaum 		if (attr.za_num_integers == 0) {
5800a586ceaSMark Shellenbaum 			(void) printf("\n");
5810a586ceaSMark Shellenbaum 			continue;
5820a586ceaSMark Shellenbaum 		}
5830a586ceaSMark Shellenbaum 
5840a586ceaSMark Shellenbaum 		VERIFY(attr.za_integer_length == 2);
5850a586ceaSMark Shellenbaum 		layout_attrs = umem_zalloc(attr.za_num_integers *
5860a586ceaSMark Shellenbaum 		    attr.za_integer_length, UMEM_NOFAIL);
5870a586ceaSMark Shellenbaum 
5880a586ceaSMark Shellenbaum 		VERIFY(zap_lookup(os, object, attr.za_name,
5890a586ceaSMark Shellenbaum 		    attr.za_integer_length,
5900a586ceaSMark Shellenbaum 		    attr.za_num_integers, layout_attrs) == 0);
5910a586ceaSMark Shellenbaum 
5920a586ceaSMark Shellenbaum 		for (i = 0; i != attr.za_num_integers; i++)
5930a586ceaSMark Shellenbaum 			(void) printf(" %d ", (int)layout_attrs[i]);
5940a586ceaSMark Shellenbaum 		(void) printf("]\n");
5950a586ceaSMark Shellenbaum 		umem_free(layout_attrs,
5960a586ceaSMark Shellenbaum 		    attr.za_num_integers * attr.za_integer_length);
5970a586ceaSMark Shellenbaum 	}
5980a586ceaSMark Shellenbaum 	zap_cursor_fini(&zc);
5990a586ceaSMark Shellenbaum }
6000a586ceaSMark Shellenbaum 
601e7437265Sahrens /*ARGSUSED*/
602e7437265Sahrens static void
603e7437265Sahrens dump_zpldir(objset_t *os, uint64_t object, void *data, size_t size)
604e7437265Sahrens {
605e7437265Sahrens 	zap_cursor_t zc;
606e7437265Sahrens 	zap_attribute_t attr;
607e7437265Sahrens 	const char *typenames[] = {
608e7437265Sahrens 		/* 0 */ "not specified",
609e7437265Sahrens 		/* 1 */ "FIFO",
610e7437265Sahrens 		/* 2 */ "Character Device",
611e7437265Sahrens 		/* 3 */ "3 (invalid)",
612e7437265Sahrens 		/* 4 */ "Directory",
613e7437265Sahrens 		/* 5 */ "5 (invalid)",
614e7437265Sahrens 		/* 6 */ "Block Device",
615e7437265Sahrens 		/* 7 */ "7 (invalid)",
616e7437265Sahrens 		/* 8 */ "Regular File",
617e7437265Sahrens 		/* 9 */ "9 (invalid)",
618e7437265Sahrens 		/* 10 */ "Symbolic Link",
619e7437265Sahrens 		/* 11 */ "11 (invalid)",
620e7437265Sahrens 		/* 12 */ "Socket",
621e7437265Sahrens 		/* 13 */ "Door",
622e7437265Sahrens 		/* 14 */ "Event Port",
623e7437265Sahrens 		/* 15 */ "15 (invalid)",
624e7437265Sahrens 	};
625e7437265Sahrens 
626e7437265Sahrens 	dump_zap_stats(os, object);
627e7437265Sahrens 	(void) printf("\n");
628e7437265Sahrens 
629e7437265Sahrens 	for (zap_cursor_init(&zc, os, object);
630e7437265Sahrens 	    zap_cursor_retrieve(&zc, &attr) == 0;
631e7437265Sahrens 	    zap_cursor_advance(&zc)) {
632e7437265Sahrens 		(void) printf("\t\t%s = %lld (type: %s)\n",
633e7437265Sahrens 		    attr.za_name, ZFS_DIRENT_OBJ(attr.za_first_integer),
634e7437265Sahrens 		    typenames[ZFS_DIRENT_TYPE(attr.za_first_integer)]);
635e7437265Sahrens 	}
636e7437265Sahrens 	zap_cursor_fini(&zc);
637e7437265Sahrens }
638e7437265Sahrens 
6390713e232SGeorge Wilson int
6400713e232SGeorge Wilson get_dtl_refcount(vdev_t *vd)
6410713e232SGeorge Wilson {
6420713e232SGeorge Wilson 	int refcount = 0;
6430713e232SGeorge Wilson 
6440713e232SGeorge Wilson 	if (vd->vdev_ops->vdev_op_leaf) {
6450713e232SGeorge Wilson 		space_map_t *sm = vd->vdev_dtl_sm;
6460713e232SGeorge Wilson 
6470713e232SGeorge Wilson 		if (sm != NULL &&
6480713e232SGeorge Wilson 		    sm->sm_dbuf->db_size == sizeof (space_map_phys_t))
6490713e232SGeorge Wilson 			return (1);
6500713e232SGeorge Wilson 		return (0);
6510713e232SGeorge Wilson 	}
6520713e232SGeorge Wilson 
6530713e232SGeorge Wilson 	for (int c = 0; c < vd->vdev_children; c++)
6540713e232SGeorge Wilson 		refcount += get_dtl_refcount(vd->vdev_child[c]);
6550713e232SGeorge Wilson 	return (refcount);
6560713e232SGeorge Wilson }
6570713e232SGeorge Wilson 
6580713e232SGeorge Wilson int
6590713e232SGeorge Wilson get_metaslab_refcount(vdev_t *vd)
6600713e232SGeorge Wilson {
6610713e232SGeorge Wilson 	int refcount = 0;
6620713e232SGeorge Wilson 
6632e4c9986SGeorge Wilson 	if (vd->vdev_top == vd && !vd->vdev_removing) {
6640713e232SGeorge Wilson 		for (int m = 0; m < vd->vdev_ms_count; m++) {
6650713e232SGeorge Wilson 			space_map_t *sm = vd->vdev_ms[m]->ms_sm;
6660713e232SGeorge Wilson 
6670713e232SGeorge Wilson 			if (sm != NULL &&
6680713e232SGeorge Wilson 			    sm->sm_dbuf->db_size == sizeof (space_map_phys_t))
6690713e232SGeorge Wilson 				refcount++;
6700713e232SGeorge Wilson 		}
6710713e232SGeorge Wilson 	}
6720713e232SGeorge Wilson 	for (int c = 0; c < vd->vdev_children; c++)
6730713e232SGeorge Wilson 		refcount += get_metaslab_refcount(vd->vdev_child[c]);
6740713e232SGeorge Wilson 
6750713e232SGeorge Wilson 	return (refcount);
6760713e232SGeorge Wilson }
6770713e232SGeorge Wilson 
6780713e232SGeorge Wilson static int
6790713e232SGeorge Wilson verify_spacemap_refcounts(spa_t *spa)
6800713e232SGeorge Wilson {
6812acef22dSMatthew Ahrens 	uint64_t expected_refcount = 0;
6822acef22dSMatthew Ahrens 	uint64_t actual_refcount;
6830713e232SGeorge Wilson 
6842acef22dSMatthew Ahrens 	(void) feature_get_refcount(spa,
6852acef22dSMatthew Ahrens 	    &spa_feature_table[SPA_FEATURE_SPACEMAP_HISTOGRAM],
6862acef22dSMatthew Ahrens 	    &expected_refcount);
6870713e232SGeorge Wilson 	actual_refcount = get_dtl_refcount(spa->spa_root_vdev);
6880713e232SGeorge Wilson 	actual_refcount += get_metaslab_refcount(spa->spa_root_vdev);
6890713e232SGeorge Wilson 
6900713e232SGeorge Wilson 	if (expected_refcount != actual_refcount) {
6912acef22dSMatthew Ahrens 		(void) printf("space map refcount mismatch: expected %lld != "
6922acef22dSMatthew Ahrens 		    "actual %lld\n",
6932acef22dSMatthew Ahrens 		    (longlong_t)expected_refcount,
6942acef22dSMatthew Ahrens 		    (longlong_t)actual_refcount);
6950713e232SGeorge Wilson 		return (2);
6960713e232SGeorge Wilson 	}
6970713e232SGeorge Wilson 	return (0);
6980713e232SGeorge Wilson }
6990713e232SGeorge Wilson 
700fa9e4066Sahrens static void
7010713e232SGeorge Wilson dump_spacemap(objset_t *os, space_map_t *sm)
702fa9e4066Sahrens {
703fa9e4066Sahrens 	uint64_t alloc, offset, entry;
7048053a263Sck 	char *ddata[] = { "ALLOC", "FREE", "CONDENSE", "INVALID",
7058053a263Sck 			    "INVALID", "INVALID", "INVALID", "INVALID" };
706fa9e4066Sahrens 
7070713e232SGeorge Wilson 	if (sm == NULL)
708fa9e4066Sahrens 		return;
709fa9e4066Sahrens 
710fa9e4066Sahrens 	/*
711fa9e4066Sahrens 	 * Print out the freelist entries in both encoded and decoded form.
712fa9e4066Sahrens 	 */
713fa9e4066Sahrens 	alloc = 0;
7140713e232SGeorge Wilson 	for (offset = 0; offset < space_map_length(sm);
7150713e232SGeorge Wilson 	    offset += sizeof (entry)) {
7160713e232SGeorge Wilson 		uint8_t mapshift = sm->sm_shift;
7170713e232SGeorge Wilson 
7180713e232SGeorge Wilson 		VERIFY0(dmu_read(os, space_map_object(sm), offset,
7197bfdf011SNeil Perrin 		    sizeof (entry), &entry, DMU_READ_PREFETCH));
720fa9e4066Sahrens 		if (SM_DEBUG_DECODE(entry)) {
7210713e232SGeorge Wilson 
72287219db7SVictor Latushkin 			(void) printf("\t    [%6llu] %s: txg %llu, pass %llu\n",
723fa9e4066Sahrens 			    (u_longlong_t)(offset / sizeof (entry)),
724fa9e4066Sahrens 			    ddata[SM_DEBUG_ACTION_DECODE(entry)],
7255ad82045Snd 			    (u_longlong_t)SM_DEBUG_TXG_DECODE(entry),
7265ad82045Snd 			    (u_longlong_t)SM_DEBUG_SYNCPASS_DECODE(entry));
727fa9e4066Sahrens 		} else {
72887219db7SVictor Latushkin 			(void) printf("\t    [%6llu]    %c  range:"
72987219db7SVictor Latushkin 			    " %010llx-%010llx  size: %06llx\n",
730fa9e4066Sahrens 			    (u_longlong_t)(offset / sizeof (entry)),
731fa9e4066Sahrens 			    SM_TYPE_DECODE(entry) == SM_ALLOC ? 'A' : 'F',
7325ad82045Snd 			    (u_longlong_t)((SM_OFFSET_DECODE(entry) <<
7330713e232SGeorge Wilson 			    mapshift) + sm->sm_start),
7345ad82045Snd 			    (u_longlong_t)((SM_OFFSET_DECODE(entry) <<
7350713e232SGeorge Wilson 			    mapshift) + sm->sm_start +
7360713e232SGeorge Wilson 			    (SM_RUN_DECODE(entry) << mapshift)),
7375ad82045Snd 			    (u_longlong_t)(SM_RUN_DECODE(entry) << mapshift));
738fa9e4066Sahrens 			if (SM_TYPE_DECODE(entry) == SM_ALLOC)
739fa9e4066Sahrens 				alloc += SM_RUN_DECODE(entry) << mapshift;
740fa9e4066Sahrens 			else
741fa9e4066Sahrens 				alloc -= SM_RUN_DECODE(entry) << mapshift;
742fa9e4066Sahrens 		}
743fa9e4066Sahrens 	}
7440713e232SGeorge Wilson 	if (alloc != space_map_allocated(sm)) {
745fa9e4066Sahrens 		(void) printf("space_map_object alloc (%llu) INCONSISTENT "
746fa9e4066Sahrens 		    "with space map summary (%llu)\n",
7470713e232SGeorge Wilson 		    (u_longlong_t)space_map_allocated(sm), (u_longlong_t)alloc);
748fa9e4066Sahrens 	}
749fa9e4066Sahrens }
750fa9e4066Sahrens 
751d6e555bdSGeorge Wilson static void
752d6e555bdSGeorge Wilson dump_metaslab_stats(metaslab_t *msp)
753d6e555bdSGeorge Wilson {
7543f9d6ad7SLin Ling 	char maxbuf[32];
7550713e232SGeorge Wilson 	range_tree_t *rt = msp->ms_tree;
7560713e232SGeorge Wilson 	avl_tree_t *t = &msp->ms_size_tree;
7570713e232SGeorge Wilson 	int free_pct = range_tree_space(rt) * 100 / msp->ms_size;
758d6e555bdSGeorge Wilson 
7590713e232SGeorge Wilson 	zdb_nicenum(metaslab_block_maxsize(msp), maxbuf);
760d6e555bdSGeorge Wilson 
76187219db7SVictor Latushkin 	(void) printf("\t %25s %10lu   %7s  %6s   %4s %4d%%\n",
762d6e555bdSGeorge Wilson 	    "segments", avl_numnodes(t), "maxsize", maxbuf,
763d6e555bdSGeorge Wilson 	    "freepct", free_pct);
7640713e232SGeorge Wilson 	(void) printf("\tIn-memory histogram:\n");
7650713e232SGeorge Wilson 	dump_histogram(rt->rt_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
766d6e555bdSGeorge Wilson }
767d6e555bdSGeorge Wilson 
768fa9e4066Sahrens static void
769fa9e4066Sahrens dump_metaslab(metaslab_t *msp)
770fa9e4066Sahrens {
771fa9e4066Sahrens 	vdev_t *vd = msp->ms_group->mg_vd;
772fa9e4066Sahrens 	spa_t *spa = vd->vdev_spa;
7730713e232SGeorge Wilson 	space_map_t *sm = msp->ms_sm;
7743f9d6ad7SLin Ling 	char freebuf[32];
775fa9e4066Sahrens 
7760713e232SGeorge Wilson 	zdb_nicenum(msp->ms_size - space_map_allocated(sm), freebuf);
777fa9e4066Sahrens 
778fa9e4066Sahrens 	(void) printf(
77987219db7SVictor Latushkin 	    "\tmetaslab %6llu   offset %12llx   spacemap %6llu   free    %5s\n",
7800713e232SGeorge Wilson 	    (u_longlong_t)msp->ms_id, (u_longlong_t)msp->ms_start,
7810713e232SGeorge Wilson 	    (u_longlong_t)space_map_object(sm), freebuf);
782fa9e4066Sahrens 
7830713e232SGeorge Wilson 	if (dump_opt['m'] > 2 && !dump_opt['L']) {
784d6e555bdSGeorge Wilson 		mutex_enter(&msp->ms_lock);
7850713e232SGeorge Wilson 		metaslab_load_wait(msp);
7860713e232SGeorge Wilson 		if (!msp->ms_loaded) {
7870713e232SGeorge Wilson 			VERIFY0(metaslab_load(msp));
7880713e232SGeorge Wilson 			range_tree_stat_verify(msp->ms_tree);
7890713e232SGeorge Wilson 		}
790bc3975b5SVictor Latushkin 		dump_metaslab_stats(msp);
7910713e232SGeorge Wilson 		metaslab_unload(msp);
792d6e555bdSGeorge Wilson 		mutex_exit(&msp->ms_lock);
793d6e555bdSGeorge Wilson 	}
794d6e555bdSGeorge Wilson 
7950713e232SGeorge Wilson 	if (dump_opt['m'] > 1 && sm != NULL &&
7962acef22dSMatthew Ahrens 	    spa_feature_is_active(spa, SPA_FEATURE_SPACEMAP_HISTOGRAM)) {
7970713e232SGeorge Wilson 		/*
7980713e232SGeorge Wilson 		 * The space map histogram represents free space in chunks
7990713e232SGeorge Wilson 		 * of sm_shift (i.e. bucket 0 refers to 2^sm_shift).
8000713e232SGeorge Wilson 		 */
8012e4c9986SGeorge Wilson 		(void) printf("\tOn-disk histogram:\t\tfragmentation %llu\n",
8022e4c9986SGeorge Wilson 		    (u_longlong_t)msp->ms_fragmentation);
8030713e232SGeorge Wilson 		dump_histogram(sm->sm_phys->smp_histogram,
8042e4c9986SGeorge Wilson 		    SPACE_MAP_HISTOGRAM_SIZE, sm->sm_shift);
8050713e232SGeorge Wilson 	}
8060713e232SGeorge Wilson 
8070713e232SGeorge Wilson 	if (dump_opt['d'] > 5 || dump_opt['m'] > 3) {
8080713e232SGeorge Wilson 		ASSERT(msp->ms_size == (1ULL << vd->vdev_ms_shift));
809d6e555bdSGeorge Wilson 
810d6e555bdSGeorge Wilson 		mutex_enter(&msp->ms_lock);
8110713e232SGeorge Wilson 		dump_spacemap(spa->spa_meta_objset, msp->ms_sm);
812d6e555bdSGeorge Wilson 		mutex_exit(&msp->ms_lock);
813d6e555bdSGeorge Wilson 	}
81487219db7SVictor Latushkin }
815fa9e4066Sahrens 
81687219db7SVictor Latushkin static void
81787219db7SVictor Latushkin print_vdev_metaslab_header(vdev_t *vd)
81887219db7SVictor Latushkin {
81987219db7SVictor Latushkin 	(void) printf("\tvdev %10llu\n\t%-10s%5llu   %-19s   %-15s   %-10s\n",
82087219db7SVictor Latushkin 	    (u_longlong_t)vd->vdev_id,
82187219db7SVictor Latushkin 	    "metaslabs", (u_longlong_t)vd->vdev_ms_count,
82287219db7SVictor Latushkin 	    "offset", "spacemap", "free");
82387219db7SVictor Latushkin 	(void) printf("\t%15s   %19s   %15s   %10s\n",
82487219db7SVictor Latushkin 	    "---------------", "-------------------",
82587219db7SVictor Latushkin 	    "---------------", "-------------");
826fa9e4066Sahrens }
827fa9e4066Sahrens 
8282e4c9986SGeorge Wilson static void
8292e4c9986SGeorge Wilson dump_metaslab_groups(spa_t *spa)
8302e4c9986SGeorge Wilson {
8312e4c9986SGeorge Wilson 	vdev_t *rvd = spa->spa_root_vdev;
8322e4c9986SGeorge Wilson 	metaslab_class_t *mc = spa_normal_class(spa);
8332e4c9986SGeorge Wilson 	uint64_t fragmentation;
8342e4c9986SGeorge Wilson 
8352e4c9986SGeorge Wilson 	metaslab_class_histogram_verify(mc);
8362e4c9986SGeorge Wilson 
8372e4c9986SGeorge Wilson 	for (int c = 0; c < rvd->vdev_children; c++) {
8382e4c9986SGeorge Wilson 		vdev_t *tvd = rvd->vdev_child[c];
8392e4c9986SGeorge Wilson 		metaslab_group_t *mg = tvd->vdev_mg;
8402e4c9986SGeorge Wilson 
8412e4c9986SGeorge Wilson 		if (mg->mg_class != mc)
8422e4c9986SGeorge Wilson 			continue;
8432e4c9986SGeorge Wilson 
8442e4c9986SGeorge Wilson 		metaslab_group_histogram_verify(mg);
8452e4c9986SGeorge Wilson 		mg->mg_fragmentation = metaslab_group_fragmentation(mg);
8462e4c9986SGeorge Wilson 
8472e4c9986SGeorge Wilson 		(void) printf("\tvdev %10llu\t\tmetaslabs%5llu\t\t"
8482e4c9986SGeorge Wilson 		    "fragmentation",
8492e4c9986SGeorge Wilson 		    (u_longlong_t)tvd->vdev_id,
8502e4c9986SGeorge Wilson 		    (u_longlong_t)tvd->vdev_ms_count);
8512e4c9986SGeorge Wilson 		if (mg->mg_fragmentation == ZFS_FRAG_INVALID) {
8522e4c9986SGeorge Wilson 			(void) printf("%3s\n", "-");
8532e4c9986SGeorge Wilson 		} else {
8542e4c9986SGeorge Wilson 			(void) printf("%3llu%%\n",
8552e4c9986SGeorge Wilson 			    (u_longlong_t)mg->mg_fragmentation);
8562e4c9986SGeorge Wilson 		}
8572e4c9986SGeorge Wilson 		dump_histogram(mg->mg_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
8582e4c9986SGeorge Wilson 	}
8592e4c9986SGeorge Wilson 
8602e4c9986SGeorge Wilson 	(void) printf("\tpool %s\tfragmentation", spa_name(spa));
8612e4c9986SGeorge Wilson 	fragmentation = metaslab_class_fragmentation(mc);
8622e4c9986SGeorge Wilson 	if (fragmentation == ZFS_FRAG_INVALID)
8632e4c9986SGeorge Wilson 		(void) printf("\t%3s\n", "-");
8642e4c9986SGeorge Wilson 	else
8652e4c9986SGeorge Wilson 		(void) printf("\t%3llu%%\n", (u_longlong_t)fragmentation);
8662e4c9986SGeorge Wilson 	dump_histogram(mc->mc_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
8672e4c9986SGeorge Wilson }
8682e4c9986SGeorge Wilson 
869fa9e4066Sahrens static void
870fa9e4066Sahrens dump_metaslabs(spa_t *spa)
871fa9e4066Sahrens {
87287219db7SVictor Latushkin 	vdev_t *vd, *rvd = spa->spa_root_vdev;
87387219db7SVictor Latushkin 	uint64_t m, c = 0, children = rvd->vdev_children;
874fa9e4066Sahrens 
875fa9e4066Sahrens 	(void) printf("\nMetaslabs:\n");
876fa9e4066Sahrens 
87787219db7SVictor Latushkin 	if (!dump_opt['d'] && zopt_objects > 0) {
87887219db7SVictor Latushkin 		c = zopt_object[0];
87987219db7SVictor Latushkin 
88087219db7SVictor Latushkin 		if (c >= children)
88187219db7SVictor Latushkin 			(void) fatal("bad vdev id: %llu", (u_longlong_t)c);
882fa9e4066Sahrens 
88387219db7SVictor Latushkin 		if (zopt_objects > 1) {
88487219db7SVictor Latushkin 			vd = rvd->vdev_child[c];
88587219db7SVictor Latushkin 			print_vdev_metaslab_header(vd);
88687219db7SVictor Latushkin 
88787219db7SVictor Latushkin 			for (m = 1; m < zopt_objects; m++) {
88887219db7SVictor Latushkin 				if (zopt_object[m] < vd->vdev_ms_count)
88987219db7SVictor Latushkin 					dump_metaslab(
89087219db7SVictor Latushkin 					    vd->vdev_ms[zopt_object[m]]);
89187219db7SVictor Latushkin 				else
89287219db7SVictor Latushkin 					(void) fprintf(stderr, "bad metaslab "
89387219db7SVictor Latushkin 					    "number %llu\n",
89487219db7SVictor Latushkin 					    (u_longlong_t)zopt_object[m]);
89587219db7SVictor Latushkin 			}
89687219db7SVictor Latushkin 			(void) printf("\n");
89787219db7SVictor Latushkin 			return;
89887219db7SVictor Latushkin 		}
89987219db7SVictor Latushkin 		children = c + 1;
90087219db7SVictor Latushkin 	}
90187219db7SVictor Latushkin 	for (; c < children; c++) {
90287219db7SVictor Latushkin 		vd = rvd->vdev_child[c];
90387219db7SVictor Latushkin 		print_vdev_metaslab_header(vd);
904fa9e4066Sahrens 
905fa9e4066Sahrens 		for (m = 0; m < vd->vdev_ms_count; m++)
906fa9e4066Sahrens 			dump_metaslab(vd->vdev_ms[m]);
907fa9e4066Sahrens 		(void) printf("\n");
908fa9e4066Sahrens 	}
909fa9e4066Sahrens }
910fa9e4066Sahrens 
911b24ab676SJeff Bonwick static void
912b24ab676SJeff Bonwick dump_dde(const ddt_t *ddt, const ddt_entry_t *dde, uint64_t index)
913b24ab676SJeff Bonwick {
914b24ab676SJeff Bonwick 	const ddt_phys_t *ddp = dde->dde_phys;
915b24ab676SJeff Bonwick 	const ddt_key_t *ddk = &dde->dde_key;
916b24ab676SJeff Bonwick 	char *types[4] = { "ditto", "single", "double", "triple" };
917b24ab676SJeff Bonwick 	char blkbuf[BP_SPRINTF_LEN];
918b24ab676SJeff Bonwick 	blkptr_t blk;
919b24ab676SJeff Bonwick 
920b24ab676SJeff Bonwick 	for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
921b24ab676SJeff Bonwick 		if (ddp->ddp_phys_birth == 0)
922b24ab676SJeff Bonwick 			continue;
923bbfd46c4SJeff Bonwick 		ddt_bp_create(ddt->ddt_checksum, ddk, ddp, &blk);
92443466aaeSMax Grossman 		snprintf_blkptr(blkbuf, sizeof (blkbuf), &blk);
925b24ab676SJeff Bonwick 		(void) printf("index %llx refcnt %llu %s %s\n",
926b24ab676SJeff Bonwick 		    (u_longlong_t)index, (u_longlong_t)ddp->ddp_refcnt,
927b24ab676SJeff Bonwick 		    types[p], blkbuf);
928b24ab676SJeff Bonwick 	}
929b24ab676SJeff Bonwick }
930b24ab676SJeff Bonwick 
931b24ab676SJeff Bonwick static void
932b24ab676SJeff Bonwick dump_dedup_ratio(const ddt_stat_t *dds)
933b24ab676SJeff Bonwick {
934b24ab676SJeff Bonwick 	double rL, rP, rD, D, dedup, compress, copies;
935b24ab676SJeff Bonwick 
936b24ab676SJeff Bonwick 	if (dds->dds_blocks == 0)
937b24ab676SJeff Bonwick 		return;
938b24ab676SJeff Bonwick 
939b24ab676SJeff Bonwick 	rL = (double)dds->dds_ref_lsize;
940b24ab676SJeff Bonwick 	rP = (double)dds->dds_ref_psize;
941b24ab676SJeff Bonwick 	rD = (double)dds->dds_ref_dsize;
942b24ab676SJeff Bonwick 	D = (double)dds->dds_dsize;
943b24ab676SJeff Bonwick 
944b24ab676SJeff Bonwick 	dedup = rD / D;
945b24ab676SJeff Bonwick 	compress = rL / rP;
946b24ab676SJeff Bonwick 	copies = rD / rP;
947b24ab676SJeff Bonwick 
948b24ab676SJeff Bonwick 	(void) printf("dedup = %.2f, compress = %.2f, copies = %.2f, "
949b24ab676SJeff Bonwick 	    "dedup * compress / copies = %.2f\n\n",
950b24ab676SJeff Bonwick 	    dedup, compress, copies, dedup * compress / copies);
951b24ab676SJeff Bonwick }
952b24ab676SJeff Bonwick 
953b24ab676SJeff Bonwick static void
954b24ab676SJeff Bonwick dump_ddt(ddt_t *ddt, enum ddt_type type, enum ddt_class class)
955b24ab676SJeff Bonwick {
956b24ab676SJeff Bonwick 	char name[DDT_NAMELEN];
957b24ab676SJeff Bonwick 	ddt_entry_t dde;
958b24ab676SJeff Bonwick 	uint64_t walk = 0;
959b24ab676SJeff Bonwick 	dmu_object_info_t doi;
960b24ab676SJeff Bonwick 	uint64_t count, dspace, mspace;
961b24ab676SJeff Bonwick 	int error;
962b24ab676SJeff Bonwick 
963b24ab676SJeff Bonwick 	error = ddt_object_info(ddt, type, class, &doi);
964b24ab676SJeff Bonwick 
965b24ab676SJeff Bonwick 	if (error == ENOENT)
966b24ab676SJeff Bonwick 		return;
967b24ab676SJeff Bonwick 	ASSERT(error == 0);
968b24ab676SJeff Bonwick 
9697448a079SGeorge Wilson 	if ((count = ddt_object_count(ddt, type, class)) == 0)
9707448a079SGeorge Wilson 		return;
9717448a079SGeorge Wilson 
972b24ab676SJeff Bonwick 	dspace = doi.doi_physical_blocks_512 << 9;
973b24ab676SJeff Bonwick 	mspace = doi.doi_fill_count * doi.doi_data_block_size;
974b24ab676SJeff Bonwick 
975b24ab676SJeff Bonwick 	ddt_object_name(ddt, type, class, name);
976b24ab676SJeff Bonwick 
977b24ab676SJeff Bonwick 	(void) printf("%s: %llu entries, size %llu on disk, %llu in core\n",
978b24ab676SJeff Bonwick 	    name,
979b24ab676SJeff Bonwick 	    (u_longlong_t)count,
980b24ab676SJeff Bonwick 	    (u_longlong_t)(dspace / count),
981b24ab676SJeff Bonwick 	    (u_longlong_t)(mspace / count));
982b24ab676SJeff Bonwick 
983b24ab676SJeff Bonwick 	if (dump_opt['D'] < 3)
984b24ab676SJeff Bonwick 		return;
985b24ab676SJeff Bonwick 
9869eb19f4dSGeorge Wilson 	zpool_dump_ddt(NULL, &ddt->ddt_histogram[type][class]);
987b24ab676SJeff Bonwick 
988b24ab676SJeff Bonwick 	if (dump_opt['D'] < 4)
989b24ab676SJeff Bonwick 		return;
990b24ab676SJeff Bonwick 
991b24ab676SJeff Bonwick 	if (dump_opt['D'] < 5 && class == DDT_CLASS_UNIQUE)
992b24ab676SJeff Bonwick 		return;
993b24ab676SJeff Bonwick 
994b24ab676SJeff Bonwick 	(void) printf("%s contents:\n\n", name);
995b24ab676SJeff Bonwick 
996bbfd46c4SJeff Bonwick 	while ((error = ddt_object_walk(ddt, type, class, &walk, &dde)) == 0)
997b24ab676SJeff Bonwick 		dump_dde(ddt, &dde, walk);
998b24ab676SJeff Bonwick 
999b24ab676SJeff Bonwick 	ASSERT(error == ENOENT);
1000b24ab676SJeff Bonwick 
1001b24ab676SJeff Bonwick 	(void) printf("\n");
1002b24ab676SJeff Bonwick }
1003b24ab676SJeff Bonwick 
1004b24ab676SJeff Bonwick static void
1005b24ab676SJeff Bonwick dump_all_ddts(spa_t *spa)
1006b24ab676SJeff Bonwick {
1007b24ab676SJeff Bonwick 	ddt_histogram_t ddh_total = { 0 };
1008b24ab676SJeff Bonwick 	ddt_stat_t dds_total = { 0 };
1009b24ab676SJeff Bonwick 
1010b24ab676SJeff Bonwick 	for (enum zio_checksum c = 0; c < ZIO_CHECKSUM_FUNCTIONS; c++) {
1011b24ab676SJeff Bonwick 		ddt_t *ddt = spa->spa_ddt[c];
1012b24ab676SJeff Bonwick 		for (enum ddt_type type = 0; type < DDT_TYPES; type++) {
1013b24ab676SJeff Bonwick 			for (enum ddt_class class = 0; class < DDT_CLASSES;
1014b24ab676SJeff Bonwick 			    class++) {
1015b24ab676SJeff Bonwick 				dump_ddt(ddt, type, class);
1016b24ab676SJeff Bonwick 			}
1017b24ab676SJeff Bonwick 		}
1018b24ab676SJeff Bonwick 	}
1019b24ab676SJeff Bonwick 
10209eb19f4dSGeorge Wilson 	ddt_get_dedup_stats(spa, &dds_total);
1021b24ab676SJeff Bonwick 
1022b24ab676SJeff Bonwick 	if (dds_total.dds_blocks == 0) {
1023b24ab676SJeff Bonwick 		(void) printf("All DDTs are empty\n");
1024b24ab676SJeff Bonwick 		return;
1025b24ab676SJeff Bonwick 	}
1026b24ab676SJeff Bonwick 
1027b24ab676SJeff Bonwick 	(void) printf("\n");
1028b24ab676SJeff Bonwick 
1029b24ab676SJeff Bonwick 	if (dump_opt['D'] > 1) {
1030b24ab676SJeff Bonwick 		(void) printf("DDT histogram (aggregated over all DDTs):\n");
10319eb19f4dSGeorge Wilson 		ddt_get_dedup_histogram(spa, &ddh_total);
10329eb19f4dSGeorge Wilson 		zpool_dump_ddt(&dds_total, &ddh_total);
1033b24ab676SJeff Bonwick 	}
1034b24ab676SJeff Bonwick 
1035b24ab676SJeff Bonwick 	dump_dedup_ratio(&dds_total);
1036b24ab676SJeff Bonwick }
1037b24ab676SJeff Bonwick 
10388ad4d6ddSJeff Bonwick static void
10390713e232SGeorge Wilson dump_dtl_seg(void *arg, uint64_t start, uint64_t size)
10408ad4d6ddSJeff Bonwick {
10410713e232SGeorge Wilson 	char *prefix = arg;
10428ad4d6ddSJeff Bonwick 
10438ad4d6ddSJeff Bonwick 	(void) printf("%s [%llu,%llu) length %llu\n",
10448ad4d6ddSJeff Bonwick 	    prefix,
10458ad4d6ddSJeff Bonwick 	    (u_longlong_t)start,
10468ad4d6ddSJeff Bonwick 	    (u_longlong_t)(start + size),
10478ad4d6ddSJeff Bonwick 	    (u_longlong_t)(size));
10488ad4d6ddSJeff Bonwick }
10498ad4d6ddSJeff Bonwick 
1050fa9e4066Sahrens static void
1051fa9e4066Sahrens dump_dtl(vdev_t *vd, int indent)
1052fa9e4066Sahrens {
10538ad4d6ddSJeff Bonwick 	spa_t *spa = vd->vdev_spa;
10548ad4d6ddSJeff Bonwick 	boolean_t required;
10558ad4d6ddSJeff Bonwick 	char *name[DTL_TYPES] = { "missing", "partial", "scrub", "outage" };
10568ad4d6ddSJeff Bonwick 	char prefix[256];
10578ad4d6ddSJeff Bonwick 
10588f18d1faSGeorge Wilson 	spa_vdev_state_enter(spa, SCL_NONE);
10598ad4d6ddSJeff Bonwick 	required = vdev_dtl_required(vd);
10608ad4d6ddSJeff Bonwick 	(void) spa_vdev_state_exit(spa, NULL, 0);
1061fa9e4066Sahrens 
1062fa9e4066Sahrens 	if (indent == 0)
1063fa9e4066Sahrens 		(void) printf("\nDirty time logs:\n\n");
1064fa9e4066Sahrens 
10658ad4d6ddSJeff Bonwick 	(void) printf("\t%*s%s [%s]\n", indent, "",
1066e14bb325SJeff Bonwick 	    vd->vdev_path ? vd->vdev_path :
10678ad4d6ddSJeff Bonwick 	    vd->vdev_parent ? vd->vdev_ops->vdev_op_type : spa_name(spa),
10688ad4d6ddSJeff Bonwick 	    required ? "DTL-required" : "DTL-expendable");
1069fa9e4066Sahrens 
10708ad4d6ddSJeff Bonwick 	for (int t = 0; t < DTL_TYPES; t++) {
10710713e232SGeorge Wilson 		range_tree_t *rt = vd->vdev_dtl[t];
10720713e232SGeorge Wilson 		if (range_tree_space(rt) == 0)
10738ad4d6ddSJeff Bonwick 			continue;
10748ad4d6ddSJeff Bonwick 		(void) snprintf(prefix, sizeof (prefix), "\t%*s%s",
10758ad4d6ddSJeff Bonwick 		    indent + 2, "", name[t]);
10760713e232SGeorge Wilson 		mutex_enter(rt->rt_lock);
10770713e232SGeorge Wilson 		range_tree_walk(rt, dump_dtl_seg, prefix);
10780713e232SGeorge Wilson 		mutex_exit(rt->rt_lock);
10798ad4d6ddSJeff Bonwick 		if (dump_opt['d'] > 5 && vd->vdev_children == 0)
10800713e232SGeorge Wilson 			dump_spacemap(spa->spa_meta_objset, vd->vdev_dtl_sm);
1081fa9e4066Sahrens 	}
1082fa9e4066Sahrens 
10838ad4d6ddSJeff Bonwick 	for (int c = 0; c < vd->vdev_children; c++)
1084fa9e4066Sahrens 		dump_dtl(vd->vdev_child[c], indent + 4);
1085fa9e4066Sahrens }
1086fa9e4066Sahrens 
10878f18d1faSGeorge Wilson static void
10888f18d1faSGeorge Wilson dump_history(spa_t *spa)
10898f18d1faSGeorge Wilson {
10908f18d1faSGeorge Wilson 	nvlist_t **events = NULL;
1091e4161df6SVictor Latushkin 	uint64_t resid, len, off = 0;
10928f18d1faSGeorge Wilson 	uint_t num = 0;
10938f18d1faSGeorge Wilson 	int error;
10948f18d1faSGeorge Wilson 	time_t tsec;
10958f18d1faSGeorge Wilson 	struct tm t;
10968f18d1faSGeorge Wilson 	char tbuf[30];
10978f18d1faSGeorge Wilson 	char internalstr[MAXPATHLEN];
10988f18d1faSGeorge Wilson 
10993f84190cSMatthew Ahrens 	char *buf = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
11008f18d1faSGeorge Wilson 	do {
11013f84190cSMatthew Ahrens 		len = SPA_MAXBLOCKSIZE;
1102e4161df6SVictor Latushkin 
11038f18d1faSGeorge Wilson 		if ((error = spa_history_get(spa, &off, &len, buf)) != 0) {
11048f18d1faSGeorge Wilson 			(void) fprintf(stderr, "Unable to read history: "
11058f18d1faSGeorge Wilson 			    "error %d\n", error);
11063f84190cSMatthew Ahrens 			umem_free(buf, SPA_MAXBLOCKSIZE);
11078f18d1faSGeorge Wilson 			return;
11088f18d1faSGeorge Wilson 		}
11098f18d1faSGeorge Wilson 
11108f18d1faSGeorge Wilson 		if (zpool_history_unpack(buf, len, &resid, &events, &num) != 0)
11118f18d1faSGeorge Wilson 			break;
11128f18d1faSGeorge Wilson 
11138f18d1faSGeorge Wilson 		off -= resid;
11148f18d1faSGeorge Wilson 	} while (len != 0);
11153f84190cSMatthew Ahrens 	umem_free(buf, SPA_MAXBLOCKSIZE);
11168f18d1faSGeorge Wilson 
11178f18d1faSGeorge Wilson 	(void) printf("\nHistory:\n");
11188f18d1faSGeorge Wilson 	for (int i = 0; i < num; i++) {
11198f18d1faSGeorge Wilson 		uint64_t time, txg, ievent;
11208f18d1faSGeorge Wilson 		char *cmd, *intstr;
11214445fffbSMatthew Ahrens 		boolean_t printed = B_FALSE;
11228f18d1faSGeorge Wilson 
11238f18d1faSGeorge Wilson 		if (nvlist_lookup_uint64(events[i], ZPOOL_HIST_TIME,
11248f18d1faSGeorge Wilson 		    &time) != 0)
11254445fffbSMatthew Ahrens 			goto next;
11268f18d1faSGeorge Wilson 		if (nvlist_lookup_string(events[i], ZPOOL_HIST_CMD,
11278f18d1faSGeorge Wilson 		    &cmd) != 0) {
11288f18d1faSGeorge Wilson 			if (nvlist_lookup_uint64(events[i],
11298f18d1faSGeorge Wilson 			    ZPOOL_HIST_INT_EVENT, &ievent) != 0)
11304445fffbSMatthew Ahrens 				goto next;
11318f18d1faSGeorge Wilson 			verify(nvlist_lookup_uint64(events[i],
11328f18d1faSGeorge Wilson 			    ZPOOL_HIST_TXG, &txg) == 0);
11338f18d1faSGeorge Wilson 			verify(nvlist_lookup_string(events[i],
11348f18d1faSGeorge Wilson 			    ZPOOL_HIST_INT_STR, &intstr) == 0);
11354445fffbSMatthew Ahrens 			if (ievent >= ZFS_NUM_LEGACY_HISTORY_EVENTS)
11364445fffbSMatthew Ahrens 				goto next;
11378f18d1faSGeorge Wilson 
11388f18d1faSGeorge Wilson 			(void) snprintf(internalstr,
11398f18d1faSGeorge Wilson 			    sizeof (internalstr),
11408f18d1faSGeorge Wilson 			    "[internal %s txg:%lld] %s",
11413f9d6ad7SLin Ling 			    zfs_history_event_names[ievent], txg,
11428f18d1faSGeorge Wilson 			    intstr);
11438f18d1faSGeorge Wilson 			cmd = internalstr;
11448f18d1faSGeorge Wilson 		}
11458f18d1faSGeorge Wilson 		tsec = time;
11468f18d1faSGeorge Wilson 		(void) localtime_r(&tsec, &t);
11478f18d1faSGeorge Wilson 		(void) strftime(tbuf, sizeof (tbuf), "%F.%T", &t);
11488f18d1faSGeorge Wilson 		(void) printf("%s %s\n", tbuf, cmd);
11494445fffbSMatthew Ahrens 		printed = B_TRUE;
11504445fffbSMatthew Ahrens 
11514445fffbSMatthew Ahrens next:
11524445fffbSMatthew Ahrens 		if (dump_opt['h'] > 1) {
11534445fffbSMatthew Ahrens 			if (!printed)
11544445fffbSMatthew Ahrens 				(void) printf("unrecognized record:\n");
11554445fffbSMatthew Ahrens 			dump_nvlist(events[i], 2);
11564445fffbSMatthew Ahrens 		}
11578f18d1faSGeorge Wilson 	}
11588f18d1faSGeorge Wilson }
11598f18d1faSGeorge Wilson 
1160fa9e4066Sahrens /*ARGSUSED*/
1161fa9e4066Sahrens static void
1162fa9e4066Sahrens dump_dnode(objset_t *os, uint64_t object, void *data, size_t size)
1163fa9e4066Sahrens {
1164fa9e4066Sahrens }
1165fa9e4066Sahrens 
1166fa9e4066Sahrens static uint64_t
11677802d7bfSMatthew Ahrens blkid2offset(const dnode_phys_t *dnp, const blkptr_t *bp,
11687802d7bfSMatthew Ahrens     const zbookmark_phys_t *zb)
1169fa9e4066Sahrens {
1170b24ab676SJeff Bonwick 	if (dnp == NULL) {
1171b24ab676SJeff Bonwick 		ASSERT(zb->zb_level < 0);
1172b24ab676SJeff Bonwick 		if (zb->zb_object == 0)
1173b24ab676SJeff Bonwick 			return (zb->zb_blkid);
1174b24ab676SJeff Bonwick 		return (zb->zb_blkid * BP_GET_LSIZE(bp));
1175b24ab676SJeff Bonwick 	}
1176b24ab676SJeff Bonwick 
1177b24ab676SJeff Bonwick 	ASSERT(zb->zb_level >= 0);
1178fa9e4066Sahrens 
1179b24ab676SJeff Bonwick 	return ((zb->zb_blkid <<
1180b24ab676SJeff Bonwick 	    (zb->zb_level * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT))) *
1181fa9e4066Sahrens 	    dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT);
1182fa9e4066Sahrens }
1183fa9e4066Sahrens 
118444cd46caSbillm static void
118543466aaeSMax Grossman snprintf_blkptr_compact(char *blkbuf, size_t buflen, const blkptr_t *bp)
118644cd46caSbillm {
1187cde58dbcSMatthew Ahrens 	const dva_t *dva = bp->blk_dva;
1188b24ab676SJeff Bonwick 	int ndvas = dump_opt['d'] > 5 ? BP_GET_NDVAS(bp) : 1;
1189b24ab676SJeff Bonwick 
1190490d05b9SMatthew Ahrens 	if (dump_opt['b'] >= 6) {
119143466aaeSMax Grossman 		snprintf_blkptr(blkbuf, buflen, bp);
1192b24ab676SJeff Bonwick 		return;
1193b24ab676SJeff Bonwick 	}
119444cd46caSbillm 
11955d7b4d43SMatthew Ahrens 	if (BP_IS_EMBEDDED(bp)) {
11965d7b4d43SMatthew Ahrens 		(void) sprintf(blkbuf,
11975d7b4d43SMatthew Ahrens 		    "EMBEDDED et=%u %llxL/%llxP B=%llu",
11985d7b4d43SMatthew Ahrens 		    (int)BPE_GET_ETYPE(bp),
11995d7b4d43SMatthew Ahrens 		    (u_longlong_t)BPE_GET_LSIZE(bp),
12005d7b4d43SMatthew Ahrens 		    (u_longlong_t)BPE_GET_PSIZE(bp),
12015d7b4d43SMatthew Ahrens 		    (u_longlong_t)bp->blk_birth);
12025d7b4d43SMatthew Ahrens 		return;
12035d7b4d43SMatthew Ahrens 	}
120444cd46caSbillm 
12055d7b4d43SMatthew Ahrens 	blkbuf[0] = '\0';
1206b24ab676SJeff Bonwick 	for (int i = 0; i < ndvas; i++)
120743466aaeSMax Grossman 		(void) snprintf(blkbuf + strlen(blkbuf),
120843466aaeSMax Grossman 		    buflen - strlen(blkbuf), "%llu:%llx:%llx ",
120944cd46caSbillm 		    (u_longlong_t)DVA_GET_VDEV(&dva[i]),
121044cd46caSbillm 		    (u_longlong_t)DVA_GET_OFFSET(&dva[i]),
121144cd46caSbillm 		    (u_longlong_t)DVA_GET_ASIZE(&dva[i]));
121244cd46caSbillm 
121343466aaeSMax Grossman 	if (BP_IS_HOLE(bp)) {
121443466aaeSMax Grossman 		(void) snprintf(blkbuf + strlen(blkbuf),
121570163ac5SPrakash Surya 		    buflen - strlen(blkbuf),
121670163ac5SPrakash Surya 		    "%llxL B=%llu",
121770163ac5SPrakash Surya 		    (u_longlong_t)BP_GET_LSIZE(bp),
121843466aaeSMax Grossman 		    (u_longlong_t)bp->blk_birth);
121943466aaeSMax Grossman 	} else {
122043466aaeSMax Grossman 		(void) snprintf(blkbuf + strlen(blkbuf),
122143466aaeSMax Grossman 		    buflen - strlen(blkbuf),
122243466aaeSMax Grossman 		    "%llxL/%llxP F=%llu B=%llu/%llu",
122343466aaeSMax Grossman 		    (u_longlong_t)BP_GET_LSIZE(bp),
122443466aaeSMax Grossman 		    (u_longlong_t)BP_GET_PSIZE(bp),
12255d7b4d43SMatthew Ahrens 		    (u_longlong_t)BP_GET_FILL(bp),
122643466aaeSMax Grossman 		    (u_longlong_t)bp->blk_birth,
122743466aaeSMax Grossman 		    (u_longlong_t)BP_PHYSICAL_BIRTH(bp));
122843466aaeSMax Grossman 	}
122944cd46caSbillm }
123044cd46caSbillm 
123188b7b0f2SMatthew Ahrens static void
12327802d7bfSMatthew Ahrens print_indirect(blkptr_t *bp, const zbookmark_phys_t *zb,
123388b7b0f2SMatthew Ahrens     const dnode_phys_t *dnp)
1234fa9e4066Sahrens {
123588b7b0f2SMatthew Ahrens 	char blkbuf[BP_SPRINTF_LEN];
1236fa9e4066Sahrens 	int l;
1237fa9e4066Sahrens 
12385d7b4d43SMatthew Ahrens 	if (!BP_IS_EMBEDDED(bp)) {
12395d7b4d43SMatthew Ahrens 		ASSERT3U(BP_GET_TYPE(bp), ==, dnp->dn_type);
12405d7b4d43SMatthew Ahrens 		ASSERT3U(BP_GET_LEVEL(bp), ==, zb->zb_level);
12415d7b4d43SMatthew Ahrens 	}
1242fa9e4066Sahrens 
1243b24ab676SJeff Bonwick 	(void) printf("%16llx ", (u_longlong_t)blkid2offset(dnp, bp, zb));
1244fa9e4066Sahrens 
1245fa9e4066Sahrens 	ASSERT(zb->zb_level >= 0);
1246fa9e4066Sahrens 
1247fa9e4066Sahrens 	for (l = dnp->dn_nlevels - 1; l >= -1; l--) {
1248fa9e4066Sahrens 		if (l == zb->zb_level) {
124988b7b0f2SMatthew Ahrens 			(void) printf("L%llx", (u_longlong_t)zb->zb_level);
1250fa9e4066Sahrens 		} else {
125188b7b0f2SMatthew Ahrens 			(void) printf(" ");
1252fa9e4066Sahrens 		}
1253fa9e4066Sahrens 	}
1254fa9e4066Sahrens 
125543466aaeSMax Grossman 	snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), bp);
125688b7b0f2SMatthew Ahrens 	(void) printf("%s\n", blkbuf);
125788b7b0f2SMatthew Ahrens }
125888b7b0f2SMatthew Ahrens 
125988b7b0f2SMatthew Ahrens static int
126088b7b0f2SMatthew Ahrens visit_indirect(spa_t *spa, const dnode_phys_t *dnp,
12617802d7bfSMatthew Ahrens     blkptr_t *bp, const zbookmark_phys_t *zb)
126288b7b0f2SMatthew Ahrens {
1263e4161df6SVictor Latushkin 	int err = 0;
126488b7b0f2SMatthew Ahrens 
126588b7b0f2SMatthew Ahrens 	if (bp->blk_birth == 0)
126688b7b0f2SMatthew Ahrens 		return (0);
126788b7b0f2SMatthew Ahrens 
126888b7b0f2SMatthew Ahrens 	print_indirect(bp, zb, dnp);
126988b7b0f2SMatthew Ahrens 
127043466aaeSMax Grossman 	if (BP_GET_LEVEL(bp) > 0 && !BP_IS_HOLE(bp)) {
12717adb730bSGeorge Wilson 		arc_flags_t flags = ARC_FLAG_WAIT;
127288b7b0f2SMatthew Ahrens 		int i;
127388b7b0f2SMatthew Ahrens 		blkptr_t *cbp;
127488b7b0f2SMatthew Ahrens 		int epb = BP_GET_LSIZE(bp) >> SPA_BLKPTRSHIFT;
127588b7b0f2SMatthew Ahrens 		arc_buf_t *buf;
127688b7b0f2SMatthew Ahrens 		uint64_t fill = 0;
127788b7b0f2SMatthew Ahrens 
12781b912ec7SGeorge Wilson 		err = arc_read(NULL, spa, bp, arc_getbuf_func, &buf,
127988b7b0f2SMatthew Ahrens 		    ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, zb);
128088b7b0f2SMatthew Ahrens 		if (err)
128188b7b0f2SMatthew Ahrens 			return (err);
12823f9d6ad7SLin Ling 		ASSERT(buf->b_data);
128388b7b0f2SMatthew Ahrens 
128488b7b0f2SMatthew Ahrens 		/* recursively visit blocks below this */
128588b7b0f2SMatthew Ahrens 		cbp = buf->b_data;
128688b7b0f2SMatthew Ahrens 		for (i = 0; i < epb; i++, cbp++) {
12877802d7bfSMatthew Ahrens 			zbookmark_phys_t czb;
128888b7b0f2SMatthew Ahrens 
128988b7b0f2SMatthew Ahrens 			SET_BOOKMARK(&czb, zb->zb_objset, zb->zb_object,
129088b7b0f2SMatthew Ahrens 			    zb->zb_level - 1,
129188b7b0f2SMatthew Ahrens 			    zb->zb_blkid * epb + i);
129288b7b0f2SMatthew Ahrens 			err = visit_indirect(spa, dnp, cbp, &czb);
129388b7b0f2SMatthew Ahrens 			if (err)
129488b7b0f2SMatthew Ahrens 				break;
12955d7b4d43SMatthew Ahrens 			fill += BP_GET_FILL(cbp);
129688b7b0f2SMatthew Ahrens 		}
12978ad4d6ddSJeff Bonwick 		if (!err)
12985d7b4d43SMatthew Ahrens 			ASSERT3U(fill, ==, BP_GET_FILL(bp));
1299dcbf3bd6SGeorge Wilson 		arc_buf_destroy(buf, &buf);
1300fa9e4066Sahrens 	}
1301fa9e4066Sahrens 
130288b7b0f2SMatthew Ahrens 	return (err);
1303fa9e4066Sahrens }
1304fa9e4066Sahrens 
1305fa9e4066Sahrens /*ARGSUSED*/
1306fa9e4066Sahrens static void
130788b7b0f2SMatthew Ahrens dump_indirect(dnode_t *dn)
1308fa9e4066Sahrens {
130988b7b0f2SMatthew Ahrens 	dnode_phys_t *dnp = dn->dn_phys;
131088b7b0f2SMatthew Ahrens 	int j;
13117802d7bfSMatthew Ahrens 	zbookmark_phys_t czb;
1312fa9e4066Sahrens 
1313fa9e4066Sahrens 	(void) printf("Indirect blocks:\n");
1314fa9e4066Sahrens 
1315503ad85cSMatthew Ahrens 	SET_BOOKMARK(&czb, dmu_objset_id(dn->dn_objset),
131688b7b0f2SMatthew Ahrens 	    dn->dn_object, dnp->dn_nlevels - 1, 0);
131788b7b0f2SMatthew Ahrens 	for (j = 0; j < dnp->dn_nblkptr; j++) {
131888b7b0f2SMatthew Ahrens 		czb.zb_blkid = j;
1319503ad85cSMatthew Ahrens 		(void) visit_indirect(dmu_objset_spa(dn->dn_objset), dnp,
132088b7b0f2SMatthew Ahrens 		    &dnp->dn_blkptr[j], &czb);
132188b7b0f2SMatthew Ahrens 	}
1322fa9e4066Sahrens 
1323fa9e4066Sahrens 	(void) printf("\n");
1324fa9e4066Sahrens }
1325fa9e4066Sahrens 
1326fa9e4066Sahrens /*ARGSUSED*/
1327fa9e4066Sahrens static void
1328fa9e4066Sahrens dump_dsl_dir(objset_t *os, uint64_t object, void *data, size_t size)
1329fa9e4066Sahrens {
1330fa9e4066Sahrens 	dsl_dir_phys_t *dd = data;
1331fa9e4066Sahrens 	time_t crtime;
13323f9d6ad7SLin Ling 	char nice[32];
1333fa9e4066Sahrens 
1334fa9e4066Sahrens 	if (dd == NULL)
1335fa9e4066Sahrens 		return;
1336fa9e4066Sahrens 
1337da6c28aaSamw 	ASSERT3U(size, >=, sizeof (dsl_dir_phys_t));
1338fa9e4066Sahrens 
1339fa9e4066Sahrens 	crtime = dd->dd_creation_time;
1340fa9e4066Sahrens 	(void) printf("\t\tcreation_time = %s", ctime(&crtime));
1341fa9e4066Sahrens 	(void) printf("\t\thead_dataset_obj = %llu\n",
1342fa9e4066Sahrens 	    (u_longlong_t)dd->dd_head_dataset_obj);
1343fa9e4066Sahrens 	(void) printf("\t\tparent_dir_obj = %llu\n",
1344fa9e4066Sahrens 	    (u_longlong_t)dd->dd_parent_obj);
13453cb34c60Sahrens 	(void) printf("\t\torigin_obj = %llu\n",
13463cb34c60Sahrens 	    (u_longlong_t)dd->dd_origin_obj);
1347fa9e4066Sahrens 	(void) printf("\t\tchild_dir_zapobj = %llu\n",
1348fa9e4066Sahrens 	    (u_longlong_t)dd->dd_child_dir_zapobj);
13493f9d6ad7SLin Ling 	zdb_nicenum(dd->dd_used_bytes, nice);
135074e7dc98SMatthew Ahrens 	(void) printf("\t\tused_bytes = %s\n", nice);
13513f9d6ad7SLin Ling 	zdb_nicenum(dd->dd_compressed_bytes, nice);
135274e7dc98SMatthew Ahrens 	(void) printf("\t\tcompressed_bytes = %s\n", nice);
13533f9d6ad7SLin Ling 	zdb_nicenum(dd->dd_uncompressed_bytes, nice);
135474e7dc98SMatthew Ahrens 	(void) printf("\t\tuncompressed_bytes = %s\n", nice);
13553f9d6ad7SLin Ling 	zdb_nicenum(dd->dd_quota, nice);
135674e7dc98SMatthew Ahrens 	(void) printf("\t\tquota = %s\n", nice);
13573f9d6ad7SLin Ling 	zdb_nicenum(dd->dd_reserved, nice);
135874e7dc98SMatthew Ahrens 	(void) printf("\t\treserved = %s\n", nice);
1359fa9e4066Sahrens 	(void) printf("\t\tprops_zapobj = %llu\n",
1360fa9e4066Sahrens 	    (u_longlong_t)dd->dd_props_zapobj);
1361ecd6cf80Smarks 	(void) printf("\t\tdeleg_zapobj = %llu\n",
1362ecd6cf80Smarks 	    (u_longlong_t)dd->dd_deleg_zapobj);
136374e7dc98SMatthew Ahrens 	(void) printf("\t\tflags = %llx\n",
136474e7dc98SMatthew Ahrens 	    (u_longlong_t)dd->dd_flags);
136574e7dc98SMatthew Ahrens 
136674e7dc98SMatthew Ahrens #define	DO(which) \
13673f9d6ad7SLin Ling 	zdb_nicenum(dd->dd_used_breakdown[DD_USED_ ## which], nice); \
136874e7dc98SMatthew Ahrens 	(void) printf("\t\tused_breakdown[" #which "] = %s\n", nice)
136974e7dc98SMatthew Ahrens 	DO(HEAD);
137074e7dc98SMatthew Ahrens 	DO(SNAP);
137174e7dc98SMatthew Ahrens 	DO(CHILD);
137274e7dc98SMatthew Ahrens 	DO(CHILD_RSRV);
137374e7dc98SMatthew Ahrens 	DO(REFRSRV);
137474e7dc98SMatthew Ahrens #undef DO
1375fa9e4066Sahrens }
1376fa9e4066Sahrens 
1377fa9e4066Sahrens /*ARGSUSED*/
1378fa9e4066Sahrens static void
1379fa9e4066Sahrens dump_dsl_dataset(objset_t *os, uint64_t object, void *data, size_t size)
1380fa9e4066Sahrens {
1381fa9e4066Sahrens 	dsl_dataset_phys_t *ds = data;
1382fa9e4066Sahrens 	time_t crtime;
13833f9d6ad7SLin Ling 	char used[32], compressed[32], uncompressed[32], unique[32];
1384fbabab8fSmaybee 	char blkbuf[BP_SPRINTF_LEN];
1385fa9e4066Sahrens 
1386fa9e4066Sahrens 	if (ds == NULL)
1387fa9e4066Sahrens 		return;
1388fa9e4066Sahrens 
1389fa9e4066Sahrens 	ASSERT(size == sizeof (*ds));
1390fa9e4066Sahrens 	crtime = ds->ds_creation_time;
1391ad135b5dSChristopher Siden 	zdb_nicenum(ds->ds_referenced_bytes, used);
13923f9d6ad7SLin Ling 	zdb_nicenum(ds->ds_compressed_bytes, compressed);
13933f9d6ad7SLin Ling 	zdb_nicenum(ds->ds_uncompressed_bytes, uncompressed);
13943f9d6ad7SLin Ling 	zdb_nicenum(ds->ds_unique_bytes, unique);
139543466aaeSMax Grossman 	snprintf_blkptr(blkbuf, sizeof (blkbuf), &ds->ds_bp);
1396fa9e4066Sahrens 
1397088f3894Sahrens 	(void) printf("\t\tdir_obj = %llu\n",
1398fa9e4066Sahrens 	    (u_longlong_t)ds->ds_dir_obj);
1399fa9e4066Sahrens 	(void) printf("\t\tprev_snap_obj = %llu\n",
1400fa9e4066Sahrens 	    (u_longlong_t)ds->ds_prev_snap_obj);
1401fa9e4066Sahrens 	(void) printf("\t\tprev_snap_txg = %llu\n",
1402fa9e4066Sahrens 	    (u_longlong_t)ds->ds_prev_snap_txg);
1403fa9e4066Sahrens 	(void) printf("\t\tnext_snap_obj = %llu\n",
1404fa9e4066Sahrens 	    (u_longlong_t)ds->ds_next_snap_obj);
1405fa9e4066Sahrens 	(void) printf("\t\tsnapnames_zapobj = %llu\n",
1406fa9e4066Sahrens 	    (u_longlong_t)ds->ds_snapnames_zapobj);
1407fa9e4066Sahrens 	(void) printf("\t\tnum_children = %llu\n",
1408fa9e4066Sahrens 	    (u_longlong_t)ds->ds_num_children);
1409842727c2SChris Kirby 	(void) printf("\t\tuserrefs_obj = %llu\n",
1410842727c2SChris Kirby 	    (u_longlong_t)ds->ds_userrefs_obj);
1411fa9e4066Sahrens 	(void) printf("\t\tcreation_time = %s", ctime(&crtime));
1412fa9e4066Sahrens 	(void) printf("\t\tcreation_txg = %llu\n",
1413fa9e4066Sahrens 	    (u_longlong_t)ds->ds_creation_txg);
1414fa9e4066Sahrens 	(void) printf("\t\tdeadlist_obj = %llu\n",
1415fa9e4066Sahrens 	    (u_longlong_t)ds->ds_deadlist_obj);
1416fa9e4066Sahrens 	(void) printf("\t\tused_bytes = %s\n", used);
1417fa9e4066Sahrens 	(void) printf("\t\tcompressed_bytes = %s\n", compressed);
1418fa9e4066Sahrens 	(void) printf("\t\tuncompressed_bytes = %s\n", uncompressed);
1419fa9e4066Sahrens 	(void) printf("\t\tunique = %s\n", unique);
1420fa9e4066Sahrens 	(void) printf("\t\tfsid_guid = %llu\n",
1421fa9e4066Sahrens 	    (u_longlong_t)ds->ds_fsid_guid);
1422fa9e4066Sahrens 	(void) printf("\t\tguid = %llu\n",
1423fa9e4066Sahrens 	    (u_longlong_t)ds->ds_guid);
142499653d4eSeschrock 	(void) printf("\t\tflags = %llx\n",
142599653d4eSeschrock 	    (u_longlong_t)ds->ds_flags);
1426088f3894Sahrens 	(void) printf("\t\tnext_clones_obj = %llu\n",
1427088f3894Sahrens 	    (u_longlong_t)ds->ds_next_clones_obj);
1428bb0ade09Sahrens 	(void) printf("\t\tprops_obj = %llu\n",
1429bb0ade09Sahrens 	    (u_longlong_t)ds->ds_props_obj);
1430fa9e4066Sahrens 	(void) printf("\t\tbp = %s\n", blkbuf);
1431fa9e4066Sahrens }
1432fa9e4066Sahrens 
1433ad135b5dSChristopher Siden /* ARGSUSED */
1434ad135b5dSChristopher Siden static int
1435ad135b5dSChristopher Siden dump_bptree_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
1436ad135b5dSChristopher Siden {
1437ad135b5dSChristopher Siden 	char blkbuf[BP_SPRINTF_LEN];
1438ad135b5dSChristopher Siden 
1439ad135b5dSChristopher Siden 	if (bp->blk_birth != 0) {
144043466aaeSMax Grossman 		snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
1441ad135b5dSChristopher Siden 		(void) printf("\t%s\n", blkbuf);
1442ad135b5dSChristopher Siden 	}
1443ad135b5dSChristopher Siden 	return (0);
1444ad135b5dSChristopher Siden }
1445ad135b5dSChristopher Siden 
1446ad135b5dSChristopher Siden static void
1447ad135b5dSChristopher Siden dump_bptree(objset_t *os, uint64_t obj, char *name)
1448ad135b5dSChristopher Siden {
1449ad135b5dSChristopher Siden 	char bytes[32];
1450ad135b5dSChristopher Siden 	bptree_phys_t *bt;
1451ad135b5dSChristopher Siden 	dmu_buf_t *db;
1452ad135b5dSChristopher Siden 
1453ad135b5dSChristopher Siden 	if (dump_opt['d'] < 3)
1454ad135b5dSChristopher Siden 		return;
1455ad135b5dSChristopher Siden 
1456b420f3adSRichard Lowe 	VERIFY3U(0, ==, dmu_bonus_hold(os, obj, FTAG, &db));
1457ad135b5dSChristopher Siden 	bt = db->db_data;
1458ad135b5dSChristopher Siden 	zdb_nicenum(bt->bt_bytes, bytes);
1459ad135b5dSChristopher Siden 	(void) printf("\n    %s: %llu datasets, %s\n",
1460ad135b5dSChristopher Siden 	    name, (unsigned long long)(bt->bt_end - bt->bt_begin), bytes);
1461ad135b5dSChristopher Siden 	dmu_buf_rele(db, FTAG);
1462ad135b5dSChristopher Siden 
1463ad135b5dSChristopher Siden 	if (dump_opt['d'] < 5)
1464ad135b5dSChristopher Siden 		return;
1465ad135b5dSChristopher Siden 
1466ad135b5dSChristopher Siden 	(void) printf("\n");
1467ad135b5dSChristopher Siden 
1468ad135b5dSChristopher Siden 	(void) bptree_iterate(os, obj, B_FALSE, dump_bptree_cb, NULL, NULL);
1469ad135b5dSChristopher Siden }
1470ad135b5dSChristopher Siden 
1471cde58dbcSMatthew Ahrens /* ARGSUSED */
1472cde58dbcSMatthew Ahrens static int
1473cde58dbcSMatthew Ahrens dump_bpobj_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
1474cde58dbcSMatthew Ahrens {
1475cde58dbcSMatthew Ahrens 	char blkbuf[BP_SPRINTF_LEN];
1476cde58dbcSMatthew Ahrens 
1477cde58dbcSMatthew Ahrens 	ASSERT(bp->blk_birth != 0);
147843466aaeSMax Grossman 	snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), bp);
1479cde58dbcSMatthew Ahrens 	(void) printf("\t%s\n", blkbuf);
1480cde58dbcSMatthew Ahrens 	return (0);
1481cde58dbcSMatthew Ahrens }
1482cde58dbcSMatthew Ahrens 
1483fa9e4066Sahrens static void
1484732885fcSMatthew Ahrens dump_full_bpobj(bpobj_t *bpo, char *name, int indent)
1485fa9e4066Sahrens {
14863f9d6ad7SLin Ling 	char bytes[32];
14873f9d6ad7SLin Ling 	char comp[32];
14883f9d6ad7SLin Ling 	char uncomp[32];
1489fa9e4066Sahrens 
1490fa9e4066Sahrens 	if (dump_opt['d'] < 3)
1491fa9e4066Sahrens 		return;
1492fa9e4066Sahrens 
1493cde58dbcSMatthew Ahrens 	zdb_nicenum(bpo->bpo_phys->bpo_bytes, bytes);
1494d0475637SMatthew Ahrens 	if (bpo->bpo_havesubobj && bpo->bpo_phys->bpo_subobjs != 0) {
1495cde58dbcSMatthew Ahrens 		zdb_nicenum(bpo->bpo_phys->bpo_comp, comp);
1496cde58dbcSMatthew Ahrens 		zdb_nicenum(bpo->bpo_phys->bpo_uncomp, uncomp);
1497d0475637SMatthew Ahrens 		(void) printf("    %*s: object %llu, %llu local blkptrs, "
1498732885fcSMatthew Ahrens 		    "%llu subobjs in object %llu, %s (%s/%s comp)\n",
1499d0475637SMatthew Ahrens 		    indent * 8, name,
1500d0475637SMatthew Ahrens 		    (u_longlong_t)bpo->bpo_object,
1501d0475637SMatthew Ahrens 		    (u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
1502cde58dbcSMatthew Ahrens 		    (u_longlong_t)bpo->bpo_phys->bpo_num_subobjs,
1503732885fcSMatthew Ahrens 		    (u_longlong_t)bpo->bpo_phys->bpo_subobjs,
150499653d4eSeschrock 		    bytes, comp, uncomp);
1505d0475637SMatthew Ahrens 
1506d0475637SMatthew Ahrens 		for (uint64_t i = 0; i < bpo->bpo_phys->bpo_num_subobjs; i++) {
1507d0475637SMatthew Ahrens 			uint64_t subobj;
1508d0475637SMatthew Ahrens 			bpobj_t subbpo;
1509d0475637SMatthew Ahrens 			int error;
1510d0475637SMatthew Ahrens 			VERIFY0(dmu_read(bpo->bpo_os,
1511d0475637SMatthew Ahrens 			    bpo->bpo_phys->bpo_subobjs,
1512d0475637SMatthew Ahrens 			    i * sizeof (subobj), sizeof (subobj), &subobj, 0));
1513d0475637SMatthew Ahrens 			error = bpobj_open(&subbpo, bpo->bpo_os, subobj);
1514d0475637SMatthew Ahrens 			if (error != 0) {
1515d0475637SMatthew Ahrens 				(void) printf("ERROR %u while trying to open "
1516d0475637SMatthew Ahrens 				    "subobj id %llu\n",
1517d0475637SMatthew Ahrens 				    error, (u_longlong_t)subobj);
1518d0475637SMatthew Ahrens 				continue;
1519d0475637SMatthew Ahrens 			}
1520732885fcSMatthew Ahrens 			dump_full_bpobj(&subbpo, "subobj", indent + 1);
152177061867SMatthew Ahrens 			bpobj_close(&subbpo);
1522d0475637SMatthew Ahrens 		}
152399653d4eSeschrock 	} else {
1524d0475637SMatthew Ahrens 		(void) printf("    %*s: object %llu, %llu blkptrs, %s\n",
1525d0475637SMatthew Ahrens 		    indent * 8, name,
1526d0475637SMatthew Ahrens 		    (u_longlong_t)bpo->bpo_object,
1527d0475637SMatthew Ahrens 		    (u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
1528d0475637SMatthew Ahrens 		    bytes);
152999653d4eSeschrock 	}
1530fa9e4066Sahrens 
1531cde58dbcSMatthew Ahrens 	if (dump_opt['d'] < 5)
1532fa9e4066Sahrens 		return;
1533fa9e4066Sahrens 
1534fa9e4066Sahrens 
1535d0475637SMatthew Ahrens 	if (indent == 0) {
1536d0475637SMatthew Ahrens 		(void) bpobj_iterate_nofree(bpo, dump_bpobj_cb, NULL, NULL);
1537d0475637SMatthew Ahrens 		(void) printf("\n");
1538d0475637SMatthew Ahrens 	}
1539cde58dbcSMatthew Ahrens }
154044cd46caSbillm 
1541cde58dbcSMatthew Ahrens static void
1542cde58dbcSMatthew Ahrens dump_deadlist(dsl_deadlist_t *dl)
1543cde58dbcSMatthew Ahrens {
1544cde58dbcSMatthew Ahrens 	dsl_deadlist_entry_t *dle;
1545d0475637SMatthew Ahrens 	uint64_t unused;
1546cde58dbcSMatthew Ahrens 	char bytes[32];
1547cde58dbcSMatthew Ahrens 	char comp[32];
1548cde58dbcSMatthew Ahrens 	char uncomp[32];
1549cde58dbcSMatthew Ahrens 
1550cde58dbcSMatthew Ahrens 	if (dump_opt['d'] < 3)
1551cde58dbcSMatthew Ahrens 		return;
1552cde58dbcSMatthew Ahrens 
155390c76c66SMatthew Ahrens 	if (dl->dl_oldfmt) {
1554732885fcSMatthew Ahrens 		dump_full_bpobj(&dl->dl_bpobj, "old-format deadlist", 0);
155590c76c66SMatthew Ahrens 		return;
155690c76c66SMatthew Ahrens 	}
155790c76c66SMatthew Ahrens 
1558cde58dbcSMatthew Ahrens 	zdb_nicenum(dl->dl_phys->dl_used, bytes);
1559cde58dbcSMatthew Ahrens 	zdb_nicenum(dl->dl_phys->dl_comp, comp);
1560cde58dbcSMatthew Ahrens 	zdb_nicenum(dl->dl_phys->dl_uncomp, uncomp);
1561cde58dbcSMatthew Ahrens 	(void) printf("\n    Deadlist: %s (%s/%s comp)\n",
1562cde58dbcSMatthew Ahrens 	    bytes, comp, uncomp);
1563cde58dbcSMatthew Ahrens 
1564cde58dbcSMatthew Ahrens 	if (dump_opt['d'] < 4)
1565cde58dbcSMatthew Ahrens 		return;
1566cde58dbcSMatthew Ahrens 
1567cde58dbcSMatthew Ahrens 	(void) printf("\n");
1568cde58dbcSMatthew Ahrens 
1569d0475637SMatthew Ahrens 	/* force the tree to be loaded */
1570d0475637SMatthew Ahrens 	dsl_deadlist_space_range(dl, 0, UINT64_MAX, &unused, &unused, &unused);
1571d0475637SMatthew Ahrens 
1572cde58dbcSMatthew Ahrens 	for (dle = avl_first(&dl->dl_tree); dle;
1573cde58dbcSMatthew Ahrens 	    dle = AVL_NEXT(&dl->dl_tree, dle)) {
1574d0475637SMatthew Ahrens 		if (dump_opt['d'] >= 5) {
1575d0475637SMatthew Ahrens 			char buf[128];
1576de05b588SRichard Yao 			(void) snprintf(buf, sizeof (buf),
1577de05b588SRichard Yao 			    "mintxg %llu -> obj %llu",
1578d0475637SMatthew Ahrens 			    (longlong_t)dle->dle_mintxg,
1579d0475637SMatthew Ahrens 			    (longlong_t)dle->dle_bpobj.bpo_object);
1580fa9e4066Sahrens 
1581732885fcSMatthew Ahrens 			dump_full_bpobj(&dle->dle_bpobj, buf, 0);
1582d0475637SMatthew Ahrens 		} else {
1583d0475637SMatthew Ahrens 			(void) printf("mintxg %llu -> obj %llu\n",
1584d0475637SMatthew Ahrens 			    (longlong_t)dle->dle_mintxg,
1585d0475637SMatthew Ahrens 			    (longlong_t)dle->dle_bpobj.bpo_object);
1586d0475637SMatthew Ahrens 
1587d0475637SMatthew Ahrens 		}
1588cde58dbcSMatthew Ahrens 	}
1589fa9e4066Sahrens }
1590fa9e4066Sahrens 
1591e0d35c44Smarks static avl_tree_t idx_tree;
1592e0d35c44Smarks static avl_tree_t domain_tree;
1593e0d35c44Smarks static boolean_t fuid_table_loaded;
1594ed61ec1dSYuri Pankov static objset_t *sa_os = NULL;
1595ed61ec1dSYuri Pankov static sa_attr_type_t *sa_attr_table = NULL;
1596ed61ec1dSYuri Pankov 
1597ed61ec1dSYuri Pankov static int
1598ed61ec1dSYuri Pankov open_objset(const char *path, dmu_objset_type_t type, void *tag, objset_t **osp)
1599ed61ec1dSYuri Pankov {
1600ed61ec1dSYuri Pankov 	int err;
1601ed61ec1dSYuri Pankov 	uint64_t sa_attrs = 0;
1602ed61ec1dSYuri Pankov 	uint64_t version = 0;
1603ed61ec1dSYuri Pankov 
1604ed61ec1dSYuri Pankov 	VERIFY3P(sa_os, ==, NULL);
1605ed61ec1dSYuri Pankov 	err = dmu_objset_own(path, type, B_TRUE, tag, osp);
1606ed61ec1dSYuri Pankov 	if (err != 0) {
1607ed61ec1dSYuri Pankov 		(void) fprintf(stderr, "failed to own dataset '%s': %s\n", path,
1608ed61ec1dSYuri Pankov 		    strerror(err));
1609ed61ec1dSYuri Pankov 		return (err);
1610ed61ec1dSYuri Pankov 	}
1611ed61ec1dSYuri Pankov 
1612ed61ec1dSYuri Pankov 	if (dmu_objset_type(*osp) == DMU_OST_ZFS) {
1613ed61ec1dSYuri Pankov 		(void) zap_lookup(*osp, MASTER_NODE_OBJ, ZPL_VERSION_STR,
1614ed61ec1dSYuri Pankov 		    8, 1, &version);
1615ed61ec1dSYuri Pankov 		if (version >= ZPL_VERSION_SA) {
1616ed61ec1dSYuri Pankov 			(void) zap_lookup(*osp, MASTER_NODE_OBJ, ZFS_SA_ATTRS,
1617ed61ec1dSYuri Pankov 			    8, 1, &sa_attrs);
1618ed61ec1dSYuri Pankov 		}
1619ed61ec1dSYuri Pankov 		err = sa_setup(*osp, sa_attrs, zfs_attr_table, ZPL_END,
1620ed61ec1dSYuri Pankov 		    &sa_attr_table);
1621ed61ec1dSYuri Pankov 		if (err != 0) {
1622ed61ec1dSYuri Pankov 			(void) fprintf(stderr, "sa_setup failed: %s\n",
1623ed61ec1dSYuri Pankov 			    strerror(err));
1624ed61ec1dSYuri Pankov 			dmu_objset_disown(*osp, tag);
1625ed61ec1dSYuri Pankov 			*osp = NULL;
1626ed61ec1dSYuri Pankov 		}
1627ed61ec1dSYuri Pankov 	}
1628ed61ec1dSYuri Pankov 	sa_os = *osp;
1629ed61ec1dSYuri Pankov 
1630ed61ec1dSYuri Pankov 	return (0);
1631ed61ec1dSYuri Pankov }
1632ed61ec1dSYuri Pankov 
1633ed61ec1dSYuri Pankov static void
1634ed61ec1dSYuri Pankov close_objset(objset_t *os, void *tag)
1635ed61ec1dSYuri Pankov {
1636ed61ec1dSYuri Pankov 	VERIFY3P(os, ==, sa_os);
1637ed61ec1dSYuri Pankov 	if (os->os_sa != NULL)
1638ed61ec1dSYuri Pankov 		sa_tear_down(os);
1639ed61ec1dSYuri Pankov 	dmu_objset_disown(os, tag);
1640ed61ec1dSYuri Pankov 	sa_attr_table = NULL;
1641ed61ec1dSYuri Pankov 	sa_os = NULL;
1642ed61ec1dSYuri Pankov }
1643e0d35c44Smarks 
1644e0d35c44Smarks static void
1645e0d35c44Smarks fuid_table_destroy()
1646e0d35c44Smarks {
1647e0d35c44Smarks 	if (fuid_table_loaded) {
1648e0d35c44Smarks 		zfs_fuid_table_destroy(&idx_tree, &domain_tree);
1649e0d35c44Smarks 		fuid_table_loaded = B_FALSE;
1650e0d35c44Smarks 	}
1651e0d35c44Smarks }
1652e0d35c44Smarks 
1653e0d35c44Smarks /*
1654e0d35c44Smarks  * print uid or gid information.
1655e0d35c44Smarks  * For normal POSIX id just the id is printed in decimal format.
1656e0d35c44Smarks  * For CIFS files with FUID the fuid is printed in hex followed by
1657d0475637SMatthew Ahrens  * the domain-rid string.
1658e0d35c44Smarks  */
1659e0d35c44Smarks static void
1660e0d35c44Smarks print_idstr(uint64_t id, const char *id_type)
1661e0d35c44Smarks {
1662e0d35c44Smarks 	if (FUID_INDEX(id)) {
1663e0d35c44Smarks 		char *domain;
1664e0d35c44Smarks 
1665e0d35c44Smarks 		domain = zfs_fuid_idx_domain(&idx_tree, FUID_INDEX(id));
1666e0d35c44Smarks 		(void) printf("\t%s     %llx [%s-%d]\n", id_type,
1667e0d35c44Smarks 		    (u_longlong_t)id, domain, (int)FUID_RID(id));
1668e0d35c44Smarks 	} else {
1669e0d35c44Smarks 		(void) printf("\t%s     %llu\n", id_type, (u_longlong_t)id);
1670e0d35c44Smarks 	}
1671e0d35c44Smarks 
1672e0d35c44Smarks }
1673e0d35c44Smarks 
1674e0d35c44Smarks static void
16750a586ceaSMark Shellenbaum dump_uidgid(objset_t *os, uint64_t uid, uint64_t gid)
1676e0d35c44Smarks {
1677e0d35c44Smarks 	uint32_t uid_idx, gid_idx;
1678e0d35c44Smarks 
16790a586ceaSMark Shellenbaum 	uid_idx = FUID_INDEX(uid);
16800a586ceaSMark Shellenbaum 	gid_idx = FUID_INDEX(gid);
1681e0d35c44Smarks 
1682e0d35c44Smarks 	/* Load domain table, if not already loaded */
1683e0d35c44Smarks 	if (!fuid_table_loaded && (uid_idx || gid_idx)) {
1684e0d35c44Smarks 		uint64_t fuid_obj;
1685e0d35c44Smarks 
1686e0d35c44Smarks 		/* first find the fuid object.  It lives in the master node */
1687e0d35c44Smarks 		VERIFY(zap_lookup(os, MASTER_NODE_OBJ, ZFS_FUID_TABLES,
1688e0d35c44Smarks 		    8, 1, &fuid_obj) == 0);
168989459e17SMark Shellenbaum 		zfs_fuid_avl_tree_create(&idx_tree, &domain_tree);
1690e0d35c44Smarks 		(void) zfs_fuid_table_load(os, fuid_obj,
1691e0d35c44Smarks 		    &idx_tree, &domain_tree);
1692e0d35c44Smarks 		fuid_table_loaded = B_TRUE;
1693e0d35c44Smarks 	}
1694e0d35c44Smarks 
16950a586ceaSMark Shellenbaum 	print_idstr(uid, "uid");
16960a586ceaSMark Shellenbaum 	print_idstr(gid, "gid");
1697e0d35c44Smarks }
1698e0d35c44Smarks 
1699fa9e4066Sahrens /*ARGSUSED*/
1700fa9e4066Sahrens static void
1701fa9e4066Sahrens dump_znode(objset_t *os, uint64_t object, void *data, size_t size)
1702fa9e4066Sahrens {
1703fa9e4066Sahrens 	char path[MAXPATHLEN * 2];	/* allow for xattr and failure prefix */
17040a586ceaSMark Shellenbaum 	sa_handle_t *hdl;
17050a586ceaSMark Shellenbaum 	uint64_t xattr, rdev, gen;
17060a586ceaSMark Shellenbaum 	uint64_t uid, gid, mode, fsize, parent, links;
17078f2529deSMark Shellenbaum 	uint64_t pflags;
17080a586ceaSMark Shellenbaum 	uint64_t acctm[2], modtm[2], chgtm[2], crtm[2];
17090a586ceaSMark Shellenbaum 	time_t z_crtime, z_atime, z_mtime, z_ctime;
17108f2529deSMark Shellenbaum 	sa_bulk_attr_t bulk[12];
17110a586ceaSMark Shellenbaum 	int idx = 0;
171255434c77Sek 	int error;
1713fa9e4066Sahrens 
1714ed61ec1dSYuri Pankov 	VERIFY3P(os, ==, sa_os);
17150a586ceaSMark Shellenbaum 	if (sa_handle_get(os, object, NULL, SA_HDL_PRIVATE, &hdl)) {
17160a586ceaSMark Shellenbaum 		(void) printf("Failed to get handle for SA znode\n");
17170a586ceaSMark Shellenbaum 		return;
17180a586ceaSMark Shellenbaum 	}
17190a586ceaSMark Shellenbaum 
17200a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_UID], NULL, &uid, 8);
17210a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_GID], NULL, &gid, 8);
17220a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_LINKS], NULL,
17230a586ceaSMark Shellenbaum 	    &links, 8);
17240a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_GEN], NULL, &gen, 8);
17250a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_MODE], NULL,
17260a586ceaSMark Shellenbaum 	    &mode, 8);
17270a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_PARENT],
17280a586ceaSMark Shellenbaum 	    NULL, &parent, 8);
17290a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_SIZE], NULL,
17300a586ceaSMark Shellenbaum 	    &fsize, 8);
17310a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_ATIME], NULL,
17320a586ceaSMark Shellenbaum 	    acctm, 16);
17330a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_MTIME], NULL,
17340a586ceaSMark Shellenbaum 	    modtm, 16);
17350a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_CRTIME], NULL,
17360a586ceaSMark Shellenbaum 	    crtm, 16);
17370a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_CTIME], NULL,
17380a586ceaSMark Shellenbaum 	    chgtm, 16);
17398f2529deSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_FLAGS], NULL,
17408f2529deSMark Shellenbaum 	    &pflags, 8);
17410a586ceaSMark Shellenbaum 
17420a586ceaSMark Shellenbaum 	if (sa_bulk_lookup(hdl, bulk, idx)) {
17430a586ceaSMark Shellenbaum 		(void) sa_handle_destroy(hdl);
17440a586ceaSMark Shellenbaum 		return;
17450a586ceaSMark Shellenbaum 	}
1746fa9e4066Sahrens 
17470a586ceaSMark Shellenbaum 	z_crtime = (time_t)crtm[0];
17480a586ceaSMark Shellenbaum 	z_atime = (time_t)acctm[0];
17490a586ceaSMark Shellenbaum 	z_mtime = (time_t)modtm[0];
17500a586ceaSMark Shellenbaum 	z_ctime = (time_t)chgtm[0];
1751fa9e4066Sahrens 
1752e548d2faSAlan Somers 	if (dump_opt['d'] > 4) {
1753e548d2faSAlan Somers 		error = zfs_obj_to_path(os, object, path, sizeof (path));
1754e548d2faSAlan Somers 		if (error != 0) {
1755e548d2faSAlan Somers 			(void) snprintf(path, sizeof (path),
1756e548d2faSAlan Somers 			    "\?\?\?<object#%llu>", (u_longlong_t)object);
1757e548d2faSAlan Somers 		}
1758e548d2faSAlan Somers 		(void) printf("\tpath	%s\n", path);
1759e548d2faSAlan Somers 	}
17600a586ceaSMark Shellenbaum 	dump_uidgid(os, uid, gid);
1761fa9e4066Sahrens 	(void) printf("\tatime	%s", ctime(&z_atime));
1762fa9e4066Sahrens 	(void) printf("\tmtime	%s", ctime(&z_mtime));
1763fa9e4066Sahrens 	(void) printf("\tctime	%s", ctime(&z_ctime));
1764fa9e4066Sahrens 	(void) printf("\tcrtime	%s", ctime(&z_crtime));
17650a586ceaSMark Shellenbaum 	(void) printf("\tgen	%llu\n", (u_longlong_t)gen);
17660a586ceaSMark Shellenbaum 	(void) printf("\tmode	%llo\n", (u_longlong_t)mode);
17670a586ceaSMark Shellenbaum 	(void) printf("\tsize	%llu\n", (u_longlong_t)fsize);
17680a586ceaSMark Shellenbaum 	(void) printf("\tparent	%llu\n", (u_longlong_t)parent);
17690a586ceaSMark Shellenbaum 	(void) printf("\tlinks	%llu\n", (u_longlong_t)links);
17708f2529deSMark Shellenbaum 	(void) printf("\tpflags	%llx\n", (u_longlong_t)pflags);
17710a586ceaSMark Shellenbaum 	if (sa_lookup(hdl, sa_attr_table[ZPL_XATTR], &xattr,
17720a586ceaSMark Shellenbaum 	    sizeof (uint64_t)) == 0)
17730a586ceaSMark Shellenbaum 		(void) printf("\txattr	%llu\n", (u_longlong_t)xattr);
17740a586ceaSMark Shellenbaum 	if (sa_lookup(hdl, sa_attr_table[ZPL_RDEV], &rdev,
17750a586ceaSMark Shellenbaum 	    sizeof (uint64_t)) == 0)
17760a586ceaSMark Shellenbaum 		(void) printf("\trdev	0x%016llx\n", (u_longlong_t)rdev);
17770a586ceaSMark Shellenbaum 	sa_handle_destroy(hdl);
1778fa9e4066Sahrens }
1779fa9e4066Sahrens 
1780fa9e4066Sahrens /*ARGSUSED*/
1781fa9e4066Sahrens static void
1782fa9e4066Sahrens dump_acl(objset_t *os, uint64_t object, void *data, size_t size)
1783fa9e4066Sahrens {
1784fa9e4066Sahrens }
1785fa9e4066Sahrens 
1786fa9e4066Sahrens /*ARGSUSED*/
1787fa9e4066Sahrens static void
1788fa9e4066Sahrens dump_dmu_objset(objset_t *os, uint64_t object, void *data, size_t size)
1789fa9e4066Sahrens {
1790fa9e4066Sahrens }
1791fa9e4066Sahrens 
17926de8f417SVictor Latushkin static object_viewer_t *object_viewer[DMU_OT_NUMTYPES + 1] = {
1793fa9e4066Sahrens 	dump_none,		/* unallocated			*/
1794fa9e4066Sahrens 	dump_zap,		/* object directory		*/
1795fa9e4066Sahrens 	dump_uint64,		/* object array			*/
1796fa9e4066Sahrens 	dump_none,		/* packed nvlist		*/
1797fa9e4066Sahrens 	dump_packed_nvlist,	/* packed nvlist size		*/
1798732885fcSMatthew Ahrens 	dump_none,		/* bpobj			*/
1799732885fcSMatthew Ahrens 	dump_bpobj,		/* bpobj header			*/
1800fa9e4066Sahrens 	dump_none,		/* SPA space map header		*/
1801fa9e4066Sahrens 	dump_none,		/* SPA space map		*/
1802fa9e4066Sahrens 	dump_none,		/* ZIL intent log		*/
1803fa9e4066Sahrens 	dump_dnode,		/* DMU dnode			*/
1804fa9e4066Sahrens 	dump_dmu_objset,	/* DMU objset			*/
1805ea8dc4b6Seschrock 	dump_dsl_dir,		/* DSL directory		*/
1806fa9e4066Sahrens 	dump_zap,		/* DSL directory child map	*/
1807fa9e4066Sahrens 	dump_zap,		/* DSL dataset snap map		*/
1808fa9e4066Sahrens 	dump_zap,		/* DSL props			*/
1809fa9e4066Sahrens 	dump_dsl_dataset,	/* DSL dataset			*/
1810fa9e4066Sahrens 	dump_znode,		/* ZFS znode			*/
1811da6c28aaSamw 	dump_acl,		/* ZFS V0 ACL			*/
1812fa9e4066Sahrens 	dump_uint8,		/* ZFS plain file		*/
1813e7437265Sahrens 	dump_zpldir,		/* ZFS directory		*/
1814fa9e4066Sahrens 	dump_zap,		/* ZFS master node		*/
1815fa9e4066Sahrens 	dump_zap,		/* ZFS delete queue		*/
1816fa9e4066Sahrens 	dump_uint8,		/* zvol object			*/
1817fa9e4066Sahrens 	dump_zap,		/* zvol prop			*/
1818fa9e4066Sahrens 	dump_uint8,		/* other uint8[]		*/
1819fa9e4066Sahrens 	dump_uint64,		/* other uint64[]		*/
1820fa9e4066Sahrens 	dump_zap,		/* other ZAP			*/
1821ea8dc4b6Seschrock 	dump_zap,		/* persistent error log		*/
182206eeb2adSek 	dump_uint8,		/* SPA history			*/
18234445fffbSMatthew Ahrens 	dump_history_offsets,	/* SPA history offsets		*/
1824b1b8ab34Slling 	dump_zap,		/* Pool properties		*/
1825ecd6cf80Smarks 	dump_zap,		/* DSL permissions		*/
1826da6c28aaSamw 	dump_acl,		/* ZFS ACL			*/
1827da6c28aaSamw 	dump_uint8,		/* ZFS SYSACL			*/
1828da6c28aaSamw 	dump_none,		/* FUID nvlist			*/
1829da6c28aaSamw 	dump_packed_nvlist,	/* FUID nvlist size		*/
1830088f3894Sahrens 	dump_zap,		/* DSL dataset next clones	*/
1831088f3894Sahrens 	dump_zap,		/* DSL scrub queue		*/
183214843421SMatthew Ahrens 	dump_zap,		/* ZFS user/group used		*/
183314843421SMatthew Ahrens 	dump_zap,		/* ZFS user/group quota		*/
1834842727c2SChris Kirby 	dump_zap,		/* snapshot refcount tags	*/
1835486ae710SMatthew Ahrens 	dump_ddt_zap,		/* DDT ZAP object		*/
1836b24ab676SJeff Bonwick 	dump_zap,		/* DDT statistics		*/
18370a586ceaSMark Shellenbaum 	dump_znode,		/* SA object			*/
18380a586ceaSMark Shellenbaum 	dump_zap,		/* SA Master Node		*/
18390a586ceaSMark Shellenbaum 	dump_sa_attrs,		/* SA attribute registration	*/
18400a586ceaSMark Shellenbaum 	dump_sa_layouts,	/* SA attribute layouts		*/
18413f9d6ad7SLin Ling 	dump_zap,		/* DSL scrub translations	*/
18423f9d6ad7SLin Ling 	dump_none,		/* fake dedup BP		*/
1843cde58dbcSMatthew Ahrens 	dump_zap,		/* deadlist			*/
1844cde58dbcSMatthew Ahrens 	dump_none,		/* deadlist hdr			*/
1845cde58dbcSMatthew Ahrens 	dump_zap,		/* dsl clones			*/
1846732885fcSMatthew Ahrens 	dump_bpobj_subobjs,	/* bpobj subobjs		*/
18470a586ceaSMark Shellenbaum 	dump_unknown,		/* Unknown type, must be last	*/
1848fa9e4066Sahrens };
1849fa9e4066Sahrens 
1850fa9e4066Sahrens static void
1851fa9e4066Sahrens dump_object(objset_t *os, uint64_t object, int verbosity, int *print_header)
1852fa9e4066Sahrens {
1853fa9e4066Sahrens 	dmu_buf_t *db = NULL;
1854fa9e4066Sahrens 	dmu_object_info_t doi;
1855fa9e4066Sahrens 	dnode_t *dn;
1856fa9e4066Sahrens 	void *bonus = NULL;
1857fa9e4066Sahrens 	size_t bsize = 0;
18583f9d6ad7SLin Ling 	char iblk[32], dblk[32], lsize[32], asize[32], fill[32];
18593f9d6ad7SLin Ling 	char bonus_size[32];
1860fa9e4066Sahrens 	char aux[50];
1861fa9e4066Sahrens 	int error;
1862fa9e4066Sahrens 
1863fa9e4066Sahrens 	if (*print_header) {
1864b24ab676SJeff Bonwick 		(void) printf("\n%10s  %3s  %5s  %5s  %5s  %5s  %6s  %s\n",
1865b24ab676SJeff Bonwick 		    "Object", "lvl", "iblk", "dblk", "dsize", "lsize",
1866b24ab676SJeff Bonwick 		    "%full", "type");
1867fa9e4066Sahrens 		*print_header = 0;
1868fa9e4066Sahrens 	}
1869fa9e4066Sahrens 
1870fa9e4066Sahrens 	if (object == 0) {
1871744947dcSTom Erickson 		dn = DMU_META_DNODE(os);
1872fa9e4066Sahrens 	} else {
1873ea8dc4b6Seschrock 		error = dmu_bonus_hold(os, object, FTAG, &db);
1874ea8dc4b6Seschrock 		if (error)
1875ea8dc4b6Seschrock 			fatal("dmu_bonus_hold(%llu) failed, errno %u",
1876ea8dc4b6Seschrock 			    object, error);
1877fa9e4066Sahrens 		bonus = db->db_data;
1878fa9e4066Sahrens 		bsize = db->db_size;
1879744947dcSTom Erickson 		dn = DB_DNODE((dmu_buf_impl_t *)db);
1880fa9e4066Sahrens 	}
1881fa9e4066Sahrens 	dmu_object_info_from_dnode(dn, &doi);
1882fa9e4066Sahrens 
18833f9d6ad7SLin Ling 	zdb_nicenum(doi.doi_metadata_block_size, iblk);
18843f9d6ad7SLin Ling 	zdb_nicenum(doi.doi_data_block_size, dblk);
18853f9d6ad7SLin Ling 	zdb_nicenum(doi.doi_max_offset, lsize);
18863f9d6ad7SLin Ling 	zdb_nicenum(doi.doi_physical_blocks_512 << 9, asize);
18873f9d6ad7SLin Ling 	zdb_nicenum(doi.doi_bonus_size, bonus_size);
1888b24ab676SJeff Bonwick 	(void) sprintf(fill, "%6.2f", 100.0 * doi.doi_fill_count *
1889bbfd46c4SJeff Bonwick 	    doi.doi_data_block_size / (object == 0 ? DNODES_PER_BLOCK : 1) /
1890bbfd46c4SJeff Bonwick 	    doi.doi_max_offset);
1891fa9e4066Sahrens 
1892fa9e4066Sahrens 	aux[0] = '\0';
1893fa9e4066Sahrens 
1894e7437265Sahrens 	if (doi.doi_checksum != ZIO_CHECKSUM_INHERIT || verbosity >= 6) {
1895fa9e4066Sahrens 		(void) snprintf(aux + strlen(aux), sizeof (aux), " (K=%s)",
18966de8f417SVictor Latushkin 		    ZDB_CHECKSUM_NAME(doi.doi_checksum));
1897e7437265Sahrens 	}
1898fa9e4066Sahrens 
1899e7437265Sahrens 	if (doi.doi_compress != ZIO_COMPRESS_INHERIT || verbosity >= 6) {
1900fa9e4066Sahrens 		(void) snprintf(aux + strlen(aux), sizeof (aux), " (Z=%s)",
19016de8f417SVictor Latushkin 		    ZDB_COMPRESS_NAME(doi.doi_compress));
1902e7437265Sahrens 	}
1903fa9e4066Sahrens 
1904b24ab676SJeff Bonwick 	(void) printf("%10lld  %3u  %5s  %5s  %5s  %5s  %6s  %s%s\n",
1905b24ab676SJeff Bonwick 	    (u_longlong_t)object, doi.doi_indirection, iblk, dblk,
1906b24ab676SJeff Bonwick 	    asize, lsize, fill, ZDB_OT_NAME(doi.doi_type), aux);
1907fa9e4066Sahrens 
1908fa9e4066Sahrens 	if (doi.doi_bonus_type != DMU_OT_NONE && verbosity > 3) {
1909b24ab676SJeff Bonwick 		(void) printf("%10s  %3s  %5s  %5s  %5s  %5s  %6s  %s\n",
1910b24ab676SJeff Bonwick 		    "", "", "", "", "", bonus_size, "bonus",
19116de8f417SVictor Latushkin 		    ZDB_OT_NAME(doi.doi_bonus_type));
1912fa9e4066Sahrens 	}
1913fa9e4066Sahrens 
1914fa9e4066Sahrens 	if (verbosity >= 4) {
19150a586ceaSMark Shellenbaum 		(void) printf("\tdnode flags: %s%s%s\n",
191614843421SMatthew Ahrens 		    (dn->dn_phys->dn_flags & DNODE_FLAG_USED_BYTES) ?
191714843421SMatthew Ahrens 		    "USED_BYTES " : "",
191814843421SMatthew Ahrens 		    (dn->dn_phys->dn_flags & DNODE_FLAG_USERUSED_ACCOUNTED) ?
19190a586ceaSMark Shellenbaum 		    "USERUSED_ACCOUNTED " : "",
19200a586ceaSMark Shellenbaum 		    (dn->dn_phys->dn_flags & DNODE_FLAG_SPILL_BLKPTR) ?
19210a586ceaSMark Shellenbaum 		    "SPILL_BLKPTR" : "");
192214843421SMatthew Ahrens 		(void) printf("\tdnode maxblkid: %llu\n",
192314843421SMatthew Ahrens 		    (longlong_t)dn->dn_phys->dn_maxblkid);
192414843421SMatthew Ahrens 
19256de8f417SVictor Latushkin 		object_viewer[ZDB_OT_TYPE(doi.doi_bonus_type)](os, object,
19266de8f417SVictor Latushkin 		    bonus, bsize);
19276de8f417SVictor Latushkin 		object_viewer[ZDB_OT_TYPE(doi.doi_type)](os, object, NULL, 0);
1928fa9e4066Sahrens 		*print_header = 1;
1929fa9e4066Sahrens 	}
1930fa9e4066Sahrens 
1931fa9e4066Sahrens 	if (verbosity >= 5)
193288b7b0f2SMatthew Ahrens 		dump_indirect(dn);
1933fa9e4066Sahrens 
1934fa9e4066Sahrens 	if (verbosity >= 5) {
1935fa9e4066Sahrens 		/*
1936fa9e4066Sahrens 		 * Report the list of segments that comprise the object.
1937fa9e4066Sahrens 		 */
1938fa9e4066Sahrens 		uint64_t start = 0;
1939fa9e4066Sahrens 		uint64_t end;
1940fa9e4066Sahrens 		uint64_t blkfill = 1;
1941fa9e4066Sahrens 		int minlvl = 1;
1942fa9e4066Sahrens 
1943fa9e4066Sahrens 		if (dn->dn_type == DMU_OT_DNODE) {
1944fa9e4066Sahrens 			minlvl = 0;
1945fa9e4066Sahrens 			blkfill = DNODES_PER_BLOCK;
1946fa9e4066Sahrens 		}
1947fa9e4066Sahrens 
1948fa9e4066Sahrens 		for (;;) {
19493f9d6ad7SLin Ling 			char segsize[32];
1950cdb0ab79Smaybee 			error = dnode_next_offset(dn,
1951cdb0ab79Smaybee 			    0, &start, minlvl, blkfill, 0);
1952fa9e4066Sahrens 			if (error)
1953fa9e4066Sahrens 				break;
1954fa9e4066Sahrens 			end = start;
1955cdb0ab79Smaybee 			error = dnode_next_offset(dn,
1956cdb0ab79Smaybee 			    DNODE_FIND_HOLE, &end, minlvl, blkfill, 0);
19573f9d6ad7SLin Ling 			zdb_nicenum(end - start, segsize);
1958fa9e4066Sahrens 			(void) printf("\t\tsegment [%016llx, %016llx)"
1959fa9e4066Sahrens 			    " size %5s\n", (u_longlong_t)start,
1960fa9e4066Sahrens 			    (u_longlong_t)end, segsize);
1961fa9e4066Sahrens 			if (error)
1962fa9e4066Sahrens 				break;
1963fa9e4066Sahrens 			start = end;
1964fa9e4066Sahrens 		}
1965fa9e4066Sahrens 	}
1966fa9e4066Sahrens 
1967fa9e4066Sahrens 	if (db != NULL)
1968ea8dc4b6Seschrock 		dmu_buf_rele(db, FTAG);
1969fa9e4066Sahrens }
1970fa9e4066Sahrens 
1971fa9e4066Sahrens static char *objset_types[DMU_OST_NUMTYPES] = {
1972fa9e4066Sahrens 	"NONE", "META", "ZPL", "ZVOL", "OTHER", "ANY" };
1973fa9e4066Sahrens 
1974fa9e4066Sahrens static void
1975fa9e4066Sahrens dump_dir(objset_t *os)
1976fa9e4066Sahrens {
1977fa9e4066Sahrens 	dmu_objset_stats_t dds;
1978fa9e4066Sahrens 	uint64_t object, object_count;
1979a2eea2e1Sahrens 	uint64_t refdbytes, usedobjs, scratch;
19803f9d6ad7SLin Ling 	char numbuf[32];
198114843421SMatthew Ahrens 	char blkbuf[BP_SPRINTF_LEN + 20];
19829adfa60dSMatthew Ahrens 	char osname[ZFS_MAX_DATASET_NAME_LEN];
1983fa9e4066Sahrens 	char *type = "UNKNOWN";
1984fa9e4066Sahrens 	int verbosity = dump_opt['d'];
1985fa9e4066Sahrens 	int print_header = 1;
1986fa9e4066Sahrens 	int i, error;
1987fa9e4066Sahrens 
19883b2aab18SMatthew Ahrens 	dsl_pool_config_enter(dmu_objset_pool(os), FTAG);
1989a2eea2e1Sahrens 	dmu_objset_fast_stat(os, &dds);
19903b2aab18SMatthew Ahrens 	dsl_pool_config_exit(dmu_objset_pool(os), FTAG);
1991fa9e4066Sahrens 
1992fa9e4066Sahrens 	if (dds.dds_type < DMU_OST_NUMTYPES)
1993fa9e4066Sahrens 		type = objset_types[dds.dds_type];
1994fa9e4066Sahrens 
1995fa9e4066Sahrens 	if (dds.dds_type == DMU_OST_META) {
1996fa9e4066Sahrens 		dds.dds_creation_txg = TXG_INITIAL;
19975d7b4d43SMatthew Ahrens 		usedobjs = BP_GET_FILL(os->os_rootbp);
1998c1379625SJustin T. Gibbs 		refdbytes = dsl_dir_phys(os->os_spa->spa_dsl_pool->dp_mos_dir)->
1999c1379625SJustin T. Gibbs 		    dd_used_bytes;
2000a2eea2e1Sahrens 	} else {
2001a2eea2e1Sahrens 		dmu_objset_space(os, &refdbytes, &scratch, &usedobjs, &scratch);
2002fa9e4066Sahrens 	}
2003fa9e4066Sahrens 
20045d7b4d43SMatthew Ahrens 	ASSERT3U(usedobjs, ==, BP_GET_FILL(os->os_rootbp));
2005fa9e4066Sahrens 
20063f9d6ad7SLin Ling 	zdb_nicenum(refdbytes, numbuf);
2007fa9e4066Sahrens 
2008fa9e4066Sahrens 	if (verbosity >= 4) {
200943466aaeSMax Grossman 		(void) snprintf(blkbuf, sizeof (blkbuf), ", rootbp ");
201043466aaeSMax Grossman 		(void) snprintf_blkptr(blkbuf + strlen(blkbuf),
201143466aaeSMax Grossman 		    sizeof (blkbuf) - strlen(blkbuf), os->os_rootbp);
2012fa9e4066Sahrens 	} else {
2013fa9e4066Sahrens 		blkbuf[0] = '\0';
2014fa9e4066Sahrens 	}
2015fa9e4066Sahrens 
2016fa9e4066Sahrens 	dmu_objset_name(os, osname);
2017fa9e4066Sahrens 
2018a2eea2e1Sahrens 	(void) printf("Dataset %s [%s], ID %llu, cr_txg %llu, "
2019fa9e4066Sahrens 	    "%s, %llu objects%s\n",
2020fa9e4066Sahrens 	    osname, type, (u_longlong_t)dmu_objset_id(os),
2021fa9e4066Sahrens 	    (u_longlong_t)dds.dds_creation_txg,
2022a2eea2e1Sahrens 	    numbuf, (u_longlong_t)usedobjs, blkbuf);
2023fa9e4066Sahrens 
2024b24ab676SJeff Bonwick 	if (zopt_objects != 0) {
2025b24ab676SJeff Bonwick 		for (i = 0; i < zopt_objects; i++)
2026b24ab676SJeff Bonwick 			dump_object(os, zopt_object[i], verbosity,
2027b24ab676SJeff Bonwick 			    &print_header);
2028b24ab676SJeff Bonwick 		(void) printf("\n");
2029b24ab676SJeff Bonwick 		return;
2030b24ab676SJeff Bonwick 	}
2031b24ab676SJeff Bonwick 
2032b24ab676SJeff Bonwick 	if (dump_opt['i'] != 0 || verbosity >= 2)
2033b24ab676SJeff Bonwick 		dump_intent_log(dmu_objset_zil(os));
2034fa9e4066Sahrens 
2035fa9e4066Sahrens 	if (dmu_objset_ds(os) != NULL)
2036cde58dbcSMatthew Ahrens 		dump_deadlist(&dmu_objset_ds(os)->ds_deadlist);
2037fa9e4066Sahrens 
2038fa9e4066Sahrens 	if (verbosity < 2)
2039fa9e4066Sahrens 		return;
2040fa9e4066Sahrens 
204143466aaeSMax Grossman 	if (BP_IS_HOLE(os->os_rootbp))
2042088f3894Sahrens 		return;
2043088f3894Sahrens 
2044fa9e4066Sahrens 	dump_object(os, 0, verbosity, &print_header);
204514843421SMatthew Ahrens 	object_count = 0;
2046744947dcSTom Erickson 	if (DMU_USERUSED_DNODE(os) != NULL &&
2047744947dcSTom Erickson 	    DMU_USERUSED_DNODE(os)->dn_type != 0) {
204814843421SMatthew Ahrens 		dump_object(os, DMU_USERUSED_OBJECT, verbosity, &print_header);
204914843421SMatthew Ahrens 		dump_object(os, DMU_GROUPUSED_OBJECT, verbosity, &print_header);
205014843421SMatthew Ahrens 	}
2051fa9e4066Sahrens 
2052fa9e4066Sahrens 	object = 0;
20536754306eSahrens 	while ((error = dmu_object_next(os, &object, B_FALSE, 0)) == 0) {
2054fa9e4066Sahrens 		dump_object(os, object, verbosity, &print_header);
2055fa9e4066Sahrens 		object_count++;
2056fa9e4066Sahrens 	}
2057fa9e4066Sahrens 
2058a2eea2e1Sahrens 	ASSERT3U(object_count, ==, usedobjs);
2059fa9e4066Sahrens 
2060fa9e4066Sahrens 	(void) printf("\n");
2061fa9e4066Sahrens 
2062ccba0801SRich Morris 	if (error != ESRCH) {
2063ccba0801SRich Morris 		(void) fprintf(stderr, "dmu_object_next() = %d\n", error);
2064ccba0801SRich Morris 		abort();
2065ccba0801SRich Morris 	}
2066fa9e4066Sahrens }
2067fa9e4066Sahrens 
2068fa9e4066Sahrens static void
206953b9a4a9SVictor Latushkin dump_uberblock(uberblock_t *ub, const char *header, const char *footer)
2070fa9e4066Sahrens {
2071fa9e4066Sahrens 	time_t timestamp = ub->ub_timestamp;
2072fa9e4066Sahrens 
207353b9a4a9SVictor Latushkin 	(void) printf(header ? header : "");
2074fa9e4066Sahrens 	(void) printf("\tmagic = %016llx\n", (u_longlong_t)ub->ub_magic);
2075fa9e4066Sahrens 	(void) printf("\tversion = %llu\n", (u_longlong_t)ub->ub_version);
2076fa9e4066Sahrens 	(void) printf("\ttxg = %llu\n", (u_longlong_t)ub->ub_txg);
2077fa9e4066Sahrens 	(void) printf("\tguid_sum = %llu\n", (u_longlong_t)ub->ub_guid_sum);
2078fa9e4066Sahrens 	(void) printf("\ttimestamp = %llu UTC = %s",
2079fa9e4066Sahrens 	    (u_longlong_t)ub->ub_timestamp, asctime(localtime(&timestamp)));
2080fa9e4066Sahrens 	if (dump_opt['u'] >= 3) {
2081fbabab8fSmaybee 		char blkbuf[BP_SPRINTF_LEN];
208243466aaeSMax Grossman 		snprintf_blkptr(blkbuf, sizeof (blkbuf), &ub->ub_rootbp);
2083fa9e4066Sahrens 		(void) printf("\trootbp = %s\n", blkbuf);
2084fa9e4066Sahrens 	}
208553b9a4a9SVictor Latushkin 	(void) printf(footer ? footer : "");
2086fa9e4066Sahrens }
2087fa9e4066Sahrens 
2088fa9e4066Sahrens static void
208907428bdfSVictor Latushkin dump_config(spa_t *spa)
2090fa9e4066Sahrens {
209107428bdfSVictor Latushkin 	dmu_buf_t *db;
209207428bdfSVictor Latushkin 	size_t nvsize = 0;
209307428bdfSVictor Latushkin 	int error = 0;
209407428bdfSVictor Latushkin 
2095fa9e4066Sahrens 
209607428bdfSVictor Latushkin 	error = dmu_bonus_hold(spa->spa_meta_objset,
209707428bdfSVictor Latushkin 	    spa->spa_config_object, FTAG, &db);
209807428bdfSVictor Latushkin 
209907428bdfSVictor Latushkin 	if (error == 0) {
210007428bdfSVictor Latushkin 		nvsize = *(uint64_t *)db->db_data;
210107428bdfSVictor Latushkin 		dmu_buf_rele(db, FTAG);
210207428bdfSVictor Latushkin 
210307428bdfSVictor Latushkin 		(void) printf("\nMOS Configuration:\n");
210407428bdfSVictor Latushkin 		dump_packed_nvlist(spa->spa_meta_objset,
210507428bdfSVictor Latushkin 		    spa->spa_config_object, (void *)&nvsize, 1);
210607428bdfSVictor Latushkin 	} else {
210707428bdfSVictor Latushkin 		(void) fprintf(stderr, "dmu_bonus_hold(%llu) failed, errno %d",
210807428bdfSVictor Latushkin 		    (u_longlong_t)spa->spa_config_object, error);
2109fa9e4066Sahrens 	}
2110fa9e4066Sahrens }
2111fa9e4066Sahrens 
2112c5904d13Seschrock static void
2113c5904d13Seschrock dump_cachefile(const char *cachefile)
2114c5904d13Seschrock {
2115c5904d13Seschrock 	int fd;
2116c5904d13Seschrock 	struct stat64 statbuf;
2117c5904d13Seschrock 	char *buf;
2118c5904d13Seschrock 	nvlist_t *config;
2119c5904d13Seschrock 
2120c5904d13Seschrock 	if ((fd = open64(cachefile, O_RDONLY)) < 0) {
2121c5904d13Seschrock 		(void) printf("cannot open '%s': %s\n", cachefile,
2122c5904d13Seschrock 		    strerror(errno));
2123c5904d13Seschrock 		exit(1);
2124c5904d13Seschrock 	}
2125c5904d13Seschrock 
2126c5904d13Seschrock 	if (fstat64(fd, &statbuf) != 0) {
2127c5904d13Seschrock 		(void) printf("failed to stat '%s': %s\n", cachefile,
2128c5904d13Seschrock 		    strerror(errno));
2129c5904d13Seschrock 		exit(1);
2130c5904d13Seschrock 	}
2131c5904d13Seschrock 
2132c5904d13Seschrock 	if ((buf = malloc(statbuf.st_size)) == NULL) {
2133c5904d13Seschrock 		(void) fprintf(stderr, "failed to allocate %llu bytes\n",
2134c5904d13Seschrock 		    (u_longlong_t)statbuf.st_size);
2135c5904d13Seschrock 		exit(1);
2136c5904d13Seschrock 	}
2137c5904d13Seschrock 
2138c5904d13Seschrock 	if (read(fd, buf, statbuf.st_size) != statbuf.st_size) {
2139c5904d13Seschrock 		(void) fprintf(stderr, "failed to read %llu bytes\n",
2140c5904d13Seschrock 		    (u_longlong_t)statbuf.st_size);
2141c5904d13Seschrock 		exit(1);
2142c5904d13Seschrock 	}
2143c5904d13Seschrock 
2144c5904d13Seschrock 	(void) close(fd);
2145c5904d13Seschrock 
2146c5904d13Seschrock 	if (nvlist_unpack(buf, statbuf.st_size, &config, 0) != 0) {
2147c5904d13Seschrock 		(void) fprintf(stderr, "failed to unpack nvlist\n");
2148c5904d13Seschrock 		exit(1);
2149c5904d13Seschrock 	}
2150c5904d13Seschrock 
2151c5904d13Seschrock 	free(buf);
2152c5904d13Seschrock 
2153c5904d13Seschrock 	dump_nvlist(config, 0);
2154c5904d13Seschrock 
2155c5904d13Seschrock 	nvlist_free(config);
2156c5904d13Seschrock }
2157c5904d13Seschrock 
215853b9a4a9SVictor Latushkin #define	ZDB_MAX_UB_HEADER_SIZE 32
215953b9a4a9SVictor Latushkin 
216053b9a4a9SVictor Latushkin static void
216153b9a4a9SVictor Latushkin dump_label_uberblocks(vdev_label_t *lbl, uint64_t ashift)
216253b9a4a9SVictor Latushkin {
216353b9a4a9SVictor Latushkin 	vdev_t vd;
216453b9a4a9SVictor Latushkin 	vdev_t *vdp = &vd;
216553b9a4a9SVictor Latushkin 	char header[ZDB_MAX_UB_HEADER_SIZE];
216653b9a4a9SVictor Latushkin 
216753b9a4a9SVictor Latushkin 	vd.vdev_ashift = ashift;
216853b9a4a9SVictor Latushkin 	vdp->vdev_top = vdp;
216953b9a4a9SVictor Latushkin 
217053b9a4a9SVictor Latushkin 	for (int i = 0; i < VDEV_UBERBLOCK_COUNT(vdp); i++) {
217153b9a4a9SVictor Latushkin 		uint64_t uoff = VDEV_UBERBLOCK_OFFSET(vdp, i);
217253b9a4a9SVictor Latushkin 		uberblock_t *ub = (void *)((char *)lbl + uoff);
217353b9a4a9SVictor Latushkin 
217453b9a4a9SVictor Latushkin 		if (uberblock_verify(ub))
217553b9a4a9SVictor Latushkin 			continue;
217653b9a4a9SVictor Latushkin 		(void) snprintf(header, ZDB_MAX_UB_HEADER_SIZE,
217753b9a4a9SVictor Latushkin 		    "Uberblock[%d]\n", i);
217853b9a4a9SVictor Latushkin 		dump_uberblock(ub, header, "");
217953b9a4a9SVictor Latushkin 	}
218053b9a4a9SVictor Latushkin }
218153b9a4a9SVictor Latushkin 
2182ed61ec1dSYuri Pankov static char curpath[PATH_MAX];
2183ed61ec1dSYuri Pankov 
2184ed61ec1dSYuri Pankov /*
2185ed61ec1dSYuri Pankov  * Iterate through the path components, recursively passing
2186ed61ec1dSYuri Pankov  * current one's obj and remaining path until we find the obj
2187ed61ec1dSYuri Pankov  * for the last one.
2188ed61ec1dSYuri Pankov  */
2189ed61ec1dSYuri Pankov static int
2190ed61ec1dSYuri Pankov dump_path_impl(objset_t *os, uint64_t obj, char *name)
2191ed61ec1dSYuri Pankov {
2192ed61ec1dSYuri Pankov 	int err;
2193ed61ec1dSYuri Pankov 	int header = 1;
2194ed61ec1dSYuri Pankov 	uint64_t child_obj;
2195ed61ec1dSYuri Pankov 	char *s;
2196ed61ec1dSYuri Pankov 	dmu_buf_t *db;
2197ed61ec1dSYuri Pankov 	dmu_object_info_t doi;
2198ed61ec1dSYuri Pankov 
2199ed61ec1dSYuri Pankov 	if ((s = strchr(name, '/')) != NULL)
2200ed61ec1dSYuri Pankov 		*s = '\0';
2201ed61ec1dSYuri Pankov 	err = zap_lookup(os, obj, name, 8, 1, &child_obj);
2202ed61ec1dSYuri Pankov 
2203ed61ec1dSYuri Pankov 	(void) strlcat(curpath, name, sizeof (curpath));
2204ed61ec1dSYuri Pankov 
2205ed61ec1dSYuri Pankov 	if (err != 0) {
2206ed61ec1dSYuri Pankov 		(void) fprintf(stderr, "failed to lookup %s: %s\n",
2207ed61ec1dSYuri Pankov 		    curpath, strerror(err));
2208ed61ec1dSYuri Pankov 		return (err);
2209ed61ec1dSYuri Pankov 	}
2210ed61ec1dSYuri Pankov 
2211ed61ec1dSYuri Pankov 	child_obj = ZFS_DIRENT_OBJ(child_obj);
2212ed61ec1dSYuri Pankov 	err = sa_buf_hold(os, child_obj, FTAG, &db);
2213ed61ec1dSYuri Pankov 	if (err != 0) {
2214ed61ec1dSYuri Pankov 		(void) fprintf(stderr,
2215ed61ec1dSYuri Pankov 		    "failed to get SA dbuf for obj %llu: %s\n",
2216ed61ec1dSYuri Pankov 		    (u_longlong_t)child_obj, strerror(err));
2217ed61ec1dSYuri Pankov 		return (EINVAL);
2218ed61ec1dSYuri Pankov 	}
2219ed61ec1dSYuri Pankov 	dmu_object_info_from_db(db, &doi);
2220ed61ec1dSYuri Pankov 	sa_buf_rele(db, FTAG);
2221ed61ec1dSYuri Pankov 
2222ed61ec1dSYuri Pankov 	if (doi.doi_bonus_type != DMU_OT_SA &&
2223ed61ec1dSYuri Pankov 	    doi.doi_bonus_type != DMU_OT_ZNODE) {
2224ed61ec1dSYuri Pankov 		(void) fprintf(stderr, "invalid bonus type %d for obj %llu\n",
2225ed61ec1dSYuri Pankov 		    doi.doi_bonus_type, (u_longlong_t)child_obj);
2226ed61ec1dSYuri Pankov 		return (EINVAL);
2227ed61ec1dSYuri Pankov 	}
2228ed61ec1dSYuri Pankov 
2229ed61ec1dSYuri Pankov 	if (dump_opt['v'] > 6) {
2230ed61ec1dSYuri Pankov 		(void) printf("obj=%llu %s type=%d bonustype=%d\n",
2231ed61ec1dSYuri Pankov 		    (u_longlong_t)child_obj, curpath, doi.doi_type,
2232ed61ec1dSYuri Pankov 		    doi.doi_bonus_type);
2233ed61ec1dSYuri Pankov 	}
2234ed61ec1dSYuri Pankov 
2235ed61ec1dSYuri Pankov 	(void) strlcat(curpath, "/", sizeof (curpath));
2236ed61ec1dSYuri Pankov 
2237ed61ec1dSYuri Pankov 	switch (doi.doi_type) {
2238ed61ec1dSYuri Pankov 	case DMU_OT_DIRECTORY_CONTENTS:
2239ed61ec1dSYuri Pankov 		if (s != NULL && *(s + 1) != '\0')
2240ed61ec1dSYuri Pankov 			return (dump_path_impl(os, child_obj, s + 1));
2241ed61ec1dSYuri Pankov 		/*FALLTHROUGH*/
2242ed61ec1dSYuri Pankov 	case DMU_OT_PLAIN_FILE_CONTENTS:
2243ed61ec1dSYuri Pankov 		dump_object(os, child_obj, dump_opt['v'], &header);
2244ed61ec1dSYuri Pankov 		return (0);
2245ed61ec1dSYuri Pankov 	default:
2246ed61ec1dSYuri Pankov 		(void) fprintf(stderr, "object %llu has non-file/directory "
2247ed61ec1dSYuri Pankov 		    "type %d\n", (u_longlong_t)obj, doi.doi_type);
2248ed61ec1dSYuri Pankov 		break;
2249ed61ec1dSYuri Pankov 	}
2250ed61ec1dSYuri Pankov 
2251ed61ec1dSYuri Pankov 	return (EINVAL);
2252ed61ec1dSYuri Pankov }
2253ed61ec1dSYuri Pankov 
2254ed61ec1dSYuri Pankov /*
2255ed61ec1dSYuri Pankov  * Dump the blocks for the object specified by path inside the dataset.
2256ed61ec1dSYuri Pankov  */
2257ed61ec1dSYuri Pankov static int
2258ed61ec1dSYuri Pankov dump_path(char *ds, char *path)
2259ed61ec1dSYuri Pankov {
2260ed61ec1dSYuri Pankov 	int err;
2261ed61ec1dSYuri Pankov 	objset_t *os;
2262ed61ec1dSYuri Pankov 	uint64_t root_obj;
2263ed61ec1dSYuri Pankov 
2264ed61ec1dSYuri Pankov 	err = open_objset(ds, DMU_OST_ZFS, FTAG, &os);
2265ed61ec1dSYuri Pankov 	if (err != 0)
2266ed61ec1dSYuri Pankov 		return (err);
2267ed61ec1dSYuri Pankov 
2268ed61ec1dSYuri Pankov 	err = zap_lookup(os, MASTER_NODE_OBJ, ZFS_ROOT_OBJ, 8, 1, &root_obj);
2269ed61ec1dSYuri Pankov 	if (err != 0) {
2270ed61ec1dSYuri Pankov 		(void) fprintf(stderr, "can't lookup root znode: %s\n",
2271ed61ec1dSYuri Pankov 		    strerror(err));
2272ed61ec1dSYuri Pankov 		dmu_objset_disown(os, FTAG);
2273ed61ec1dSYuri Pankov 		return (EINVAL);
2274ed61ec1dSYuri Pankov 	}
2275ed61ec1dSYuri Pankov 
2276ed61ec1dSYuri Pankov 	(void) snprintf(curpath, sizeof (curpath), "dataset=%s path=/", ds);
2277ed61ec1dSYuri Pankov 
2278ed61ec1dSYuri Pankov 	err = dump_path_impl(os, root_obj, path);
2279ed61ec1dSYuri Pankov 
2280ed61ec1dSYuri Pankov 	close_objset(os, FTAG);
2281ed61ec1dSYuri Pankov 	return (err);
2282ed61ec1dSYuri Pankov }
2283ed61ec1dSYuri Pankov 
228464723e36SYuri Pankov static int
2285fa9e4066Sahrens dump_label(const char *dev)
2286fa9e4066Sahrens {
2287fa9e4066Sahrens 	int fd;
2288fa9e4066Sahrens 	vdev_label_t label;
228964723e36SYuri Pankov 	char path[MAXPATHLEN];
229064723e36SYuri Pankov 	char *buf = label.vl_vdev_phys.vp_nvlist;
2291fa9e4066Sahrens 	size_t buflen = sizeof (label.vl_vdev_phys.vp_nvlist);
2292fa9e4066Sahrens 	struct stat64 statbuf;
229353b9a4a9SVictor Latushkin 	uint64_t psize, ashift;
229464723e36SYuri Pankov 	boolean_t label_found = B_FALSE;
229564723e36SYuri Pankov 
229664723e36SYuri Pankov 	(void) strlcpy(path, dev, sizeof (path));
229764723e36SYuri Pankov 	if (dev[0] == '/') {
229864723e36SYuri Pankov 		if (strncmp(dev, ZFS_DISK_ROOTD,
229964723e36SYuri Pankov 		    strlen(ZFS_DISK_ROOTD)) == 0) {
230064723e36SYuri Pankov 			(void) snprintf(path, sizeof (path), "%s%s",
230164723e36SYuri Pankov 			    ZFS_RDISK_ROOTD, dev + strlen(ZFS_DISK_ROOTD));
230264723e36SYuri Pankov 		}
230364723e36SYuri Pankov 	} else if (stat64(path, &statbuf) != 0) {
230464723e36SYuri Pankov 		char *s;
2305c6065d0fSGeorge Wilson 
230664723e36SYuri Pankov 		(void) snprintf(path, sizeof (path), "%s%s", ZFS_RDISK_ROOTD,
230764723e36SYuri Pankov 		    dev);
230822c8b958SYuri Pankov 		if (((s = strrchr(dev, 's')) == NULL &&
230922c8b958SYuri Pankov 		    (s = strchr(dev, 'p')) == NULL) ||
231022c8b958SYuri Pankov 		    !isdigit(*(s + 1)))
231164723e36SYuri Pankov 			(void) strlcat(path, "s0", sizeof (path));
2312fa9e4066Sahrens 	}
2313fa9e4066Sahrens 
231422c8b958SYuri Pankov 	if ((fd = open64(path, O_RDONLY)) < 0) {
231522c8b958SYuri Pankov 		(void) fprintf(stderr, "cannot open '%s': %s\n", path,
2316fa9e4066Sahrens 		    strerror(errno));
2317c6065d0fSGeorge Wilson 		exit(1);
2318c6065d0fSGeorge Wilson 	}
2319c6065d0fSGeorge Wilson 
232022c8b958SYuri Pankov 	if (fstat64(fd, &statbuf) != 0) {
232122c8b958SYuri Pankov 		(void) fprintf(stderr, "failed to stat '%s': %s\n", path,
232222c8b958SYuri Pankov 		    strerror(errno));
232322c8b958SYuri Pankov 		(void) close(fd);
232464723e36SYuri Pankov 		exit(1);
232564723e36SYuri Pankov 	}
232664723e36SYuri Pankov 
232722c8b958SYuri Pankov 	if (S_ISBLK(statbuf.st_mode)) {
232822c8b958SYuri Pankov 		(void) fprintf(stderr,
232922c8b958SYuri Pankov 		    "cannot use '%s': character device required\n", path);
233022c8b958SYuri Pankov 		(void) close(fd);
2331c6065d0fSGeorge Wilson 		exit(1);
2332fa9e4066Sahrens 	}
2333fa9e4066Sahrens 
2334fa9e4066Sahrens 	psize = statbuf.st_size;
2335fa9e4066Sahrens 	psize = P2ALIGN(psize, (uint64_t)sizeof (vdev_label_t));
2336fa9e4066Sahrens 
233753b9a4a9SVictor Latushkin 	for (int l = 0; l < VDEV_LABELS; l++) {
2338fa9e4066Sahrens 		nvlist_t *config = NULL;
2339fa9e4066Sahrens 
234064723e36SYuri Pankov 		if (!dump_opt['q']) {
234164723e36SYuri Pankov 			(void) printf("------------------------------------\n");
234264723e36SYuri Pankov 			(void) printf("LABEL %d\n", l);
234364723e36SYuri Pankov 			(void) printf("------------------------------------\n");
234464723e36SYuri Pankov 		}
2345fa9e4066Sahrens 
23460d981225Seschrock 		if (pread64(fd, &label, sizeof (label),
2347fa9e4066Sahrens 		    vdev_label_offset(psize, l, 0)) != sizeof (label)) {
234864723e36SYuri Pankov 			if (!dump_opt['q'])
234964723e36SYuri Pankov 				(void) printf("failed to read label %d\n", l);
2350fa9e4066Sahrens 			continue;
2351fa9e4066Sahrens 		}
2352fa9e4066Sahrens 
2353fa9e4066Sahrens 		if (nvlist_unpack(buf, buflen, &config, 0) != 0) {
235464723e36SYuri Pankov 			if (!dump_opt['q'])
235564723e36SYuri Pankov 				(void) printf("failed to unpack label %d\n", l);
235653b9a4a9SVictor Latushkin 			ashift = SPA_MINBLOCKSHIFT;
235753b9a4a9SVictor Latushkin 		} else {
235853b9a4a9SVictor Latushkin 			nvlist_t *vdev_tree = NULL;
235953b9a4a9SVictor Latushkin 
236064723e36SYuri Pankov 			if (!dump_opt['q'])
236164723e36SYuri Pankov 				dump_nvlist(config, 4);
236253b9a4a9SVictor Latushkin 			if ((nvlist_lookup_nvlist(config,
236353b9a4a9SVictor Latushkin 			    ZPOOL_CONFIG_VDEV_TREE, &vdev_tree) != 0) ||
236453b9a4a9SVictor Latushkin 			    (nvlist_lookup_uint64(vdev_tree,
236553b9a4a9SVictor Latushkin 			    ZPOOL_CONFIG_ASHIFT, &ashift) != 0))
236653b9a4a9SVictor Latushkin 				ashift = SPA_MINBLOCKSHIFT;
236753b9a4a9SVictor Latushkin 			nvlist_free(config);
236864723e36SYuri Pankov 			label_found = B_TRUE;
2369fa9e4066Sahrens 		}
237053b9a4a9SVictor Latushkin 		if (dump_opt['u'])
237153b9a4a9SVictor Latushkin 			dump_label_uberblocks(&label, ashift);
2372fa9e4066Sahrens 	}
2373c6065d0fSGeorge Wilson 
2374c6065d0fSGeorge Wilson 	(void) close(fd);
237564723e36SYuri Pankov 
237664723e36SYuri Pankov 	return (label_found ? 0 : 2);
2377fa9e4066Sahrens }
2378fa9e4066Sahrens 
2379ca0cc391SMatthew Ahrens static uint64_t dataset_feature_count[SPA_FEATURES];
2380b5152584SMatthew Ahrens 
2381fa9e4066Sahrens /*ARGSUSED*/
23821d452cf5Sahrens static int
2383fd136879SMatthew Ahrens dump_one_dir(const char *dsname, void *arg)
2384fa9e4066Sahrens {
2385fa9e4066Sahrens 	int error;
2386fa9e4066Sahrens 	objset_t *os;
2387fa9e4066Sahrens 
2388ed61ec1dSYuri Pankov 	error = open_objset(dsname, DMU_OST_ANY, FTAG, &os);
2389ed61ec1dSYuri Pankov 	if (error != 0)
23901d452cf5Sahrens 		return (0);
2391ca0cc391SMatthew Ahrens 
2392ca0cc391SMatthew Ahrens 	for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
2393ca0cc391SMatthew Ahrens 		if (!dmu_objset_ds(os)->ds_feature_inuse[f])
2394ca0cc391SMatthew Ahrens 			continue;
2395ca0cc391SMatthew Ahrens 		ASSERT(spa_feature_table[f].fi_flags &
2396ca0cc391SMatthew Ahrens 		    ZFEATURE_FLAG_PER_DATASET);
2397ca0cc391SMatthew Ahrens 		dataset_feature_count[f]++;
2398ca0cc391SMatthew Ahrens 	}
2399ca0cc391SMatthew Ahrens 
2400fa9e4066Sahrens 	dump_dir(os);
2401ed61ec1dSYuri Pankov 	close_objset(os, FTAG);
2402e0d35c44Smarks 	fuid_table_destroy();
24031d452cf5Sahrens 	return (0);
2404fa9e4066Sahrens }
2405fa9e4066Sahrens 
2406fa9e4066Sahrens /*
2407b24ab676SJeff Bonwick  * Block statistics.
2408fa9e4066Sahrens  */
2409b5152584SMatthew Ahrens #define	PSIZE_HISTO_SIZE (SPA_OLD_MAXBLOCKSIZE / SPA_MINBLOCKSIZE + 2)
2410fa9e4066Sahrens typedef struct zdb_blkstats {
2411490d05b9SMatthew Ahrens 	uint64_t zb_asize;
2412490d05b9SMatthew Ahrens 	uint64_t zb_lsize;
2413490d05b9SMatthew Ahrens 	uint64_t zb_psize;
2414490d05b9SMatthew Ahrens 	uint64_t zb_count;
2415d5ee8a13SMatthew Ahrens 	uint64_t zb_gangs;
2416d5ee8a13SMatthew Ahrens 	uint64_t zb_ditto_samevdev;
2417490d05b9SMatthew Ahrens 	uint64_t zb_psize_histogram[PSIZE_HISTO_SIZE];
2418fa9e4066Sahrens } zdb_blkstats_t;
2419fa9e4066Sahrens 
2420b24ab676SJeff Bonwick /*
2421b24ab676SJeff Bonwick  * Extended object types to report deferred frees and dedup auto-ditto blocks.
2422b24ab676SJeff Bonwick  */
2423b24ab676SJeff Bonwick #define	ZDB_OT_DEFERRED	(DMU_OT_NUMTYPES + 0)
2424b24ab676SJeff Bonwick #define	ZDB_OT_DITTO	(DMU_OT_NUMTYPES + 1)
2425ad135b5dSChristopher Siden #define	ZDB_OT_OTHER	(DMU_OT_NUMTYPES + 2)
2426ad135b5dSChristopher Siden #define	ZDB_OT_TOTAL	(DMU_OT_NUMTYPES + 3)
2427b24ab676SJeff Bonwick 
2428b24ab676SJeff Bonwick static char *zdb_ot_extname[] = {
2429b24ab676SJeff Bonwick 	"deferred free",
2430b24ab676SJeff Bonwick 	"dedup ditto",
2431ad135b5dSChristopher Siden 	"other",
2432b24ab676SJeff Bonwick 	"Total",
2433b24ab676SJeff Bonwick };
2434fa9e4066Sahrens 
243588b7b0f2SMatthew Ahrens #define	ZB_TOTAL	DN_MAX_LEVELS
2436fa9e4066Sahrens 
2437fa9e4066Sahrens typedef struct zdb_cb {
2438b24ab676SJeff Bonwick 	zdb_blkstats_t	zcb_type[ZB_TOTAL + 1][ZDB_OT_TOTAL + 1];
2439b24ab676SJeff Bonwick 	uint64_t	zcb_dedup_asize;
2440b24ab676SJeff Bonwick 	uint64_t	zcb_dedup_blocks;
24415d7b4d43SMatthew Ahrens 	uint64_t	zcb_embedded_blocks[NUM_BP_EMBEDDED_TYPES];
24425d7b4d43SMatthew Ahrens 	uint64_t	zcb_embedded_histogram[NUM_BP_EMBEDDED_TYPES]
24435d7b4d43SMatthew Ahrens 	    [BPE_PAYLOAD_SIZE];
2444490d05b9SMatthew Ahrens 	uint64_t	zcb_start;
2445490d05b9SMatthew Ahrens 	uint64_t	zcb_lastprint;
2446490d05b9SMatthew Ahrens 	uint64_t	zcb_totalasize;
2447fa9e4066Sahrens 	uint64_t	zcb_errors[256];
2448fa9e4066Sahrens 	int		zcb_readfails;
2449fa9e4066Sahrens 	int		zcb_haderrors;
2450cde58dbcSMatthew Ahrens 	spa_t		*zcb_spa;
2451fa9e4066Sahrens } zdb_cb_t;
2452fa9e4066Sahrens 
2453fa9e4066Sahrens static void
2454cde58dbcSMatthew Ahrens zdb_count_block(zdb_cb_t *zcb, zilog_t *zilog, const blkptr_t *bp,
2455b24ab676SJeff Bonwick     dmu_object_type_t type)
2456fa9e4066Sahrens {
2457b24ab676SJeff Bonwick 	uint64_t refcnt = 0;
2458b24ab676SJeff Bonwick 
2459b24ab676SJeff Bonwick 	ASSERT(type < ZDB_OT_TOTAL);
2460b24ab676SJeff Bonwick 
2461b24ab676SJeff Bonwick 	if (zilog && zil_bp_tree_add(zilog, bp) != 0)
2462b24ab676SJeff Bonwick 		return;
2463b24ab676SJeff Bonwick 
2464e14bb325SJeff Bonwick 	for (int i = 0; i < 4; i++) {
2465fa9e4066Sahrens 		int l = (i < 2) ? BP_GET_LEVEL(bp) : ZB_TOTAL;
2466b24ab676SJeff Bonwick 		int t = (i & 1) ? type : ZDB_OT_TOTAL;
2467d5ee8a13SMatthew Ahrens 		int equal;
2468fa9e4066Sahrens 		zdb_blkstats_t *zb = &zcb->zcb_type[l][t];
2469fa9e4066Sahrens 
2470fa9e4066Sahrens 		zb->zb_asize += BP_GET_ASIZE(bp);
2471fa9e4066Sahrens 		zb->zb_lsize += BP_GET_LSIZE(bp);
2472fa9e4066Sahrens 		zb->zb_psize += BP_GET_PSIZE(bp);
2473fa9e4066Sahrens 		zb->zb_count++;
2474b5152584SMatthew Ahrens 
2475b5152584SMatthew Ahrens 		/*
2476b5152584SMatthew Ahrens 		 * The histogram is only big enough to record blocks up to
2477b5152584SMatthew Ahrens 		 * SPA_OLD_MAXBLOCKSIZE; larger blocks go into the last,
2478b5152584SMatthew Ahrens 		 * "other", bucket.
2479b5152584SMatthew Ahrens 		 */
2480b5152584SMatthew Ahrens 		int idx = BP_GET_PSIZE(bp) >> SPA_MINBLOCKSHIFT;
2481b5152584SMatthew Ahrens 		idx = MIN(idx, SPA_OLD_MAXBLOCKSIZE / SPA_MINBLOCKSIZE + 1);
2482b5152584SMatthew Ahrens 		zb->zb_psize_histogram[idx]++;
2483d5ee8a13SMatthew Ahrens 
2484d5ee8a13SMatthew Ahrens 		zb->zb_gangs += BP_COUNT_GANG(bp);
2485d5ee8a13SMatthew Ahrens 
2486d5ee8a13SMatthew Ahrens 		switch (BP_GET_NDVAS(bp)) {
2487d5ee8a13SMatthew Ahrens 		case 2:
2488d5ee8a13SMatthew Ahrens 			if (DVA_GET_VDEV(&bp->blk_dva[0]) ==
2489d5ee8a13SMatthew Ahrens 			    DVA_GET_VDEV(&bp->blk_dva[1]))
2490d5ee8a13SMatthew Ahrens 				zb->zb_ditto_samevdev++;
2491d5ee8a13SMatthew Ahrens 			break;
2492d5ee8a13SMatthew Ahrens 		case 3:
2493d5ee8a13SMatthew Ahrens 			equal = (DVA_GET_VDEV(&bp->blk_dva[0]) ==
2494d5ee8a13SMatthew Ahrens 			    DVA_GET_VDEV(&bp->blk_dva[1])) +
2495d5ee8a13SMatthew Ahrens 			    (DVA_GET_VDEV(&bp->blk_dva[0]) ==
2496d5ee8a13SMatthew Ahrens 			    DVA_GET_VDEV(&bp->blk_dva[2])) +
2497d5ee8a13SMatthew Ahrens 			    (DVA_GET_VDEV(&bp->blk_dva[1]) ==
2498d5ee8a13SMatthew Ahrens 			    DVA_GET_VDEV(&bp->blk_dva[2]));
2499d5ee8a13SMatthew Ahrens 			if (equal != 0)
2500d5ee8a13SMatthew Ahrens 				zb->zb_ditto_samevdev++;
2501d5ee8a13SMatthew Ahrens 			break;
2502d5ee8a13SMatthew Ahrens 		}
2503d5ee8a13SMatthew Ahrens 
2504fa9e4066Sahrens 	}
2505fa9e4066Sahrens 
25065d7b4d43SMatthew Ahrens 	if (BP_IS_EMBEDDED(bp)) {
25075d7b4d43SMatthew Ahrens 		zcb->zcb_embedded_blocks[BPE_GET_ETYPE(bp)]++;
25085d7b4d43SMatthew Ahrens 		zcb->zcb_embedded_histogram[BPE_GET_ETYPE(bp)]
25095d7b4d43SMatthew Ahrens 		    [BPE_GET_PSIZE(bp)]++;
25105d7b4d43SMatthew Ahrens 		return;
25115d7b4d43SMatthew Ahrens 	}
25125d7b4d43SMatthew Ahrens 
2513b24ab676SJeff Bonwick 	if (dump_opt['L'])
2514b24ab676SJeff Bonwick 		return;
2515b24ab676SJeff Bonwick 
2516b24ab676SJeff Bonwick 	if (BP_GET_DEDUP(bp)) {
2517b24ab676SJeff Bonwick 		ddt_t *ddt;
2518b24ab676SJeff Bonwick 		ddt_entry_t *dde;
2519b24ab676SJeff Bonwick 
2520cde58dbcSMatthew Ahrens 		ddt = ddt_select(zcb->zcb_spa, bp);
2521b24ab676SJeff Bonwick 		ddt_enter(ddt);
2522b24ab676SJeff Bonwick 		dde = ddt_lookup(ddt, bp, B_FALSE);
2523b24ab676SJeff Bonwick 
2524b24ab676SJeff Bonwick 		if (dde == NULL) {
2525b24ab676SJeff Bonwick 			refcnt = 0;
2526b24ab676SJeff Bonwick 		} else {
2527b24ab676SJeff Bonwick 			ddt_phys_t *ddp = ddt_phys_select(dde, bp);
2528b24ab676SJeff Bonwick 			ddt_phys_decref(ddp);
2529b24ab676SJeff Bonwick 			refcnt = ddp->ddp_refcnt;
2530b24ab676SJeff Bonwick 			if (ddt_phys_total_refcnt(dde) == 0)
2531b24ab676SJeff Bonwick 				ddt_remove(ddt, dde);
2532d41e7643Sek 		}
2533b24ab676SJeff Bonwick 		ddt_exit(ddt);
2534d41e7643Sek 	}
2535d41e7643Sek 
2536cde58dbcSMatthew Ahrens 	VERIFY3U(zio_wait(zio_claim(NULL, zcb->zcb_spa,
2537cde58dbcSMatthew Ahrens 	    refcnt ? 0 : spa_first_txg(zcb->zcb_spa),
2538b24ab676SJeff Bonwick 	    bp, NULL, NULL, ZIO_FLAG_CANFAIL)), ==, 0);
2539fa9e4066Sahrens }
2540fa9e4066Sahrens 
254131d7e8faSGeorge Wilson static void
254231d7e8faSGeorge Wilson zdb_blkptr_done(zio_t *zio)
254331d7e8faSGeorge Wilson {
254431d7e8faSGeorge Wilson 	spa_t *spa = zio->io_spa;
254531d7e8faSGeorge Wilson 	blkptr_t *bp = zio->io_bp;
254631d7e8faSGeorge Wilson 	int ioerr = zio->io_error;
254731d7e8faSGeorge Wilson 	zdb_cb_t *zcb = zio->io_private;
25487802d7bfSMatthew Ahrens 	zbookmark_phys_t *zb = &zio->io_bookmark;
254931d7e8faSGeorge Wilson 
2550770499e1SDan Kimmel 	abd_free(zio->io_abd);
255131d7e8faSGeorge Wilson 
255231d7e8faSGeorge Wilson 	mutex_enter(&spa->spa_scrub_lock);
255331d7e8faSGeorge Wilson 	spa->spa_scrub_inflight--;
255431d7e8faSGeorge Wilson 	cv_broadcast(&spa->spa_scrub_io_cv);
255531d7e8faSGeorge Wilson 
255631d7e8faSGeorge Wilson 	if (ioerr && !(zio->io_flags & ZIO_FLAG_SPECULATIVE)) {
255731d7e8faSGeorge Wilson 		char blkbuf[BP_SPRINTF_LEN];
255831d7e8faSGeorge Wilson 
255931d7e8faSGeorge Wilson 		zcb->zcb_haderrors = 1;
256031d7e8faSGeorge Wilson 		zcb->zcb_errors[ioerr]++;
256131d7e8faSGeorge Wilson 
256231d7e8faSGeorge Wilson 		if (dump_opt['b'] >= 2)
256343466aaeSMax Grossman 			snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
256431d7e8faSGeorge Wilson 		else
256531d7e8faSGeorge Wilson 			blkbuf[0] = '\0';
256631d7e8faSGeorge Wilson 
256731d7e8faSGeorge Wilson 		(void) printf("zdb_blkptr_cb: "
256831d7e8faSGeorge Wilson 		    "Got error %d reading "
256931d7e8faSGeorge Wilson 		    "<%llu, %llu, %lld, %llx> %s -- skipping\n",
257031d7e8faSGeorge Wilson 		    ioerr,
257131d7e8faSGeorge Wilson 		    (u_longlong_t)zb->zb_objset,
257231d7e8faSGeorge Wilson 		    (u_longlong_t)zb->zb_object,
257331d7e8faSGeorge Wilson 		    (u_longlong_t)zb->zb_level,
257431d7e8faSGeorge Wilson 		    (u_longlong_t)zb->zb_blkid,
257531d7e8faSGeorge Wilson 		    blkbuf);
257631d7e8faSGeorge Wilson 	}
257731d7e8faSGeorge Wilson 	mutex_exit(&spa->spa_scrub_lock);
257831d7e8faSGeorge Wilson }
257931d7e8faSGeorge Wilson 
2580fa9e4066Sahrens static int
25811b912ec7SGeorge Wilson zdb_blkptr_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
25827802d7bfSMatthew Ahrens     const zbookmark_phys_t *zb, const dnode_phys_t *dnp, void *arg)
2583fa9e4066Sahrens {
2584fa9e4066Sahrens 	zdb_cb_t *zcb = arg;
25856365109dSVictor Latushkin 	dmu_object_type_t type;
2586468c413aSTim Haley 	boolean_t is_metadata;
2587fa9e4066Sahrens 
2588a2cdcdd2SPaul Dagnelie 	if (bp == NULL)
2589a2cdcdd2SPaul Dagnelie 		return (0);
2590a2cdcdd2SPaul Dagnelie 
259143466aaeSMax Grossman 	if (dump_opt['b'] >= 5 && bp->blk_birth > 0) {
259243466aaeSMax Grossman 		char blkbuf[BP_SPRINTF_LEN];
259343466aaeSMax Grossman 		snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
259443466aaeSMax Grossman 		(void) printf("objset %llu object %llu "
259543466aaeSMax Grossman 		    "level %lld offset 0x%llx %s\n",
259643466aaeSMax Grossman 		    (u_longlong_t)zb->zb_objset,
259743466aaeSMax Grossman 		    (u_longlong_t)zb->zb_object,
259843466aaeSMax Grossman 		    (longlong_t)zb->zb_level,
259943466aaeSMax Grossman 		    (u_longlong_t)blkid2offset(dnp, bp, zb),
260043466aaeSMax Grossman 		    blkbuf);
260143466aaeSMax Grossman 	}
260243466aaeSMax Grossman 
260343466aaeSMax Grossman 	if (BP_IS_HOLE(bp))
260488b7b0f2SMatthew Ahrens 		return (0);
2605e14bb325SJeff Bonwick 
26066365109dSVictor Latushkin 	type = BP_GET_TYPE(bp);
2607e14bb325SJeff Bonwick 
2608ad135b5dSChristopher Siden 	zdb_count_block(zcb, zilog, bp,
2609ad135b5dSChristopher Siden 	    (type & DMU_OT_NEWTYPE) ? ZDB_OT_OTHER : type);
26106365109dSVictor Latushkin 
2611ad135b5dSChristopher Siden 	is_metadata = (BP_GET_LEVEL(bp) != 0 || DMU_OT_IS_METADATA(type));
26126365109dSVictor Latushkin 
26135d7b4d43SMatthew Ahrens 	if (!BP_IS_EMBEDDED(bp) &&
26145d7b4d43SMatthew Ahrens 	    (dump_opt['c'] > 1 || (dump_opt['c'] && is_metadata))) {
2615468c413aSTim Haley 		size_t size = BP_GET_PSIZE(bp);
2616770499e1SDan Kimmel 		abd_t *abd = abd_alloc(size, B_FALSE);
2617b24ab676SJeff Bonwick 		int flags = ZIO_FLAG_CANFAIL | ZIO_FLAG_SCRUB | ZIO_FLAG_RAW;
2618b24ab676SJeff Bonwick 
2619b24ab676SJeff Bonwick 		/* If it's an intent log block, failure is expected. */
2620b24ab676SJeff Bonwick 		if (zb->zb_level == ZB_ZIL_LEVEL)
2621b24ab676SJeff Bonwick 			flags |= ZIO_FLAG_SPECULATIVE;
2622b24ab676SJeff Bonwick 
262331d7e8faSGeorge Wilson 		mutex_enter(&spa->spa_scrub_lock);
262431d7e8faSGeorge Wilson 		while (spa->spa_scrub_inflight > max_inflight)
262531d7e8faSGeorge Wilson 			cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock);
262631d7e8faSGeorge Wilson 		spa->spa_scrub_inflight++;
262731d7e8faSGeorge Wilson 		mutex_exit(&spa->spa_scrub_lock);
2628b24ab676SJeff Bonwick 
2629770499e1SDan Kimmel 		zio_nowait(zio_read(NULL, spa, bp, abd, size,
263031d7e8faSGeorge Wilson 		    zdb_blkptr_done, zcb, ZIO_PRIORITY_ASYNC_READ, flags, zb));
2631fa9e4066Sahrens 	}
2632fa9e4066Sahrens 
2633fa9e4066Sahrens 	zcb->zcb_readfails = 0;
2634fa9e4066Sahrens 
2635f7950bf1SMatthew Ahrens 	/* only call gethrtime() every 100 blocks */
2636f7950bf1SMatthew Ahrens 	static int iters;
2637f7950bf1SMatthew Ahrens 	if (++iters > 100)
2638f7950bf1SMatthew Ahrens 		iters = 0;
2639f7950bf1SMatthew Ahrens 	else
2640f7950bf1SMatthew Ahrens 		return (0);
2641f7950bf1SMatthew Ahrens 
2642f7950bf1SMatthew Ahrens 	if (dump_opt['b'] < 5 && gethrtime() > zcb->zcb_lastprint + NANOSEC) {
2643490d05b9SMatthew Ahrens 		uint64_t now = gethrtime();
2644490d05b9SMatthew Ahrens 		char buf[10];
2645490d05b9SMatthew Ahrens 		uint64_t bytes = zcb->zcb_type[ZB_TOTAL][ZDB_OT_TOTAL].zb_asize;
2646490d05b9SMatthew Ahrens 		int kb_per_sec =
2647490d05b9SMatthew Ahrens 		    1 + bytes / (1 + ((now - zcb->zcb_start) / 1000 / 1000));
2648490d05b9SMatthew Ahrens 		int sec_remaining =
2649490d05b9SMatthew Ahrens 		    (zcb->zcb_totalasize - bytes) / 1024 / kb_per_sec;
2650490d05b9SMatthew Ahrens 
2651490d05b9SMatthew Ahrens 		zfs_nicenum(bytes, buf, sizeof (buf));
2652490d05b9SMatthew Ahrens 		(void) fprintf(stderr,
2653490d05b9SMatthew Ahrens 		    "\r%5s completed (%4dMB/s) "
2654490d05b9SMatthew Ahrens 		    "estimated time remaining: %uhr %02umin %02usec        ",
2655490d05b9SMatthew Ahrens 		    buf, kb_per_sec / 1024,
2656490d05b9SMatthew Ahrens 		    sec_remaining / 60 / 60,
2657490d05b9SMatthew Ahrens 		    sec_remaining / 60 % 60,
2658490d05b9SMatthew Ahrens 		    sec_remaining % 60);
2659490d05b9SMatthew Ahrens 
2660490d05b9SMatthew Ahrens 		zcb->zcb_lastprint = now;
2661490d05b9SMatthew Ahrens 	}
2662490d05b9SMatthew Ahrens 
2663fa9e4066Sahrens 	return (0);
2664fa9e4066Sahrens }
2665fa9e4066Sahrens 
2666b24ab676SJeff Bonwick static void
26670713e232SGeorge Wilson zdb_leak(void *arg, uint64_t start, uint64_t size)
2668b24ab676SJeff Bonwick {
26690713e232SGeorge Wilson 	vdev_t *vd = arg;
2670b24ab676SJeff Bonwick 
2671b24ab676SJeff Bonwick 	(void) printf("leaked space: vdev %llu, offset 0x%llx, size %llu\n",
2672b24ab676SJeff Bonwick 	    (u_longlong_t)vd->vdev_id, (u_longlong_t)start, (u_longlong_t)size);
2673b24ab676SJeff Bonwick }
2674b24ab676SJeff Bonwick 
26750713e232SGeorge Wilson static metaslab_ops_t zdb_metaslab_ops = {
26762e4c9986SGeorge Wilson 	NULL	/* alloc */
2677b24ab676SJeff Bonwick };
2678b24ab676SJeff Bonwick 
2679b24ab676SJeff Bonwick static void
2680bbfd46c4SJeff Bonwick zdb_ddt_leak_init(spa_t *spa, zdb_cb_t *zcb)
2681b24ab676SJeff Bonwick {
2682bbfd46c4SJeff Bonwick 	ddt_bookmark_t ddb = { 0 };
2683b24ab676SJeff Bonwick 	ddt_entry_t dde;
2684b24ab676SJeff Bonwick 	int error;
2685b24ab676SJeff Bonwick 
2686bbfd46c4SJeff Bonwick 	while ((error = ddt_walk(spa, &ddb, &dde)) == 0) {
2687b24ab676SJeff Bonwick 		blkptr_t blk;
2688b24ab676SJeff Bonwick 		ddt_phys_t *ddp = dde.dde_phys;
2689bbfd46c4SJeff Bonwick 
2690bbfd46c4SJeff Bonwick 		if (ddb.ddb_class == DDT_CLASS_UNIQUE)
2691bbfd46c4SJeff Bonwick 			return;
2692bbfd46c4SJeff Bonwick 
2693b24ab676SJeff Bonwick 		ASSERT(ddt_phys_total_refcnt(&dde) > 1);
2694bbfd46c4SJeff Bonwick 
2695b24ab676SJeff Bonwick 		for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
2696b24ab676SJeff Bonwick 			if (ddp->ddp_phys_birth == 0)
2697b24ab676SJeff Bonwick 				continue;
2698bbfd46c4SJeff Bonwick 			ddt_bp_create(ddb.ddb_checksum,
2699bbfd46c4SJeff Bonwick 			    &dde.dde_key, ddp, &blk);
2700b24ab676SJeff Bonwick 			if (p == DDT_PHYS_DITTO) {
2701cde58dbcSMatthew Ahrens 				zdb_count_block(zcb, NULL, &blk, ZDB_OT_DITTO);
2702b24ab676SJeff Bonwick 			} else {
2703b24ab676SJeff Bonwick 				zcb->zcb_dedup_asize +=
2704b24ab676SJeff Bonwick 				    BP_GET_ASIZE(&blk) * (ddp->ddp_refcnt - 1);
2705b24ab676SJeff Bonwick 				zcb->zcb_dedup_blocks++;
2706b24ab676SJeff Bonwick 			}
2707b24ab676SJeff Bonwick 		}
2708b24ab676SJeff Bonwick 		if (!dump_opt['L']) {
2709bbfd46c4SJeff Bonwick 			ddt_t *ddt = spa->spa_ddt[ddb.ddb_checksum];
2710b24ab676SJeff Bonwick 			ddt_enter(ddt);
2711b24ab676SJeff Bonwick 			VERIFY(ddt_lookup(ddt, &blk, B_TRUE) != NULL);
2712b24ab676SJeff Bonwick 			ddt_exit(ddt);
2713b24ab676SJeff Bonwick 		}
2714b24ab676SJeff Bonwick 	}
2715b24ab676SJeff Bonwick 
2716b24ab676SJeff Bonwick 	ASSERT(error == ENOENT);
2717b24ab676SJeff Bonwick }
2718b24ab676SJeff Bonwick 
2719b24ab676SJeff Bonwick static void
2720b24ab676SJeff Bonwick zdb_leak_init(spa_t *spa, zdb_cb_t *zcb)
2721b24ab676SJeff Bonwick {
2722cde58dbcSMatthew Ahrens 	zcb->zcb_spa = spa;
2723cde58dbcSMatthew Ahrens 
2724b24ab676SJeff Bonwick 	if (!dump_opt['L']) {
2725b24ab676SJeff Bonwick 		vdev_t *rvd = spa->spa_root_vdev;
27268363e80aSGeorge Wilson 
27278363e80aSGeorge Wilson 		/*
27288363e80aSGeorge Wilson 		 * We are going to be changing the meaning of the metaslab's
27298363e80aSGeorge Wilson 		 * ms_tree.  Ensure that the allocator doesn't try to
27308363e80aSGeorge Wilson 		 * use the tree.
27318363e80aSGeorge Wilson 		 */
27328363e80aSGeorge Wilson 		spa->spa_normal_class->mc_ops = &zdb_metaslab_ops;
27338363e80aSGeorge Wilson 		spa->spa_log_class->mc_ops = &zdb_metaslab_ops;
27348363e80aSGeorge Wilson 
273506be9802SMatthew Ahrens 		for (uint64_t c = 0; c < rvd->vdev_children; c++) {
2736b24ab676SJeff Bonwick 			vdev_t *vd = rvd->vdev_child[c];
27378363e80aSGeorge Wilson 			metaslab_group_t *mg = vd->vdev_mg;
273806be9802SMatthew Ahrens 			for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
2739b24ab676SJeff Bonwick 				metaslab_t *msp = vd->vdev_ms[m];
27408363e80aSGeorge Wilson 				ASSERT3P(msp->ms_group, ==, mg);
2741b24ab676SJeff Bonwick 				mutex_enter(&msp->ms_lock);
27420713e232SGeorge Wilson 				metaslab_unload(msp);
27430713e232SGeorge Wilson 
27440713e232SGeorge Wilson 				/*
27450713e232SGeorge Wilson 				 * For leak detection, we overload the metaslab
27460713e232SGeorge Wilson 				 * ms_tree to contain allocated segments
27470713e232SGeorge Wilson 				 * instead of free segments. As a result,
27480713e232SGeorge Wilson 				 * we can't use the normal metaslab_load/unload
27490713e232SGeorge Wilson 				 * interfaces.
27500713e232SGeorge Wilson 				 */
27510713e232SGeorge Wilson 				if (msp->ms_sm != NULL) {
275206be9802SMatthew Ahrens 					(void) fprintf(stderr,
275306be9802SMatthew Ahrens 					    "\rloading space map for "
275406be9802SMatthew Ahrens 					    "vdev %llu of %llu, "
275506be9802SMatthew Ahrens 					    "metaslab %llu of %llu ...",
275606be9802SMatthew Ahrens 					    (longlong_t)c,
275706be9802SMatthew Ahrens 					    (longlong_t)rvd->vdev_children,
275806be9802SMatthew Ahrens 					    (longlong_t)m,
275906be9802SMatthew Ahrens 					    (longlong_t)vd->vdev_ms_count);
276006be9802SMatthew Ahrens 
2761f7950bf1SMatthew Ahrens 					/*
2762f7950bf1SMatthew Ahrens 					 * We don't want to spend the CPU
2763f7950bf1SMatthew Ahrens 					 * manipulating the size-ordered
2764f7950bf1SMatthew Ahrens 					 * tree, so clear the range_tree
2765f7950bf1SMatthew Ahrens 					 * ops.
2766f7950bf1SMatthew Ahrens 					 */
2767f7950bf1SMatthew Ahrens 					msp->ms_tree->rt_ops = NULL;
27680713e232SGeorge Wilson 					VERIFY0(space_map_load(msp->ms_sm,
27690713e232SGeorge Wilson 					    msp->ms_tree, SM_ALLOC));
27708363e80aSGeorge Wilson 
27718363e80aSGeorge Wilson 					if (!msp->ms_loaded) {
27728363e80aSGeorge Wilson 						msp->ms_loaded = B_TRUE;
27738363e80aSGeorge Wilson 					}
27740713e232SGeorge Wilson 				}
2775b24ab676SJeff Bonwick 				mutex_exit(&msp->ms_lock);
2776b24ab676SJeff Bonwick 			}
2777b24ab676SJeff Bonwick 		}
277806be9802SMatthew Ahrens 		(void) fprintf(stderr, "\n");
2779b24ab676SJeff Bonwick 	}
2780b24ab676SJeff Bonwick 
2781b24ab676SJeff Bonwick 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
2782b24ab676SJeff Bonwick 
2783bbfd46c4SJeff Bonwick 	zdb_ddt_leak_init(spa, zcb);
2784b24ab676SJeff Bonwick 
2785b24ab676SJeff Bonwick 	spa_config_exit(spa, SCL_CONFIG, FTAG);
2786b24ab676SJeff Bonwick }
2787b24ab676SJeff Bonwick 
2788b24ab676SJeff Bonwick static void
2789b24ab676SJeff Bonwick zdb_leak_fini(spa_t *spa)
2790b24ab676SJeff Bonwick {
2791b24ab676SJeff Bonwick 	if (!dump_opt['L']) {
2792b24ab676SJeff Bonwick 		vdev_t *rvd = spa->spa_root_vdev;
2793b24ab676SJeff Bonwick 		for (int c = 0; c < rvd->vdev_children; c++) {
2794b24ab676SJeff Bonwick 			vdev_t *vd = rvd->vdev_child[c];
27958363e80aSGeorge Wilson 			metaslab_group_t *mg = vd->vdev_mg;
2796b24ab676SJeff Bonwick 			for (int m = 0; m < vd->vdev_ms_count; m++) {
2797b24ab676SJeff Bonwick 				metaslab_t *msp = vd->vdev_ms[m];
27988363e80aSGeorge Wilson 				ASSERT3P(mg, ==, msp->ms_group);
2799b24ab676SJeff Bonwick 				mutex_enter(&msp->ms_lock);
28000713e232SGeorge Wilson 
28010713e232SGeorge Wilson 				/*
28020713e232SGeorge Wilson 				 * The ms_tree has been overloaded to
28030713e232SGeorge Wilson 				 * contain allocated segments. Now that we
28040713e232SGeorge Wilson 				 * finished traversing all blocks, any
28050713e232SGeorge Wilson 				 * block that remains in the ms_tree
28060713e232SGeorge Wilson 				 * represents an allocated block that we
28070713e232SGeorge Wilson 				 * did not claim during the traversal.
28080713e232SGeorge Wilson 				 * Claimed blocks would have been removed
28090713e232SGeorge Wilson 				 * from the ms_tree.
28100713e232SGeorge Wilson 				 */
28110713e232SGeorge Wilson 				range_tree_vacate(msp->ms_tree, zdb_leak, vd);
28128363e80aSGeorge Wilson 
28138363e80aSGeorge Wilson 				if (msp->ms_loaded) {
28148363e80aSGeorge Wilson 					msp->ms_loaded = B_FALSE;
28158363e80aSGeorge Wilson 				}
28160713e232SGeorge Wilson 
2817b24ab676SJeff Bonwick 				mutex_exit(&msp->ms_lock);
2818b24ab676SJeff Bonwick 			}
2819b24ab676SJeff Bonwick 		}
2820b24ab676SJeff Bonwick 	}
2821b24ab676SJeff Bonwick }
2822b24ab676SJeff Bonwick 
2823cde58dbcSMatthew Ahrens /* ARGSUSED */
2824cde58dbcSMatthew Ahrens static int
2825cde58dbcSMatthew Ahrens count_block_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
2826cde58dbcSMatthew Ahrens {
2827cde58dbcSMatthew Ahrens 	zdb_cb_t *zcb = arg;
2828cde58dbcSMatthew Ahrens 
2829490d05b9SMatthew Ahrens 	if (dump_opt['b'] >= 5) {
2830cde58dbcSMatthew Ahrens 		char blkbuf[BP_SPRINTF_LEN];
283143466aaeSMax Grossman 		snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
2832cde58dbcSMatthew Ahrens 		(void) printf("[%s] %s\n",
2833cde58dbcSMatthew Ahrens 		    "deferred free", blkbuf);
2834cde58dbcSMatthew Ahrens 	}
2835cde58dbcSMatthew Ahrens 	zdb_count_block(zcb, NULL, bp, ZDB_OT_DEFERRED);
2836cde58dbcSMatthew Ahrens 	return (0);
2837cde58dbcSMatthew Ahrens }
2838cde58dbcSMatthew Ahrens 
2839fa9e4066Sahrens static int
2840fa9e4066Sahrens dump_block_stats(spa_t *spa)
2841fa9e4066Sahrens {
2842fa9e4066Sahrens 	zdb_cb_t zcb = { 0 };
2843fa9e4066Sahrens 	zdb_blkstats_t *zb, *tzb;
2844b24ab676SJeff Bonwick 	uint64_t norm_alloc, norm_space, total_alloc, total_found;
2845cd088ea4SVictor Latushkin 	int flags = TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA | TRAVERSE_HARD;
28465d7b4d43SMatthew Ahrens 	boolean_t leaks = B_FALSE;
2847fa9e4066Sahrens 
2848490d05b9SMatthew Ahrens 	(void) printf("\nTraversing all blocks %s%s%s%s%s...\n\n",
2849b24ab676SJeff Bonwick 	    (dump_opt['c'] || !dump_opt['L']) ? "to verify " : "",
2850b24ab676SJeff Bonwick 	    (dump_opt['c'] == 1) ? "metadata " : "",
2851b24ab676SJeff Bonwick 	    dump_opt['c'] ? "checksums " : "",
2852b24ab676SJeff Bonwick 	    (dump_opt['c'] && !dump_opt['L']) ? "and verify " : "",
2853b24ab676SJeff Bonwick 	    !dump_opt['L'] ? "nothing leaked " : "");
2854fa9e4066Sahrens 
2855fa9e4066Sahrens 	/*
2856e14bb325SJeff Bonwick 	 * Load all space maps as SM_ALLOC maps, then traverse the pool
2857e14bb325SJeff Bonwick 	 * claiming each block we discover.  If the pool is perfectly
2858e14bb325SJeff Bonwick 	 * consistent, the space maps will be empty when we're done.
2859e14bb325SJeff Bonwick 	 * Anything left over is a leak; any block we can't claim (because
2860e14bb325SJeff Bonwick 	 * it's not part of any space map) is a double allocation,
2861e14bb325SJeff Bonwick 	 * reference to a freed block, or an unclaimed log block.
2862fa9e4066Sahrens 	 */
2863b24ab676SJeff Bonwick 	zdb_leak_init(spa, &zcb);
2864fa9e4066Sahrens 
2865fa9e4066Sahrens 	/*
2866fa9e4066Sahrens 	 * If there's a deferred-free bplist, process that first.
2867fa9e4066Sahrens 	 */
2868cde58dbcSMatthew Ahrens 	(void) bpobj_iterate_nofree(&spa->spa_deferred_bpobj,
2869cde58dbcSMatthew Ahrens 	    count_block_cb, &zcb, NULL);
28703b2aab18SMatthew Ahrens 	if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
28713b2aab18SMatthew Ahrens 		(void) bpobj_iterate_nofree(&spa->spa_dsl_pool->dp_free_bpobj,
28723b2aab18SMatthew Ahrens 		    count_block_cb, &zcb, NULL);
28733b2aab18SMatthew Ahrens 	}
28742acef22dSMatthew Ahrens 	if (spa_feature_is_active(spa, SPA_FEATURE_ASYNC_DESTROY)) {
2875b420f3adSRichard Lowe 		VERIFY3U(0, ==, bptree_iterate(spa->spa_meta_objset,
2876ad135b5dSChristopher Siden 		    spa->spa_dsl_pool->dp_bptree_obj, B_FALSE, count_block_cb,
2877ad135b5dSChristopher Siden 		    &zcb, NULL));
2878ad135b5dSChristopher Siden 	}
2879fa9e4066Sahrens 
2880bbfd46c4SJeff Bonwick 	if (dump_opt['c'] > 1)
2881bbfd46c4SJeff Bonwick 		flags |= TRAVERSE_PREFETCH_DATA;
2882bbfd46c4SJeff Bonwick 
2883490d05b9SMatthew Ahrens 	zcb.zcb_totalasize = metaslab_class_get_alloc(spa_normal_class(spa));
2884490d05b9SMatthew Ahrens 	zcb.zcb_start = zcb.zcb_lastprint = gethrtime();
2885bbfd46c4SJeff Bonwick 	zcb.zcb_haderrors |= traverse_pool(spa, 0, flags, zdb_blkptr_cb, &zcb);
2886fa9e4066Sahrens 
288731d7e8faSGeorge Wilson 	/*
288831d7e8faSGeorge Wilson 	 * If we've traversed the data blocks then we need to wait for those
288931d7e8faSGeorge Wilson 	 * I/Os to complete. We leverage "The Godfather" zio to wait on
289031d7e8faSGeorge Wilson 	 * all async I/Os to complete.
289131d7e8faSGeorge Wilson 	 */
289231d7e8faSGeorge Wilson 	if (dump_opt['c']) {
28936f834bc1SMatthew Ahrens 		for (int i = 0; i < max_ncpus; i++) {
28946f834bc1SMatthew Ahrens 			(void) zio_wait(spa->spa_async_zio_root[i]);
28956f834bc1SMatthew Ahrens 			spa->spa_async_zio_root[i] = zio_root(spa, NULL, NULL,
28966f834bc1SMatthew Ahrens 			    ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE |
28976f834bc1SMatthew Ahrens 			    ZIO_FLAG_GODFATHER);
28986f834bc1SMatthew Ahrens 		}
289931d7e8faSGeorge Wilson 	}
290031d7e8faSGeorge Wilson 
2901b24ab676SJeff Bonwick 	if (zcb.zcb_haderrors) {
2902fa9e4066Sahrens 		(void) printf("\nError counts:\n\n");
2903fa9e4066Sahrens 		(void) printf("\t%5s  %s\n", "errno", "count");
2904b24ab676SJeff Bonwick 		for (int e = 0; e < 256; e++) {
2905fa9e4066Sahrens 			if (zcb.zcb_errors[e] != 0) {
2906fa9e4066Sahrens 				(void) printf("\t%5d  %llu\n",
2907fa9e4066Sahrens 				    e, (u_longlong_t)zcb.zcb_errors[e]);
2908fa9e4066Sahrens 			}
2909fa9e4066Sahrens 		}
2910fa9e4066Sahrens 	}
2911fa9e4066Sahrens 
2912fa9e4066Sahrens 	/*
2913fa9e4066Sahrens 	 * Report any leaked segments.
2914fa9e4066Sahrens 	 */
2915b24ab676SJeff Bonwick 	zdb_leak_fini(spa);
2916fa9e4066Sahrens 
2917b24ab676SJeff Bonwick 	tzb = &zcb.zcb_type[ZB_TOTAL][ZDB_OT_TOTAL];
29188654d025Sperrin 
2919b24ab676SJeff Bonwick 	norm_alloc = metaslab_class_get_alloc(spa_normal_class(spa));
2920b24ab676SJeff Bonwick 	norm_space = metaslab_class_get_space(spa_normal_class(spa));
29218654d025Sperrin 
2922b24ab676SJeff Bonwick 	total_alloc = norm_alloc + metaslab_class_get_alloc(spa_log_class(spa));
2923b24ab676SJeff Bonwick 	total_found = tzb->zb_asize - zcb.zcb_dedup_asize;
2924fa9e4066Sahrens 
2925b24ab676SJeff Bonwick 	if (total_found == total_alloc) {
292682a0a985SVictor Latushkin 		if (!dump_opt['L'])
292782a0a985SVictor Latushkin 			(void) printf("\n\tNo leaks (block sum matches space"
292882a0a985SVictor Latushkin 			    " maps exactly)\n");
2929fa9e4066Sahrens 	} else {
2930fa9e4066Sahrens 		(void) printf("block traversal size %llu != alloc %llu "
293182a0a985SVictor Latushkin 		    "(%s %lld)\n",
2932b24ab676SJeff Bonwick 		    (u_longlong_t)total_found,
2933b24ab676SJeff Bonwick 		    (u_longlong_t)total_alloc,
293482a0a985SVictor Latushkin 		    (dump_opt['L']) ? "unreachable" : "leaked",
2935b24ab676SJeff Bonwick 		    (longlong_t)(total_alloc - total_found));
29365d7b4d43SMatthew Ahrens 		leaks = B_TRUE;
2937fa9e4066Sahrens 	}
2938fa9e4066Sahrens 
2939fa9e4066Sahrens 	if (tzb->zb_count == 0)
2940fa9e4066Sahrens 		return (2);
2941fa9e4066Sahrens 
2942fa9e4066Sahrens 	(void) printf("\n");
2943fa9e4066Sahrens 	(void) printf("\tbp count:      %10llu\n",
2944fa9e4066Sahrens 	    (u_longlong_t)tzb->zb_count);
2945d5ee8a13SMatthew Ahrens 	(void) printf("\tganged count:  %10llu\n",
2946d5ee8a13SMatthew Ahrens 	    (longlong_t)tzb->zb_gangs);
2947b24ab676SJeff Bonwick 	(void) printf("\tbp logical:    %10llu      avg: %6llu\n",
2948fa9e4066Sahrens 	    (u_longlong_t)tzb->zb_lsize,
2949fa9e4066Sahrens 	    (u_longlong_t)(tzb->zb_lsize / tzb->zb_count));
2950b24ab676SJeff Bonwick 	(void) printf("\tbp physical:   %10llu      avg:"
2951b24ab676SJeff Bonwick 	    " %6llu     compression: %6.2f\n",
2952fa9e4066Sahrens 	    (u_longlong_t)tzb->zb_psize,
2953fa9e4066Sahrens 	    (u_longlong_t)(tzb->zb_psize / tzb->zb_count),
2954fa9e4066Sahrens 	    (double)tzb->zb_lsize / tzb->zb_psize);
2955b24ab676SJeff Bonwick 	(void) printf("\tbp allocated:  %10llu      avg:"
2956b24ab676SJeff Bonwick 	    " %6llu     compression: %6.2f\n",
2957fa9e4066Sahrens 	    (u_longlong_t)tzb->zb_asize,
2958fa9e4066Sahrens 	    (u_longlong_t)(tzb->zb_asize / tzb->zb_count),
2959fa9e4066Sahrens 	    (double)tzb->zb_lsize / tzb->zb_asize);
2960b24ab676SJeff Bonwick 	(void) printf("\tbp deduped:    %10llu    ref>1:"
2961b24ab676SJeff Bonwick 	    " %6llu   deduplication: %6.2f\n",
2962b24ab676SJeff Bonwick 	    (u_longlong_t)zcb.zcb_dedup_asize,
2963b24ab676SJeff Bonwick 	    (u_longlong_t)zcb.zcb_dedup_blocks,
2964b24ab676SJeff Bonwick 	    (double)zcb.zcb_dedup_asize / tzb->zb_asize + 1.0);
2965b24ab676SJeff Bonwick 	(void) printf("\tSPA allocated: %10llu     used: %5.2f%%\n",
2966b24ab676SJeff Bonwick 	    (u_longlong_t)norm_alloc, 100.0 * norm_alloc / norm_space);
2967fa9e4066Sahrens 
29685d7b4d43SMatthew Ahrens 	for (bp_embedded_type_t i = 0; i < NUM_BP_EMBEDDED_TYPES; i++) {
29695d7b4d43SMatthew Ahrens 		if (zcb.zcb_embedded_blocks[i] == 0)
29705d7b4d43SMatthew Ahrens 			continue;
29715d7b4d43SMatthew Ahrens 		(void) printf("\n");
29725d7b4d43SMatthew Ahrens 		(void) printf("\tadditional, non-pointer bps of type %u: "
29735d7b4d43SMatthew Ahrens 		    "%10llu\n",
29745d7b4d43SMatthew Ahrens 		    i, (u_longlong_t)zcb.zcb_embedded_blocks[i]);
29755d7b4d43SMatthew Ahrens 
29765d7b4d43SMatthew Ahrens 		if (dump_opt['b'] >= 3) {
29775d7b4d43SMatthew Ahrens 			(void) printf("\t number of (compressed) bytes:  "
29785d7b4d43SMatthew Ahrens 			    "number of bps\n");
29795d7b4d43SMatthew Ahrens 			dump_histogram(zcb.zcb_embedded_histogram[i],
29805d7b4d43SMatthew Ahrens 			    sizeof (zcb.zcb_embedded_histogram[i]) /
29815d7b4d43SMatthew Ahrens 			    sizeof (zcb.zcb_embedded_histogram[i][0]), 0);
29825d7b4d43SMatthew Ahrens 		}
29835d7b4d43SMatthew Ahrens 	}
29845d7b4d43SMatthew Ahrens 
2985d5ee8a13SMatthew Ahrens 	if (tzb->zb_ditto_samevdev != 0) {
2986d5ee8a13SMatthew Ahrens 		(void) printf("\tDittoed blocks on same vdev: %llu\n",
2987d5ee8a13SMatthew Ahrens 		    (longlong_t)tzb->zb_ditto_samevdev);
2988d5ee8a13SMatthew Ahrens 	}
2989d5ee8a13SMatthew Ahrens 
2990fa9e4066Sahrens 	if (dump_opt['b'] >= 2) {
2991fa9e4066Sahrens 		int l, t, level;
2992fa9e4066Sahrens 		(void) printf("\nBlocks\tLSIZE\tPSIZE\tASIZE"
2993fa9e4066Sahrens 		    "\t  avg\t comp\t%%Total\tType\n");
2994fa9e4066Sahrens 
2995b24ab676SJeff Bonwick 		for (t = 0; t <= ZDB_OT_TOTAL; t++) {
29963f9d6ad7SLin Ling 			char csize[32], lsize[32], psize[32], asize[32];
2997d5ee8a13SMatthew Ahrens 			char avg[32], gang[32];
2998fa9e4066Sahrens 			char *typename;
2999fa9e4066Sahrens 
3000b24ab676SJeff Bonwick 			if (t < DMU_OT_NUMTYPES)
3001b24ab676SJeff Bonwick 				typename = dmu_ot[t].ot_name;
3002b24ab676SJeff Bonwick 			else
3003b24ab676SJeff Bonwick 				typename = zdb_ot_extname[t - DMU_OT_NUMTYPES];
3004fa9e4066Sahrens 
3005fa9e4066Sahrens 			if (zcb.zcb_type[ZB_TOTAL][t].zb_asize == 0) {
3006fa9e4066Sahrens 				(void) printf("%6s\t%5s\t%5s\t%5s"
3007fa9e4066Sahrens 				    "\t%5s\t%5s\t%6s\t%s\n",
3008fa9e4066Sahrens 				    "-",
3009fa9e4066Sahrens 				    "-",
3010fa9e4066Sahrens 				    "-",
3011fa9e4066Sahrens 				    "-",
3012fa9e4066Sahrens 				    "-",
3013fa9e4066Sahrens 				    "-",
3014fa9e4066Sahrens 				    "-",
3015fa9e4066Sahrens 				    typename);
3016fa9e4066Sahrens 				continue;
3017fa9e4066Sahrens 			}
3018fa9e4066Sahrens 
3019fa9e4066Sahrens 			for (l = ZB_TOTAL - 1; l >= -1; l--) {
3020fa9e4066Sahrens 				level = (l == -1 ? ZB_TOTAL : l);
3021fa9e4066Sahrens 				zb = &zcb.zcb_type[level][t];
3022fa9e4066Sahrens 
3023fa9e4066Sahrens 				if (zb->zb_asize == 0)
3024fa9e4066Sahrens 					continue;
3025fa9e4066Sahrens 
3026fa9e4066Sahrens 				if (dump_opt['b'] < 3 && level != ZB_TOTAL)
3027fa9e4066Sahrens 					continue;
3028fa9e4066Sahrens 
3029fa9e4066Sahrens 				if (level == 0 && zb->zb_asize ==
3030fa9e4066Sahrens 				    zcb.zcb_type[ZB_TOTAL][t].zb_asize)
3031fa9e4066Sahrens 					continue;
3032fa9e4066Sahrens 
30333f9d6ad7SLin Ling 				zdb_nicenum(zb->zb_count, csize);
30343f9d6ad7SLin Ling 				zdb_nicenum(zb->zb_lsize, lsize);
30353f9d6ad7SLin Ling 				zdb_nicenum(zb->zb_psize, psize);
30363f9d6ad7SLin Ling 				zdb_nicenum(zb->zb_asize, asize);
30373f9d6ad7SLin Ling 				zdb_nicenum(zb->zb_asize / zb->zb_count, avg);
3038d5ee8a13SMatthew Ahrens 				zdb_nicenum(zb->zb_gangs, gang);
3039fa9e4066Sahrens 
3040fa9e4066Sahrens 				(void) printf("%6s\t%5s\t%5s\t%5s\t%5s"
3041fa9e4066Sahrens 				    "\t%5.2f\t%6.2f\t",
3042fa9e4066Sahrens 				    csize, lsize, psize, asize, avg,
3043fa9e4066Sahrens 				    (double)zb->zb_lsize / zb->zb_psize,
3044fa9e4066Sahrens 				    100.0 * zb->zb_asize / tzb->zb_asize);
3045fa9e4066Sahrens 
3046fa9e4066Sahrens 				if (level == ZB_TOTAL)
3047fa9e4066Sahrens 					(void) printf("%s\n", typename);
3048fa9e4066Sahrens 				else
3049fa9e4066Sahrens 					(void) printf("    L%d %s\n",
3050fa9e4066Sahrens 					    level, typename);
3051490d05b9SMatthew Ahrens 
3052d5ee8a13SMatthew Ahrens 				if (dump_opt['b'] >= 3 && zb->zb_gangs > 0) {
3053d5ee8a13SMatthew Ahrens 					(void) printf("\t number of ganged "
3054d5ee8a13SMatthew Ahrens 					    "blocks: %s\n", gang);
3055d5ee8a13SMatthew Ahrens 				}
3056d5ee8a13SMatthew Ahrens 
3057490d05b9SMatthew Ahrens 				if (dump_opt['b'] >= 4) {
3058490d05b9SMatthew Ahrens 					(void) printf("psize "
3059490d05b9SMatthew Ahrens 					    "(in 512-byte sectors): "
3060490d05b9SMatthew Ahrens 					    "number of blocks\n");
3061490d05b9SMatthew Ahrens 					dump_histogram(zb->zb_psize_histogram,
30620713e232SGeorge Wilson 					    PSIZE_HISTO_SIZE, 0);
3063490d05b9SMatthew Ahrens 				}
3064fa9e4066Sahrens 			}
3065fa9e4066Sahrens 		}
3066fa9e4066Sahrens 	}
3067fa9e4066Sahrens 
3068fa9e4066Sahrens 	(void) printf("\n");
3069fa9e4066Sahrens 
3070fa9e4066Sahrens 	if (leaks)
3071fa9e4066Sahrens 		return (2);
3072fa9e4066Sahrens 
3073fa9e4066Sahrens 	if (zcb.zcb_haderrors)
3074fa9e4066Sahrens 		return (3);
3075fa9e4066Sahrens 
3076fa9e4066Sahrens 	return (0);
3077fa9e4066Sahrens }
3078fa9e4066Sahrens 
3079b24ab676SJeff Bonwick typedef struct zdb_ddt_entry {
3080b24ab676SJeff Bonwick 	ddt_key_t	zdde_key;
3081b24ab676SJeff Bonwick 	uint64_t	zdde_ref_blocks;
3082b24ab676SJeff Bonwick 	uint64_t	zdde_ref_lsize;
3083b24ab676SJeff Bonwick 	uint64_t	zdde_ref_psize;
3084b24ab676SJeff Bonwick 	uint64_t	zdde_ref_dsize;
3085b24ab676SJeff Bonwick 	avl_node_t	zdde_node;
3086b24ab676SJeff Bonwick } zdb_ddt_entry_t;
3087b24ab676SJeff Bonwick 
3088b24ab676SJeff Bonwick /* ARGSUSED */
3089b24ab676SJeff Bonwick static int
3090b24ab676SJeff Bonwick zdb_ddt_add_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
30917802d7bfSMatthew Ahrens     const zbookmark_phys_t *zb, const dnode_phys_t *dnp, void *arg)
3092b24ab676SJeff Bonwick {
3093b24ab676SJeff Bonwick 	avl_tree_t *t = arg;
3094b24ab676SJeff Bonwick 	avl_index_t where;
3095b24ab676SJeff Bonwick 	zdb_ddt_entry_t *zdde, zdde_search;
3096b24ab676SJeff Bonwick 
3097a2cdcdd2SPaul Dagnelie 	if (bp == NULL || BP_IS_HOLE(bp) || BP_IS_EMBEDDED(bp))
3098b24ab676SJeff Bonwick 		return (0);
3099b24ab676SJeff Bonwick 
3100b24ab676SJeff Bonwick 	if (dump_opt['S'] > 1 && zb->zb_level == ZB_ROOT_LEVEL) {
3101b24ab676SJeff Bonwick 		(void) printf("traversing objset %llu, %llu objects, "
3102b24ab676SJeff Bonwick 		    "%lu blocks so far\n",
3103b24ab676SJeff Bonwick 		    (u_longlong_t)zb->zb_objset,
31045d7b4d43SMatthew Ahrens 		    (u_longlong_t)BP_GET_FILL(bp),
3105b24ab676SJeff Bonwick 		    avl_numnodes(t));
3106b24ab676SJeff Bonwick 	}
3107b24ab676SJeff Bonwick 
3108bbfd46c4SJeff Bonwick 	if (BP_IS_HOLE(bp) || BP_GET_CHECKSUM(bp) == ZIO_CHECKSUM_OFF ||
3109ad135b5dSChristopher Siden 	    BP_GET_LEVEL(bp) > 0 || DMU_OT_IS_METADATA(BP_GET_TYPE(bp)))
3110b24ab676SJeff Bonwick 		return (0);
3111b24ab676SJeff Bonwick 
3112b24ab676SJeff Bonwick 	ddt_key_fill(&zdde_search.zdde_key, bp);
3113b24ab676SJeff Bonwick 
3114b24ab676SJeff Bonwick 	zdde = avl_find(t, &zdde_search, &where);
3115b24ab676SJeff Bonwick 
3116b24ab676SJeff Bonwick 	if (zdde == NULL) {
3117b24ab676SJeff Bonwick 		zdde = umem_zalloc(sizeof (*zdde), UMEM_NOFAIL);
3118b24ab676SJeff Bonwick 		zdde->zdde_key = zdde_search.zdde_key;
3119b24ab676SJeff Bonwick 		avl_insert(t, zdde, where);
3120b24ab676SJeff Bonwick 	}
3121b24ab676SJeff Bonwick 
3122b24ab676SJeff Bonwick 	zdde->zdde_ref_blocks += 1;
3123b24ab676SJeff Bonwick 	zdde->zdde_ref_lsize += BP_GET_LSIZE(bp);
3124b24ab676SJeff Bonwick 	zdde->zdde_ref_psize += BP_GET_PSIZE(bp);
3125b24ab676SJeff Bonwick 	zdde->zdde_ref_dsize += bp_get_dsize_sync(spa, bp);
3126b24ab676SJeff Bonwick 
3127b24ab676SJeff Bonwick 	return (0);
3128b24ab676SJeff Bonwick }
3129b24ab676SJeff Bonwick 
3130b24ab676SJeff Bonwick static void
3131b24ab676SJeff Bonwick dump_simulated_ddt(spa_t *spa)
3132b24ab676SJeff Bonwick {
3133b24ab676SJeff Bonwick 	avl_tree_t t;
3134b24ab676SJeff Bonwick 	void *cookie = NULL;
3135b24ab676SJeff Bonwick 	zdb_ddt_entry_t *zdde;
3136b24ab676SJeff Bonwick 	ddt_histogram_t ddh_total = { 0 };
3137b24ab676SJeff Bonwick 	ddt_stat_t dds_total = { 0 };
3138b24ab676SJeff Bonwick 
3139b24ab676SJeff Bonwick 	avl_create(&t, ddt_entry_compare,
3140b24ab676SJeff Bonwick 	    sizeof (zdb_ddt_entry_t), offsetof(zdb_ddt_entry_t, zdde_node));
3141b24ab676SJeff Bonwick 
3142b24ab676SJeff Bonwick 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
3143b24ab676SJeff Bonwick 
3144bbfd46c4SJeff Bonwick 	(void) traverse_pool(spa, 0, TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA,
3145bbfd46c4SJeff Bonwick 	    zdb_ddt_add_cb, &t);
3146b24ab676SJeff Bonwick 
3147b24ab676SJeff Bonwick 	spa_config_exit(spa, SCL_CONFIG, FTAG);
3148b24ab676SJeff Bonwick 
3149b24ab676SJeff Bonwick 	while ((zdde = avl_destroy_nodes(&t, &cookie)) != NULL) {
3150b24ab676SJeff Bonwick 		ddt_stat_t dds;
3151b24ab676SJeff Bonwick 		uint64_t refcnt = zdde->zdde_ref_blocks;
3152b24ab676SJeff Bonwick 		ASSERT(refcnt != 0);
3153b24ab676SJeff Bonwick 
3154b24ab676SJeff Bonwick 		dds.dds_blocks = zdde->zdde_ref_blocks / refcnt;
3155b24ab676SJeff Bonwick 		dds.dds_lsize = zdde->zdde_ref_lsize / refcnt;
3156b24ab676SJeff Bonwick 		dds.dds_psize = zdde->zdde_ref_psize / refcnt;
3157b24ab676SJeff Bonwick 		dds.dds_dsize = zdde->zdde_ref_dsize / refcnt;
3158b24ab676SJeff Bonwick 
3159b24ab676SJeff Bonwick 		dds.dds_ref_blocks = zdde->zdde_ref_blocks;
3160b24ab676SJeff Bonwick 		dds.dds_ref_lsize = zdde->zdde_ref_lsize;
3161b24ab676SJeff Bonwick 		dds.dds_ref_psize = zdde->zdde_ref_psize;
3162b24ab676SJeff Bonwick 		dds.dds_ref_dsize = zdde->zdde_ref_dsize;
3163b24ab676SJeff Bonwick 
3164bf16b11eSMatthew Ahrens 		ddt_stat_add(&ddh_total.ddh_stat[highbit64(refcnt) - 1],
3165bf16b11eSMatthew Ahrens 		    &dds, 0);
3166b24ab676SJeff Bonwick 
3167b24ab676SJeff Bonwick 		umem_free(zdde, sizeof (*zdde));
3168b24ab676SJeff Bonwick 	}
3169b24ab676SJeff Bonwick 
3170b24ab676SJeff Bonwick 	avl_destroy(&t);
3171b24ab676SJeff Bonwick 
3172b24ab676SJeff Bonwick 	ddt_histogram_stat(&dds_total, &ddh_total);
3173b24ab676SJeff Bonwick 
3174b24ab676SJeff Bonwick 	(void) printf("Simulated DDT histogram:\n");
3175b24ab676SJeff Bonwick 
31769eb19f4dSGeorge Wilson 	zpool_dump_ddt(&dds_total, &ddh_total);
3177b24ab676SJeff Bonwick 
3178b24ab676SJeff Bonwick 	dump_dedup_ratio(&dds_total);
3179b24ab676SJeff Bonwick }
3180b24ab676SJeff Bonwick 
3181fa9e4066Sahrens static void
3182fa9e4066Sahrens dump_zpool(spa_t *spa)
3183fa9e4066Sahrens {
3184fa9e4066Sahrens 	dsl_pool_t *dp = spa_get_dsl(spa);
3185fa9e4066Sahrens 	int rc = 0;
3186fa9e4066Sahrens 
3187b24ab676SJeff Bonwick 	if (dump_opt['S']) {
3188b24ab676SJeff Bonwick 		dump_simulated_ddt(spa);
3189b24ab676SJeff Bonwick 		return;
3190b24ab676SJeff Bonwick 	}
3191b24ab676SJeff Bonwick 
319207428bdfSVictor Latushkin 	if (!dump_opt['e'] && dump_opt['C'] > 1) {
319307428bdfSVictor Latushkin 		(void) printf("\nCached configuration:\n");
319407428bdfSVictor Latushkin 		dump_nvlist(spa->spa_config, 8);
319507428bdfSVictor Latushkin 	}
319607428bdfSVictor Latushkin 
319707428bdfSVictor Latushkin 	if (dump_opt['C'])
319807428bdfSVictor Latushkin 		dump_config(spa);
319907428bdfSVictor Latushkin 
3200fa9e4066Sahrens 	if (dump_opt['u'])
320153b9a4a9SVictor Latushkin 		dump_uberblock(&spa->spa_uberblock, "\nUberblock:\n", "\n");
3202fa9e4066Sahrens 
3203b24ab676SJeff Bonwick 	if (dump_opt['D'])
3204b24ab676SJeff Bonwick 		dump_all_ddts(spa);
3205b24ab676SJeff Bonwick 
320687219db7SVictor Latushkin 	if (dump_opt['d'] > 2 || dump_opt['m'])
320787219db7SVictor Latushkin 		dump_metaslabs(spa);
32082e4c9986SGeorge Wilson 	if (dump_opt['M'])
32092e4c9986SGeorge Wilson 		dump_metaslab_groups(spa);
321087219db7SVictor Latushkin 
321187219db7SVictor Latushkin 	if (dump_opt['d'] || dump_opt['i']) {
3212fa9e4066Sahrens 		dump_dir(dp->dp_meta_objset);
3213fa9e4066Sahrens 		if (dump_opt['d'] >= 3) {
3214732885fcSMatthew Ahrens 			dump_full_bpobj(&spa->spa_deferred_bpobj,
3215d0475637SMatthew Ahrens 			    "Deferred frees", 0);
3216cde58dbcSMatthew Ahrens 			if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
3217732885fcSMatthew Ahrens 				dump_full_bpobj(
3218732885fcSMatthew Ahrens 				    &spa->spa_dsl_pool->dp_free_bpobj,
3219d0475637SMatthew Ahrens 				    "Pool snapshot frees", 0);
3220ad135b5dSChristopher Siden 			}
3221ad135b5dSChristopher Siden 
3222ad135b5dSChristopher Siden 			if (spa_feature_is_active(spa,
32232acef22dSMatthew Ahrens 			    SPA_FEATURE_ASYNC_DESTROY)) {
3224ad135b5dSChristopher Siden 				dump_bptree(spa->spa_meta_objset,
3225ad135b5dSChristopher Siden 				    spa->spa_dsl_pool->dp_bptree_obj,
3226ad135b5dSChristopher Siden 				    "Pool dataset frees");
3227cde58dbcSMatthew Ahrens 			}
3228fa9e4066Sahrens 			dump_dtl(spa->spa_root_vdev, 0);
3229fa9e4066Sahrens 		}
323007428bdfSVictor Latushkin 		(void) dmu_objset_find(spa_name(spa), dump_one_dir,
323107428bdfSVictor Latushkin 		    NULL, DS_FIND_SNAPSHOTS | DS_FIND_CHILDREN);
3232b5152584SMatthew Ahrens 
3233ca0cc391SMatthew Ahrens 		for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
3234ca0cc391SMatthew Ahrens 			uint64_t refcount;
3235ca0cc391SMatthew Ahrens 
3236ca0cc391SMatthew Ahrens 			if (!(spa_feature_table[f].fi_flags &
3237c5d1600cSMatthew Ahrens 			    ZFEATURE_FLAG_PER_DATASET) ||
3238c5d1600cSMatthew Ahrens 			    !spa_feature_is_enabled(spa, f)) {
3239ca0cc391SMatthew Ahrens 				ASSERT0(dataset_feature_count[f]);
3240ca0cc391SMatthew Ahrens 				continue;
3241ca0cc391SMatthew Ahrens 			}
3242ca0cc391SMatthew Ahrens 			(void) feature_get_refcount(spa,
3243ca0cc391SMatthew Ahrens 			    &spa_feature_table[f], &refcount);
3244ca0cc391SMatthew Ahrens 			if (dataset_feature_count[f] != refcount) {
3245ca0cc391SMatthew Ahrens 				(void) printf("%s feature refcount mismatch: "
3246ca0cc391SMatthew Ahrens 				    "%lld datasets != %lld refcount\n",
3247ca0cc391SMatthew Ahrens 				    spa_feature_table[f].fi_uname,
3248ca0cc391SMatthew Ahrens 				    (longlong_t)dataset_feature_count[f],
3249ca0cc391SMatthew Ahrens 				    (longlong_t)refcount);
3250ca0cc391SMatthew Ahrens 				rc = 2;
3251ca0cc391SMatthew Ahrens 			} else {
3252ca0cc391SMatthew Ahrens 				(void) printf("Verified %s feature refcount "
3253ca0cc391SMatthew Ahrens 				    "of %llu is correct\n",
3254ca0cc391SMatthew Ahrens 				    spa_feature_table[f].fi_uname,
3255ca0cc391SMatthew Ahrens 				    (longlong_t)refcount);
3256ca0cc391SMatthew Ahrens 			}
3257b5152584SMatthew Ahrens 		}
3258fa9e4066Sahrens 	}
3259b5152584SMatthew Ahrens 	if (rc == 0 && (dump_opt['b'] || dump_opt['c']))
3260fa9e4066Sahrens 		rc = dump_block_stats(spa);
3261fa9e4066Sahrens 
32620713e232SGeorge Wilson 	if (rc == 0)
32630713e232SGeorge Wilson 		rc = verify_spacemap_refcounts(spa);
32640713e232SGeorge Wilson 
3265fa9e4066Sahrens 	if (dump_opt['s'])
3266fa9e4066Sahrens 		show_pool_stats(spa);
3267fa9e4066Sahrens 
32688f18d1faSGeorge Wilson 	if (dump_opt['h'])
32698f18d1faSGeorge Wilson 		dump_history(spa);
32708f18d1faSGeorge Wilson 
327129bdd2f9SPavel Zakharov 	if (rc != 0) {
327229bdd2f9SPavel Zakharov 		dump_debug_buffer();
3273fa9e4066Sahrens 		exit(rc);
327429bdd2f9SPavel Zakharov 	}
3275fa9e4066Sahrens }
3276fa9e4066Sahrens 
327744cd46caSbillm #define	ZDB_FLAG_CHECKSUM	0x0001
327844cd46caSbillm #define	ZDB_FLAG_DECOMPRESS	0x0002
327944cd46caSbillm #define	ZDB_FLAG_BSWAP		0x0004
328044cd46caSbillm #define	ZDB_FLAG_GBH		0x0008
328144cd46caSbillm #define	ZDB_FLAG_INDIRECT	0x0010
328244cd46caSbillm #define	ZDB_FLAG_PHYS		0x0020
328344cd46caSbillm #define	ZDB_FLAG_RAW		0x0040
328444cd46caSbillm #define	ZDB_FLAG_PRINT_BLKPTR	0x0080
328544cd46caSbillm 
328644cd46caSbillm int flagbits[256];
328744cd46caSbillm 
328844cd46caSbillm static void
328944cd46caSbillm zdb_print_blkptr(blkptr_t *bp, int flags)
329044cd46caSbillm {
3291b24ab676SJeff Bonwick 	char blkbuf[BP_SPRINTF_LEN];
329244cd46caSbillm 
329344cd46caSbillm 	if (flags & ZDB_FLAG_BSWAP)
329444cd46caSbillm 		byteswap_uint64_array((void *)bp, sizeof (blkptr_t));
3295b24ab676SJeff Bonwick 
329643466aaeSMax Grossman 	snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
3297b24ab676SJeff Bonwick 	(void) printf("%s\n", blkbuf);
329844cd46caSbillm }
329944cd46caSbillm 
330044cd46caSbillm static void
330144cd46caSbillm zdb_dump_indirect(blkptr_t *bp, int nbps, int flags)
330244cd46caSbillm {
330344cd46caSbillm 	int i;
330444cd46caSbillm 
330544cd46caSbillm 	for (i = 0; i < nbps; i++)
330644cd46caSbillm 		zdb_print_blkptr(&bp[i], flags);
330744cd46caSbillm }
330844cd46caSbillm 
330944cd46caSbillm static void
331044cd46caSbillm zdb_dump_gbh(void *buf, int flags)
331144cd46caSbillm {
331244cd46caSbillm 	zdb_dump_indirect((blkptr_t *)buf, SPA_GBH_NBLKPTRS, flags);
331344cd46caSbillm }
331444cd46caSbillm 
331544cd46caSbillm static void
331644cd46caSbillm zdb_dump_block_raw(void *buf, uint64_t size, int flags)
331744cd46caSbillm {
331844cd46caSbillm 	if (flags & ZDB_FLAG_BSWAP)
331944cd46caSbillm 		byteswap_uint64_array(buf, size);
3320b24ab676SJeff Bonwick 	(void) write(1, buf, size);
332144cd46caSbillm }
332244cd46caSbillm 
332344cd46caSbillm static void
332444cd46caSbillm zdb_dump_block(char *label, void *buf, uint64_t size, int flags)
332544cd46caSbillm {
332644cd46caSbillm 	uint64_t *d = (uint64_t *)buf;
332744cd46caSbillm 	int nwords = size / sizeof (uint64_t);
332844cd46caSbillm 	int do_bswap = !!(flags & ZDB_FLAG_BSWAP);
332944cd46caSbillm 	int i, j;
333044cd46caSbillm 	char *hdr, *c;
333144cd46caSbillm 
333244cd46caSbillm 
333344cd46caSbillm 	if (do_bswap)
333444cd46caSbillm 		hdr = " 7 6 5 4 3 2 1 0   f e d c b a 9 8";
333544cd46caSbillm 	else
333644cd46caSbillm 		hdr = " 0 1 2 3 4 5 6 7   8 9 a b c d e f";
333744cd46caSbillm 
333844cd46caSbillm 	(void) printf("\n%s\n%6s   %s  0123456789abcdef\n", label, "", hdr);
333944cd46caSbillm 
334044cd46caSbillm 	for (i = 0; i < nwords; i += 2) {
334144cd46caSbillm 		(void) printf("%06llx:  %016llx  %016llx  ",
334244cd46caSbillm 		    (u_longlong_t)(i * sizeof (uint64_t)),
334344cd46caSbillm 		    (u_longlong_t)(do_bswap ? BSWAP_64(d[i]) : d[i]),
334444cd46caSbillm 		    (u_longlong_t)(do_bswap ? BSWAP_64(d[i + 1]) : d[i + 1]));
334544cd46caSbillm 
334644cd46caSbillm 		c = (char *)&d[i];
334744cd46caSbillm 		for (j = 0; j < 2 * sizeof (uint64_t); j++)
334844cd46caSbillm 			(void) printf("%c", isprint(c[j]) ? c[j] : '.');
334944cd46caSbillm 		(void) printf("\n");
335044cd46caSbillm 	}
335144cd46caSbillm }
335244cd46caSbillm 
335344cd46caSbillm /*
335444cd46caSbillm  * There are two acceptable formats:
335544cd46caSbillm  *	leaf_name	  - For example: c1t0d0 or /tmp/ztest.0a
335644cd46caSbillm  *	child[.child]*    - For example: 0.1.1
335744cd46caSbillm  *
335844cd46caSbillm  * The second form can be used to specify arbitrary vdevs anywhere
335944cd46caSbillm  * in the heirarchy.  For example, in a pool with a mirror of
336044cd46caSbillm  * RAID-Zs, you can specify either RAID-Z vdev with 0.0 or 0.1 .
336144cd46caSbillm  */
336244cd46caSbillm static vdev_t *
336344cd46caSbillm zdb_vdev_lookup(vdev_t *vdev, char *path)
336444cd46caSbillm {
336544cd46caSbillm 	char *s, *p, *q;
336644cd46caSbillm 	int i;
336744cd46caSbillm 
336844cd46caSbillm 	if (vdev == NULL)
336944cd46caSbillm 		return (NULL);
337044cd46caSbillm 
337144cd46caSbillm 	/* First, assume the x.x.x.x format */
337244cd46caSbillm 	i = (int)strtoul(path, &s, 10);
337344cd46caSbillm 	if (s == path || (s && *s != '.' && *s != '\0'))
337444cd46caSbillm 		goto name;
337544cd46caSbillm 	if (i < 0 || i >= vdev->vdev_children)
337644cd46caSbillm 		return (NULL);
337744cd46caSbillm 
337844cd46caSbillm 	vdev = vdev->vdev_child[i];
337944cd46caSbillm 	if (*s == '\0')
338044cd46caSbillm 		return (vdev);
338144cd46caSbillm 	return (zdb_vdev_lookup(vdev, s+1));
338244cd46caSbillm 
338344cd46caSbillm name:
338444cd46caSbillm 	for (i = 0; i < vdev->vdev_children; i++) {
338544cd46caSbillm 		vdev_t *vc = vdev->vdev_child[i];
338644cd46caSbillm 
338744cd46caSbillm 		if (vc->vdev_path == NULL) {
338844cd46caSbillm 			vc = zdb_vdev_lookup(vc, path);
338944cd46caSbillm 			if (vc == NULL)
339044cd46caSbillm 				continue;
339144cd46caSbillm 			else
339244cd46caSbillm 				return (vc);
339344cd46caSbillm 		}
339444cd46caSbillm 
339544cd46caSbillm 		p = strrchr(vc->vdev_path, '/');
339644cd46caSbillm 		p = p ? p + 1 : vc->vdev_path;
339744cd46caSbillm 		q = &vc->vdev_path[strlen(vc->vdev_path) - 2];
339844cd46caSbillm 
339944cd46caSbillm 		if (strcmp(vc->vdev_path, path) == 0)
340044cd46caSbillm 			return (vc);
340144cd46caSbillm 		if (strcmp(p, path) == 0)
340244cd46caSbillm 			return (vc);
340344cd46caSbillm 		if (strcmp(q, "s0") == 0 && strncmp(p, path, q - p) == 0)
340444cd46caSbillm 			return (vc);
340544cd46caSbillm 	}
340644cd46caSbillm 
340744cd46caSbillm 	return (NULL);
340844cd46caSbillm }
340944cd46caSbillm 
3410770499e1SDan Kimmel /* ARGSUSED */
3411770499e1SDan Kimmel static int
3412770499e1SDan Kimmel random_get_pseudo_bytes_cb(void *buf, size_t len, void *unused)
3413770499e1SDan Kimmel {
3414770499e1SDan Kimmel 	return (random_get_pseudo_bytes(buf, len));
3415770499e1SDan Kimmel }
3416770499e1SDan Kimmel 
341744cd46caSbillm /*
341844cd46caSbillm  * Read a block from a pool and print it out.  The syntax of the
341944cd46caSbillm  * block descriptor is:
342044cd46caSbillm  *
342144cd46caSbillm  *	pool:vdev_specifier:offset:size[:flags]
342244cd46caSbillm  *
342344cd46caSbillm  *	pool           - The name of the pool you wish to read from
342444cd46caSbillm  *	vdev_specifier - Which vdev (see comment for zdb_vdev_lookup)
342544cd46caSbillm  *	offset         - offset, in hex, in bytes
342644cd46caSbillm  *	size           - Amount of data to read, in hex, in bytes
342744cd46caSbillm  *	flags          - A string of characters specifying options
342844cd46caSbillm  *		 b: Decode a blkptr at given offset within block
342944cd46caSbillm  *		*c: Calculate and display checksums
3430b24ab676SJeff Bonwick  *		 d: Decompress data before dumping
343144cd46caSbillm  *		 e: Byteswap data before dumping
3432b24ab676SJeff Bonwick  *		 g: Display data as a gang block header
3433b24ab676SJeff Bonwick  *		 i: Display as an indirect block
343444cd46caSbillm  *		 p: Do I/O to physical offset
343544cd46caSbillm  *		 r: Dump raw data to stdout
343644cd46caSbillm  *
343744cd46caSbillm  *              * = not yet implemented
343844cd46caSbillm  */
343944cd46caSbillm static void
344007428bdfSVictor Latushkin zdb_read_block(char *thing, spa_t *spa)
344144cd46caSbillm {
3442b24ab676SJeff Bonwick 	blkptr_t blk, *bp = &blk;
3443b24ab676SJeff Bonwick 	dva_t *dva = bp->blk_dva;
344444cd46caSbillm 	int flags = 0;
3445b24ab676SJeff Bonwick 	uint64_t offset = 0, size = 0, psize = 0, lsize = 0, blkptr_offset = 0;
344644cd46caSbillm 	zio_t *zio;
344744cd46caSbillm 	vdev_t *vd;
3448770499e1SDan Kimmel 	abd_t *pabd;
3449770499e1SDan Kimmel 	void *lbuf, *buf;
345007428bdfSVictor Latushkin 	char *s, *p, *dup, *vdev, *flagstr;
3451b24ab676SJeff Bonwick 	int i, error;
345244cd46caSbillm 
345344cd46caSbillm 	dup = strdup(thing);
345444cd46caSbillm 	s = strtok(dup, ":");
345544cd46caSbillm 	vdev = s ? s : "";
345644cd46caSbillm 	s = strtok(NULL, ":");
345744cd46caSbillm 	offset = strtoull(s ? s : "", NULL, 16);
345844cd46caSbillm 	s = strtok(NULL, ":");
345944cd46caSbillm 	size = strtoull(s ? s : "", NULL, 16);
346044cd46caSbillm 	s = strtok(NULL, ":");
346144cd46caSbillm 	flagstr = s ? s : "";
346244cd46caSbillm 
346344cd46caSbillm 	s = NULL;
346444cd46caSbillm 	if (size == 0)
346544cd46caSbillm 		s = "size must not be zero";
346644cd46caSbillm 	if (!IS_P2ALIGNED(size, DEV_BSIZE))
346744cd46caSbillm 		s = "size must be a multiple of sector size";
346844cd46caSbillm 	if (!IS_P2ALIGNED(offset, DEV_BSIZE))
346944cd46caSbillm 		s = "offset must be a multiple of sector size";
347044cd46caSbillm 	if (s) {
347144cd46caSbillm 		(void) printf("Invalid block specifier: %s  - %s\n", thing, s);
347244cd46caSbillm 		free(dup);
347344cd46caSbillm 		return;
347444cd46caSbillm 	}
347544cd46caSbillm 
347644cd46caSbillm 	for (s = strtok(flagstr, ":"); s; s = strtok(NULL, ":")) {
347744cd46caSbillm 		for (i = 0; flagstr[i]; i++) {
34785ad82045Snd 			int bit = flagbits[(uchar_t)flagstr[i]];
347944cd46caSbillm 
348044cd46caSbillm 			if (bit == 0) {
348144cd46caSbillm 				(void) printf("***Invalid flag: %c\n",
348244cd46caSbillm 				    flagstr[i]);
348344cd46caSbillm 				continue;
348444cd46caSbillm 			}
348544cd46caSbillm 			flags |= bit;
348644cd46caSbillm 
348744cd46caSbillm 			/* If it's not something with an argument, keep going */
3488b24ab676SJeff Bonwick 			if ((bit & (ZDB_FLAG_CHECKSUM |
348944cd46caSbillm 			    ZDB_FLAG_PRINT_BLKPTR)) == 0)
349044cd46caSbillm 				continue;
349144cd46caSbillm 
349244cd46caSbillm 			p = &flagstr[i + 1];
349344cd46caSbillm 			if (bit == ZDB_FLAG_PRINT_BLKPTR)
349444cd46caSbillm 				blkptr_offset = strtoull(p, &p, 16);
349544cd46caSbillm 			if (*p != ':' && *p != '\0') {
349644cd46caSbillm 				(void) printf("***Invalid flag arg: '%s'\n", s);
349744cd46caSbillm 				free(dup);
349844cd46caSbillm 				return;
349944cd46caSbillm 			}
350044cd46caSbillm 		}
350144cd46caSbillm 	}
350244cd46caSbillm 
350344cd46caSbillm 	vd = zdb_vdev_lookup(spa->spa_root_vdev, vdev);
350444cd46caSbillm 	if (vd == NULL) {
350544cd46caSbillm 		(void) printf("***Invalid vdev: %s\n", vdev);
350644cd46caSbillm 		free(dup);
350744cd46caSbillm 		return;
350844cd46caSbillm 	} else {
350944cd46caSbillm 		if (vd->vdev_path)
3510b24ab676SJeff Bonwick 			(void) fprintf(stderr, "Found vdev: %s\n",
3511b24ab676SJeff Bonwick 			    vd->vdev_path);
351244cd46caSbillm 		else
3513b24ab676SJeff Bonwick 			(void) fprintf(stderr, "Found vdev type: %s\n",
351444cd46caSbillm 			    vd->vdev_ops->vdev_op_type);
351544cd46caSbillm 	}
351644cd46caSbillm 
3517b24ab676SJeff Bonwick 	psize = size;
3518b24ab676SJeff Bonwick 	lsize = size;
351944cd46caSbillm 
3520770499e1SDan Kimmel 	pabd = abd_alloc_linear(SPA_MAXBLOCKSIZE, B_FALSE);
3521b24ab676SJeff Bonwick 	lbuf = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
3522b24ab676SJeff Bonwick 
3523b24ab676SJeff Bonwick 	BP_ZERO(bp);
3524b24ab676SJeff Bonwick 
3525b24ab676SJeff Bonwick 	DVA_SET_VDEV(&dva[0], vd->vdev_id);
3526b24ab676SJeff Bonwick 	DVA_SET_OFFSET(&dva[0], offset);
3527b24ab676SJeff Bonwick 	DVA_SET_GANG(&dva[0], !!(flags & ZDB_FLAG_GBH));
3528b24ab676SJeff Bonwick 	DVA_SET_ASIZE(&dva[0], vdev_psize_to_asize(vd, psize));
3529b24ab676SJeff Bonwick 
3530b24ab676SJeff Bonwick 	BP_SET_BIRTH(bp, TXG_INITIAL, TXG_INITIAL);
3531b24ab676SJeff Bonwick 
3532b24ab676SJeff Bonwick 	BP_SET_LSIZE(bp, lsize);
3533b24ab676SJeff Bonwick 	BP_SET_PSIZE(bp, psize);
3534b24ab676SJeff Bonwick 	BP_SET_COMPRESS(bp, ZIO_COMPRESS_OFF);
3535b24ab676SJeff Bonwick 	BP_SET_CHECKSUM(bp, ZIO_CHECKSUM_OFF);
3536b24ab676SJeff Bonwick 	BP_SET_TYPE(bp, DMU_OT_NONE);
3537b24ab676SJeff Bonwick 	BP_SET_LEVEL(bp, 0);
3538b24ab676SJeff Bonwick 	BP_SET_DEDUP(bp, 0);
3539b24ab676SJeff Bonwick 	BP_SET_BYTEORDER(bp, ZFS_HOST_BYTEORDER);
354044cd46caSbillm 
3541e14bb325SJeff Bonwick 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
354244cd46caSbillm 	zio = zio_root(spa, NULL, NULL, 0);
3543b24ab676SJeff Bonwick 
3544b24ab676SJeff Bonwick 	if (vd == vd->vdev_top) {
3545b24ab676SJeff Bonwick 		/*
3546b24ab676SJeff Bonwick 		 * Treat this as a normal block read.
3547b24ab676SJeff Bonwick 		 */
3548770499e1SDan Kimmel 		zio_nowait(zio_read(zio, spa, bp, pabd, psize, NULL, NULL,
3549b24ab676SJeff Bonwick 		    ZIO_PRIORITY_SYNC_READ,
3550b24ab676SJeff Bonwick 		    ZIO_FLAG_CANFAIL | ZIO_FLAG_RAW, NULL));
3551b24ab676SJeff Bonwick 	} else {
3552b24ab676SJeff Bonwick 		/*
3553b24ab676SJeff Bonwick 		 * Treat this as a vdev child I/O.
3554b24ab676SJeff Bonwick 		 */
3555770499e1SDan Kimmel 		zio_nowait(zio_vdev_child_io(zio, bp, vd, offset, pabd,
3556770499e1SDan Kimmel 		    psize, ZIO_TYPE_READ, ZIO_PRIORITY_SYNC_READ,
3557b24ab676SJeff Bonwick 		    ZIO_FLAG_DONT_CACHE | ZIO_FLAG_DONT_QUEUE |
3558b24ab676SJeff Bonwick 		    ZIO_FLAG_DONT_PROPAGATE | ZIO_FLAG_DONT_RETRY |
3559b24ab676SJeff Bonwick 		    ZIO_FLAG_CANFAIL | ZIO_FLAG_RAW, NULL, NULL));
3560b24ab676SJeff Bonwick 	}
3561b24ab676SJeff Bonwick 
356244cd46caSbillm 	error = zio_wait(zio);
3563e14bb325SJeff Bonwick 	spa_config_exit(spa, SCL_STATE, FTAG);
356444cd46caSbillm 
356544cd46caSbillm 	if (error) {
356644cd46caSbillm 		(void) printf("Read of %s failed, error: %d\n", thing, error);
356744cd46caSbillm 		goto out;
356844cd46caSbillm 	}
356944cd46caSbillm 
3570b24ab676SJeff Bonwick 	if (flags & ZDB_FLAG_DECOMPRESS) {
3571b24ab676SJeff Bonwick 		/*
3572b24ab676SJeff Bonwick 		 * We don't know how the data was compressed, so just try
3573b24ab676SJeff Bonwick 		 * every decompress function at every inflated blocksize.
3574b24ab676SJeff Bonwick 		 */
3575b24ab676SJeff Bonwick 		enum zio_compress c;
3576b24ab676SJeff Bonwick 		void *pbuf2 = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
3577b24ab676SJeff Bonwick 		void *lbuf2 = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
3578b24ab676SJeff Bonwick 
3579770499e1SDan Kimmel 		abd_copy_to_buf(pbuf2, pabd, psize);
3580b24ab676SJeff Bonwick 
3581770499e1SDan Kimmel 		VERIFY0(abd_iterate_func(pabd, psize, SPA_MAXBLOCKSIZE - psize,
3582770499e1SDan Kimmel 		    random_get_pseudo_bytes_cb, NULL));
3583b24ab676SJeff Bonwick 
3584770499e1SDan Kimmel 		VERIFY0(random_get_pseudo_bytes((uint8_t *)pbuf2 + psize,
3585770499e1SDan Kimmel 		    SPA_MAXBLOCKSIZE - psize));
3586b24ab676SJeff Bonwick 
3587b24ab676SJeff Bonwick 		for (lsize = SPA_MAXBLOCKSIZE; lsize > psize;
3588b24ab676SJeff Bonwick 		    lsize -= SPA_MINBLOCKSIZE) {
3589b24ab676SJeff Bonwick 			for (c = 0; c < ZIO_COMPRESS_FUNCTIONS; c++) {
3590770499e1SDan Kimmel 				if (zio_decompress_data(c, pabd,
3591770499e1SDan Kimmel 				    lbuf, psize, lsize) == 0 &&
3592770499e1SDan Kimmel 				    zio_decompress_data_buf(c, pbuf2,
3593770499e1SDan Kimmel 				    lbuf2, psize, lsize) == 0 &&
3594b24ab676SJeff Bonwick 				    bcmp(lbuf, lbuf2, lsize) == 0)
3595b24ab676SJeff Bonwick 					break;
3596b24ab676SJeff Bonwick 			}
3597b24ab676SJeff Bonwick 			if (c != ZIO_COMPRESS_FUNCTIONS)
3598b24ab676SJeff Bonwick 				break;
3599b24ab676SJeff Bonwick 			lsize -= SPA_MINBLOCKSIZE;
3600b24ab676SJeff Bonwick 		}
3601b24ab676SJeff Bonwick 
3602b24ab676SJeff Bonwick 		umem_free(pbuf2, SPA_MAXBLOCKSIZE);
3603b24ab676SJeff Bonwick 		umem_free(lbuf2, SPA_MAXBLOCKSIZE);
3604b24ab676SJeff Bonwick 
3605b24ab676SJeff Bonwick 		if (lsize <= psize) {
3606b24ab676SJeff Bonwick 			(void) printf("Decompress of %s failed\n", thing);
3607b24ab676SJeff Bonwick 			goto out;
3608b24ab676SJeff Bonwick 		}
3609b24ab676SJeff Bonwick 		buf = lbuf;
3610b24ab676SJeff Bonwick 		size = lsize;
3611b24ab676SJeff Bonwick 	} else {
3612770499e1SDan Kimmel 		buf = abd_to_buf(pabd);
3613b24ab676SJeff Bonwick 		size = psize;
3614b24ab676SJeff Bonwick 	}
3615b24ab676SJeff Bonwick 
361644cd46caSbillm 	if (flags & ZDB_FLAG_PRINT_BLKPTR)
361744cd46caSbillm 		zdb_print_blkptr((blkptr_t *)(void *)
361844cd46caSbillm 		    ((uintptr_t)buf + (uintptr_t)blkptr_offset), flags);
361944cd46caSbillm 	else if (flags & ZDB_FLAG_RAW)
362044cd46caSbillm 		zdb_dump_block_raw(buf, size, flags);
362144cd46caSbillm 	else if (flags & ZDB_FLAG_INDIRECT)
362244cd46caSbillm 		zdb_dump_indirect((blkptr_t *)buf, size / sizeof (blkptr_t),
362344cd46caSbillm 		    flags);
362444cd46caSbillm 	else if (flags & ZDB_FLAG_GBH)
362544cd46caSbillm 		zdb_dump_gbh(buf, flags);
362644cd46caSbillm 	else
362744cd46caSbillm 		zdb_dump_block(thing, buf, size, flags);
362844cd46caSbillm 
362944cd46caSbillm out:
3630770499e1SDan Kimmel 	abd_free(pabd);
3631b24ab676SJeff Bonwick 	umem_free(lbuf, SPA_MAXBLOCKSIZE);
363244cd46caSbillm 	free(dup);
363344cd46caSbillm }
363444cd46caSbillm 
3635*4923c69fSMatthew Ahrens static void
3636*4923c69fSMatthew Ahrens zdb_embedded_block(char *thing)
3637*4923c69fSMatthew Ahrens {
3638*4923c69fSMatthew Ahrens 	blkptr_t bp = { 0 };
3639*4923c69fSMatthew Ahrens 	unsigned long long *words = (void *)&bp;
3640*4923c69fSMatthew Ahrens 	char buf[SPA_MAXBLOCKSIZE];
3641*4923c69fSMatthew Ahrens 	int err;
3642*4923c69fSMatthew Ahrens 
3643*4923c69fSMatthew Ahrens 	err = sscanf(thing, "%llx:%llx:%llx:%llx:%llx:%llx:%llx:%llx:"
3644*4923c69fSMatthew Ahrens 	    "%llx:%llx:%llx:%llx:%llx:%llx:%llx:%llx",
3645*4923c69fSMatthew Ahrens 	    words + 0, words + 1, words + 2, words + 3,
3646*4923c69fSMatthew Ahrens 	    words + 4, words + 5, words + 6, words + 7,
3647*4923c69fSMatthew Ahrens 	    words + 8, words + 9, words + 10, words + 11,
3648*4923c69fSMatthew Ahrens 	    words + 12, words + 13, words + 14, words + 15);
3649*4923c69fSMatthew Ahrens 	if (err != 16) {
3650*4923c69fSMatthew Ahrens 		(void) printf("invalid input format\n");
3651*4923c69fSMatthew Ahrens 		exit(1);
3652*4923c69fSMatthew Ahrens 	}
3653*4923c69fSMatthew Ahrens 	ASSERT3U(BPE_GET_LSIZE(&bp), <=, SPA_MAXBLOCKSIZE);
3654*4923c69fSMatthew Ahrens 	err = decode_embedded_bp(&bp, buf, BPE_GET_LSIZE(&bp));
3655*4923c69fSMatthew Ahrens 	if (err != 0) {
3656*4923c69fSMatthew Ahrens 		(void) printf("decode failed: %u\n", err);
3657*4923c69fSMatthew Ahrens 		exit(1);
3658*4923c69fSMatthew Ahrens 	}
3659*4923c69fSMatthew Ahrens 	zdb_dump_block_raw(buf, BPE_GET_LSIZE(&bp), 0);
3660*4923c69fSMatthew Ahrens }
3661*4923c69fSMatthew Ahrens 
3662de6628f0Sck static boolean_t
36633ad6c7f9SVictor Latushkin pool_match(nvlist_t *cfg, char *tgt)
3664de6628f0Sck {
36653ad6c7f9SVictor Latushkin 	uint64_t v, guid = strtoull(tgt, NULL, 0);
3666de6628f0Sck 	char *s;
3667de6628f0Sck 
3668de6628f0Sck 	if (guid != 0) {
36693ad6c7f9SVictor Latushkin 		if (nvlist_lookup_uint64(cfg, ZPOOL_CONFIG_POOL_GUID, &v) == 0)
36703ad6c7f9SVictor Latushkin 			return (v == guid);
3671de6628f0Sck 	} else {
36723ad6c7f9SVictor Latushkin 		if (nvlist_lookup_string(cfg, ZPOOL_CONFIG_POOL_NAME, &s) == 0)
36733ad6c7f9SVictor Latushkin 			return (strcmp(s, tgt) == 0);
3674de6628f0Sck 	}
36753ad6c7f9SVictor Latushkin 	return (B_FALSE);
3676de6628f0Sck }
3677de6628f0Sck 
36783ad6c7f9SVictor Latushkin static char *
36793ad6c7f9SVictor Latushkin find_zpool(char **target, nvlist_t **configp, int dirc, char **dirv)
3680de6628f0Sck {
3681de6628f0Sck 	nvlist_t *pools;
3682de6628f0Sck 	nvlist_t *match = NULL;
36833ad6c7f9SVictor Latushkin 	char *name = NULL;
36843ad6c7f9SVictor Latushkin 	char *sepp = NULL;
36859adfa60dSMatthew Ahrens 	char sep = '\0';
36863ad6c7f9SVictor Latushkin 	int count = 0;
3687d41c4376SMark J Musante 	importargs_t args = { 0 };
3688d41c4376SMark J Musante 
3689d41c4376SMark J Musante 	args.paths = dirc;
3690d41c4376SMark J Musante 	args.path = dirv;
3691d41c4376SMark J Musante 	args.can_be_active = B_TRUE;
3692de6628f0Sck 
36933ad6c7f9SVictor Latushkin 	if ((sepp = strpbrk(*target, "/@")) != NULL) {
36943ad6c7f9SVictor Latushkin 		sep = *sepp;
36953ad6c7f9SVictor Latushkin 		*sepp = '\0';
36963ad6c7f9SVictor Latushkin 	}
36973ad6c7f9SVictor Latushkin 
3698d41c4376SMark J Musante 	pools = zpool_search_import(g_zfs, &args);
3699de6628f0Sck 
3700de6628f0Sck 	if (pools != NULL) {
3701de6628f0Sck 		nvpair_t *elem = NULL;
3702de6628f0Sck 		while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) {
3703de6628f0Sck 			verify(nvpair_value_nvlist(elem, configp) == 0);
37043ad6c7f9SVictor Latushkin 			if (pool_match(*configp, *target)) {
37053ad6c7f9SVictor Latushkin 				count++;
3706de6628f0Sck 				if (match != NULL) {
37073ad6c7f9SVictor Latushkin 					/* print previously found config */
37083ad6c7f9SVictor Latushkin 					if (name != NULL) {
37093ad6c7f9SVictor Latushkin 						(void) printf("%s\n", name);
37103ad6c7f9SVictor Latushkin 						dump_nvlist(match, 8);
37113ad6c7f9SVictor Latushkin 						name = NULL;
37123ad6c7f9SVictor Latushkin 					}
37133ad6c7f9SVictor Latushkin 					(void) printf("%s\n",
37143ad6c7f9SVictor Latushkin 					    nvpair_name(elem));
37153ad6c7f9SVictor Latushkin 					dump_nvlist(*configp, 8);
3716de6628f0Sck 				} else {
3717de6628f0Sck 					match = *configp;
37183ad6c7f9SVictor Latushkin 					name = nvpair_name(elem);
3719de6628f0Sck 				}
3720de6628f0Sck 			}
3721de6628f0Sck 		}
3722de6628f0Sck 	}
37233ad6c7f9SVictor Latushkin 	if (count > 1)
37243ad6c7f9SVictor Latushkin 		(void) fatal("\tMatched %d pools - use pool GUID "
37253ad6c7f9SVictor Latushkin 		    "instead of pool name or \n"
37263ad6c7f9SVictor Latushkin 		    "\tpool name part of a dataset name to select pool", count);
37273ad6c7f9SVictor Latushkin 
37283ad6c7f9SVictor Latushkin 	if (sepp)
37293ad6c7f9SVictor Latushkin 		*sepp = sep;
37303ad6c7f9SVictor Latushkin 	/*
37313ad6c7f9SVictor Latushkin 	 * If pool GUID was specified for pool id, replace it with pool name
37323ad6c7f9SVictor Latushkin 	 */
37333ad6c7f9SVictor Latushkin 	if (name && (strstr(*target, name) != *target)) {
37343ad6c7f9SVictor Latushkin 		int sz = 1 + strlen(name) + ((sepp) ? strlen(sepp) : 0);
37353ad6c7f9SVictor Latushkin 
37363ad6c7f9SVictor Latushkin 		*target = umem_alloc(sz, UMEM_NOFAIL);
37373ad6c7f9SVictor Latushkin 		(void) snprintf(*target, sz, "%s%s", name, sepp ? sepp : "");
37383ad6c7f9SVictor Latushkin 	}
3739de6628f0Sck 
37403ad6c7f9SVictor Latushkin 	*configp = name ? match : NULL;
3741de6628f0Sck 
37423ad6c7f9SVictor Latushkin 	return (name);
3743de6628f0Sck }
3744de6628f0Sck 
3745fa9e4066Sahrens int
3746fa9e4066Sahrens main(int argc, char **argv)
3747fa9e4066Sahrens {
3748fa9e4066Sahrens 	int i, c;
3749fa9e4066Sahrens 	struct rlimit rl = { 1024, 1024 };
37503ad6c7f9SVictor Latushkin 	spa_t *spa = NULL;
3751fa9e4066Sahrens 	objset_t *os = NULL;
3752fa9e4066Sahrens 	int dump_all = 1;
3753fa9e4066Sahrens 	int verbose = 0;
3754c8ee1847SVictor Latushkin 	int error = 0;
37553ad6c7f9SVictor Latushkin 	char **searchdirs = NULL;
37563ad6c7f9SVictor Latushkin 	int nsearch = 0;
37573ad6c7f9SVictor Latushkin 	char *target;
3758468c413aSTim Haley 	nvlist_t *policy = NULL;
3759468c413aSTim Haley 	uint64_t max_txg = UINT64_MAX;
3760dfd5965fSRichard Yao 	int flags = ZFS_IMPORT_MISSING_LOG;
3761c8ee1847SVictor Latushkin 	int rewind = ZPOOL_NEVER_REWIND;
3762ae24175bSCyril Plisko 	char *spa_config_path_env;
3763b702644aSTim Chase 	boolean_t target_is_spa = B_TRUE;
3764fa9e4066Sahrens 
3765fa9e4066Sahrens 	(void) setrlimit(RLIMIT_NOFILE, &rl);
3766004388ebScasper 	(void) enable_extended_FILE_stdio(-1, -1);
3767fa9e4066Sahrens 
3768fa9e4066Sahrens 	dprintf_setup(&argc, argv);
3769fa9e4066Sahrens 
3770ae24175bSCyril Plisko 	/*
3771ae24175bSCyril Plisko 	 * If there is an environment variable SPA_CONFIG_PATH it overrides
3772ae24175bSCyril Plisko 	 * default spa_config_path setting. If -U flag is specified it will
3773ae24175bSCyril Plisko 	 * override this environment variable settings once again.
3774ae24175bSCyril Plisko 	 */
3775ae24175bSCyril Plisko 	spa_config_path_env = getenv("SPA_CONFIG_PATH");
3776ae24175bSCyril Plisko 	if (spa_config_path_env != NULL)
3777ae24175bSCyril Plisko 		spa_config_path = spa_config_path_env;
3778ae24175bSCyril Plisko 
3779df15e419SMatthew Ahrens 	while ((c = getopt(argc, argv,
3780*4923c69fSMatthew Ahrens 	    "AbcCdDeEFGhiI:lLmMo:Op:PqRsSt:uU:vVx:X")) != -1) {
3781fa9e4066Sahrens 		switch (c) {
3782fa9e4066Sahrens 		case 'b':
3783fa9e4066Sahrens 		case 'c':
3784ed61ec1dSYuri Pankov 		case 'C':
3785b24ab676SJeff Bonwick 		case 'd':
3786ed61ec1dSYuri Pankov 		case 'D':
3787*4923c69fSMatthew Ahrens 		case 'E':
3788ed61ec1dSYuri Pankov 		case 'G':
3789b24ab676SJeff Bonwick 		case 'h':
3790b24ab676SJeff Bonwick 		case 'i':
3791b24ab676SJeff Bonwick 		case 'l':
3792d6e555bdSGeorge Wilson 		case 'm':
37932e4c9986SGeorge Wilson 		case 'M':
3794ed61ec1dSYuri Pankov 		case 'O':
379544cd46caSbillm 		case 'R':
3796ed61ec1dSYuri Pankov 		case 's':
3797b24ab676SJeff Bonwick 		case 'S':
3798ed61ec1dSYuri Pankov 		case 'u':
3799fa9e4066Sahrens 			dump_opt[c]++;
3800fa9e4066Sahrens 			dump_all = 0;
3801fa9e4066Sahrens 			break;
3802feef89cfSVictor Latushkin 		case 'A':
3803ed61ec1dSYuri Pankov 		case 'e':
3804c8ee1847SVictor Latushkin 		case 'F':
380582a0a985SVictor Latushkin 		case 'L':
38063f9d6ad7SLin Ling 		case 'P':
380764723e36SYuri Pankov 		case 'q':
3808ed61ec1dSYuri Pankov 		case 'X':
380982a0a985SVictor Latushkin 			dump_opt[c]++;
381082a0a985SVictor Latushkin 			break;
3811ed61ec1dSYuri Pankov 		/* NB: Sort single match options below. */
38122e4c9986SGeorge Wilson 		case 'I':
381331d7e8faSGeorge Wilson 			max_inflight = strtoull(optarg, NULL, 0);
381431d7e8faSGeorge Wilson 			if (max_inflight == 0) {
381531d7e8faSGeorge Wilson 				(void) fprintf(stderr, "maximum number "
381631d7e8faSGeorge Wilson 				    "of inflight I/Os must be greater "
381731d7e8faSGeorge Wilson 				    "than 0\n");
381831d7e8faSGeorge Wilson 				usage();
381931d7e8faSGeorge Wilson 			}
382031d7e8faSGeorge Wilson 			break;
3821ed61ec1dSYuri Pankov 		case 'o':
3822ed61ec1dSYuri Pankov 			error = set_global_var(optarg);
3823ed61ec1dSYuri Pankov 			if (error != 0)
3824ed61ec1dSYuri Pankov 				usage();
3825ed61ec1dSYuri Pankov 			break;
3826de6628f0Sck 		case 'p':
38273ad6c7f9SVictor Latushkin 			if (searchdirs == NULL) {
38283ad6c7f9SVictor Latushkin 				searchdirs = umem_alloc(sizeof (char *),
38293ad6c7f9SVictor Latushkin 				    UMEM_NOFAIL);
38303ad6c7f9SVictor Latushkin 			} else {
38313ad6c7f9SVictor Latushkin 				char **tmp = umem_alloc((nsearch + 1) *
38323ad6c7f9SVictor Latushkin 				    sizeof (char *), UMEM_NOFAIL);
38333ad6c7f9SVictor Latushkin 				bcopy(searchdirs, tmp, nsearch *
38343ad6c7f9SVictor Latushkin 				    sizeof (char *));
38353ad6c7f9SVictor Latushkin 				umem_free(searchdirs,
38363ad6c7f9SVictor Latushkin 				    nsearch * sizeof (char *));
38373ad6c7f9SVictor Latushkin 				searchdirs = tmp;
38383ad6c7f9SVictor Latushkin 			}
38393ad6c7f9SVictor Latushkin 			searchdirs[nsearch++] = optarg;
3840de6628f0Sck 			break;
38412e551927SVictor Latushkin 		case 't':
3842468c413aSTim Haley 			max_txg = strtoull(optarg, NULL, 0);
3843468c413aSTim Haley 			if (max_txg < TXG_INITIAL) {
38442e551927SVictor Latushkin 				(void) fprintf(stderr, "incorrect txg "
38452e551927SVictor Latushkin 				    "specified: %s\n", optarg);
38462e551927SVictor Latushkin 				usage();
38472e551927SVictor Latushkin 			}
38482e551927SVictor Latushkin 			break;
3849b24ab676SJeff Bonwick 		case 'U':
3850b24ab676SJeff Bonwick 			spa_config_path = optarg;
3851*4923c69fSMatthew Ahrens 			if (spa_config_path[0] != '/') {
3852*4923c69fSMatthew Ahrens 				(void) fprintf(stderr,
3853*4923c69fSMatthew Ahrens 				    "cachefile must be an absolute path "
3854*4923c69fSMatthew Ahrens 				    "(i.e. start with a slash)\n");
3855*4923c69fSMatthew Ahrens 				usage();
3856*4923c69fSMatthew Ahrens 			}
3857b24ab676SJeff Bonwick 			break;
38582e4c9986SGeorge Wilson 		case 'v':
38592e4c9986SGeorge Wilson 			verbose++;
38602e4c9986SGeorge Wilson 			break;
3861dfd5965fSRichard Yao 		case 'V':
3862dfd5965fSRichard Yao 			flags = ZFS_IMPORT_VERBATIM;
3863dfd5965fSRichard Yao 			break;
38642e4c9986SGeorge Wilson 		case 'x':
38652e4c9986SGeorge Wilson 			vn_dumpdir = optarg;
38662e4c9986SGeorge Wilson 			break;
3867fa9e4066Sahrens 		default:
3868fa9e4066Sahrens 			usage();
3869fa9e4066Sahrens 			break;
3870fa9e4066Sahrens 		}
3871fa9e4066Sahrens 	}
3872fa9e4066Sahrens 
38733ad6c7f9SVictor Latushkin 	if (!dump_opt['e'] && searchdirs != NULL) {
387488b7b0f2SMatthew Ahrens 		(void) fprintf(stderr, "-p option requires use of -e\n");
387588b7b0f2SMatthew Ahrens 		usage();
387688b7b0f2SMatthew Ahrens 	}
3877de6628f0Sck 
387806be9802SMatthew Ahrens 	/*
387906be9802SMatthew Ahrens 	 * ZDB does not typically re-read blocks; therefore limit the ARC
388006be9802SMatthew Ahrens 	 * to 256 MB, which can be used entirely for metadata.
388106be9802SMatthew Ahrens 	 */
388206be9802SMatthew Ahrens 	zfs_arc_max = zfs_arc_meta_limit = 256 * 1024 * 1024;
388306be9802SMatthew Ahrens 
3884f7950bf1SMatthew Ahrens 	/*
3885f7950bf1SMatthew Ahrens 	 * "zdb -c" uses checksum-verifying scrub i/os which are async reads.
3886f7950bf1SMatthew Ahrens 	 * "zdb -b" uses traversal prefetch which uses async reads.
3887f7950bf1SMatthew Ahrens 	 * For good performance, let several of them be active at once.
3888f7950bf1SMatthew Ahrens 	 */
3889f7950bf1SMatthew Ahrens 	zfs_vdev_async_read_max_active = 10;
3890f7950bf1SMatthew Ahrens 
38914dd77f9eSMatthew Ahrens 	/*
38924dd77f9eSMatthew Ahrens 	 * Disable reference tracking for better performance.
38934dd77f9eSMatthew Ahrens 	 */
38944dd77f9eSMatthew Ahrens 	reference_tracking_enable = B_FALSE;
38954dd77f9eSMatthew Ahrens 
3896fa9e4066Sahrens 	kernel_init(FREAD);
3897de6628f0Sck 	g_zfs = libzfs_init();
389891ebeef5Sahrens 	ASSERT(g_zfs != NULL);
3899fa9e4066Sahrens 
3900b24ab676SJeff Bonwick 	if (dump_all)
3901b24ab676SJeff Bonwick 		verbose = MAX(verbose, 1);
3902b24ab676SJeff Bonwick 
3903fa9e4066Sahrens 	for (c = 0; c < 256; c++) {
3904*4923c69fSMatthew Ahrens 		if (dump_all && strchr("AeEFlLOPRSX", c) == NULL)
3905fa9e4066Sahrens 			dump_opt[c] = 1;
3906fa9e4066Sahrens 		if (dump_opt[c])
3907fa9e4066Sahrens 			dump_opt[c] += verbose;
3908fa9e4066Sahrens 	}
3909fa9e4066Sahrens 
3910feef89cfSVictor Latushkin 	aok = (dump_opt['A'] == 1) || (dump_opt['A'] > 2);
3911feef89cfSVictor Latushkin 	zfs_recover = (dump_opt['A'] > 1);
3912feef89cfSVictor Latushkin 
3913fa9e4066Sahrens 	argc -= optind;
3914fa9e4066Sahrens 	argv += optind;
3915fa9e4066Sahrens 
391607428bdfSVictor Latushkin 	if (argc < 2 && dump_opt['R'])
391707428bdfSVictor Latushkin 		usage();
3918*4923c69fSMatthew Ahrens 
3919*4923c69fSMatthew Ahrens 	if (dump_opt['E']) {
3920*4923c69fSMatthew Ahrens 		if (argc != 1)
3921*4923c69fSMatthew Ahrens 			usage();
3922*4923c69fSMatthew Ahrens 		zdb_embedded_block(argv[0]);
3923*4923c69fSMatthew Ahrens 		return (0);
3924*4923c69fSMatthew Ahrens 	}
3925*4923c69fSMatthew Ahrens 
3926fa9e4066Sahrens 	if (argc < 1) {
39273ad6c7f9SVictor Latushkin 		if (!dump_opt['e'] && dump_opt['C']) {
3928e829d913Sck 			dump_cachefile(spa_config_path);
3929fa9e4066Sahrens 			return (0);
3930fa9e4066Sahrens 		}
3931fa9e4066Sahrens 		usage();
3932fa9e4066Sahrens 	}
3933fa9e4066Sahrens 
393464723e36SYuri Pankov 	if (dump_opt['l'])
393564723e36SYuri Pankov 		return (dump_label(argv[0]));
3936fa9e4066Sahrens 
3937ed61ec1dSYuri Pankov 	if (dump_opt['O']) {
3938ed61ec1dSYuri Pankov 		if (argc != 2)
3939ed61ec1dSYuri Pankov 			usage();
3940ed61ec1dSYuri Pankov 		dump_opt['v'] = verbose + 3;
3941ed61ec1dSYuri Pankov 		return (dump_path(argv[0], argv[1]));
3942ed61ec1dSYuri Pankov 	}
3943ed61ec1dSYuri Pankov 
3944c8ee1847SVictor Latushkin 	if (dump_opt['X'] || dump_opt['F'])
3945c8ee1847SVictor Latushkin 		rewind = ZPOOL_DO_REWIND |
3946c8ee1847SVictor Latushkin 		    (dump_opt['X'] ? ZPOOL_EXTREME_REWIND : 0);
3947c8ee1847SVictor Latushkin 
3948c8ee1847SVictor Latushkin 	if (nvlist_alloc(&policy, NV_UNIQUE_NAME_TYPE, 0) != 0 ||
3949c8ee1847SVictor Latushkin 	    nvlist_add_uint64(policy, ZPOOL_REWIND_REQUEST_TXG, max_txg) != 0 ||
3950c8ee1847SVictor Latushkin 	    nvlist_add_uint32(policy, ZPOOL_REWIND_REQUEST, rewind) != 0)
3951c8ee1847SVictor Latushkin 		fatal("internal error: %s", strerror(ENOMEM));
3952c8ee1847SVictor Latushkin 
3953c5904d13Seschrock 	error = 0;
39543ad6c7f9SVictor Latushkin 	target = argv[0];
3955990b4856Slling 
39563ad6c7f9SVictor Latushkin 	if (dump_opt['e']) {
39573ad6c7f9SVictor Latushkin 		nvlist_t *cfg = NULL;
39583ad6c7f9SVictor Latushkin 		char *name = find_zpool(&target, &cfg, nsearch, searchdirs);
3959990b4856Slling 
39603ad6c7f9SVictor Latushkin 		error = ENOENT;
39613ad6c7f9SVictor Latushkin 		if (name) {
396207428bdfSVictor Latushkin 			if (dump_opt['C'] > 1) {
396307428bdfSVictor Latushkin 				(void) printf("\nConfiguration for import:\n");
396407428bdfSVictor Latushkin 				dump_nvlist(cfg, 8);
396507428bdfSVictor Latushkin 			}
3966c8ee1847SVictor Latushkin 			if (nvlist_add_nvlist(cfg,
3967468c413aSTim Haley 			    ZPOOL_REWIND_POLICY, policy) != 0) {
3968468c413aSTim Haley 				fatal("can't open '%s': %s",
3969468c413aSTim Haley 				    target, strerror(ENOMEM));
3970468c413aSTim Haley 			}
3971dfd5965fSRichard Yao 			error = spa_import(name, cfg, NULL, flags);
3972de6628f0Sck 		}
3973c5904d13Seschrock 	}
3974c5904d13Seschrock 
3975b702644aSTim Chase 	if (strpbrk(target, "/@") != NULL) {
3976b702644aSTim Chase 		size_t targetlen;
3977b702644aSTim Chase 
3978b702644aSTim Chase 		target_is_spa = B_FALSE;
3979b702644aSTim Chase 		/*
3980b702644aSTim Chase 		 * Remove any trailing slash.  Later code would get confused
3981b702644aSTim Chase 		 * by it, but we want to allow it so that "pool/" can
3982b702644aSTim Chase 		 * indicate that we want to dump the topmost filesystem,
3983b702644aSTim Chase 		 * rather than the whole pool.
3984b702644aSTim Chase 		 */
3985b702644aSTim Chase 		targetlen = strlen(target);
3986b702644aSTim Chase 		if (targetlen != 0 && target[targetlen - 1] == '/')
3987b702644aSTim Chase 			target[targetlen - 1] = '\0';
3988b702644aSTim Chase 	}
3989b702644aSTim Chase 
3990c5904d13Seschrock 	if (error == 0) {
3991b702644aSTim Chase 		if (target_is_spa || dump_opt['R']) {
399280eb36f2SGeorge Wilson 			error = spa_open_rewind(target, &spa, FTAG, policy,
399380eb36f2SGeorge Wilson 			    NULL);
39948f18d1faSGeorge Wilson 			if (error) {
39958f18d1faSGeorge Wilson 				/*
39968f18d1faSGeorge Wilson 				 * If we're missing the log device then
39978f18d1faSGeorge Wilson 				 * try opening the pool after clearing the
39988f18d1faSGeorge Wilson 				 * log state.
39998f18d1faSGeorge Wilson 				 */
40008f18d1faSGeorge Wilson 				mutex_enter(&spa_namespace_lock);
40013ad6c7f9SVictor Latushkin 				if ((spa = spa_lookup(target)) != NULL &&
40028f18d1faSGeorge Wilson 				    spa->spa_log_state == SPA_LOG_MISSING) {
40038f18d1faSGeorge Wilson 					spa->spa_log_state = SPA_LOG_CLEAR;
40048f18d1faSGeorge Wilson 					error = 0;
40058f18d1faSGeorge Wilson 				}
40068f18d1faSGeorge Wilson 				mutex_exit(&spa_namespace_lock);
40078f18d1faSGeorge Wilson 
400880eb36f2SGeorge Wilson 				if (!error) {
400980eb36f2SGeorge Wilson 					error = spa_open_rewind(target, &spa,
401080eb36f2SGeorge Wilson 					    FTAG, policy, NULL);
401180eb36f2SGeorge Wilson 				}
40128f18d1faSGeorge Wilson 			}
401307428bdfSVictor Latushkin 		} else {
4014ed61ec1dSYuri Pankov 			error = open_objset(target, DMU_OST_ANY, FTAG, &os);
4015c5904d13Seschrock 		}
4016fa9e4066Sahrens 	}
401780eb36f2SGeorge Wilson 	nvlist_free(policy);
401880eb36f2SGeorge Wilson 
4019fa9e4066Sahrens 	if (error)
40203ad6c7f9SVictor Latushkin 		fatal("can't open '%s': %s", target, strerror(error));
4021fa9e4066Sahrens 
4022fa9e4066Sahrens 	argv++;
402307428bdfSVictor Latushkin 	argc--;
402407428bdfSVictor Latushkin 	if (!dump_opt['R']) {
402507428bdfSVictor Latushkin 		if (argc > 0) {
402607428bdfSVictor Latushkin 			zopt_objects = argc;
402707428bdfSVictor Latushkin 			zopt_object = calloc(zopt_objects, sizeof (uint64_t));
402807428bdfSVictor Latushkin 			for (i = 0; i < zopt_objects; i++) {
402907428bdfSVictor Latushkin 				errno = 0;
403007428bdfSVictor Latushkin 				zopt_object[i] = strtoull(argv[i], NULL, 0);
403107428bdfSVictor Latushkin 				if (zopt_object[i] == 0 && errno != 0)
403287219db7SVictor Latushkin 					fatal("bad number %s: %s",
403307428bdfSVictor Latushkin 					    argv[i], strerror(errno));
403407428bdfSVictor Latushkin 			}
4035fa9e4066Sahrens 		}
4036e690fb27SChristopher Siden 		if (os != NULL) {
4037e690fb27SChristopher Siden 			dump_dir(os);
4038e690fb27SChristopher Siden 		} else if (zopt_objects > 0 && !dump_opt['m']) {
4039e690fb27SChristopher Siden 			dump_dir(spa->spa_meta_objset);
4040e690fb27SChristopher Siden 		} else {
4041e690fb27SChristopher Siden 			dump_zpool(spa);
4042e690fb27SChristopher Siden 		}
4043fa9e4066Sahrens 	} else {
404407428bdfSVictor Latushkin 		flagbits['b'] = ZDB_FLAG_PRINT_BLKPTR;
404507428bdfSVictor Latushkin 		flagbits['c'] = ZDB_FLAG_CHECKSUM;
404607428bdfSVictor Latushkin 		flagbits['d'] = ZDB_FLAG_DECOMPRESS;
404707428bdfSVictor Latushkin 		flagbits['e'] = ZDB_FLAG_BSWAP;
404807428bdfSVictor Latushkin 		flagbits['g'] = ZDB_FLAG_GBH;
404907428bdfSVictor Latushkin 		flagbits['i'] = ZDB_FLAG_INDIRECT;
405007428bdfSVictor Latushkin 		flagbits['p'] = ZDB_FLAG_PHYS;
405107428bdfSVictor Latushkin 		flagbits['r'] = ZDB_FLAG_RAW;
405207428bdfSVictor Latushkin 
405307428bdfSVictor Latushkin 		for (i = 0; i < argc; i++)
405407428bdfSVictor Latushkin 			zdb_read_block(argv[i], spa);
4055fa9e4066Sahrens 	}
4056fa9e4066Sahrens 
4057ed61ec1dSYuri Pankov 	if (os != NULL)
4058ed61ec1dSYuri Pankov 		close_objset(os, FTAG);
4059ed61ec1dSYuri Pankov 	else
4060ed61ec1dSYuri Pankov 		spa_close(spa, FTAG);
406107428bdfSVictor Latushkin 
4062e0d35c44Smarks 	fuid_table_destroy();
4063e0d35c44Smarks 
406429bdd2f9SPavel Zakharov 	dump_debug_buffer();
406529bdd2f9SPavel Zakharov 
4066de6628f0Sck 	libzfs_fini(g_zfs);
4067fa9e4066Sahrens 	kernel_fini();
4068fa9e4066Sahrens 
4069fa9e4066Sahrens 	return (0);
4070fa9e4066Sahrens }
4071