xref: /illumos-gate/usr/src/cmd/zdb/zdb.c (revision 2acef22db7808606888f8f92715629ff3ba555b9)
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.
24490d05b9SMatthew Ahrens  * Copyright (c) 2013 by Delphix. All rights reserved.
25fa9e4066Sahrens  */
26fa9e4066Sahrens 
27fa9e4066Sahrens #include <stdio.h>
28490d05b9SMatthew Ahrens #include <unistd.h>
29004388ebScasper #include <stdio_ext.h>
30fa9e4066Sahrens #include <stdlib.h>
3144cd46caSbillm #include <ctype.h>
32fa9e4066Sahrens #include <sys/zfs_context.h>
33fa9e4066Sahrens #include <sys/spa.h>
34fa9e4066Sahrens #include <sys/spa_impl.h>
35fa9e4066Sahrens #include <sys/dmu.h>
36fa9e4066Sahrens #include <sys/zap.h>
37fa9e4066Sahrens #include <sys/fs/zfs.h>
38fa9e4066Sahrens #include <sys/zfs_znode.h>
390a586ceaSMark Shellenbaum #include <sys/zfs_sa.h>
400a586ceaSMark Shellenbaum #include <sys/sa.h>
410a586ceaSMark Shellenbaum #include <sys/sa_impl.h>
42fa9e4066Sahrens #include <sys/vdev.h>
43fa9e4066Sahrens #include <sys/vdev_impl.h>
44fa9e4066Sahrens #include <sys/metaslab_impl.h>
45fa9e4066Sahrens #include <sys/dmu_objset.h>
46fa9e4066Sahrens #include <sys/dsl_dir.h>
47fa9e4066Sahrens #include <sys/dsl_dataset.h>
48fa9e4066Sahrens #include <sys/dsl_pool.h>
49fa9e4066Sahrens #include <sys/dbuf.h>
50fa9e4066Sahrens #include <sys/zil.h>
51fa9e4066Sahrens #include <sys/zil_impl.h>
52fa9e4066Sahrens #include <sys/stat.h>
53fa9e4066Sahrens #include <sys/resource.h>
54fa9e4066Sahrens #include <sys/dmu_traverse.h>
55fa9e4066Sahrens #include <sys/zio_checksum.h>
56fa9e4066Sahrens #include <sys/zio_compress.h>
57e0d35c44Smarks #include <sys/zfs_fuid.h>
5888b7b0f2SMatthew Ahrens #include <sys/arc.h>
59b24ab676SJeff Bonwick #include <sys/ddt.h>
60ad135b5dSChristopher Siden #include <sys/zfeature.h>
614445fffbSMatthew Ahrens #include <zfs_comutil.h>
62de6628f0Sck #undef ZFS_MAXNAMELEN
63de6628f0Sck #undef verify
64de6628f0Sck #include <libzfs.h>
65fa9e4066Sahrens 
66e690fb27SChristopher Siden #define	ZDB_COMPRESS_NAME(idx) ((idx) < ZIO_COMPRESS_FUNCTIONS ?	\
67e690fb27SChristopher Siden 	zio_compress_table[(idx)].ci_name : "UNKNOWN")
68e690fb27SChristopher Siden #define	ZDB_CHECKSUM_NAME(idx) ((idx) < ZIO_CHECKSUM_FUNCTIONS ?	\
69e690fb27SChristopher Siden 	zio_checksum_table[(idx)].ci_name : "UNKNOWN")
70e690fb27SChristopher Siden #define	ZDB_OT_NAME(idx) ((idx) < DMU_OT_NUMTYPES ?	\
71e690fb27SChristopher Siden 	dmu_ot[(idx)].ot_name : DMU_OT_IS_VALID(idx) ?	\
72e690fb27SChristopher Siden 	dmu_ot_byteswap[DMU_OT_BYTESWAP(idx)].ob_name : "UNKNOWN")
73e690fb27SChristopher Siden #define	ZDB_OT_TYPE(idx) ((idx) < DMU_OT_NUMTYPES ? (idx) :		\
74e690fb27SChristopher Siden 	(((idx) == DMU_OTN_ZAP_DATA || (idx) == DMU_OTN_ZAP_METADATA) ?	\
75e690fb27SChristopher Siden 	DMU_OT_ZAP_OTHER : DMU_OT_NUMTYPES))
766de8f417SVictor Latushkin 
77feef89cfSVictor Latushkin #ifndef lint
78feef89cfSVictor Latushkin extern int zfs_recover;
79feef89cfSVictor Latushkin #else
80feef89cfSVictor Latushkin int zfs_recover;
81feef89cfSVictor Latushkin #endif
82feef89cfSVictor Latushkin 
83fa9e4066Sahrens const char cmdname[] = "zdb";
84fa9e4066Sahrens uint8_t dump_opt[256];
85fa9e4066Sahrens 
86fa9e4066Sahrens typedef void object_viewer_t(objset_t *, uint64_t, void *data, size_t size);
87fa9e4066Sahrens 
88fa9e4066Sahrens extern void dump_intent_log(zilog_t *);
89fa9e4066Sahrens uint64_t *zopt_object = NULL;
90fa9e4066Sahrens int zopt_objects = 0;
91de6628f0Sck libzfs_handle_t *g_zfs;
9231d7e8faSGeorge Wilson uint64_t max_inflight = 200;
93fa9e4066Sahrens 
94fa9e4066Sahrens /*
95fa9e4066Sahrens  * These libumem hooks provide a reasonable set of defaults for the allocator's
96fa9e4066Sahrens  * debugging facilities.
97fa9e4066Sahrens  */
98fa9e4066Sahrens const char *
99fa9e4066Sahrens _umem_debug_init()
100fa9e4066Sahrens {
101fa9e4066Sahrens 	return ("default,verbose"); /* $UMEM_DEBUG setting */
102fa9e4066Sahrens }
103fa9e4066Sahrens 
104fa9e4066Sahrens const char *
105fa9e4066Sahrens _umem_logging_init(void)
106fa9e4066Sahrens {
107fa9e4066Sahrens 	return ("fail,contents"); /* $UMEM_LOGGING setting */
108fa9e4066Sahrens }
109fa9e4066Sahrens 
110fa9e4066Sahrens static void
111fa9e4066Sahrens usage(void)
112fa9e4066Sahrens {
113fa9e4066Sahrens 	(void) fprintf(stderr,
11490e894e2SRichard Lowe 	    "Usage: %s [-CumdibcsDvhLXFPA] [-t txg] [-e [-p path...]] "
11531d7e8faSGeorge Wilson 	    "[-U config] [-M inflight I/Os] poolname [object...]\n"
11631d7e8faSGeorge Wilson 	    "       %s [-divPA] [-e -p path...] [-U config] dataset "
11731d7e8faSGeorge Wilson 	    "[object...]\n"
11831d7e8faSGeorge Wilson 	    "       %s -m [-LXFPA] [-t txg] [-e [-p path...]] [-U config] "
11990e894e2SRichard Lowe 	    "poolname [vdev [metaslab...]]\n"
12090e894e2SRichard Lowe 	    "       %s -R [-A] [-e [-p path...]] poolname "
12190e894e2SRichard Lowe 	    "vdev:offset:size[:flags]\n"
12231d7e8faSGeorge Wilson 	    "       %s -S [-PA] [-e [-p path...]] [-U config] poolname\n"
12390e894e2SRichard Lowe 	    "       %s -l [-uA] device\n"
12490e894e2SRichard Lowe 	    "       %s -C [-A] [-U config]\n\n",
125bbfd46c4SJeff Bonwick 	    cmdname, cmdname, cmdname, cmdname, cmdname, cmdname, cmdname);
1263ad6c7f9SVictor Latushkin 
1273ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    Dataset name must include at least one "
1283ad6c7f9SVictor Latushkin 	    "separator character '/' or '@'\n");
1293ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    If dataset name is specified, only that "
1303ad6c7f9SVictor Latushkin 	    "dataset is dumped\n");
1313ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    If object numbers are specified, only "
1323ad6c7f9SVictor Latushkin 	    "those objects are dumped\n\n");
1333ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    Options to control amount of output:\n");
1343ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -u uberblock\n");
1353ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -d dataset(s)\n");
1363ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -i intent logs\n");
13707428bdfSVictor Latushkin 	(void) fprintf(stderr, "        -C config (or cachefile if alone)\n");
1388f18d1faSGeorge Wilson 	(void) fprintf(stderr, "        -h pool history\n");
1393ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -b block statistics\n");
1403ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -m metaslabs\n");
1413ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -c checksum all metadata (twice for "
1426365109dSVictor Latushkin 	    "all data) blocks\n");
1433ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -s report stats on zdb's I/O\n");
144f0ba89beSJeff Bonwick 	(void) fprintf(stderr, "        -D dedup statistics\n");
145b24ab676SJeff Bonwick 	(void) fprintf(stderr, "        -S simulate dedup to measure effect\n");
1463ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -v verbose (applies to all others)\n");
147fa9e4066Sahrens 	(void) fprintf(stderr, "        -l dump label contents\n");
14882a0a985SVictor Latushkin 	(void) fprintf(stderr, "        -L disable leak tracking (do not "
14982a0a985SVictor Latushkin 	    "load spacemaps)\n");
150d41e7643Sek 	(void) fprintf(stderr, "        -R read and display block from a "
1513ad6c7f9SVictor Latushkin 	    "device\n\n");
1523ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    Below options are intended for use "
1533ad6c7f9SVictor Latushkin 	    "with other options (except -l):\n");
154feef89cfSVictor Latushkin 	(void) fprintf(stderr, "        -A ignore assertions (-A), enable "
155feef89cfSVictor Latushkin 	    "panic recovery (-AA) or both (-AAA)\n");
156c8ee1847SVictor Latushkin 	(void) fprintf(stderr, "        -F attempt automatic rewind within "
157c8ee1847SVictor Latushkin 	    "safe range of transaction groups\n");
1583ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -U <cachefile_path> -- use alternate "
1593ad6c7f9SVictor Latushkin 	    "cachefile\n");
160c8ee1847SVictor Latushkin 	(void) fprintf(stderr, "        -X attempt extreme rewind (does not "
161c8ee1847SVictor Latushkin 	    "work with dataset)\n");
1623ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -e pool is exported/destroyed/"
1633ad6c7f9SVictor Latushkin 	    "has altroot/not in a cachefile\n");
1643ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -p <path> -- use one or more with "
1653ad6c7f9SVictor Latushkin 	    "-e to specify path to vdev dir\n");
16690e894e2SRichard Lowe 	(void) fprintf(stderr, "        -P print numbers in parseable form\n");
1673ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -t <txg> -- highest txg to use when "
1682e551927SVictor Latushkin 	    "searching for uberblocks\n");
16931d7e8faSGeorge Wilson 	(void) fprintf(stderr, "        -M <number of inflight I/Os> -- "
17031d7e8faSGeorge Wilson 	    "specify the maximum number of checksumming I/Os [default is 200]");
171fa9e4066Sahrens 	(void) fprintf(stderr, "Specify an option more than once (e.g. -bb) "
172fa9e4066Sahrens 	    "to make only that option verbose\n");
173fa9e4066Sahrens 	(void) fprintf(stderr, "Default is to dump everything non-verbosely\n");
174fa9e4066Sahrens 	exit(1);
175fa9e4066Sahrens }
176fa9e4066Sahrens 
177ccba0801SRich Morris /*
178ccba0801SRich Morris  * Called for usage errors that are discovered after a call to spa_open(),
179ccba0801SRich Morris  * dmu_bonus_hold(), or pool_match().  abort() is called for other errors.
180ccba0801SRich Morris  */
181ccba0801SRich Morris 
182fa9e4066Sahrens static void
183fa9e4066Sahrens fatal(const char *fmt, ...)
184fa9e4066Sahrens {
185fa9e4066Sahrens 	va_list ap;
186fa9e4066Sahrens 
187fa9e4066Sahrens 	va_start(ap, fmt);
188fa9e4066Sahrens 	(void) fprintf(stderr, "%s: ", cmdname);
189fa9e4066Sahrens 	(void) vfprintf(stderr, fmt, ap);
190fa9e4066Sahrens 	va_end(ap);
191fa9e4066Sahrens 	(void) fprintf(stderr, "\n");
192fa9e4066Sahrens 
193ccba0801SRich Morris 	exit(1);
194fa9e4066Sahrens }
195fa9e4066Sahrens 
196fa9e4066Sahrens /* ARGSUSED */
197fa9e4066Sahrens static void
198fa9e4066Sahrens dump_packed_nvlist(objset_t *os, uint64_t object, void *data, size_t size)
199fa9e4066Sahrens {
200fa9e4066Sahrens 	nvlist_t *nv;
201fa9e4066Sahrens 	size_t nvsize = *(uint64_t *)data;
202fa9e4066Sahrens 	char *packed = umem_alloc(nvsize, UMEM_NOFAIL);
203fa9e4066Sahrens 
2047bfdf011SNeil Perrin 	VERIFY(0 == dmu_read(os, object, 0, nvsize, packed, DMU_READ_PREFETCH));
205fa9e4066Sahrens 
206fa9e4066Sahrens 	VERIFY(nvlist_unpack(packed, nvsize, &nv, 0) == 0);
207fa9e4066Sahrens 
208fa9e4066Sahrens 	umem_free(packed, nvsize);
209fa9e4066Sahrens 
210fa9e4066Sahrens 	dump_nvlist(nv, 8);
211fa9e4066Sahrens 
212fa9e4066Sahrens 	nvlist_free(nv);
213fa9e4066Sahrens }
214fa9e4066Sahrens 
2154445fffbSMatthew Ahrens /* ARGSUSED */
2164445fffbSMatthew Ahrens static void
2174445fffbSMatthew Ahrens dump_history_offsets(objset_t *os, uint64_t object, void *data, size_t size)
2184445fffbSMatthew Ahrens {
2194445fffbSMatthew Ahrens 	spa_history_phys_t *shp = data;
2204445fffbSMatthew Ahrens 
2214445fffbSMatthew Ahrens 	if (shp == NULL)
2224445fffbSMatthew Ahrens 		return;
2234445fffbSMatthew Ahrens 
2244445fffbSMatthew Ahrens 	(void) printf("\t\tpool_create_len = %llu\n",
2254445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_pool_create_len);
2264445fffbSMatthew Ahrens 	(void) printf("\t\tphys_max_off = %llu\n",
2274445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_phys_max_off);
2284445fffbSMatthew Ahrens 	(void) printf("\t\tbof = %llu\n",
2294445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_bof);
2304445fffbSMatthew Ahrens 	(void) printf("\t\teof = %llu\n",
2314445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_eof);
2324445fffbSMatthew Ahrens 	(void) printf("\t\trecords_lost = %llu\n",
2334445fffbSMatthew Ahrens 	    (u_longlong_t)shp->sh_records_lost);
2344445fffbSMatthew Ahrens }
2354445fffbSMatthew Ahrens 
2363f9d6ad7SLin Ling static void
2373f9d6ad7SLin Ling zdb_nicenum(uint64_t num, char *buf)
2383f9d6ad7SLin Ling {
2393f9d6ad7SLin Ling 	if (dump_opt['P'])
2403f9d6ad7SLin Ling 		(void) sprintf(buf, "%llu", (longlong_t)num);
2413f9d6ad7SLin Ling 	else
2423f9d6ad7SLin Ling 		nicenum(num, buf);
2433f9d6ad7SLin Ling }
2443f9d6ad7SLin Ling 
245490d05b9SMatthew Ahrens const char histo_stars[] = "****************************************";
246490d05b9SMatthew Ahrens const int histo_width = sizeof (histo_stars) - 1;
247fa9e4066Sahrens 
248fa9e4066Sahrens static void
2490713e232SGeorge Wilson dump_histogram(const uint64_t *histo, int size, int offset)
250fa9e4066Sahrens {
251fa9e4066Sahrens 	int i;
252490d05b9SMatthew Ahrens 	int minidx = size - 1;
253fa9e4066Sahrens 	int maxidx = 0;
254fa9e4066Sahrens 	uint64_t max = 0;
255fa9e4066Sahrens 
256490d05b9SMatthew Ahrens 	for (i = 0; i < size; i++) {
257fa9e4066Sahrens 		if (histo[i] > max)
258fa9e4066Sahrens 			max = histo[i];
259fa9e4066Sahrens 		if (histo[i] > 0 && i > maxidx)
260fa9e4066Sahrens 			maxidx = i;
261fa9e4066Sahrens 		if (histo[i] > 0 && i < minidx)
262fa9e4066Sahrens 			minidx = i;
263fa9e4066Sahrens 	}
264fa9e4066Sahrens 
265490d05b9SMatthew Ahrens 	if (max < histo_width)
266490d05b9SMatthew Ahrens 		max = histo_width;
267fa9e4066Sahrens 
268490d05b9SMatthew Ahrens 	for (i = minidx; i <= maxidx; i++) {
269490d05b9SMatthew Ahrens 		(void) printf("\t\t\t%3u: %6llu %s\n",
2700713e232SGeorge Wilson 		    i + offset, (u_longlong_t)histo[i],
271490d05b9SMatthew Ahrens 		    &histo_stars[(max - histo[i]) * histo_width / max]);
272490d05b9SMatthew Ahrens 	}
273fa9e4066Sahrens }
274fa9e4066Sahrens 
275fa9e4066Sahrens static void
276fa9e4066Sahrens dump_zap_stats(objset_t *os, uint64_t object)
277fa9e4066Sahrens {
278fa9e4066Sahrens 	int error;
279fa9e4066Sahrens 	zap_stats_t zs;
280fa9e4066Sahrens 
281fa9e4066Sahrens 	error = zap_get_stats(os, object, &zs);
282fa9e4066Sahrens 	if (error)
283fa9e4066Sahrens 		return;
284fa9e4066Sahrens 
285fa9e4066Sahrens 	if (zs.zs_ptrtbl_len == 0) {
286fa9e4066Sahrens 		ASSERT(zs.zs_num_blocks == 1);
287fa9e4066Sahrens 		(void) printf("\tmicrozap: %llu bytes, %llu entries\n",
288fa9e4066Sahrens 		    (u_longlong_t)zs.zs_blocksize,
289fa9e4066Sahrens 		    (u_longlong_t)zs.zs_num_entries);
290fa9e4066Sahrens 		return;
291fa9e4066Sahrens 	}
292fa9e4066Sahrens 
293fa9e4066Sahrens 	(void) printf("\tFat ZAP stats:\n");
2948248818dSnd 
2958248818dSnd 	(void) printf("\t\tPointer table:\n");
2968248818dSnd 	(void) printf("\t\t\t%llu elements\n",
297fa9e4066Sahrens 	    (u_longlong_t)zs.zs_ptrtbl_len);
2988248818dSnd 	(void) printf("\t\t\tzt_blk: %llu\n",
2998248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_zt_blk);
3008248818dSnd 	(void) printf("\t\t\tzt_numblks: %llu\n",
3018248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_zt_numblks);
3028248818dSnd 	(void) printf("\t\t\tzt_shift: %llu\n",
3038248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_zt_shift);
3048248818dSnd 	(void) printf("\t\t\tzt_blks_copied: %llu\n",
3058248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_blks_copied);
3068248818dSnd 	(void) printf("\t\t\tzt_nextblk: %llu\n",
3078248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_nextblk);
3088248818dSnd 
309fa9e4066Sahrens 	(void) printf("\t\tZAP entries: %llu\n",
310fa9e4066Sahrens 	    (u_longlong_t)zs.zs_num_entries);
311fa9e4066Sahrens 	(void) printf("\t\tLeaf blocks: %llu\n",
312fa9e4066Sahrens 	    (u_longlong_t)zs.zs_num_leafs);
313fa9e4066Sahrens 	(void) printf("\t\tTotal blocks: %llu\n",
314fa9e4066Sahrens 	    (u_longlong_t)zs.zs_num_blocks);
3158248818dSnd 	(void) printf("\t\tzap_block_type: 0x%llx\n",
3168248818dSnd 	    (u_longlong_t)zs.zs_block_type);
3178248818dSnd 	(void) printf("\t\tzap_magic: 0x%llx\n",
3188248818dSnd 	    (u_longlong_t)zs.zs_magic);
3198248818dSnd 	(void) printf("\t\tzap_salt: 0x%llx\n",
3208248818dSnd 	    (u_longlong_t)zs.zs_salt);
321fa9e4066Sahrens 
322fa9e4066Sahrens 	(void) printf("\t\tLeafs with 2^n pointers:\n");
3230713e232SGeorge Wilson 	dump_histogram(zs.zs_leafs_with_2n_pointers, ZAP_HISTOGRAM_SIZE, 0);
324fa9e4066Sahrens 
325fa9e4066Sahrens 	(void) printf("\t\tBlocks with n*5 entries:\n");
3260713e232SGeorge Wilson 	dump_histogram(zs.zs_blocks_with_n5_entries, ZAP_HISTOGRAM_SIZE, 0);
327fa9e4066Sahrens 
328fa9e4066Sahrens 	(void) printf("\t\tBlocks n/10 full:\n");
3290713e232SGeorge Wilson 	dump_histogram(zs.zs_blocks_n_tenths_full, ZAP_HISTOGRAM_SIZE, 0);
330fa9e4066Sahrens 
331fa9e4066Sahrens 	(void) printf("\t\tEntries with n chunks:\n");
3320713e232SGeorge Wilson 	dump_histogram(zs.zs_entries_using_n_chunks, ZAP_HISTOGRAM_SIZE, 0);
333fa9e4066Sahrens 
334fa9e4066Sahrens 	(void) printf("\t\tBuckets with n entries:\n");
3350713e232SGeorge Wilson 	dump_histogram(zs.zs_buckets_with_n_entries, ZAP_HISTOGRAM_SIZE, 0);
336fa9e4066Sahrens }
337fa9e4066Sahrens 
338fa9e4066Sahrens /*ARGSUSED*/
339fa9e4066Sahrens static void
340fa9e4066Sahrens dump_none(objset_t *os, uint64_t object, void *data, size_t size)
341fa9e4066Sahrens {
342fa9e4066Sahrens }
343fa9e4066Sahrens 
3446de8f417SVictor Latushkin /*ARGSUSED*/
3456de8f417SVictor Latushkin static void
3466de8f417SVictor Latushkin dump_unknown(objset_t *os, uint64_t object, void *data, size_t size)
3476de8f417SVictor Latushkin {
3486de8f417SVictor Latushkin 	(void) printf("\tUNKNOWN OBJECT TYPE\n");
3496de8f417SVictor Latushkin }
3506de8f417SVictor Latushkin 
351fa9e4066Sahrens /*ARGSUSED*/
352fa9e4066Sahrens void
353fa9e4066Sahrens dump_uint8(objset_t *os, uint64_t object, void *data, size_t size)
354fa9e4066Sahrens {
355fa9e4066Sahrens }
356fa9e4066Sahrens 
357fa9e4066Sahrens /*ARGSUSED*/
358fa9e4066Sahrens static void
359fa9e4066Sahrens dump_uint64(objset_t *os, uint64_t object, void *data, size_t size)
360fa9e4066Sahrens {
361fa9e4066Sahrens }
362fa9e4066Sahrens 
363fa9e4066Sahrens /*ARGSUSED*/
364fa9e4066Sahrens static void
365fa9e4066Sahrens dump_zap(objset_t *os, uint64_t object, void *data, size_t size)
366fa9e4066Sahrens {
367fa9e4066Sahrens 	zap_cursor_t zc;
368fa9e4066Sahrens 	zap_attribute_t attr;
369fa9e4066Sahrens 	void *prop;
370fa9e4066Sahrens 	int i;
371fa9e4066Sahrens 
372fa9e4066Sahrens 	dump_zap_stats(os, object);
373fa9e4066Sahrens 	(void) printf("\n");
374fa9e4066Sahrens 
375fa9e4066Sahrens 	for (zap_cursor_init(&zc, os, object);
376fa9e4066Sahrens 	    zap_cursor_retrieve(&zc, &attr) == 0;
377fa9e4066Sahrens 	    zap_cursor_advance(&zc)) {
378fa9e4066Sahrens 		(void) printf("\t\t%s = ", attr.za_name);
379fa9e4066Sahrens 		if (attr.za_num_integers == 0) {
380fa9e4066Sahrens 			(void) printf("\n");
381fa9e4066Sahrens 			continue;
382fa9e4066Sahrens 		}
383fa9e4066Sahrens 		prop = umem_zalloc(attr.za_num_integers *
384fa9e4066Sahrens 		    attr.za_integer_length, UMEM_NOFAIL);
385fa9e4066Sahrens 		(void) zap_lookup(os, object, attr.za_name,
386fa9e4066Sahrens 		    attr.za_integer_length, attr.za_num_integers, prop);
387fa9e4066Sahrens 		if (attr.za_integer_length == 1) {
388fa9e4066Sahrens 			(void) printf("%s", (char *)prop);
389fa9e4066Sahrens 		} else {
390fa9e4066Sahrens 			for (i = 0; i < attr.za_num_integers; i++) {
391fa9e4066Sahrens 				switch (attr.za_integer_length) {
392fa9e4066Sahrens 				case 2:
393fa9e4066Sahrens 					(void) printf("%u ",
394fa9e4066Sahrens 					    ((uint16_t *)prop)[i]);
395fa9e4066Sahrens 					break;
396fa9e4066Sahrens 				case 4:
397fa9e4066Sahrens 					(void) printf("%u ",
398fa9e4066Sahrens 					    ((uint32_t *)prop)[i]);
399fa9e4066Sahrens 					break;
400fa9e4066Sahrens 				case 8:
401fa9e4066Sahrens 					(void) printf("%lld ",
402fa9e4066Sahrens 					    (u_longlong_t)((int64_t *)prop)[i]);
403fa9e4066Sahrens 					break;
404fa9e4066Sahrens 				}
405fa9e4066Sahrens 			}
406fa9e4066Sahrens 		}
407fa9e4066Sahrens 		(void) printf("\n");
408fa9e4066Sahrens 		umem_free(prop, attr.za_num_integers * attr.za_integer_length);
409fa9e4066Sahrens 	}
41087e5029aSahrens 	zap_cursor_fini(&zc);
411fa9e4066Sahrens }
412fa9e4066Sahrens 
413486ae710SMatthew Ahrens /*ARGSUSED*/
414486ae710SMatthew Ahrens static void
415486ae710SMatthew Ahrens dump_ddt_zap(objset_t *os, uint64_t object, void *data, size_t size)
416486ae710SMatthew Ahrens {
417486ae710SMatthew Ahrens 	dump_zap_stats(os, object);
418486ae710SMatthew Ahrens 	/* contents are printed elsewhere, properly decoded */
419486ae710SMatthew Ahrens }
420486ae710SMatthew Ahrens 
4210a586ceaSMark Shellenbaum /*ARGSUSED*/
4220a586ceaSMark Shellenbaum static void
4230a586ceaSMark Shellenbaum dump_sa_attrs(objset_t *os, uint64_t object, void *data, size_t size)
4240a586ceaSMark Shellenbaum {
4250a586ceaSMark Shellenbaum 	zap_cursor_t zc;
4260a586ceaSMark Shellenbaum 	zap_attribute_t attr;
4270a586ceaSMark Shellenbaum 
4280a586ceaSMark Shellenbaum 	dump_zap_stats(os, object);
4290a586ceaSMark Shellenbaum 	(void) printf("\n");
4300a586ceaSMark Shellenbaum 
4310a586ceaSMark Shellenbaum 	for (zap_cursor_init(&zc, os, object);
4320a586ceaSMark Shellenbaum 	    zap_cursor_retrieve(&zc, &attr) == 0;
4330a586ceaSMark Shellenbaum 	    zap_cursor_advance(&zc)) {
4340a586ceaSMark Shellenbaum 		(void) printf("\t\t%s = ", attr.za_name);
4350a586ceaSMark Shellenbaum 		if (attr.za_num_integers == 0) {
4360a586ceaSMark Shellenbaum 			(void) printf("\n");
4370a586ceaSMark Shellenbaum 			continue;
4380a586ceaSMark Shellenbaum 		}
4390a586ceaSMark Shellenbaum 		(void) printf(" %llx : [%d:%d:%d]\n",
4400a586ceaSMark Shellenbaum 		    (u_longlong_t)attr.za_first_integer,
4410a586ceaSMark Shellenbaum 		    (int)ATTR_LENGTH(attr.za_first_integer),
4420a586ceaSMark Shellenbaum 		    (int)ATTR_BSWAP(attr.za_first_integer),
4430a586ceaSMark Shellenbaum 		    (int)ATTR_NUM(attr.za_first_integer));
4440a586ceaSMark Shellenbaum 	}
4450a586ceaSMark Shellenbaum 	zap_cursor_fini(&zc);
4460a586ceaSMark Shellenbaum }
4470a586ceaSMark Shellenbaum 
4480a586ceaSMark Shellenbaum /*ARGSUSED*/
4490a586ceaSMark Shellenbaum static void
4500a586ceaSMark Shellenbaum dump_sa_layouts(objset_t *os, uint64_t object, void *data, size_t size)
4510a586ceaSMark Shellenbaum {
4520a586ceaSMark Shellenbaum 	zap_cursor_t zc;
4530a586ceaSMark Shellenbaum 	zap_attribute_t attr;
4540a586ceaSMark Shellenbaum 	uint16_t *layout_attrs;
4550a586ceaSMark Shellenbaum 	int i;
4560a586ceaSMark Shellenbaum 
4570a586ceaSMark Shellenbaum 	dump_zap_stats(os, object);
4580a586ceaSMark Shellenbaum 	(void) printf("\n");
4590a586ceaSMark Shellenbaum 
4600a586ceaSMark Shellenbaum 	for (zap_cursor_init(&zc, os, object);
4610a586ceaSMark Shellenbaum 	    zap_cursor_retrieve(&zc, &attr) == 0;
4620a586ceaSMark Shellenbaum 	    zap_cursor_advance(&zc)) {
4630a586ceaSMark Shellenbaum 		(void) printf("\t\t%s = [", attr.za_name);
4640a586ceaSMark Shellenbaum 		if (attr.za_num_integers == 0) {
4650a586ceaSMark Shellenbaum 			(void) printf("\n");
4660a586ceaSMark Shellenbaum 			continue;
4670a586ceaSMark Shellenbaum 		}
4680a586ceaSMark Shellenbaum 
4690a586ceaSMark Shellenbaum 		VERIFY(attr.za_integer_length == 2);
4700a586ceaSMark Shellenbaum 		layout_attrs = umem_zalloc(attr.za_num_integers *
4710a586ceaSMark Shellenbaum 		    attr.za_integer_length, UMEM_NOFAIL);
4720a586ceaSMark Shellenbaum 
4730a586ceaSMark Shellenbaum 		VERIFY(zap_lookup(os, object, attr.za_name,
4740a586ceaSMark Shellenbaum 		    attr.za_integer_length,
4750a586ceaSMark Shellenbaum 		    attr.za_num_integers, layout_attrs) == 0);
4760a586ceaSMark Shellenbaum 
4770a586ceaSMark Shellenbaum 		for (i = 0; i != attr.za_num_integers; i++)
4780a586ceaSMark Shellenbaum 			(void) printf(" %d ", (int)layout_attrs[i]);
4790a586ceaSMark Shellenbaum 		(void) printf("]\n");
4800a586ceaSMark Shellenbaum 		umem_free(layout_attrs,
4810a586ceaSMark Shellenbaum 		    attr.za_num_integers * attr.za_integer_length);
4820a586ceaSMark Shellenbaum 	}
4830a586ceaSMark Shellenbaum 	zap_cursor_fini(&zc);
4840a586ceaSMark Shellenbaum }
4850a586ceaSMark Shellenbaum 
486e7437265Sahrens /*ARGSUSED*/
487e7437265Sahrens static void
488e7437265Sahrens dump_zpldir(objset_t *os, uint64_t object, void *data, size_t size)
489e7437265Sahrens {
490e7437265Sahrens 	zap_cursor_t zc;
491e7437265Sahrens 	zap_attribute_t attr;
492e7437265Sahrens 	const char *typenames[] = {
493e7437265Sahrens 		/* 0 */ "not specified",
494e7437265Sahrens 		/* 1 */ "FIFO",
495e7437265Sahrens 		/* 2 */ "Character Device",
496e7437265Sahrens 		/* 3 */ "3 (invalid)",
497e7437265Sahrens 		/* 4 */ "Directory",
498e7437265Sahrens 		/* 5 */ "5 (invalid)",
499e7437265Sahrens 		/* 6 */ "Block Device",
500e7437265Sahrens 		/* 7 */ "7 (invalid)",
501e7437265Sahrens 		/* 8 */ "Regular File",
502e7437265Sahrens 		/* 9 */ "9 (invalid)",
503e7437265Sahrens 		/* 10 */ "Symbolic Link",
504e7437265Sahrens 		/* 11 */ "11 (invalid)",
505e7437265Sahrens 		/* 12 */ "Socket",
506e7437265Sahrens 		/* 13 */ "Door",
507e7437265Sahrens 		/* 14 */ "Event Port",
508e7437265Sahrens 		/* 15 */ "15 (invalid)",
509e7437265Sahrens 	};
510e7437265Sahrens 
511e7437265Sahrens 	dump_zap_stats(os, object);
512e7437265Sahrens 	(void) printf("\n");
513e7437265Sahrens 
514e7437265Sahrens 	for (zap_cursor_init(&zc, os, object);
515e7437265Sahrens 	    zap_cursor_retrieve(&zc, &attr) == 0;
516e7437265Sahrens 	    zap_cursor_advance(&zc)) {
517e7437265Sahrens 		(void) printf("\t\t%s = %lld (type: %s)\n",
518e7437265Sahrens 		    attr.za_name, ZFS_DIRENT_OBJ(attr.za_first_integer),
519e7437265Sahrens 		    typenames[ZFS_DIRENT_TYPE(attr.za_first_integer)]);
520e7437265Sahrens 	}
521e7437265Sahrens 	zap_cursor_fini(&zc);
522e7437265Sahrens }
523e7437265Sahrens 
5240713e232SGeorge Wilson int
5250713e232SGeorge Wilson get_dtl_refcount(vdev_t *vd)
5260713e232SGeorge Wilson {
5270713e232SGeorge Wilson 	int refcount = 0;
5280713e232SGeorge Wilson 
5290713e232SGeorge Wilson 	if (vd->vdev_ops->vdev_op_leaf) {
5300713e232SGeorge Wilson 		space_map_t *sm = vd->vdev_dtl_sm;
5310713e232SGeorge Wilson 
5320713e232SGeorge Wilson 		if (sm != NULL &&
5330713e232SGeorge Wilson 		    sm->sm_dbuf->db_size == sizeof (space_map_phys_t))
5340713e232SGeorge Wilson 			return (1);
5350713e232SGeorge Wilson 		return (0);
5360713e232SGeorge Wilson 	}
5370713e232SGeorge Wilson 
5380713e232SGeorge Wilson 	for (int c = 0; c < vd->vdev_children; c++)
5390713e232SGeorge Wilson 		refcount += get_dtl_refcount(vd->vdev_child[c]);
5400713e232SGeorge Wilson 	return (refcount);
5410713e232SGeorge Wilson }
5420713e232SGeorge Wilson 
5430713e232SGeorge Wilson int
5440713e232SGeorge Wilson get_metaslab_refcount(vdev_t *vd)
5450713e232SGeorge Wilson {
5460713e232SGeorge Wilson 	int refcount = 0;
5470713e232SGeorge Wilson 
5480713e232SGeorge Wilson 	if (vd->vdev_top == vd) {
5490713e232SGeorge Wilson 		for (int m = 0; m < vd->vdev_ms_count; m++) {
5500713e232SGeorge Wilson 			space_map_t *sm = vd->vdev_ms[m]->ms_sm;
5510713e232SGeorge Wilson 
5520713e232SGeorge Wilson 			if (sm != NULL &&
5530713e232SGeorge Wilson 			    sm->sm_dbuf->db_size == sizeof (space_map_phys_t))
5540713e232SGeorge Wilson 				refcount++;
5550713e232SGeorge Wilson 		}
5560713e232SGeorge Wilson 	}
5570713e232SGeorge Wilson 	for (int c = 0; c < vd->vdev_children; c++)
5580713e232SGeorge Wilson 		refcount += get_metaslab_refcount(vd->vdev_child[c]);
5590713e232SGeorge Wilson 
5600713e232SGeorge Wilson 	return (refcount);
5610713e232SGeorge Wilson }
5620713e232SGeorge Wilson 
5630713e232SGeorge Wilson static int
5640713e232SGeorge Wilson verify_spacemap_refcounts(spa_t *spa)
5650713e232SGeorge Wilson {
566*2acef22dSMatthew Ahrens 	uint64_t expected_refcount = 0;
567*2acef22dSMatthew Ahrens 	uint64_t actual_refcount;
5680713e232SGeorge Wilson 
569*2acef22dSMatthew Ahrens 	(void) feature_get_refcount(spa,
570*2acef22dSMatthew Ahrens 	    &spa_feature_table[SPA_FEATURE_SPACEMAP_HISTOGRAM],
571*2acef22dSMatthew Ahrens 	    &expected_refcount);
5720713e232SGeorge Wilson 	actual_refcount = get_dtl_refcount(spa->spa_root_vdev);
5730713e232SGeorge Wilson 	actual_refcount += get_metaslab_refcount(spa->spa_root_vdev);
5740713e232SGeorge Wilson 
5750713e232SGeorge Wilson 	if (expected_refcount != actual_refcount) {
576*2acef22dSMatthew Ahrens 		(void) printf("space map refcount mismatch: expected %lld != "
577*2acef22dSMatthew Ahrens 		    "actual %lld\n",
578*2acef22dSMatthew Ahrens 		    (longlong_t)expected_refcount,
579*2acef22dSMatthew Ahrens 		    (longlong_t)actual_refcount);
5800713e232SGeorge Wilson 		return (2);
5810713e232SGeorge Wilson 	}
5820713e232SGeorge Wilson 	return (0);
5830713e232SGeorge Wilson }
5840713e232SGeorge Wilson 
585fa9e4066Sahrens static void
5860713e232SGeorge Wilson dump_spacemap(objset_t *os, space_map_t *sm)
587fa9e4066Sahrens {
588fa9e4066Sahrens 	uint64_t alloc, offset, entry;
5898053a263Sck 	char *ddata[] = { "ALLOC", "FREE", "CONDENSE", "INVALID",
5908053a263Sck 			    "INVALID", "INVALID", "INVALID", "INVALID" };
591fa9e4066Sahrens 
5920713e232SGeorge Wilson 	if (sm == NULL)
593fa9e4066Sahrens 		return;
594fa9e4066Sahrens 
595fa9e4066Sahrens 	/*
596fa9e4066Sahrens 	 * Print out the freelist entries in both encoded and decoded form.
597fa9e4066Sahrens 	 */
598fa9e4066Sahrens 	alloc = 0;
5990713e232SGeorge Wilson 	for (offset = 0; offset < space_map_length(sm);
6000713e232SGeorge Wilson 	    offset += sizeof (entry)) {
6010713e232SGeorge Wilson 		uint8_t mapshift = sm->sm_shift;
6020713e232SGeorge Wilson 
6030713e232SGeorge Wilson 		VERIFY0(dmu_read(os, space_map_object(sm), offset,
6047bfdf011SNeil Perrin 		    sizeof (entry), &entry, DMU_READ_PREFETCH));
605fa9e4066Sahrens 		if (SM_DEBUG_DECODE(entry)) {
6060713e232SGeorge Wilson 
60787219db7SVictor Latushkin 			(void) printf("\t    [%6llu] %s: txg %llu, pass %llu\n",
608fa9e4066Sahrens 			    (u_longlong_t)(offset / sizeof (entry)),
609fa9e4066Sahrens 			    ddata[SM_DEBUG_ACTION_DECODE(entry)],
6105ad82045Snd 			    (u_longlong_t)SM_DEBUG_TXG_DECODE(entry),
6115ad82045Snd 			    (u_longlong_t)SM_DEBUG_SYNCPASS_DECODE(entry));
612fa9e4066Sahrens 		} else {
61387219db7SVictor Latushkin 			(void) printf("\t    [%6llu]    %c  range:"
61487219db7SVictor Latushkin 			    " %010llx-%010llx  size: %06llx\n",
615fa9e4066Sahrens 			    (u_longlong_t)(offset / sizeof (entry)),
616fa9e4066Sahrens 			    SM_TYPE_DECODE(entry) == SM_ALLOC ? 'A' : 'F',
6175ad82045Snd 			    (u_longlong_t)((SM_OFFSET_DECODE(entry) <<
6180713e232SGeorge Wilson 			    mapshift) + sm->sm_start),
6195ad82045Snd 			    (u_longlong_t)((SM_OFFSET_DECODE(entry) <<
6200713e232SGeorge Wilson 			    mapshift) + sm->sm_start +
6210713e232SGeorge Wilson 			    (SM_RUN_DECODE(entry) << mapshift)),
6225ad82045Snd 			    (u_longlong_t)(SM_RUN_DECODE(entry) << mapshift));
623fa9e4066Sahrens 			if (SM_TYPE_DECODE(entry) == SM_ALLOC)
624fa9e4066Sahrens 				alloc += SM_RUN_DECODE(entry) << mapshift;
625fa9e4066Sahrens 			else
626fa9e4066Sahrens 				alloc -= SM_RUN_DECODE(entry) << mapshift;
627fa9e4066Sahrens 		}
628fa9e4066Sahrens 	}
6290713e232SGeorge Wilson 	if (alloc != space_map_allocated(sm)) {
630fa9e4066Sahrens 		(void) printf("space_map_object alloc (%llu) INCONSISTENT "
631fa9e4066Sahrens 		    "with space map summary (%llu)\n",
6320713e232SGeorge Wilson 		    (u_longlong_t)space_map_allocated(sm), (u_longlong_t)alloc);
633fa9e4066Sahrens 	}
634fa9e4066Sahrens }
635fa9e4066Sahrens 
636d6e555bdSGeorge Wilson static void
637d6e555bdSGeorge Wilson dump_metaslab_stats(metaslab_t *msp)
638d6e555bdSGeorge Wilson {
6393f9d6ad7SLin Ling 	char maxbuf[32];
6400713e232SGeorge Wilson 	range_tree_t *rt = msp->ms_tree;
6410713e232SGeorge Wilson 	avl_tree_t *t = &msp->ms_size_tree;
6420713e232SGeorge Wilson 	int free_pct = range_tree_space(rt) * 100 / msp->ms_size;
643d6e555bdSGeorge Wilson 
6440713e232SGeorge Wilson 	zdb_nicenum(metaslab_block_maxsize(msp), maxbuf);
645d6e555bdSGeorge Wilson 
64687219db7SVictor Latushkin 	(void) printf("\t %25s %10lu   %7s  %6s   %4s %4d%%\n",
647d6e555bdSGeorge Wilson 	    "segments", avl_numnodes(t), "maxsize", maxbuf,
648d6e555bdSGeorge Wilson 	    "freepct", free_pct);
6490713e232SGeorge Wilson 	(void) printf("\tIn-memory histogram:\n");
6500713e232SGeorge Wilson 	dump_histogram(rt->rt_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
651d6e555bdSGeorge Wilson }
652d6e555bdSGeorge Wilson 
653fa9e4066Sahrens static void
654fa9e4066Sahrens dump_metaslab(metaslab_t *msp)
655fa9e4066Sahrens {
656fa9e4066Sahrens 	vdev_t *vd = msp->ms_group->mg_vd;
657fa9e4066Sahrens 	spa_t *spa = vd->vdev_spa;
6580713e232SGeorge Wilson 	space_map_t *sm = msp->ms_sm;
6593f9d6ad7SLin Ling 	char freebuf[32];
660fa9e4066Sahrens 
6610713e232SGeorge Wilson 	zdb_nicenum(msp->ms_size - space_map_allocated(sm), freebuf);
662fa9e4066Sahrens 
663fa9e4066Sahrens 	(void) printf(
66487219db7SVictor Latushkin 	    "\tmetaslab %6llu   offset %12llx   spacemap %6llu   free    %5s\n",
6650713e232SGeorge Wilson 	    (u_longlong_t)msp->ms_id, (u_longlong_t)msp->ms_start,
6660713e232SGeorge Wilson 	    (u_longlong_t)space_map_object(sm), freebuf);
667fa9e4066Sahrens 
6680713e232SGeorge Wilson 	if (dump_opt['m'] > 2 && !dump_opt['L']) {
669d6e555bdSGeorge Wilson 		mutex_enter(&msp->ms_lock);
6700713e232SGeorge Wilson 		metaslab_load_wait(msp);
6710713e232SGeorge Wilson 		if (!msp->ms_loaded) {
6720713e232SGeorge Wilson 			VERIFY0(metaslab_load(msp));
6730713e232SGeorge Wilson 			range_tree_stat_verify(msp->ms_tree);
6740713e232SGeorge Wilson 		}
675bc3975b5SVictor Latushkin 		dump_metaslab_stats(msp);
6760713e232SGeorge Wilson 		metaslab_unload(msp);
677d6e555bdSGeorge Wilson 		mutex_exit(&msp->ms_lock);
678d6e555bdSGeorge Wilson 	}
679d6e555bdSGeorge Wilson 
6800713e232SGeorge Wilson 	if (dump_opt['m'] > 1 && sm != NULL &&
681*2acef22dSMatthew Ahrens 	    spa_feature_is_active(spa, SPA_FEATURE_SPACEMAP_HISTOGRAM)) {
6820713e232SGeorge Wilson 		/*
6830713e232SGeorge Wilson 		 * The space map histogram represents free space in chunks
6840713e232SGeorge Wilson 		 * of sm_shift (i.e. bucket 0 refers to 2^sm_shift).
6850713e232SGeorge Wilson 		 */
6860713e232SGeorge Wilson 		(void) printf("\tOn-disk histogram:\n");
6870713e232SGeorge Wilson 		dump_histogram(sm->sm_phys->smp_histogram,
6880713e232SGeorge Wilson 		    SPACE_MAP_HISTOGRAM_SIZE(sm), sm->sm_shift);
6890713e232SGeorge Wilson 	}
6900713e232SGeorge Wilson 
6910713e232SGeorge Wilson 	if (dump_opt['d'] > 5 || dump_opt['m'] > 3) {
6920713e232SGeorge Wilson 		ASSERT(msp->ms_size == (1ULL << vd->vdev_ms_shift));
693d6e555bdSGeorge Wilson 
694d6e555bdSGeorge Wilson 		mutex_enter(&msp->ms_lock);
6950713e232SGeorge Wilson 		dump_spacemap(spa->spa_meta_objset, msp->ms_sm);
696d6e555bdSGeorge Wilson 		mutex_exit(&msp->ms_lock);
697d6e555bdSGeorge Wilson 	}
69887219db7SVictor Latushkin }
699fa9e4066Sahrens 
70087219db7SVictor Latushkin static void
70187219db7SVictor Latushkin print_vdev_metaslab_header(vdev_t *vd)
70287219db7SVictor Latushkin {
70387219db7SVictor Latushkin 	(void) printf("\tvdev %10llu\n\t%-10s%5llu   %-19s   %-15s   %-10s\n",
70487219db7SVictor Latushkin 	    (u_longlong_t)vd->vdev_id,
70587219db7SVictor Latushkin 	    "metaslabs", (u_longlong_t)vd->vdev_ms_count,
70687219db7SVictor Latushkin 	    "offset", "spacemap", "free");
70787219db7SVictor Latushkin 	(void) printf("\t%15s   %19s   %15s   %10s\n",
70887219db7SVictor Latushkin 	    "---------------", "-------------------",
70987219db7SVictor Latushkin 	    "---------------", "-------------");
710fa9e4066Sahrens }
711fa9e4066Sahrens 
712fa9e4066Sahrens static void
713fa9e4066Sahrens dump_metaslabs(spa_t *spa)
714fa9e4066Sahrens {
71587219db7SVictor Latushkin 	vdev_t *vd, *rvd = spa->spa_root_vdev;
71687219db7SVictor Latushkin 	uint64_t m, c = 0, children = rvd->vdev_children;
717fa9e4066Sahrens 
718fa9e4066Sahrens 	(void) printf("\nMetaslabs:\n");
719fa9e4066Sahrens 
72087219db7SVictor Latushkin 	if (!dump_opt['d'] && zopt_objects > 0) {
72187219db7SVictor Latushkin 		c = zopt_object[0];
72287219db7SVictor Latushkin 
72387219db7SVictor Latushkin 		if (c >= children)
72487219db7SVictor Latushkin 			(void) fatal("bad vdev id: %llu", (u_longlong_t)c);
725fa9e4066Sahrens 
72687219db7SVictor Latushkin 		if (zopt_objects > 1) {
72787219db7SVictor Latushkin 			vd = rvd->vdev_child[c];
72887219db7SVictor Latushkin 			print_vdev_metaslab_header(vd);
72987219db7SVictor Latushkin 
73087219db7SVictor Latushkin 			for (m = 1; m < zopt_objects; m++) {
73187219db7SVictor Latushkin 				if (zopt_object[m] < vd->vdev_ms_count)
73287219db7SVictor Latushkin 					dump_metaslab(
73387219db7SVictor Latushkin 					    vd->vdev_ms[zopt_object[m]]);
73487219db7SVictor Latushkin 				else
73587219db7SVictor Latushkin 					(void) fprintf(stderr, "bad metaslab "
73687219db7SVictor Latushkin 					    "number %llu\n",
73787219db7SVictor Latushkin 					    (u_longlong_t)zopt_object[m]);
73887219db7SVictor Latushkin 			}
73987219db7SVictor Latushkin 			(void) printf("\n");
74087219db7SVictor Latushkin 			return;
74187219db7SVictor Latushkin 		}
74287219db7SVictor Latushkin 		children = c + 1;
74387219db7SVictor Latushkin 	}
74487219db7SVictor Latushkin 	for (; c < children; c++) {
74587219db7SVictor Latushkin 		vd = rvd->vdev_child[c];
74687219db7SVictor Latushkin 		print_vdev_metaslab_header(vd);
747fa9e4066Sahrens 
748fa9e4066Sahrens 		for (m = 0; m < vd->vdev_ms_count; m++)
749fa9e4066Sahrens 			dump_metaslab(vd->vdev_ms[m]);
750fa9e4066Sahrens 		(void) printf("\n");
751fa9e4066Sahrens 	}
752fa9e4066Sahrens }
753fa9e4066Sahrens 
754b24ab676SJeff Bonwick static void
755b24ab676SJeff Bonwick dump_dde(const ddt_t *ddt, const ddt_entry_t *dde, uint64_t index)
756b24ab676SJeff Bonwick {
757b24ab676SJeff Bonwick 	const ddt_phys_t *ddp = dde->dde_phys;
758b24ab676SJeff Bonwick 	const ddt_key_t *ddk = &dde->dde_key;
759b24ab676SJeff Bonwick 	char *types[4] = { "ditto", "single", "double", "triple" };
760b24ab676SJeff Bonwick 	char blkbuf[BP_SPRINTF_LEN];
761b24ab676SJeff Bonwick 	blkptr_t blk;
762b24ab676SJeff Bonwick 
763b24ab676SJeff Bonwick 	for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
764b24ab676SJeff Bonwick 		if (ddp->ddp_phys_birth == 0)
765b24ab676SJeff Bonwick 			continue;
766bbfd46c4SJeff Bonwick 		ddt_bp_create(ddt->ddt_checksum, ddk, ddp, &blk);
767b24ab676SJeff Bonwick 		sprintf_blkptr(blkbuf, &blk);
768b24ab676SJeff Bonwick 		(void) printf("index %llx refcnt %llu %s %s\n",
769b24ab676SJeff Bonwick 		    (u_longlong_t)index, (u_longlong_t)ddp->ddp_refcnt,
770b24ab676SJeff Bonwick 		    types[p], blkbuf);
771b24ab676SJeff Bonwick 	}
772b24ab676SJeff Bonwick }
773b24ab676SJeff Bonwick 
774b24ab676SJeff Bonwick static void
775b24ab676SJeff Bonwick dump_dedup_ratio(const ddt_stat_t *dds)
776b24ab676SJeff Bonwick {
777b24ab676SJeff Bonwick 	double rL, rP, rD, D, dedup, compress, copies;
778b24ab676SJeff Bonwick 
779b24ab676SJeff Bonwick 	if (dds->dds_blocks == 0)
780b24ab676SJeff Bonwick 		return;
781b24ab676SJeff Bonwick 
782b24ab676SJeff Bonwick 	rL = (double)dds->dds_ref_lsize;
783b24ab676SJeff Bonwick 	rP = (double)dds->dds_ref_psize;
784b24ab676SJeff Bonwick 	rD = (double)dds->dds_ref_dsize;
785b24ab676SJeff Bonwick 	D = (double)dds->dds_dsize;
786b24ab676SJeff Bonwick 
787b24ab676SJeff Bonwick 	dedup = rD / D;
788b24ab676SJeff Bonwick 	compress = rL / rP;
789b24ab676SJeff Bonwick 	copies = rD / rP;
790b24ab676SJeff Bonwick 
791b24ab676SJeff Bonwick 	(void) printf("dedup = %.2f, compress = %.2f, copies = %.2f, "
792b24ab676SJeff Bonwick 	    "dedup * compress / copies = %.2f\n\n",
793b24ab676SJeff Bonwick 	    dedup, compress, copies, dedup * compress / copies);
794b24ab676SJeff Bonwick }
795b24ab676SJeff Bonwick 
796b24ab676SJeff Bonwick static void
797b24ab676SJeff Bonwick dump_ddt(ddt_t *ddt, enum ddt_type type, enum ddt_class class)
798b24ab676SJeff Bonwick {
799b24ab676SJeff Bonwick 	char name[DDT_NAMELEN];
800b24ab676SJeff Bonwick 	ddt_entry_t dde;
801b24ab676SJeff Bonwick 	uint64_t walk = 0;
802b24ab676SJeff Bonwick 	dmu_object_info_t doi;
803b24ab676SJeff Bonwick 	uint64_t count, dspace, mspace;
804b24ab676SJeff Bonwick 	int error;
805b24ab676SJeff Bonwick 
806b24ab676SJeff Bonwick 	error = ddt_object_info(ddt, type, class, &doi);
807b24ab676SJeff Bonwick 
808b24ab676SJeff Bonwick 	if (error == ENOENT)
809b24ab676SJeff Bonwick 		return;
810b24ab676SJeff Bonwick 	ASSERT(error == 0);
811b24ab676SJeff Bonwick 
8127448a079SGeorge Wilson 	if ((count = ddt_object_count(ddt, type, class)) == 0)
8137448a079SGeorge Wilson 		return;
8147448a079SGeorge Wilson 
815b24ab676SJeff Bonwick 	dspace = doi.doi_physical_blocks_512 << 9;
816b24ab676SJeff Bonwick 	mspace = doi.doi_fill_count * doi.doi_data_block_size;
817b24ab676SJeff Bonwick 
818b24ab676SJeff Bonwick 	ddt_object_name(ddt, type, class, name);
819b24ab676SJeff Bonwick 
820b24ab676SJeff Bonwick 	(void) printf("%s: %llu entries, size %llu on disk, %llu in core\n",
821b24ab676SJeff Bonwick 	    name,
822b24ab676SJeff Bonwick 	    (u_longlong_t)count,
823b24ab676SJeff Bonwick 	    (u_longlong_t)(dspace / count),
824b24ab676SJeff Bonwick 	    (u_longlong_t)(mspace / count));
825b24ab676SJeff Bonwick 
826b24ab676SJeff Bonwick 	if (dump_opt['D'] < 3)
827b24ab676SJeff Bonwick 		return;
828b24ab676SJeff Bonwick 
8299eb19f4dSGeorge Wilson 	zpool_dump_ddt(NULL, &ddt->ddt_histogram[type][class]);
830b24ab676SJeff Bonwick 
831b24ab676SJeff Bonwick 	if (dump_opt['D'] < 4)
832b24ab676SJeff Bonwick 		return;
833b24ab676SJeff Bonwick 
834b24ab676SJeff Bonwick 	if (dump_opt['D'] < 5 && class == DDT_CLASS_UNIQUE)
835b24ab676SJeff Bonwick 		return;
836b24ab676SJeff Bonwick 
837b24ab676SJeff Bonwick 	(void) printf("%s contents:\n\n", name);
838b24ab676SJeff Bonwick 
839bbfd46c4SJeff Bonwick 	while ((error = ddt_object_walk(ddt, type, class, &walk, &dde)) == 0)
840b24ab676SJeff Bonwick 		dump_dde(ddt, &dde, walk);
841b24ab676SJeff Bonwick 
842b24ab676SJeff Bonwick 	ASSERT(error == ENOENT);
843b24ab676SJeff Bonwick 
844b24ab676SJeff Bonwick 	(void) printf("\n");
845b24ab676SJeff Bonwick }
846b24ab676SJeff Bonwick 
847b24ab676SJeff Bonwick static void
848b24ab676SJeff Bonwick dump_all_ddts(spa_t *spa)
849b24ab676SJeff Bonwick {
850b24ab676SJeff Bonwick 	ddt_histogram_t ddh_total = { 0 };
851b24ab676SJeff Bonwick 	ddt_stat_t dds_total = { 0 };
852b24ab676SJeff Bonwick 
853b24ab676SJeff Bonwick 	for (enum zio_checksum c = 0; c < ZIO_CHECKSUM_FUNCTIONS; c++) {
854b24ab676SJeff Bonwick 		ddt_t *ddt = spa->spa_ddt[c];
855b24ab676SJeff Bonwick 		for (enum ddt_type type = 0; type < DDT_TYPES; type++) {
856b24ab676SJeff Bonwick 			for (enum ddt_class class = 0; class < DDT_CLASSES;
857b24ab676SJeff Bonwick 			    class++) {
858b24ab676SJeff Bonwick 				dump_ddt(ddt, type, class);
859b24ab676SJeff Bonwick 			}
860b24ab676SJeff Bonwick 		}
861b24ab676SJeff Bonwick 	}
862b24ab676SJeff Bonwick 
8639eb19f4dSGeorge Wilson 	ddt_get_dedup_stats(spa, &dds_total);
864b24ab676SJeff Bonwick 
865b24ab676SJeff Bonwick 	if (dds_total.dds_blocks == 0) {
866b24ab676SJeff Bonwick 		(void) printf("All DDTs are empty\n");
867b24ab676SJeff Bonwick 		return;
868b24ab676SJeff Bonwick 	}
869b24ab676SJeff Bonwick 
870b24ab676SJeff Bonwick 	(void) printf("\n");
871b24ab676SJeff Bonwick 
872b24ab676SJeff Bonwick 	if (dump_opt['D'] > 1) {
873b24ab676SJeff Bonwick 		(void) printf("DDT histogram (aggregated over all DDTs):\n");
8749eb19f4dSGeorge Wilson 		ddt_get_dedup_histogram(spa, &ddh_total);
8759eb19f4dSGeorge Wilson 		zpool_dump_ddt(&dds_total, &ddh_total);
876b24ab676SJeff Bonwick 	}
877b24ab676SJeff Bonwick 
878b24ab676SJeff Bonwick 	dump_dedup_ratio(&dds_total);
879b24ab676SJeff Bonwick }
880b24ab676SJeff Bonwick 
8818ad4d6ddSJeff Bonwick static void
8820713e232SGeorge Wilson dump_dtl_seg(void *arg, uint64_t start, uint64_t size)
8838ad4d6ddSJeff Bonwick {
8840713e232SGeorge Wilson 	char *prefix = arg;
8858ad4d6ddSJeff Bonwick 
8868ad4d6ddSJeff Bonwick 	(void) printf("%s [%llu,%llu) length %llu\n",
8878ad4d6ddSJeff Bonwick 	    prefix,
8888ad4d6ddSJeff Bonwick 	    (u_longlong_t)start,
8898ad4d6ddSJeff Bonwick 	    (u_longlong_t)(start + size),
8908ad4d6ddSJeff Bonwick 	    (u_longlong_t)(size));
8918ad4d6ddSJeff Bonwick }
8928ad4d6ddSJeff Bonwick 
893fa9e4066Sahrens static void
894fa9e4066Sahrens dump_dtl(vdev_t *vd, int indent)
895fa9e4066Sahrens {
8968ad4d6ddSJeff Bonwick 	spa_t *spa = vd->vdev_spa;
8978ad4d6ddSJeff Bonwick 	boolean_t required;
8988ad4d6ddSJeff Bonwick 	char *name[DTL_TYPES] = { "missing", "partial", "scrub", "outage" };
8998ad4d6ddSJeff Bonwick 	char prefix[256];
9008ad4d6ddSJeff Bonwick 
9018f18d1faSGeorge Wilson 	spa_vdev_state_enter(spa, SCL_NONE);
9028ad4d6ddSJeff Bonwick 	required = vdev_dtl_required(vd);
9038ad4d6ddSJeff Bonwick 	(void) spa_vdev_state_exit(spa, NULL, 0);
904fa9e4066Sahrens 
905fa9e4066Sahrens 	if (indent == 0)
906fa9e4066Sahrens 		(void) printf("\nDirty time logs:\n\n");
907fa9e4066Sahrens 
9088ad4d6ddSJeff Bonwick 	(void) printf("\t%*s%s [%s]\n", indent, "",
909e14bb325SJeff Bonwick 	    vd->vdev_path ? vd->vdev_path :
9108ad4d6ddSJeff Bonwick 	    vd->vdev_parent ? vd->vdev_ops->vdev_op_type : spa_name(spa),
9118ad4d6ddSJeff Bonwick 	    required ? "DTL-required" : "DTL-expendable");
912fa9e4066Sahrens 
9138ad4d6ddSJeff Bonwick 	for (int t = 0; t < DTL_TYPES; t++) {
9140713e232SGeorge Wilson 		range_tree_t *rt = vd->vdev_dtl[t];
9150713e232SGeorge Wilson 		if (range_tree_space(rt) == 0)
9168ad4d6ddSJeff Bonwick 			continue;
9178ad4d6ddSJeff Bonwick 		(void) snprintf(prefix, sizeof (prefix), "\t%*s%s",
9188ad4d6ddSJeff Bonwick 		    indent + 2, "", name[t]);
9190713e232SGeorge Wilson 		mutex_enter(rt->rt_lock);
9200713e232SGeorge Wilson 		range_tree_walk(rt, dump_dtl_seg, prefix);
9210713e232SGeorge Wilson 		mutex_exit(rt->rt_lock);
9228ad4d6ddSJeff Bonwick 		if (dump_opt['d'] > 5 && vd->vdev_children == 0)
9230713e232SGeorge Wilson 			dump_spacemap(spa->spa_meta_objset, vd->vdev_dtl_sm);
924fa9e4066Sahrens 	}
925fa9e4066Sahrens 
9268ad4d6ddSJeff Bonwick 	for (int c = 0; c < vd->vdev_children; c++)
927fa9e4066Sahrens 		dump_dtl(vd->vdev_child[c], indent + 4);
928fa9e4066Sahrens }
929fa9e4066Sahrens 
9308f18d1faSGeorge Wilson static void
9318f18d1faSGeorge Wilson dump_history(spa_t *spa)
9328f18d1faSGeorge Wilson {
9338f18d1faSGeorge Wilson 	nvlist_t **events = NULL;
9348f18d1faSGeorge Wilson 	char buf[SPA_MAXBLOCKSIZE];
935e4161df6SVictor Latushkin 	uint64_t resid, len, off = 0;
9368f18d1faSGeorge Wilson 	uint_t num = 0;
9378f18d1faSGeorge Wilson 	int error;
9388f18d1faSGeorge Wilson 	time_t tsec;
9398f18d1faSGeorge Wilson 	struct tm t;
9408f18d1faSGeorge Wilson 	char tbuf[30];
9418f18d1faSGeorge Wilson 	char internalstr[MAXPATHLEN];
9428f18d1faSGeorge Wilson 
9438f18d1faSGeorge Wilson 	do {
944e4161df6SVictor Latushkin 		len = sizeof (buf);
945e4161df6SVictor Latushkin 
9468f18d1faSGeorge Wilson 		if ((error = spa_history_get(spa, &off, &len, buf)) != 0) {
9478f18d1faSGeorge Wilson 			(void) fprintf(stderr, "Unable to read history: "
9488f18d1faSGeorge Wilson 			    "error %d\n", error);
9498f18d1faSGeorge Wilson 			return;
9508f18d1faSGeorge Wilson 		}
9518f18d1faSGeorge Wilson 
9528f18d1faSGeorge Wilson 		if (zpool_history_unpack(buf, len, &resid, &events, &num) != 0)
9538f18d1faSGeorge Wilson 			break;
9548f18d1faSGeorge Wilson 
9558f18d1faSGeorge Wilson 		off -= resid;
9568f18d1faSGeorge Wilson 	} while (len != 0);
9578f18d1faSGeorge Wilson 
9588f18d1faSGeorge Wilson 	(void) printf("\nHistory:\n");
9598f18d1faSGeorge Wilson 	for (int i = 0; i < num; i++) {
9608f18d1faSGeorge Wilson 		uint64_t time, txg, ievent;
9618f18d1faSGeorge Wilson 		char *cmd, *intstr;
9624445fffbSMatthew Ahrens 		boolean_t printed = B_FALSE;
9638f18d1faSGeorge Wilson 
9648f18d1faSGeorge Wilson 		if (nvlist_lookup_uint64(events[i], ZPOOL_HIST_TIME,
9658f18d1faSGeorge Wilson 		    &time) != 0)
9664445fffbSMatthew Ahrens 			goto next;
9678f18d1faSGeorge Wilson 		if (nvlist_lookup_string(events[i], ZPOOL_HIST_CMD,
9688f18d1faSGeorge Wilson 		    &cmd) != 0) {
9698f18d1faSGeorge Wilson 			if (nvlist_lookup_uint64(events[i],
9708f18d1faSGeorge Wilson 			    ZPOOL_HIST_INT_EVENT, &ievent) != 0)
9714445fffbSMatthew Ahrens 				goto next;
9728f18d1faSGeorge Wilson 			verify(nvlist_lookup_uint64(events[i],
9738f18d1faSGeorge Wilson 			    ZPOOL_HIST_TXG, &txg) == 0);
9748f18d1faSGeorge Wilson 			verify(nvlist_lookup_string(events[i],
9758f18d1faSGeorge Wilson 			    ZPOOL_HIST_INT_STR, &intstr) == 0);
9764445fffbSMatthew Ahrens 			if (ievent >= ZFS_NUM_LEGACY_HISTORY_EVENTS)
9774445fffbSMatthew Ahrens 				goto next;
9788f18d1faSGeorge Wilson 
9798f18d1faSGeorge Wilson 			(void) snprintf(internalstr,
9808f18d1faSGeorge Wilson 			    sizeof (internalstr),
9818f18d1faSGeorge Wilson 			    "[internal %s txg:%lld] %s",
9823f9d6ad7SLin Ling 			    zfs_history_event_names[ievent], txg,
9838f18d1faSGeorge Wilson 			    intstr);
9848f18d1faSGeorge Wilson 			cmd = internalstr;
9858f18d1faSGeorge Wilson 		}
9868f18d1faSGeorge Wilson 		tsec = time;
9878f18d1faSGeorge Wilson 		(void) localtime_r(&tsec, &t);
9888f18d1faSGeorge Wilson 		(void) strftime(tbuf, sizeof (tbuf), "%F.%T", &t);
9898f18d1faSGeorge Wilson 		(void) printf("%s %s\n", tbuf, cmd);
9904445fffbSMatthew Ahrens 		printed = B_TRUE;
9914445fffbSMatthew Ahrens 
9924445fffbSMatthew Ahrens next:
9934445fffbSMatthew Ahrens 		if (dump_opt['h'] > 1) {
9944445fffbSMatthew Ahrens 			if (!printed)
9954445fffbSMatthew Ahrens 				(void) printf("unrecognized record:\n");
9964445fffbSMatthew Ahrens 			dump_nvlist(events[i], 2);
9974445fffbSMatthew Ahrens 		}
9988f18d1faSGeorge Wilson 	}
9998f18d1faSGeorge Wilson }
10008f18d1faSGeorge Wilson 
1001fa9e4066Sahrens /*ARGSUSED*/
1002fa9e4066Sahrens static void
1003fa9e4066Sahrens dump_dnode(objset_t *os, uint64_t object, void *data, size_t size)
1004fa9e4066Sahrens {
1005fa9e4066Sahrens }
1006fa9e4066Sahrens 
1007fa9e4066Sahrens static uint64_t
1008b24ab676SJeff Bonwick blkid2offset(const dnode_phys_t *dnp, const blkptr_t *bp, const zbookmark_t *zb)
1009fa9e4066Sahrens {
1010b24ab676SJeff Bonwick 	if (dnp == NULL) {
1011b24ab676SJeff Bonwick 		ASSERT(zb->zb_level < 0);
1012b24ab676SJeff Bonwick 		if (zb->zb_object == 0)
1013b24ab676SJeff Bonwick 			return (zb->zb_blkid);
1014b24ab676SJeff Bonwick 		return (zb->zb_blkid * BP_GET_LSIZE(bp));
1015b24ab676SJeff Bonwick 	}
1016b24ab676SJeff Bonwick 
1017b24ab676SJeff Bonwick 	ASSERT(zb->zb_level >= 0);
1018fa9e4066Sahrens 
1019b24ab676SJeff Bonwick 	return ((zb->zb_blkid <<
1020b24ab676SJeff Bonwick 	    (zb->zb_level * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT))) *
1021fa9e4066Sahrens 	    dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT);
1022fa9e4066Sahrens }
1023fa9e4066Sahrens 
102444cd46caSbillm static void
1025cde58dbcSMatthew Ahrens sprintf_blkptr_compact(char *blkbuf, const blkptr_t *bp)
102644cd46caSbillm {
1027cde58dbcSMatthew Ahrens 	const dva_t *dva = bp->blk_dva;
1028b24ab676SJeff Bonwick 	int ndvas = dump_opt['d'] > 5 ? BP_GET_NDVAS(bp) : 1;
1029b24ab676SJeff Bonwick 
1030490d05b9SMatthew Ahrens 	if (dump_opt['b'] >= 6) {
1031b24ab676SJeff Bonwick 		sprintf_blkptr(blkbuf, bp);
1032b24ab676SJeff Bonwick 		return;
1033b24ab676SJeff Bonwick 	}
103444cd46caSbillm 
103544cd46caSbillm 	blkbuf[0] = '\0';
103644cd46caSbillm 
1037b24ab676SJeff Bonwick 	for (int i = 0; i < ndvas; i++)
103844cd46caSbillm 		(void) sprintf(blkbuf + strlen(blkbuf), "%llu:%llx:%llx ",
103944cd46caSbillm 		    (u_longlong_t)DVA_GET_VDEV(&dva[i]),
104044cd46caSbillm 		    (u_longlong_t)DVA_GET_OFFSET(&dva[i]),
104144cd46caSbillm 		    (u_longlong_t)DVA_GET_ASIZE(&dva[i]));
104244cd46caSbillm 
1043b24ab676SJeff Bonwick 	(void) sprintf(blkbuf + strlen(blkbuf),
1044b24ab676SJeff Bonwick 	    "%llxL/%llxP F=%llu B=%llu/%llu",
104544cd46caSbillm 	    (u_longlong_t)BP_GET_LSIZE(bp),
104644cd46caSbillm 	    (u_longlong_t)BP_GET_PSIZE(bp),
104744cd46caSbillm 	    (u_longlong_t)bp->blk_fill,
1048b24ab676SJeff Bonwick 	    (u_longlong_t)bp->blk_birth,
1049b24ab676SJeff Bonwick 	    (u_longlong_t)BP_PHYSICAL_BIRTH(bp));
105044cd46caSbillm }
105144cd46caSbillm 
105288b7b0f2SMatthew Ahrens static void
105388b7b0f2SMatthew Ahrens print_indirect(blkptr_t *bp, const zbookmark_t *zb,
105488b7b0f2SMatthew Ahrens     const dnode_phys_t *dnp)
1055fa9e4066Sahrens {
105688b7b0f2SMatthew Ahrens 	char blkbuf[BP_SPRINTF_LEN];
1057fa9e4066Sahrens 	int l;
1058fa9e4066Sahrens 
105988b7b0f2SMatthew Ahrens 	ASSERT3U(BP_GET_TYPE(bp), ==, dnp->dn_type);
106088b7b0f2SMatthew Ahrens 	ASSERT3U(BP_GET_LEVEL(bp), ==, zb->zb_level);
1061fa9e4066Sahrens 
1062b24ab676SJeff Bonwick 	(void) printf("%16llx ", (u_longlong_t)blkid2offset(dnp, bp, zb));
1063fa9e4066Sahrens 
1064fa9e4066Sahrens 	ASSERT(zb->zb_level >= 0);
1065fa9e4066Sahrens 
1066fa9e4066Sahrens 	for (l = dnp->dn_nlevels - 1; l >= -1; l--) {
1067fa9e4066Sahrens 		if (l == zb->zb_level) {
106888b7b0f2SMatthew Ahrens 			(void) printf("L%llx", (u_longlong_t)zb->zb_level);
1069fa9e4066Sahrens 		} else {
107088b7b0f2SMatthew Ahrens 			(void) printf(" ");
1071fa9e4066Sahrens 		}
1072fa9e4066Sahrens 	}
1073fa9e4066Sahrens 
1074b24ab676SJeff Bonwick 	sprintf_blkptr_compact(blkbuf, bp);
107588b7b0f2SMatthew Ahrens 	(void) printf("%s\n", blkbuf);
107688b7b0f2SMatthew Ahrens }
107788b7b0f2SMatthew Ahrens 
107888b7b0f2SMatthew Ahrens static int
107988b7b0f2SMatthew Ahrens visit_indirect(spa_t *spa, const dnode_phys_t *dnp,
108088b7b0f2SMatthew Ahrens     blkptr_t *bp, const zbookmark_t *zb)
108188b7b0f2SMatthew Ahrens {
1082e4161df6SVictor Latushkin 	int err = 0;
108388b7b0f2SMatthew Ahrens 
108488b7b0f2SMatthew Ahrens 	if (bp->blk_birth == 0)
108588b7b0f2SMatthew Ahrens 		return (0);
108688b7b0f2SMatthew Ahrens 
108788b7b0f2SMatthew Ahrens 	print_indirect(bp, zb, dnp);
108888b7b0f2SMatthew Ahrens 
108988b7b0f2SMatthew Ahrens 	if (BP_GET_LEVEL(bp) > 0) {
109088b7b0f2SMatthew Ahrens 		uint32_t flags = ARC_WAIT;
109188b7b0f2SMatthew Ahrens 		int i;
109288b7b0f2SMatthew Ahrens 		blkptr_t *cbp;
109388b7b0f2SMatthew Ahrens 		int epb = BP_GET_LSIZE(bp) >> SPA_BLKPTRSHIFT;
109488b7b0f2SMatthew Ahrens 		arc_buf_t *buf;
109588b7b0f2SMatthew Ahrens 		uint64_t fill = 0;
109688b7b0f2SMatthew Ahrens 
10971b912ec7SGeorge Wilson 		err = arc_read(NULL, spa, bp, arc_getbuf_func, &buf,
109888b7b0f2SMatthew Ahrens 		    ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, zb);
109988b7b0f2SMatthew Ahrens 		if (err)
110088b7b0f2SMatthew Ahrens 			return (err);
11013f9d6ad7SLin Ling 		ASSERT(buf->b_data);
110288b7b0f2SMatthew Ahrens 
110388b7b0f2SMatthew Ahrens 		/* recursively visit blocks below this */
110488b7b0f2SMatthew Ahrens 		cbp = buf->b_data;
110588b7b0f2SMatthew Ahrens 		for (i = 0; i < epb; i++, cbp++) {
110688b7b0f2SMatthew Ahrens 			zbookmark_t czb;
110788b7b0f2SMatthew Ahrens 
110888b7b0f2SMatthew Ahrens 			SET_BOOKMARK(&czb, zb->zb_objset, zb->zb_object,
110988b7b0f2SMatthew Ahrens 			    zb->zb_level - 1,
111088b7b0f2SMatthew Ahrens 			    zb->zb_blkid * epb + i);
111188b7b0f2SMatthew Ahrens 			err = visit_indirect(spa, dnp, cbp, &czb);
111288b7b0f2SMatthew Ahrens 			if (err)
111388b7b0f2SMatthew Ahrens 				break;
111488b7b0f2SMatthew Ahrens 			fill += cbp->blk_fill;
111588b7b0f2SMatthew Ahrens 		}
11168ad4d6ddSJeff Bonwick 		if (!err)
11178ad4d6ddSJeff Bonwick 			ASSERT3U(fill, ==, bp->blk_fill);
111888b7b0f2SMatthew Ahrens 		(void) arc_buf_remove_ref(buf, &buf);
1119fa9e4066Sahrens 	}
1120fa9e4066Sahrens 
112188b7b0f2SMatthew Ahrens 	return (err);
1122fa9e4066Sahrens }
1123fa9e4066Sahrens 
1124fa9e4066Sahrens /*ARGSUSED*/
1125fa9e4066Sahrens static void
112688b7b0f2SMatthew Ahrens dump_indirect(dnode_t *dn)
1127fa9e4066Sahrens {
112888b7b0f2SMatthew Ahrens 	dnode_phys_t *dnp = dn->dn_phys;
112988b7b0f2SMatthew Ahrens 	int j;
113088b7b0f2SMatthew Ahrens 	zbookmark_t czb;
1131fa9e4066Sahrens 
1132fa9e4066Sahrens 	(void) printf("Indirect blocks:\n");
1133fa9e4066Sahrens 
1134503ad85cSMatthew Ahrens 	SET_BOOKMARK(&czb, dmu_objset_id(dn->dn_objset),
113588b7b0f2SMatthew Ahrens 	    dn->dn_object, dnp->dn_nlevels - 1, 0);
113688b7b0f2SMatthew Ahrens 	for (j = 0; j < dnp->dn_nblkptr; j++) {
113788b7b0f2SMatthew Ahrens 		czb.zb_blkid = j;
1138503ad85cSMatthew Ahrens 		(void) visit_indirect(dmu_objset_spa(dn->dn_objset), dnp,
113988b7b0f2SMatthew Ahrens 		    &dnp->dn_blkptr[j], &czb);
114088b7b0f2SMatthew Ahrens 	}
1141fa9e4066Sahrens 
1142fa9e4066Sahrens 	(void) printf("\n");
1143fa9e4066Sahrens }
1144fa9e4066Sahrens 
1145fa9e4066Sahrens /*ARGSUSED*/
1146fa9e4066Sahrens static void
1147fa9e4066Sahrens dump_dsl_dir(objset_t *os, uint64_t object, void *data, size_t size)
1148fa9e4066Sahrens {
1149fa9e4066Sahrens 	dsl_dir_phys_t *dd = data;
1150fa9e4066Sahrens 	time_t crtime;
11513f9d6ad7SLin Ling 	char nice[32];
1152fa9e4066Sahrens 
1153fa9e4066Sahrens 	if (dd == NULL)
1154fa9e4066Sahrens 		return;
1155fa9e4066Sahrens 
1156da6c28aaSamw 	ASSERT3U(size, >=, sizeof (dsl_dir_phys_t));
1157fa9e4066Sahrens 
1158fa9e4066Sahrens 	crtime = dd->dd_creation_time;
1159fa9e4066Sahrens 	(void) printf("\t\tcreation_time = %s", ctime(&crtime));
1160fa9e4066Sahrens 	(void) printf("\t\thead_dataset_obj = %llu\n",
1161fa9e4066Sahrens 	    (u_longlong_t)dd->dd_head_dataset_obj);
1162fa9e4066Sahrens 	(void) printf("\t\tparent_dir_obj = %llu\n",
1163fa9e4066Sahrens 	    (u_longlong_t)dd->dd_parent_obj);
11643cb34c60Sahrens 	(void) printf("\t\torigin_obj = %llu\n",
11653cb34c60Sahrens 	    (u_longlong_t)dd->dd_origin_obj);
1166fa9e4066Sahrens 	(void) printf("\t\tchild_dir_zapobj = %llu\n",
1167fa9e4066Sahrens 	    (u_longlong_t)dd->dd_child_dir_zapobj);
11683f9d6ad7SLin Ling 	zdb_nicenum(dd->dd_used_bytes, nice);
116974e7dc98SMatthew Ahrens 	(void) printf("\t\tused_bytes = %s\n", nice);
11703f9d6ad7SLin Ling 	zdb_nicenum(dd->dd_compressed_bytes, nice);
117174e7dc98SMatthew Ahrens 	(void) printf("\t\tcompressed_bytes = %s\n", nice);
11723f9d6ad7SLin Ling 	zdb_nicenum(dd->dd_uncompressed_bytes, nice);
117374e7dc98SMatthew Ahrens 	(void) printf("\t\tuncompressed_bytes = %s\n", nice);
11743f9d6ad7SLin Ling 	zdb_nicenum(dd->dd_quota, nice);
117574e7dc98SMatthew Ahrens 	(void) printf("\t\tquota = %s\n", nice);
11763f9d6ad7SLin Ling 	zdb_nicenum(dd->dd_reserved, nice);
117774e7dc98SMatthew Ahrens 	(void) printf("\t\treserved = %s\n", nice);
1178fa9e4066Sahrens 	(void) printf("\t\tprops_zapobj = %llu\n",
1179fa9e4066Sahrens 	    (u_longlong_t)dd->dd_props_zapobj);
1180ecd6cf80Smarks 	(void) printf("\t\tdeleg_zapobj = %llu\n",
1181ecd6cf80Smarks 	    (u_longlong_t)dd->dd_deleg_zapobj);
118274e7dc98SMatthew Ahrens 	(void) printf("\t\tflags = %llx\n",
118374e7dc98SMatthew Ahrens 	    (u_longlong_t)dd->dd_flags);
118474e7dc98SMatthew Ahrens 
118574e7dc98SMatthew Ahrens #define	DO(which) \
11863f9d6ad7SLin Ling 	zdb_nicenum(dd->dd_used_breakdown[DD_USED_ ## which], nice); \
118774e7dc98SMatthew Ahrens 	(void) printf("\t\tused_breakdown[" #which "] = %s\n", nice)
118874e7dc98SMatthew Ahrens 	DO(HEAD);
118974e7dc98SMatthew Ahrens 	DO(SNAP);
119074e7dc98SMatthew Ahrens 	DO(CHILD);
119174e7dc98SMatthew Ahrens 	DO(CHILD_RSRV);
119274e7dc98SMatthew Ahrens 	DO(REFRSRV);
119374e7dc98SMatthew Ahrens #undef DO
1194fa9e4066Sahrens }
1195fa9e4066Sahrens 
1196fa9e4066Sahrens /*ARGSUSED*/
1197fa9e4066Sahrens static void
1198fa9e4066Sahrens dump_dsl_dataset(objset_t *os, uint64_t object, void *data, size_t size)
1199fa9e4066Sahrens {
1200fa9e4066Sahrens 	dsl_dataset_phys_t *ds = data;
1201fa9e4066Sahrens 	time_t crtime;
12023f9d6ad7SLin Ling 	char used[32], compressed[32], uncompressed[32], unique[32];
1203fbabab8fSmaybee 	char blkbuf[BP_SPRINTF_LEN];
1204fa9e4066Sahrens 
1205fa9e4066Sahrens 	if (ds == NULL)
1206fa9e4066Sahrens 		return;
1207fa9e4066Sahrens 
1208fa9e4066Sahrens 	ASSERT(size == sizeof (*ds));
1209fa9e4066Sahrens 	crtime = ds->ds_creation_time;
1210ad135b5dSChristopher Siden 	zdb_nicenum(ds->ds_referenced_bytes, used);
12113f9d6ad7SLin Ling 	zdb_nicenum(ds->ds_compressed_bytes, compressed);
12123f9d6ad7SLin Ling 	zdb_nicenum(ds->ds_uncompressed_bytes, uncompressed);
12133f9d6ad7SLin Ling 	zdb_nicenum(ds->ds_unique_bytes, unique);
1214b24ab676SJeff Bonwick 	sprintf_blkptr(blkbuf, &ds->ds_bp);
1215fa9e4066Sahrens 
1216088f3894Sahrens 	(void) printf("\t\tdir_obj = %llu\n",
1217fa9e4066Sahrens 	    (u_longlong_t)ds->ds_dir_obj);
1218fa9e4066Sahrens 	(void) printf("\t\tprev_snap_obj = %llu\n",
1219fa9e4066Sahrens 	    (u_longlong_t)ds->ds_prev_snap_obj);
1220fa9e4066Sahrens 	(void) printf("\t\tprev_snap_txg = %llu\n",
1221fa9e4066Sahrens 	    (u_longlong_t)ds->ds_prev_snap_txg);
1222fa9e4066Sahrens 	(void) printf("\t\tnext_snap_obj = %llu\n",
1223fa9e4066Sahrens 	    (u_longlong_t)ds->ds_next_snap_obj);
1224fa9e4066Sahrens 	(void) printf("\t\tsnapnames_zapobj = %llu\n",
1225fa9e4066Sahrens 	    (u_longlong_t)ds->ds_snapnames_zapobj);
1226fa9e4066Sahrens 	(void) printf("\t\tnum_children = %llu\n",
1227fa9e4066Sahrens 	    (u_longlong_t)ds->ds_num_children);
1228842727c2SChris Kirby 	(void) printf("\t\tuserrefs_obj = %llu\n",
1229842727c2SChris Kirby 	    (u_longlong_t)ds->ds_userrefs_obj);
1230fa9e4066Sahrens 	(void) printf("\t\tcreation_time = %s", ctime(&crtime));
1231fa9e4066Sahrens 	(void) printf("\t\tcreation_txg = %llu\n",
1232fa9e4066Sahrens 	    (u_longlong_t)ds->ds_creation_txg);
1233fa9e4066Sahrens 	(void) printf("\t\tdeadlist_obj = %llu\n",
1234fa9e4066Sahrens 	    (u_longlong_t)ds->ds_deadlist_obj);
1235fa9e4066Sahrens 	(void) printf("\t\tused_bytes = %s\n", used);
1236fa9e4066Sahrens 	(void) printf("\t\tcompressed_bytes = %s\n", compressed);
1237fa9e4066Sahrens 	(void) printf("\t\tuncompressed_bytes = %s\n", uncompressed);
1238fa9e4066Sahrens 	(void) printf("\t\tunique = %s\n", unique);
1239fa9e4066Sahrens 	(void) printf("\t\tfsid_guid = %llu\n",
1240fa9e4066Sahrens 	    (u_longlong_t)ds->ds_fsid_guid);
1241fa9e4066Sahrens 	(void) printf("\t\tguid = %llu\n",
1242fa9e4066Sahrens 	    (u_longlong_t)ds->ds_guid);
124399653d4eSeschrock 	(void) printf("\t\tflags = %llx\n",
124499653d4eSeschrock 	    (u_longlong_t)ds->ds_flags);
1245088f3894Sahrens 	(void) printf("\t\tnext_clones_obj = %llu\n",
1246088f3894Sahrens 	    (u_longlong_t)ds->ds_next_clones_obj);
1247bb0ade09Sahrens 	(void) printf("\t\tprops_obj = %llu\n",
1248bb0ade09Sahrens 	    (u_longlong_t)ds->ds_props_obj);
1249fa9e4066Sahrens 	(void) printf("\t\tbp = %s\n", blkbuf);
1250fa9e4066Sahrens }
1251fa9e4066Sahrens 
1252ad135b5dSChristopher Siden /* ARGSUSED */
1253ad135b5dSChristopher Siden static int
1254ad135b5dSChristopher Siden dump_bptree_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
1255ad135b5dSChristopher Siden {
1256ad135b5dSChristopher Siden 	char blkbuf[BP_SPRINTF_LEN];
1257ad135b5dSChristopher Siden 
1258ad135b5dSChristopher Siden 	if (bp->blk_birth != 0) {
1259ad135b5dSChristopher Siden 		sprintf_blkptr(blkbuf, bp);
1260ad135b5dSChristopher Siden 		(void) printf("\t%s\n", blkbuf);
1261ad135b5dSChristopher Siden 	}
1262ad135b5dSChristopher Siden 	return (0);
1263ad135b5dSChristopher Siden }
1264ad135b5dSChristopher Siden 
1265ad135b5dSChristopher Siden static void
1266ad135b5dSChristopher Siden dump_bptree(objset_t *os, uint64_t obj, char *name)
1267ad135b5dSChristopher Siden {
1268ad135b5dSChristopher Siden 	char bytes[32];
1269ad135b5dSChristopher Siden 	bptree_phys_t *bt;
1270ad135b5dSChristopher Siden 	dmu_buf_t *db;
1271ad135b5dSChristopher Siden 
1272ad135b5dSChristopher Siden 	if (dump_opt['d'] < 3)
1273ad135b5dSChristopher Siden 		return;
1274ad135b5dSChristopher Siden 
1275b420f3adSRichard Lowe 	VERIFY3U(0, ==, dmu_bonus_hold(os, obj, FTAG, &db));
1276ad135b5dSChristopher Siden 	bt = db->db_data;
1277ad135b5dSChristopher Siden 	zdb_nicenum(bt->bt_bytes, bytes);
1278ad135b5dSChristopher Siden 	(void) printf("\n    %s: %llu datasets, %s\n",
1279ad135b5dSChristopher Siden 	    name, (unsigned long long)(bt->bt_end - bt->bt_begin), bytes);
1280ad135b5dSChristopher Siden 	dmu_buf_rele(db, FTAG);
1281ad135b5dSChristopher Siden 
1282ad135b5dSChristopher Siden 	if (dump_opt['d'] < 5)
1283ad135b5dSChristopher Siden 		return;
1284ad135b5dSChristopher Siden 
1285ad135b5dSChristopher Siden 	(void) printf("\n");
1286ad135b5dSChristopher Siden 
1287ad135b5dSChristopher Siden 	(void) bptree_iterate(os, obj, B_FALSE, dump_bptree_cb, NULL, NULL);
1288ad135b5dSChristopher Siden }
1289ad135b5dSChristopher Siden 
1290cde58dbcSMatthew Ahrens /* ARGSUSED */
1291cde58dbcSMatthew Ahrens static int
1292cde58dbcSMatthew Ahrens dump_bpobj_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
1293cde58dbcSMatthew Ahrens {
1294cde58dbcSMatthew Ahrens 	char blkbuf[BP_SPRINTF_LEN];
1295cde58dbcSMatthew Ahrens 
1296cde58dbcSMatthew Ahrens 	ASSERT(bp->blk_birth != 0);
1297cde58dbcSMatthew Ahrens 	sprintf_blkptr_compact(blkbuf, bp);
1298cde58dbcSMatthew Ahrens 	(void) printf("\t%s\n", blkbuf);
1299cde58dbcSMatthew Ahrens 	return (0);
1300cde58dbcSMatthew Ahrens }
1301cde58dbcSMatthew Ahrens 
1302fa9e4066Sahrens static void
1303d0475637SMatthew Ahrens dump_bpobj(bpobj_t *bpo, char *name, int indent)
1304fa9e4066Sahrens {
13053f9d6ad7SLin Ling 	char bytes[32];
13063f9d6ad7SLin Ling 	char comp[32];
13073f9d6ad7SLin Ling 	char uncomp[32];
1308fa9e4066Sahrens 
1309fa9e4066Sahrens 	if (dump_opt['d'] < 3)
1310fa9e4066Sahrens 		return;
1311fa9e4066Sahrens 
1312cde58dbcSMatthew Ahrens 	zdb_nicenum(bpo->bpo_phys->bpo_bytes, bytes);
1313d0475637SMatthew Ahrens 	if (bpo->bpo_havesubobj && bpo->bpo_phys->bpo_subobjs != 0) {
1314cde58dbcSMatthew Ahrens 		zdb_nicenum(bpo->bpo_phys->bpo_comp, comp);
1315cde58dbcSMatthew Ahrens 		zdb_nicenum(bpo->bpo_phys->bpo_uncomp, uncomp);
1316d0475637SMatthew Ahrens 		(void) printf("    %*s: object %llu, %llu local blkptrs, "
1317d0475637SMatthew Ahrens 		    "%llu subobjs, %s (%s/%s comp)\n",
1318d0475637SMatthew Ahrens 		    indent * 8, name,
1319d0475637SMatthew Ahrens 		    (u_longlong_t)bpo->bpo_object,
1320d0475637SMatthew Ahrens 		    (u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
1321cde58dbcSMatthew Ahrens 		    (u_longlong_t)bpo->bpo_phys->bpo_num_subobjs,
132299653d4eSeschrock 		    bytes, comp, uncomp);
1323d0475637SMatthew Ahrens 
1324d0475637SMatthew Ahrens 		for (uint64_t i = 0; i < bpo->bpo_phys->bpo_num_subobjs; i++) {
1325d0475637SMatthew Ahrens 			uint64_t subobj;
1326d0475637SMatthew Ahrens 			bpobj_t subbpo;
1327d0475637SMatthew Ahrens 			int error;
1328d0475637SMatthew Ahrens 			VERIFY0(dmu_read(bpo->bpo_os,
1329d0475637SMatthew Ahrens 			    bpo->bpo_phys->bpo_subobjs,
1330d0475637SMatthew Ahrens 			    i * sizeof (subobj), sizeof (subobj), &subobj, 0));
1331d0475637SMatthew Ahrens 			error = bpobj_open(&subbpo, bpo->bpo_os, subobj);
1332d0475637SMatthew Ahrens 			if (error != 0) {
1333d0475637SMatthew Ahrens 				(void) printf("ERROR %u while trying to open "
1334d0475637SMatthew Ahrens 				    "subobj id %llu\n",
1335d0475637SMatthew Ahrens 				    error, (u_longlong_t)subobj);
1336d0475637SMatthew Ahrens 				continue;
1337d0475637SMatthew Ahrens 			}
1338d0475637SMatthew Ahrens 			dump_bpobj(&subbpo, "subobj", indent + 1);
133977061867SMatthew Ahrens 			bpobj_close(&subbpo);
1340d0475637SMatthew Ahrens 		}
134199653d4eSeschrock 	} else {
1342d0475637SMatthew Ahrens 		(void) printf("    %*s: object %llu, %llu blkptrs, %s\n",
1343d0475637SMatthew Ahrens 		    indent * 8, name,
1344d0475637SMatthew Ahrens 		    (u_longlong_t)bpo->bpo_object,
1345d0475637SMatthew Ahrens 		    (u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
1346d0475637SMatthew Ahrens 		    bytes);
134799653d4eSeschrock 	}
1348fa9e4066Sahrens 
1349cde58dbcSMatthew Ahrens 	if (dump_opt['d'] < 5)
1350fa9e4066Sahrens 		return;
1351fa9e4066Sahrens 
1352fa9e4066Sahrens 
1353d0475637SMatthew Ahrens 	if (indent == 0) {
1354d0475637SMatthew Ahrens 		(void) bpobj_iterate_nofree(bpo, dump_bpobj_cb, NULL, NULL);
1355d0475637SMatthew Ahrens 		(void) printf("\n");
1356d0475637SMatthew Ahrens 	}
1357cde58dbcSMatthew Ahrens }
135844cd46caSbillm 
1359cde58dbcSMatthew Ahrens static void
1360cde58dbcSMatthew Ahrens dump_deadlist(dsl_deadlist_t *dl)
1361cde58dbcSMatthew Ahrens {
1362cde58dbcSMatthew Ahrens 	dsl_deadlist_entry_t *dle;
1363d0475637SMatthew Ahrens 	uint64_t unused;
1364cde58dbcSMatthew Ahrens 	char bytes[32];
1365cde58dbcSMatthew Ahrens 	char comp[32];
1366cde58dbcSMatthew Ahrens 	char uncomp[32];
1367cde58dbcSMatthew Ahrens 
1368cde58dbcSMatthew Ahrens 	if (dump_opt['d'] < 3)
1369cde58dbcSMatthew Ahrens 		return;
1370cde58dbcSMatthew Ahrens 
1371cde58dbcSMatthew Ahrens 	zdb_nicenum(dl->dl_phys->dl_used, bytes);
1372cde58dbcSMatthew Ahrens 	zdb_nicenum(dl->dl_phys->dl_comp, comp);
1373cde58dbcSMatthew Ahrens 	zdb_nicenum(dl->dl_phys->dl_uncomp, uncomp);
1374cde58dbcSMatthew Ahrens 	(void) printf("\n    Deadlist: %s (%s/%s comp)\n",
1375cde58dbcSMatthew Ahrens 	    bytes, comp, uncomp);
1376cde58dbcSMatthew Ahrens 
1377cde58dbcSMatthew Ahrens 	if (dump_opt['d'] < 4)
1378cde58dbcSMatthew Ahrens 		return;
1379cde58dbcSMatthew Ahrens 
1380cde58dbcSMatthew Ahrens 	(void) printf("\n");
1381cde58dbcSMatthew Ahrens 
1382d0475637SMatthew Ahrens 	/* force the tree to be loaded */
1383d0475637SMatthew Ahrens 	dsl_deadlist_space_range(dl, 0, UINT64_MAX, &unused, &unused, &unused);
1384d0475637SMatthew Ahrens 
1385cde58dbcSMatthew Ahrens 	for (dle = avl_first(&dl->dl_tree); dle;
1386cde58dbcSMatthew Ahrens 	    dle = AVL_NEXT(&dl->dl_tree, dle)) {
1387d0475637SMatthew Ahrens 		if (dump_opt['d'] >= 5) {
1388d0475637SMatthew Ahrens 			char buf[128];
1389d0475637SMatthew Ahrens 			(void) snprintf(buf, sizeof (buf), "mintxg %llu -> ",
1390d0475637SMatthew Ahrens 			    (longlong_t)dle->dle_mintxg,
1391d0475637SMatthew Ahrens 			    (longlong_t)dle->dle_bpobj.bpo_object);
1392fa9e4066Sahrens 
1393d0475637SMatthew Ahrens 			dump_bpobj(&dle->dle_bpobj, buf, 0);
1394d0475637SMatthew Ahrens 		} else {
1395d0475637SMatthew Ahrens 			(void) printf("mintxg %llu -> obj %llu\n",
1396d0475637SMatthew Ahrens 			    (longlong_t)dle->dle_mintxg,
1397d0475637SMatthew Ahrens 			    (longlong_t)dle->dle_bpobj.bpo_object);
1398d0475637SMatthew Ahrens 
1399d0475637SMatthew Ahrens 		}
1400cde58dbcSMatthew Ahrens 	}
1401fa9e4066Sahrens }
1402fa9e4066Sahrens 
1403e0d35c44Smarks static avl_tree_t idx_tree;
1404e0d35c44Smarks static avl_tree_t domain_tree;
1405e0d35c44Smarks static boolean_t fuid_table_loaded;
14060a586ceaSMark Shellenbaum static boolean_t sa_loaded;
14070a586ceaSMark Shellenbaum sa_attr_type_t *sa_attr_table;
1408e0d35c44Smarks 
1409e0d35c44Smarks static void
1410e0d35c44Smarks fuid_table_destroy()
1411e0d35c44Smarks {
1412e0d35c44Smarks 	if (fuid_table_loaded) {
1413e0d35c44Smarks 		zfs_fuid_table_destroy(&idx_tree, &domain_tree);
1414e0d35c44Smarks 		fuid_table_loaded = B_FALSE;
1415e0d35c44Smarks 	}
1416e0d35c44Smarks }
1417e0d35c44Smarks 
1418e0d35c44Smarks /*
1419e0d35c44Smarks  * print uid or gid information.
1420e0d35c44Smarks  * For normal POSIX id just the id is printed in decimal format.
1421e0d35c44Smarks  * For CIFS files with FUID the fuid is printed in hex followed by
1422d0475637SMatthew Ahrens  * the domain-rid string.
1423e0d35c44Smarks  */
1424e0d35c44Smarks static void
1425e0d35c44Smarks print_idstr(uint64_t id, const char *id_type)
1426e0d35c44Smarks {
1427e0d35c44Smarks 	if (FUID_INDEX(id)) {
1428e0d35c44Smarks 		char *domain;
1429e0d35c44Smarks 
1430e0d35c44Smarks 		domain = zfs_fuid_idx_domain(&idx_tree, FUID_INDEX(id));
1431e0d35c44Smarks 		(void) printf("\t%s     %llx [%s-%d]\n", id_type,
1432e0d35c44Smarks 		    (u_longlong_t)id, domain, (int)FUID_RID(id));
1433e0d35c44Smarks 	} else {
1434e0d35c44Smarks 		(void) printf("\t%s     %llu\n", id_type, (u_longlong_t)id);
1435e0d35c44Smarks 	}
1436e0d35c44Smarks 
1437e0d35c44Smarks }
1438e0d35c44Smarks 
1439e0d35c44Smarks static void
14400a586ceaSMark Shellenbaum dump_uidgid(objset_t *os, uint64_t uid, uint64_t gid)
1441e0d35c44Smarks {
1442e0d35c44Smarks 	uint32_t uid_idx, gid_idx;
1443e0d35c44Smarks 
14440a586ceaSMark Shellenbaum 	uid_idx = FUID_INDEX(uid);
14450a586ceaSMark Shellenbaum 	gid_idx = FUID_INDEX(gid);
1446e0d35c44Smarks 
1447e0d35c44Smarks 	/* Load domain table, if not already loaded */
1448e0d35c44Smarks 	if (!fuid_table_loaded && (uid_idx || gid_idx)) {
1449e0d35c44Smarks 		uint64_t fuid_obj;
1450e0d35c44Smarks 
1451e0d35c44Smarks 		/* first find the fuid object.  It lives in the master node */
1452e0d35c44Smarks 		VERIFY(zap_lookup(os, MASTER_NODE_OBJ, ZFS_FUID_TABLES,
1453e0d35c44Smarks 		    8, 1, &fuid_obj) == 0);
145489459e17SMark Shellenbaum 		zfs_fuid_avl_tree_create(&idx_tree, &domain_tree);
1455e0d35c44Smarks 		(void) zfs_fuid_table_load(os, fuid_obj,
1456e0d35c44Smarks 		    &idx_tree, &domain_tree);
1457e0d35c44Smarks 		fuid_table_loaded = B_TRUE;
1458e0d35c44Smarks 	}
1459e0d35c44Smarks 
14600a586ceaSMark Shellenbaum 	print_idstr(uid, "uid");
14610a586ceaSMark Shellenbaum 	print_idstr(gid, "gid");
1462e0d35c44Smarks }
1463e0d35c44Smarks 
1464fa9e4066Sahrens /*ARGSUSED*/
1465fa9e4066Sahrens static void
1466fa9e4066Sahrens dump_znode(objset_t *os, uint64_t object, void *data, size_t size)
1467fa9e4066Sahrens {
1468fa9e4066Sahrens 	char path[MAXPATHLEN * 2];	/* allow for xattr and failure prefix */
14690a586ceaSMark Shellenbaum 	sa_handle_t *hdl;
14700a586ceaSMark Shellenbaum 	uint64_t xattr, rdev, gen;
14710a586ceaSMark Shellenbaum 	uint64_t uid, gid, mode, fsize, parent, links;
14728f2529deSMark Shellenbaum 	uint64_t pflags;
14730a586ceaSMark Shellenbaum 	uint64_t acctm[2], modtm[2], chgtm[2], crtm[2];
14740a586ceaSMark Shellenbaum 	time_t z_crtime, z_atime, z_mtime, z_ctime;
14758f2529deSMark Shellenbaum 	sa_bulk_attr_t bulk[12];
14760a586ceaSMark Shellenbaum 	int idx = 0;
147755434c77Sek 	int error;
1478fa9e4066Sahrens 
14790a586ceaSMark Shellenbaum 	if (!sa_loaded) {
14800a586ceaSMark Shellenbaum 		uint64_t sa_attrs = 0;
14810a586ceaSMark Shellenbaum 		uint64_t version;
14820a586ceaSMark Shellenbaum 
14830a586ceaSMark Shellenbaum 		VERIFY(zap_lookup(os, MASTER_NODE_OBJ, ZPL_VERSION_STR,
14840a586ceaSMark Shellenbaum 		    8, 1, &version) == 0);
14850a586ceaSMark Shellenbaum 		if (version >= ZPL_VERSION_SA) {
14860a586ceaSMark Shellenbaum 			VERIFY(zap_lookup(os, MASTER_NODE_OBJ, ZFS_SA_ATTRS,
14870a586ceaSMark Shellenbaum 			    8, 1, &sa_attrs) == 0);
14880a586ceaSMark Shellenbaum 		}
14891d8ccc7bSMark Shellenbaum 		if ((error = sa_setup(os, sa_attrs, zfs_attr_table,
14901d8ccc7bSMark Shellenbaum 		    ZPL_END, &sa_attr_table)) != 0) {
14911d8ccc7bSMark Shellenbaum 			(void) printf("sa_setup failed errno %d, can't "
14921d8ccc7bSMark Shellenbaum 			    "display znode contents\n", error);
14931d8ccc7bSMark Shellenbaum 			return;
14941d8ccc7bSMark Shellenbaum 		}
14950a586ceaSMark Shellenbaum 		sa_loaded = B_TRUE;
14960a586ceaSMark Shellenbaum 	}
14970a586ceaSMark Shellenbaum 
14980a586ceaSMark Shellenbaum 	if (sa_handle_get(os, object, NULL, SA_HDL_PRIVATE, &hdl)) {
14990a586ceaSMark Shellenbaum 		(void) printf("Failed to get handle for SA znode\n");
15000a586ceaSMark Shellenbaum 		return;
15010a586ceaSMark Shellenbaum 	}
15020a586ceaSMark Shellenbaum 
15030a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_UID], NULL, &uid, 8);
15040a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_GID], NULL, &gid, 8);
15050a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_LINKS], NULL,
15060a586ceaSMark Shellenbaum 	    &links, 8);
15070a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_GEN], NULL, &gen, 8);
15080a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_MODE], NULL,
15090a586ceaSMark Shellenbaum 	    &mode, 8);
15100a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_PARENT],
15110a586ceaSMark Shellenbaum 	    NULL, &parent, 8);
15120a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_SIZE], NULL,
15130a586ceaSMark Shellenbaum 	    &fsize, 8);
15140a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_ATIME], NULL,
15150a586ceaSMark Shellenbaum 	    acctm, 16);
15160a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_MTIME], NULL,
15170a586ceaSMark Shellenbaum 	    modtm, 16);
15180a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_CRTIME], NULL,
15190a586ceaSMark Shellenbaum 	    crtm, 16);
15200a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_CTIME], NULL,
15210a586ceaSMark Shellenbaum 	    chgtm, 16);
15228f2529deSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_FLAGS], NULL,
15238f2529deSMark Shellenbaum 	    &pflags, 8);
15240a586ceaSMark Shellenbaum 
15250a586ceaSMark Shellenbaum 	if (sa_bulk_lookup(hdl, bulk, idx)) {
15260a586ceaSMark Shellenbaum 		(void) sa_handle_destroy(hdl);
15270a586ceaSMark Shellenbaum 		return;
15280a586ceaSMark Shellenbaum 	}
1529fa9e4066Sahrens 
153055434c77Sek 	error = zfs_obj_to_path(os, object, path, sizeof (path));
153155434c77Sek 	if (error != 0) {
153255434c77Sek 		(void) snprintf(path, sizeof (path), "\?\?\?<object#%llu>",
153355434c77Sek 		    (u_longlong_t)object);
153455434c77Sek 	}
1535fa9e4066Sahrens 	if (dump_opt['d'] < 3) {
153655434c77Sek 		(void) printf("\t%s\n", path);
15370a586ceaSMark Shellenbaum 		(void) sa_handle_destroy(hdl);
1538fa9e4066Sahrens 		return;
1539fa9e4066Sahrens 	}
1540fa9e4066Sahrens 
15410a586ceaSMark Shellenbaum 	z_crtime = (time_t)crtm[0];
15420a586ceaSMark Shellenbaum 	z_atime = (time_t)acctm[0];
15430a586ceaSMark Shellenbaum 	z_mtime = (time_t)modtm[0];
15440a586ceaSMark Shellenbaum 	z_ctime = (time_t)chgtm[0];
1545fa9e4066Sahrens 
154655434c77Sek 	(void) printf("\tpath	%s\n", path);
15470a586ceaSMark Shellenbaum 	dump_uidgid(os, uid, gid);
1548fa9e4066Sahrens 	(void) printf("\tatime	%s", ctime(&z_atime));
1549fa9e4066Sahrens 	(void) printf("\tmtime	%s", ctime(&z_mtime));
1550fa9e4066Sahrens 	(void) printf("\tctime	%s", ctime(&z_ctime));
1551fa9e4066Sahrens 	(void) printf("\tcrtime	%s", ctime(&z_crtime));
15520a586ceaSMark Shellenbaum 	(void) printf("\tgen	%llu\n", (u_longlong_t)gen);
15530a586ceaSMark Shellenbaum 	(void) printf("\tmode	%llo\n", (u_longlong_t)mode);
15540a586ceaSMark Shellenbaum 	(void) printf("\tsize	%llu\n", (u_longlong_t)fsize);
15550a586ceaSMark Shellenbaum 	(void) printf("\tparent	%llu\n", (u_longlong_t)parent);
15560a586ceaSMark Shellenbaum 	(void) printf("\tlinks	%llu\n", (u_longlong_t)links);
15578f2529deSMark Shellenbaum 	(void) printf("\tpflags	%llx\n", (u_longlong_t)pflags);
15580a586ceaSMark Shellenbaum 	if (sa_lookup(hdl, sa_attr_table[ZPL_XATTR], &xattr,
15590a586ceaSMark Shellenbaum 	    sizeof (uint64_t)) == 0)
15600a586ceaSMark Shellenbaum 		(void) printf("\txattr	%llu\n", (u_longlong_t)xattr);
15610a586ceaSMark Shellenbaum 	if (sa_lookup(hdl, sa_attr_table[ZPL_RDEV], &rdev,
15620a586ceaSMark Shellenbaum 	    sizeof (uint64_t)) == 0)
15630a586ceaSMark Shellenbaum 		(void) printf("\trdev	0x%016llx\n", (u_longlong_t)rdev);
15640a586ceaSMark Shellenbaum 	sa_handle_destroy(hdl);
1565fa9e4066Sahrens }
1566fa9e4066Sahrens 
1567fa9e4066Sahrens /*ARGSUSED*/
1568fa9e4066Sahrens static void
1569fa9e4066Sahrens dump_acl(objset_t *os, uint64_t object, void *data, size_t size)
1570fa9e4066Sahrens {
1571fa9e4066Sahrens }
1572fa9e4066Sahrens 
1573fa9e4066Sahrens /*ARGSUSED*/
1574fa9e4066Sahrens static void
1575fa9e4066Sahrens dump_dmu_objset(objset_t *os, uint64_t object, void *data, size_t size)
1576fa9e4066Sahrens {
1577fa9e4066Sahrens }
1578fa9e4066Sahrens 
15796de8f417SVictor Latushkin static object_viewer_t *object_viewer[DMU_OT_NUMTYPES + 1] = {
1580fa9e4066Sahrens 	dump_none,		/* unallocated			*/
1581fa9e4066Sahrens 	dump_zap,		/* object directory		*/
1582fa9e4066Sahrens 	dump_uint64,		/* object array			*/
1583fa9e4066Sahrens 	dump_none,		/* packed nvlist		*/
1584fa9e4066Sahrens 	dump_packed_nvlist,	/* packed nvlist size		*/
1585fa9e4066Sahrens 	dump_none,		/* bplist			*/
1586fa9e4066Sahrens 	dump_none,		/* bplist header		*/
1587fa9e4066Sahrens 	dump_none,		/* SPA space map header		*/
1588fa9e4066Sahrens 	dump_none,		/* SPA space map		*/
1589fa9e4066Sahrens 	dump_none,		/* ZIL intent log		*/
1590fa9e4066Sahrens 	dump_dnode,		/* DMU dnode			*/
1591fa9e4066Sahrens 	dump_dmu_objset,	/* DMU objset			*/
1592ea8dc4b6Seschrock 	dump_dsl_dir,		/* DSL directory		*/
1593fa9e4066Sahrens 	dump_zap,		/* DSL directory child map	*/
1594fa9e4066Sahrens 	dump_zap,		/* DSL dataset snap map		*/
1595fa9e4066Sahrens 	dump_zap,		/* DSL props			*/
1596fa9e4066Sahrens 	dump_dsl_dataset,	/* DSL dataset			*/
1597fa9e4066Sahrens 	dump_znode,		/* ZFS znode			*/
1598da6c28aaSamw 	dump_acl,		/* ZFS V0 ACL			*/
1599fa9e4066Sahrens 	dump_uint8,		/* ZFS plain file		*/
1600e7437265Sahrens 	dump_zpldir,		/* ZFS directory		*/
1601fa9e4066Sahrens 	dump_zap,		/* ZFS master node		*/
1602fa9e4066Sahrens 	dump_zap,		/* ZFS delete queue		*/
1603fa9e4066Sahrens 	dump_uint8,		/* zvol object			*/
1604fa9e4066Sahrens 	dump_zap,		/* zvol prop			*/
1605fa9e4066Sahrens 	dump_uint8,		/* other uint8[]		*/
1606fa9e4066Sahrens 	dump_uint64,		/* other uint64[]		*/
1607fa9e4066Sahrens 	dump_zap,		/* other ZAP			*/
1608ea8dc4b6Seschrock 	dump_zap,		/* persistent error log		*/
160906eeb2adSek 	dump_uint8,		/* SPA history			*/
16104445fffbSMatthew Ahrens 	dump_history_offsets,	/* SPA history offsets		*/
1611b1b8ab34Slling 	dump_zap,		/* Pool properties		*/
1612ecd6cf80Smarks 	dump_zap,		/* DSL permissions		*/
1613da6c28aaSamw 	dump_acl,		/* ZFS ACL			*/
1614da6c28aaSamw 	dump_uint8,		/* ZFS SYSACL			*/
1615da6c28aaSamw 	dump_none,		/* FUID nvlist			*/
1616da6c28aaSamw 	dump_packed_nvlist,	/* FUID nvlist size		*/
1617088f3894Sahrens 	dump_zap,		/* DSL dataset next clones	*/
1618088f3894Sahrens 	dump_zap,		/* DSL scrub queue		*/
161914843421SMatthew Ahrens 	dump_zap,		/* ZFS user/group used		*/
162014843421SMatthew Ahrens 	dump_zap,		/* ZFS user/group quota		*/
1621842727c2SChris Kirby 	dump_zap,		/* snapshot refcount tags	*/
1622486ae710SMatthew Ahrens 	dump_ddt_zap,		/* DDT ZAP object		*/
1623b24ab676SJeff Bonwick 	dump_zap,		/* DDT statistics		*/
16240a586ceaSMark Shellenbaum 	dump_znode,		/* SA object			*/
16250a586ceaSMark Shellenbaum 	dump_zap,		/* SA Master Node		*/
16260a586ceaSMark Shellenbaum 	dump_sa_attrs,		/* SA attribute registration	*/
16270a586ceaSMark Shellenbaum 	dump_sa_layouts,	/* SA attribute layouts		*/
16283f9d6ad7SLin Ling 	dump_zap,		/* DSL scrub translations	*/
16293f9d6ad7SLin Ling 	dump_none,		/* fake dedup BP		*/
1630cde58dbcSMatthew Ahrens 	dump_zap,		/* deadlist			*/
1631cde58dbcSMatthew Ahrens 	dump_none,		/* deadlist hdr			*/
1632cde58dbcSMatthew Ahrens 	dump_zap,		/* dsl clones			*/
1633cde58dbcSMatthew Ahrens 	dump_none,		/* bpobj subobjs		*/
16340a586ceaSMark Shellenbaum 	dump_unknown,		/* Unknown type, must be last	*/
1635fa9e4066Sahrens };
1636fa9e4066Sahrens 
1637fa9e4066Sahrens static void
1638fa9e4066Sahrens dump_object(objset_t *os, uint64_t object, int verbosity, int *print_header)
1639fa9e4066Sahrens {
1640fa9e4066Sahrens 	dmu_buf_t *db = NULL;
1641fa9e4066Sahrens 	dmu_object_info_t doi;
1642fa9e4066Sahrens 	dnode_t *dn;
1643fa9e4066Sahrens 	void *bonus = NULL;
1644fa9e4066Sahrens 	size_t bsize = 0;
16453f9d6ad7SLin Ling 	char iblk[32], dblk[32], lsize[32], asize[32], fill[32];
16463f9d6ad7SLin Ling 	char bonus_size[32];
1647fa9e4066Sahrens 	char aux[50];
1648fa9e4066Sahrens 	int error;
1649fa9e4066Sahrens 
1650fa9e4066Sahrens 	if (*print_header) {
1651b24ab676SJeff Bonwick 		(void) printf("\n%10s  %3s  %5s  %5s  %5s  %5s  %6s  %s\n",
1652b24ab676SJeff Bonwick 		    "Object", "lvl", "iblk", "dblk", "dsize", "lsize",
1653b24ab676SJeff Bonwick 		    "%full", "type");
1654fa9e4066Sahrens 		*print_header = 0;
1655fa9e4066Sahrens 	}
1656fa9e4066Sahrens 
1657fa9e4066Sahrens 	if (object == 0) {
1658744947dcSTom Erickson 		dn = DMU_META_DNODE(os);
1659fa9e4066Sahrens 	} else {
1660ea8dc4b6Seschrock 		error = dmu_bonus_hold(os, object, FTAG, &db);
1661ea8dc4b6Seschrock 		if (error)
1662ea8dc4b6Seschrock 			fatal("dmu_bonus_hold(%llu) failed, errno %u",
1663ea8dc4b6Seschrock 			    object, error);
1664fa9e4066Sahrens 		bonus = db->db_data;
1665fa9e4066Sahrens 		bsize = db->db_size;
1666744947dcSTom Erickson 		dn = DB_DNODE((dmu_buf_impl_t *)db);
1667fa9e4066Sahrens 	}
1668fa9e4066Sahrens 	dmu_object_info_from_dnode(dn, &doi);
1669fa9e4066Sahrens 
16703f9d6ad7SLin Ling 	zdb_nicenum(doi.doi_metadata_block_size, iblk);
16713f9d6ad7SLin Ling 	zdb_nicenum(doi.doi_data_block_size, dblk);
16723f9d6ad7SLin Ling 	zdb_nicenum(doi.doi_max_offset, lsize);
16733f9d6ad7SLin Ling 	zdb_nicenum(doi.doi_physical_blocks_512 << 9, asize);
16743f9d6ad7SLin Ling 	zdb_nicenum(doi.doi_bonus_size, bonus_size);
1675b24ab676SJeff Bonwick 	(void) sprintf(fill, "%6.2f", 100.0 * doi.doi_fill_count *
1676bbfd46c4SJeff Bonwick 	    doi.doi_data_block_size / (object == 0 ? DNODES_PER_BLOCK : 1) /
1677bbfd46c4SJeff Bonwick 	    doi.doi_max_offset);
1678fa9e4066Sahrens 
1679fa9e4066Sahrens 	aux[0] = '\0';
1680fa9e4066Sahrens 
1681e7437265Sahrens 	if (doi.doi_checksum != ZIO_CHECKSUM_INHERIT || verbosity >= 6) {
1682fa9e4066Sahrens 		(void) snprintf(aux + strlen(aux), sizeof (aux), " (K=%s)",
16836de8f417SVictor Latushkin 		    ZDB_CHECKSUM_NAME(doi.doi_checksum));
1684e7437265Sahrens 	}
1685fa9e4066Sahrens 
1686e7437265Sahrens 	if (doi.doi_compress != ZIO_COMPRESS_INHERIT || verbosity >= 6) {
1687fa9e4066Sahrens 		(void) snprintf(aux + strlen(aux), sizeof (aux), " (Z=%s)",
16886de8f417SVictor Latushkin 		    ZDB_COMPRESS_NAME(doi.doi_compress));
1689e7437265Sahrens 	}
1690fa9e4066Sahrens 
1691b24ab676SJeff Bonwick 	(void) printf("%10lld  %3u  %5s  %5s  %5s  %5s  %6s  %s%s\n",
1692b24ab676SJeff Bonwick 	    (u_longlong_t)object, doi.doi_indirection, iblk, dblk,
1693b24ab676SJeff Bonwick 	    asize, lsize, fill, ZDB_OT_NAME(doi.doi_type), aux);
1694fa9e4066Sahrens 
1695fa9e4066Sahrens 	if (doi.doi_bonus_type != DMU_OT_NONE && verbosity > 3) {
1696b24ab676SJeff Bonwick 		(void) printf("%10s  %3s  %5s  %5s  %5s  %5s  %6s  %s\n",
1697b24ab676SJeff Bonwick 		    "", "", "", "", "", bonus_size, "bonus",
16986de8f417SVictor Latushkin 		    ZDB_OT_NAME(doi.doi_bonus_type));
1699fa9e4066Sahrens 	}
1700fa9e4066Sahrens 
1701fa9e4066Sahrens 	if (verbosity >= 4) {
17020a586ceaSMark Shellenbaum 		(void) printf("\tdnode flags: %s%s%s\n",
170314843421SMatthew Ahrens 		    (dn->dn_phys->dn_flags & DNODE_FLAG_USED_BYTES) ?
170414843421SMatthew Ahrens 		    "USED_BYTES " : "",
170514843421SMatthew Ahrens 		    (dn->dn_phys->dn_flags & DNODE_FLAG_USERUSED_ACCOUNTED) ?
17060a586ceaSMark Shellenbaum 		    "USERUSED_ACCOUNTED " : "",
17070a586ceaSMark Shellenbaum 		    (dn->dn_phys->dn_flags & DNODE_FLAG_SPILL_BLKPTR) ?
17080a586ceaSMark Shellenbaum 		    "SPILL_BLKPTR" : "");
170914843421SMatthew Ahrens 		(void) printf("\tdnode maxblkid: %llu\n",
171014843421SMatthew Ahrens 		    (longlong_t)dn->dn_phys->dn_maxblkid);
171114843421SMatthew Ahrens 
17126de8f417SVictor Latushkin 		object_viewer[ZDB_OT_TYPE(doi.doi_bonus_type)](os, object,
17136de8f417SVictor Latushkin 		    bonus, bsize);
17146de8f417SVictor Latushkin 		object_viewer[ZDB_OT_TYPE(doi.doi_type)](os, object, NULL, 0);
1715fa9e4066Sahrens 		*print_header = 1;
1716fa9e4066Sahrens 	}
1717fa9e4066Sahrens 
1718fa9e4066Sahrens 	if (verbosity >= 5)
171988b7b0f2SMatthew Ahrens 		dump_indirect(dn);
1720fa9e4066Sahrens 
1721fa9e4066Sahrens 	if (verbosity >= 5) {
1722fa9e4066Sahrens 		/*
1723fa9e4066Sahrens 		 * Report the list of segments that comprise the object.
1724fa9e4066Sahrens 		 */
1725fa9e4066Sahrens 		uint64_t start = 0;
1726fa9e4066Sahrens 		uint64_t end;
1727fa9e4066Sahrens 		uint64_t blkfill = 1;
1728fa9e4066Sahrens 		int minlvl = 1;
1729fa9e4066Sahrens 
1730fa9e4066Sahrens 		if (dn->dn_type == DMU_OT_DNODE) {
1731fa9e4066Sahrens 			minlvl = 0;
1732fa9e4066Sahrens 			blkfill = DNODES_PER_BLOCK;
1733fa9e4066Sahrens 		}
1734fa9e4066Sahrens 
1735fa9e4066Sahrens 		for (;;) {
17363f9d6ad7SLin Ling 			char segsize[32];
1737cdb0ab79Smaybee 			error = dnode_next_offset(dn,
1738cdb0ab79Smaybee 			    0, &start, minlvl, blkfill, 0);
1739fa9e4066Sahrens 			if (error)
1740fa9e4066Sahrens 				break;
1741fa9e4066Sahrens 			end = start;
1742cdb0ab79Smaybee 			error = dnode_next_offset(dn,
1743cdb0ab79Smaybee 			    DNODE_FIND_HOLE, &end, minlvl, blkfill, 0);
17443f9d6ad7SLin Ling 			zdb_nicenum(end - start, segsize);
1745fa9e4066Sahrens 			(void) printf("\t\tsegment [%016llx, %016llx)"
1746fa9e4066Sahrens 			    " size %5s\n", (u_longlong_t)start,
1747fa9e4066Sahrens 			    (u_longlong_t)end, segsize);
1748fa9e4066Sahrens 			if (error)
1749fa9e4066Sahrens 				break;
1750fa9e4066Sahrens 			start = end;
1751fa9e4066Sahrens 		}
1752fa9e4066Sahrens 	}
1753fa9e4066Sahrens 
1754fa9e4066Sahrens 	if (db != NULL)
1755ea8dc4b6Seschrock 		dmu_buf_rele(db, FTAG);
1756fa9e4066Sahrens }
1757fa9e4066Sahrens 
1758fa9e4066Sahrens static char *objset_types[DMU_OST_NUMTYPES] = {
1759fa9e4066Sahrens 	"NONE", "META", "ZPL", "ZVOL", "OTHER", "ANY" };
1760fa9e4066Sahrens 
1761fa9e4066Sahrens static void
1762fa9e4066Sahrens dump_dir(objset_t *os)
1763fa9e4066Sahrens {
1764fa9e4066Sahrens 	dmu_objset_stats_t dds;
1765fa9e4066Sahrens 	uint64_t object, object_count;
1766a2eea2e1Sahrens 	uint64_t refdbytes, usedobjs, scratch;
17673f9d6ad7SLin Ling 	char numbuf[32];
176814843421SMatthew Ahrens 	char blkbuf[BP_SPRINTF_LEN + 20];
1769fa9e4066Sahrens 	char osname[MAXNAMELEN];
1770fa9e4066Sahrens 	char *type = "UNKNOWN";
1771fa9e4066Sahrens 	int verbosity = dump_opt['d'];
1772fa9e4066Sahrens 	int print_header = 1;
1773fa9e4066Sahrens 	int i, error;
1774fa9e4066Sahrens 
17753b2aab18SMatthew Ahrens 	dsl_pool_config_enter(dmu_objset_pool(os), FTAG);
1776a2eea2e1Sahrens 	dmu_objset_fast_stat(os, &dds);
17773b2aab18SMatthew Ahrens 	dsl_pool_config_exit(dmu_objset_pool(os), FTAG);
1778fa9e4066Sahrens 
1779fa9e4066Sahrens 	if (dds.dds_type < DMU_OST_NUMTYPES)
1780fa9e4066Sahrens 		type = objset_types[dds.dds_type];
1781fa9e4066Sahrens 
1782fa9e4066Sahrens 	if (dds.dds_type == DMU_OST_META) {
1783fa9e4066Sahrens 		dds.dds_creation_txg = TXG_INITIAL;
1784503ad85cSMatthew Ahrens 		usedobjs = os->os_rootbp->blk_fill;
1785503ad85cSMatthew Ahrens 		refdbytes = os->os_spa->spa_dsl_pool->
178674e7dc98SMatthew Ahrens 		    dp_mos_dir->dd_phys->dd_used_bytes;
1787a2eea2e1Sahrens 	} else {
1788a2eea2e1Sahrens 		dmu_objset_space(os, &refdbytes, &scratch, &usedobjs, &scratch);
1789fa9e4066Sahrens 	}
1790fa9e4066Sahrens 
1791503ad85cSMatthew Ahrens 	ASSERT3U(usedobjs, ==, os->os_rootbp->blk_fill);
1792fa9e4066Sahrens 
17933f9d6ad7SLin Ling 	zdb_nicenum(refdbytes, numbuf);
1794fa9e4066Sahrens 
1795fa9e4066Sahrens 	if (verbosity >= 4) {
1796e4161df6SVictor Latushkin 		(void) sprintf(blkbuf, ", rootbp ");
1797b24ab676SJeff Bonwick 		(void) sprintf_blkptr(blkbuf + strlen(blkbuf), os->os_rootbp);
1798fa9e4066Sahrens 	} else {
1799fa9e4066Sahrens 		blkbuf[0] = '\0';
1800fa9e4066Sahrens 	}
1801fa9e4066Sahrens 
1802fa9e4066Sahrens 	dmu_objset_name(os, osname);
1803fa9e4066Sahrens 
1804a2eea2e1Sahrens 	(void) printf("Dataset %s [%s], ID %llu, cr_txg %llu, "
1805fa9e4066Sahrens 	    "%s, %llu objects%s\n",
1806fa9e4066Sahrens 	    osname, type, (u_longlong_t)dmu_objset_id(os),
1807fa9e4066Sahrens 	    (u_longlong_t)dds.dds_creation_txg,
1808a2eea2e1Sahrens 	    numbuf, (u_longlong_t)usedobjs, blkbuf);
1809fa9e4066Sahrens 
1810b24ab676SJeff Bonwick 	if (zopt_objects != 0) {
1811b24ab676SJeff Bonwick 		for (i = 0; i < zopt_objects; i++)
1812b24ab676SJeff Bonwick 			dump_object(os, zopt_object[i], verbosity,
1813b24ab676SJeff Bonwick 			    &print_header);
1814b24ab676SJeff Bonwick 		(void) printf("\n");
1815b24ab676SJeff Bonwick 		return;
1816b24ab676SJeff Bonwick 	}
1817b24ab676SJeff Bonwick 
1818b24ab676SJeff Bonwick 	if (dump_opt['i'] != 0 || verbosity >= 2)
1819b24ab676SJeff Bonwick 		dump_intent_log(dmu_objset_zil(os));
1820fa9e4066Sahrens 
1821fa9e4066Sahrens 	if (dmu_objset_ds(os) != NULL)
1822cde58dbcSMatthew Ahrens 		dump_deadlist(&dmu_objset_ds(os)->ds_deadlist);
1823fa9e4066Sahrens 
1824fa9e4066Sahrens 	if (verbosity < 2)
1825fa9e4066Sahrens 		return;
1826fa9e4066Sahrens 
1827503ad85cSMatthew Ahrens 	if (os->os_rootbp->blk_birth == 0)
1828088f3894Sahrens 		return;
1829088f3894Sahrens 
1830fa9e4066Sahrens 	dump_object(os, 0, verbosity, &print_header);
183114843421SMatthew Ahrens 	object_count = 0;
1832744947dcSTom Erickson 	if (DMU_USERUSED_DNODE(os) != NULL &&
1833744947dcSTom Erickson 	    DMU_USERUSED_DNODE(os)->dn_type != 0) {
183414843421SMatthew Ahrens 		dump_object(os, DMU_USERUSED_OBJECT, verbosity, &print_header);
183514843421SMatthew Ahrens 		dump_object(os, DMU_GROUPUSED_OBJECT, verbosity, &print_header);
183614843421SMatthew Ahrens 	}
1837fa9e4066Sahrens 
1838fa9e4066Sahrens 	object = 0;
18396754306eSahrens 	while ((error = dmu_object_next(os, &object, B_FALSE, 0)) == 0) {
1840fa9e4066Sahrens 		dump_object(os, object, verbosity, &print_header);
1841fa9e4066Sahrens 		object_count++;
1842fa9e4066Sahrens 	}
1843fa9e4066Sahrens 
1844a2eea2e1Sahrens 	ASSERT3U(object_count, ==, usedobjs);
1845fa9e4066Sahrens 
1846fa9e4066Sahrens 	(void) printf("\n");
1847fa9e4066Sahrens 
1848ccba0801SRich Morris 	if (error != ESRCH) {
1849ccba0801SRich Morris 		(void) fprintf(stderr, "dmu_object_next() = %d\n", error);
1850ccba0801SRich Morris 		abort();
1851ccba0801SRich Morris 	}
1852fa9e4066Sahrens }
1853fa9e4066Sahrens 
1854fa9e4066Sahrens static void
185553b9a4a9SVictor Latushkin dump_uberblock(uberblock_t *ub, const char *header, const char *footer)
1856fa9e4066Sahrens {
1857fa9e4066Sahrens 	time_t timestamp = ub->ub_timestamp;
1858fa9e4066Sahrens 
185953b9a4a9SVictor Latushkin 	(void) printf(header ? header : "");
1860fa9e4066Sahrens 	(void) printf("\tmagic = %016llx\n", (u_longlong_t)ub->ub_magic);
1861fa9e4066Sahrens 	(void) printf("\tversion = %llu\n", (u_longlong_t)ub->ub_version);
1862fa9e4066Sahrens 	(void) printf("\ttxg = %llu\n", (u_longlong_t)ub->ub_txg);
1863fa9e4066Sahrens 	(void) printf("\tguid_sum = %llu\n", (u_longlong_t)ub->ub_guid_sum);
1864fa9e4066Sahrens 	(void) printf("\ttimestamp = %llu UTC = %s",
1865fa9e4066Sahrens 	    (u_longlong_t)ub->ub_timestamp, asctime(localtime(&timestamp)));
1866fa9e4066Sahrens 	if (dump_opt['u'] >= 3) {
1867fbabab8fSmaybee 		char blkbuf[BP_SPRINTF_LEN];
1868b24ab676SJeff Bonwick 		sprintf_blkptr(blkbuf, &ub->ub_rootbp);
1869fa9e4066Sahrens 		(void) printf("\trootbp = %s\n", blkbuf);
1870fa9e4066Sahrens 	}
187153b9a4a9SVictor Latushkin 	(void) printf(footer ? footer : "");
1872fa9e4066Sahrens }
1873fa9e4066Sahrens 
1874fa9e4066Sahrens static void
187507428bdfSVictor Latushkin dump_config(spa_t *spa)
1876fa9e4066Sahrens {
187707428bdfSVictor Latushkin 	dmu_buf_t *db;
187807428bdfSVictor Latushkin 	size_t nvsize = 0;
187907428bdfSVictor Latushkin 	int error = 0;
188007428bdfSVictor Latushkin 
1881fa9e4066Sahrens 
188207428bdfSVictor Latushkin 	error = dmu_bonus_hold(spa->spa_meta_objset,
188307428bdfSVictor Latushkin 	    spa->spa_config_object, FTAG, &db);
188407428bdfSVictor Latushkin 
188507428bdfSVictor Latushkin 	if (error == 0) {
188607428bdfSVictor Latushkin 		nvsize = *(uint64_t *)db->db_data;
188707428bdfSVictor Latushkin 		dmu_buf_rele(db, FTAG);
188807428bdfSVictor Latushkin 
188907428bdfSVictor Latushkin 		(void) printf("\nMOS Configuration:\n");
189007428bdfSVictor Latushkin 		dump_packed_nvlist(spa->spa_meta_objset,
189107428bdfSVictor Latushkin 		    spa->spa_config_object, (void *)&nvsize, 1);
189207428bdfSVictor Latushkin 	} else {
189307428bdfSVictor Latushkin 		(void) fprintf(stderr, "dmu_bonus_hold(%llu) failed, errno %d",
189407428bdfSVictor Latushkin 		    (u_longlong_t)spa->spa_config_object, error);
1895fa9e4066Sahrens 	}
1896fa9e4066Sahrens }
1897fa9e4066Sahrens 
1898c5904d13Seschrock static void
1899c5904d13Seschrock dump_cachefile(const char *cachefile)
1900c5904d13Seschrock {
1901c5904d13Seschrock 	int fd;
1902c5904d13Seschrock 	struct stat64 statbuf;
1903c5904d13Seschrock 	char *buf;
1904c5904d13Seschrock 	nvlist_t *config;
1905c5904d13Seschrock 
1906c5904d13Seschrock 	if ((fd = open64(cachefile, O_RDONLY)) < 0) {
1907c5904d13Seschrock 		(void) printf("cannot open '%s': %s\n", cachefile,
1908c5904d13Seschrock 		    strerror(errno));
1909c5904d13Seschrock 		exit(1);
1910c5904d13Seschrock 	}
1911c5904d13Seschrock 
1912c5904d13Seschrock 	if (fstat64(fd, &statbuf) != 0) {
1913c5904d13Seschrock 		(void) printf("failed to stat '%s': %s\n", cachefile,
1914c5904d13Seschrock 		    strerror(errno));
1915c5904d13Seschrock 		exit(1);
1916c5904d13Seschrock 	}
1917c5904d13Seschrock 
1918c5904d13Seschrock 	if ((buf = malloc(statbuf.st_size)) == NULL) {
1919c5904d13Seschrock 		(void) fprintf(stderr, "failed to allocate %llu bytes\n",
1920c5904d13Seschrock 		    (u_longlong_t)statbuf.st_size);
1921c5904d13Seschrock 		exit(1);
1922c5904d13Seschrock 	}
1923c5904d13Seschrock 
1924c5904d13Seschrock 	if (read(fd, buf, statbuf.st_size) != statbuf.st_size) {
1925c5904d13Seschrock 		(void) fprintf(stderr, "failed to read %llu bytes\n",
1926c5904d13Seschrock 		    (u_longlong_t)statbuf.st_size);
1927c5904d13Seschrock 		exit(1);
1928c5904d13Seschrock 	}
1929c5904d13Seschrock 
1930c5904d13Seschrock 	(void) close(fd);
1931c5904d13Seschrock 
1932c5904d13Seschrock 	if (nvlist_unpack(buf, statbuf.st_size, &config, 0) != 0) {
1933c5904d13Seschrock 		(void) fprintf(stderr, "failed to unpack nvlist\n");
1934c5904d13Seschrock 		exit(1);
1935c5904d13Seschrock 	}
1936c5904d13Seschrock 
1937c5904d13Seschrock 	free(buf);
1938c5904d13Seschrock 
1939c5904d13Seschrock 	dump_nvlist(config, 0);
1940c5904d13Seschrock 
1941c5904d13Seschrock 	nvlist_free(config);
1942c5904d13Seschrock }
1943c5904d13Seschrock 
194453b9a4a9SVictor Latushkin #define	ZDB_MAX_UB_HEADER_SIZE 32
194553b9a4a9SVictor Latushkin 
194653b9a4a9SVictor Latushkin static void
194753b9a4a9SVictor Latushkin dump_label_uberblocks(vdev_label_t *lbl, uint64_t ashift)
194853b9a4a9SVictor Latushkin {
194953b9a4a9SVictor Latushkin 	vdev_t vd;
195053b9a4a9SVictor Latushkin 	vdev_t *vdp = &vd;
195153b9a4a9SVictor Latushkin 	char header[ZDB_MAX_UB_HEADER_SIZE];
195253b9a4a9SVictor Latushkin 
195353b9a4a9SVictor Latushkin 	vd.vdev_ashift = ashift;
195453b9a4a9SVictor Latushkin 	vdp->vdev_top = vdp;
195553b9a4a9SVictor Latushkin 
195653b9a4a9SVictor Latushkin 	for (int i = 0; i < VDEV_UBERBLOCK_COUNT(vdp); i++) {
195753b9a4a9SVictor Latushkin 		uint64_t uoff = VDEV_UBERBLOCK_OFFSET(vdp, i);
195853b9a4a9SVictor Latushkin 		uberblock_t *ub = (void *)((char *)lbl + uoff);
195953b9a4a9SVictor Latushkin 
196053b9a4a9SVictor Latushkin 		if (uberblock_verify(ub))
196153b9a4a9SVictor Latushkin 			continue;
196253b9a4a9SVictor Latushkin 		(void) snprintf(header, ZDB_MAX_UB_HEADER_SIZE,
196353b9a4a9SVictor Latushkin 		    "Uberblock[%d]\n", i);
196453b9a4a9SVictor Latushkin 		dump_uberblock(ub, header, "");
196553b9a4a9SVictor Latushkin 	}
196653b9a4a9SVictor Latushkin }
196753b9a4a9SVictor Latushkin 
1968fa9e4066Sahrens static void
1969fa9e4066Sahrens dump_label(const char *dev)
1970fa9e4066Sahrens {
1971fa9e4066Sahrens 	int fd;
1972fa9e4066Sahrens 	vdev_label_t label;
1973c6065d0fSGeorge Wilson 	char *path, *buf = label.vl_vdev_phys.vp_nvlist;
1974fa9e4066Sahrens 	size_t buflen = sizeof (label.vl_vdev_phys.vp_nvlist);
1975fa9e4066Sahrens 	struct stat64 statbuf;
197653b9a4a9SVictor Latushkin 	uint64_t psize, ashift;
1977c6065d0fSGeorge Wilson 	int len = strlen(dev) + 1;
1978fa9e4066Sahrens 
1979c6065d0fSGeorge Wilson 	if (strncmp(dev, "/dev/dsk/", 9) == 0) {
1980c6065d0fSGeorge Wilson 		len++;
1981c6065d0fSGeorge Wilson 		path = malloc(len);
1982c6065d0fSGeorge Wilson 		(void) snprintf(path, len, "%s%s", "/dev/rdsk/", dev + 9);
1983c6065d0fSGeorge Wilson 	} else {
1984c6065d0fSGeorge Wilson 		path = strdup(dev);
1985c6065d0fSGeorge Wilson 	}
1986c6065d0fSGeorge Wilson 
1987c6065d0fSGeorge Wilson 	if ((fd = open64(path, O_RDONLY)) < 0) {
1988c6065d0fSGeorge Wilson 		(void) printf("cannot open '%s': %s\n", path, strerror(errno));
1989c6065d0fSGeorge Wilson 		free(path);
1990fa9e4066Sahrens 		exit(1);
1991fa9e4066Sahrens 	}
1992fa9e4066Sahrens 
1993fa9e4066Sahrens 	if (fstat64(fd, &statbuf) != 0) {
1994c6065d0fSGeorge Wilson 		(void) printf("failed to stat '%s': %s\n", path,
1995fa9e4066Sahrens 		    strerror(errno));
1996c6065d0fSGeorge Wilson 		free(path);
1997c6065d0fSGeorge Wilson 		(void) close(fd);
1998c6065d0fSGeorge Wilson 		exit(1);
1999c6065d0fSGeorge Wilson 	}
2000c6065d0fSGeorge Wilson 
2001c6065d0fSGeorge Wilson 	if (S_ISBLK(statbuf.st_mode)) {
2002c6065d0fSGeorge Wilson 		(void) printf("cannot use '%s': character device required\n",
2003c6065d0fSGeorge Wilson 		    path);
2004c6065d0fSGeorge Wilson 		free(path);
2005c6065d0fSGeorge Wilson 		(void) close(fd);
2006c6065d0fSGeorge Wilson 		exit(1);
2007fa9e4066Sahrens 	}
2008fa9e4066Sahrens 
2009fa9e4066Sahrens 	psize = statbuf.st_size;
2010fa9e4066Sahrens 	psize = P2ALIGN(psize, (uint64_t)sizeof (vdev_label_t));
2011fa9e4066Sahrens 
201253b9a4a9SVictor Latushkin 	for (int l = 0; l < VDEV_LABELS; l++) {
2013fa9e4066Sahrens 		nvlist_t *config = NULL;
2014fa9e4066Sahrens 
2015fa9e4066Sahrens 		(void) printf("--------------------------------------------\n");
2016fa9e4066Sahrens 		(void) printf("LABEL %d\n", l);
2017fa9e4066Sahrens 		(void) printf("--------------------------------------------\n");
2018fa9e4066Sahrens 
20190d981225Seschrock 		if (pread64(fd, &label, sizeof (label),
2020fa9e4066Sahrens 		    vdev_label_offset(psize, l, 0)) != sizeof (label)) {
2021fa9e4066Sahrens 			(void) printf("failed to read label %d\n", l);
2022fa9e4066Sahrens 			continue;
2023fa9e4066Sahrens 		}
2024fa9e4066Sahrens 
2025fa9e4066Sahrens 		if (nvlist_unpack(buf, buflen, &config, 0) != 0) {
2026fa9e4066Sahrens 			(void) printf("failed to unpack label %d\n", l);
202753b9a4a9SVictor Latushkin 			ashift = SPA_MINBLOCKSHIFT;
202853b9a4a9SVictor Latushkin 		} else {
202953b9a4a9SVictor Latushkin 			nvlist_t *vdev_tree = NULL;
203053b9a4a9SVictor Latushkin 
203153b9a4a9SVictor Latushkin 			dump_nvlist(config, 4);
203253b9a4a9SVictor Latushkin 			if ((nvlist_lookup_nvlist(config,
203353b9a4a9SVictor Latushkin 			    ZPOOL_CONFIG_VDEV_TREE, &vdev_tree) != 0) ||
203453b9a4a9SVictor Latushkin 			    (nvlist_lookup_uint64(vdev_tree,
203553b9a4a9SVictor Latushkin 			    ZPOOL_CONFIG_ASHIFT, &ashift) != 0))
203653b9a4a9SVictor Latushkin 				ashift = SPA_MINBLOCKSHIFT;
203753b9a4a9SVictor Latushkin 			nvlist_free(config);
2038fa9e4066Sahrens 		}
203953b9a4a9SVictor Latushkin 		if (dump_opt['u'])
204053b9a4a9SVictor Latushkin 			dump_label_uberblocks(&label, ashift);
2041fa9e4066Sahrens 	}
2042c6065d0fSGeorge Wilson 
2043c6065d0fSGeorge Wilson 	free(path);
2044c6065d0fSGeorge Wilson 	(void) close(fd);
2045fa9e4066Sahrens }
2046fa9e4066Sahrens 
2047fa9e4066Sahrens /*ARGSUSED*/
20481d452cf5Sahrens static int
2049fd136879SMatthew Ahrens dump_one_dir(const char *dsname, void *arg)
2050fa9e4066Sahrens {
2051fa9e4066Sahrens 	int error;
2052fa9e4066Sahrens 	objset_t *os;
2053fa9e4066Sahrens 
2054503ad85cSMatthew Ahrens 	error = dmu_objset_own(dsname, DMU_OST_ANY, B_TRUE, FTAG, &os);
2055fa9e4066Sahrens 	if (error) {
2056b24ab676SJeff Bonwick 		(void) printf("Could not open %s, error %d\n", dsname, error);
20571d452cf5Sahrens 		return (0);
2058fa9e4066Sahrens 	}
2059fa9e4066Sahrens 	dump_dir(os);
2060503ad85cSMatthew Ahrens 	dmu_objset_disown(os, FTAG);
2061e0d35c44Smarks 	fuid_table_destroy();
20620a586ceaSMark Shellenbaum 	sa_loaded = B_FALSE;
20631d452cf5Sahrens 	return (0);
2064fa9e4066Sahrens }
2065fa9e4066Sahrens 
2066fa9e4066Sahrens /*
2067b24ab676SJeff Bonwick  * Block statistics.
2068fa9e4066Sahrens  */
2069490d05b9SMatthew Ahrens #define	PSIZE_HISTO_SIZE (SPA_MAXBLOCKSIZE / SPA_MINBLOCKSIZE + 1)
2070fa9e4066Sahrens typedef struct zdb_blkstats {
2071490d05b9SMatthew Ahrens 	uint64_t zb_asize;
2072490d05b9SMatthew Ahrens 	uint64_t zb_lsize;
2073490d05b9SMatthew Ahrens 	uint64_t zb_psize;
2074490d05b9SMatthew Ahrens 	uint64_t zb_count;
2075d5ee8a13SMatthew Ahrens 	uint64_t zb_gangs;
2076d5ee8a13SMatthew Ahrens 	uint64_t zb_ditto_samevdev;
2077490d05b9SMatthew Ahrens 	uint64_t zb_psize_histogram[PSIZE_HISTO_SIZE];
2078fa9e4066Sahrens } zdb_blkstats_t;
2079fa9e4066Sahrens 
2080b24ab676SJeff Bonwick /*
2081b24ab676SJeff Bonwick  * Extended object types to report deferred frees and dedup auto-ditto blocks.
2082b24ab676SJeff Bonwick  */
2083b24ab676SJeff Bonwick #define	ZDB_OT_DEFERRED	(DMU_OT_NUMTYPES + 0)
2084b24ab676SJeff Bonwick #define	ZDB_OT_DITTO	(DMU_OT_NUMTYPES + 1)
2085ad135b5dSChristopher Siden #define	ZDB_OT_OTHER	(DMU_OT_NUMTYPES + 2)
2086ad135b5dSChristopher Siden #define	ZDB_OT_TOTAL	(DMU_OT_NUMTYPES + 3)
2087b24ab676SJeff Bonwick 
2088b24ab676SJeff Bonwick static char *zdb_ot_extname[] = {
2089b24ab676SJeff Bonwick 	"deferred free",
2090b24ab676SJeff Bonwick 	"dedup ditto",
2091ad135b5dSChristopher Siden 	"other",
2092b24ab676SJeff Bonwick 	"Total",
2093b24ab676SJeff Bonwick };
2094fa9e4066Sahrens 
209588b7b0f2SMatthew Ahrens #define	ZB_TOTAL	DN_MAX_LEVELS
2096fa9e4066Sahrens 
2097fa9e4066Sahrens typedef struct zdb_cb {
2098b24ab676SJeff Bonwick 	zdb_blkstats_t	zcb_type[ZB_TOTAL + 1][ZDB_OT_TOTAL + 1];
2099b24ab676SJeff Bonwick 	uint64_t	zcb_dedup_asize;
2100b24ab676SJeff Bonwick 	uint64_t	zcb_dedup_blocks;
2101490d05b9SMatthew Ahrens 	uint64_t	zcb_start;
2102490d05b9SMatthew Ahrens 	uint64_t	zcb_lastprint;
2103490d05b9SMatthew Ahrens 	uint64_t	zcb_totalasize;
2104fa9e4066Sahrens 	uint64_t	zcb_errors[256];
2105fa9e4066Sahrens 	int		zcb_readfails;
2106fa9e4066Sahrens 	int		zcb_haderrors;
2107cde58dbcSMatthew Ahrens 	spa_t		*zcb_spa;
2108fa9e4066Sahrens } zdb_cb_t;
2109fa9e4066Sahrens 
2110fa9e4066Sahrens static void
2111cde58dbcSMatthew Ahrens zdb_count_block(zdb_cb_t *zcb, zilog_t *zilog, const blkptr_t *bp,
2112b24ab676SJeff Bonwick     dmu_object_type_t type)
2113fa9e4066Sahrens {
2114b24ab676SJeff Bonwick 	uint64_t refcnt = 0;
2115b24ab676SJeff Bonwick 
2116b24ab676SJeff Bonwick 	ASSERT(type < ZDB_OT_TOTAL);
2117b24ab676SJeff Bonwick 
2118b24ab676SJeff Bonwick 	if (zilog && zil_bp_tree_add(zilog, bp) != 0)
2119b24ab676SJeff Bonwick 		return;
2120b24ab676SJeff Bonwick 
2121e14bb325SJeff Bonwick 	for (int i = 0; i < 4; i++) {
2122fa9e4066Sahrens 		int l = (i < 2) ? BP_GET_LEVEL(bp) : ZB_TOTAL;
2123b24ab676SJeff Bonwick 		int t = (i & 1) ? type : ZDB_OT_TOTAL;
2124d5ee8a13SMatthew Ahrens 		int equal;
2125fa9e4066Sahrens 		zdb_blkstats_t *zb = &zcb->zcb_type[l][t];
2126fa9e4066Sahrens 
2127fa9e4066Sahrens 		zb->zb_asize += BP_GET_ASIZE(bp);
2128fa9e4066Sahrens 		zb->zb_lsize += BP_GET_LSIZE(bp);
2129fa9e4066Sahrens 		zb->zb_psize += BP_GET_PSIZE(bp);
2130fa9e4066Sahrens 		zb->zb_count++;
2131490d05b9SMatthew Ahrens 		zb->zb_psize_histogram[BP_GET_PSIZE(bp) >> SPA_MINBLOCKSHIFT]++;
2132d5ee8a13SMatthew Ahrens 
2133d5ee8a13SMatthew Ahrens 		zb->zb_gangs += BP_COUNT_GANG(bp);
2134d5ee8a13SMatthew Ahrens 
2135d5ee8a13SMatthew Ahrens 		switch (BP_GET_NDVAS(bp)) {
2136d5ee8a13SMatthew Ahrens 		case 2:
2137d5ee8a13SMatthew Ahrens 			if (DVA_GET_VDEV(&bp->blk_dva[0]) ==
2138d5ee8a13SMatthew Ahrens 			    DVA_GET_VDEV(&bp->blk_dva[1]))
2139d5ee8a13SMatthew Ahrens 				zb->zb_ditto_samevdev++;
2140d5ee8a13SMatthew Ahrens 			break;
2141d5ee8a13SMatthew Ahrens 		case 3:
2142d5ee8a13SMatthew Ahrens 			equal = (DVA_GET_VDEV(&bp->blk_dva[0]) ==
2143d5ee8a13SMatthew Ahrens 			    DVA_GET_VDEV(&bp->blk_dva[1])) +
2144d5ee8a13SMatthew Ahrens 			    (DVA_GET_VDEV(&bp->blk_dva[0]) ==
2145d5ee8a13SMatthew Ahrens 			    DVA_GET_VDEV(&bp->blk_dva[2])) +
2146d5ee8a13SMatthew Ahrens 			    (DVA_GET_VDEV(&bp->blk_dva[1]) ==
2147d5ee8a13SMatthew Ahrens 			    DVA_GET_VDEV(&bp->blk_dva[2]));
2148d5ee8a13SMatthew Ahrens 			if (equal != 0)
2149d5ee8a13SMatthew Ahrens 				zb->zb_ditto_samevdev++;
2150d5ee8a13SMatthew Ahrens 			break;
2151d5ee8a13SMatthew Ahrens 		}
2152d5ee8a13SMatthew Ahrens 
2153fa9e4066Sahrens 	}
2154fa9e4066Sahrens 
2155b24ab676SJeff Bonwick 	if (dump_opt['L'])
2156b24ab676SJeff Bonwick 		return;
2157b24ab676SJeff Bonwick 
2158b24ab676SJeff Bonwick 	if (BP_GET_DEDUP(bp)) {
2159b24ab676SJeff Bonwick 		ddt_t *ddt;
2160b24ab676SJeff Bonwick 		ddt_entry_t *dde;
2161b24ab676SJeff Bonwick 
2162cde58dbcSMatthew Ahrens 		ddt = ddt_select(zcb->zcb_spa, bp);
2163b24ab676SJeff Bonwick 		ddt_enter(ddt);
2164b24ab676SJeff Bonwick 		dde = ddt_lookup(ddt, bp, B_FALSE);
2165b24ab676SJeff Bonwick 
2166b24ab676SJeff Bonwick 		if (dde == NULL) {
2167b24ab676SJeff Bonwick 			refcnt = 0;
2168b24ab676SJeff Bonwick 		} else {
2169b24ab676SJeff Bonwick 			ddt_phys_t *ddp = ddt_phys_select(dde, bp);
2170b24ab676SJeff Bonwick 			ddt_phys_decref(ddp);
2171b24ab676SJeff Bonwick 			refcnt = ddp->ddp_refcnt;
2172b24ab676SJeff Bonwick 			if (ddt_phys_total_refcnt(dde) == 0)
2173b24ab676SJeff Bonwick 				ddt_remove(ddt, dde);
2174d41e7643Sek 		}
2175b24ab676SJeff Bonwick 		ddt_exit(ddt);
2176d41e7643Sek 	}
2177d41e7643Sek 
2178cde58dbcSMatthew Ahrens 	VERIFY3U(zio_wait(zio_claim(NULL, zcb->zcb_spa,
2179cde58dbcSMatthew Ahrens 	    refcnt ? 0 : spa_first_txg(zcb->zcb_spa),
2180b24ab676SJeff Bonwick 	    bp, NULL, NULL, ZIO_FLAG_CANFAIL)), ==, 0);
2181fa9e4066Sahrens }
2182fa9e4066Sahrens 
218331d7e8faSGeorge Wilson static void
218431d7e8faSGeorge Wilson zdb_blkptr_done(zio_t *zio)
218531d7e8faSGeorge Wilson {
218631d7e8faSGeorge Wilson 	spa_t *spa = zio->io_spa;
218731d7e8faSGeorge Wilson 	blkptr_t *bp = zio->io_bp;
218831d7e8faSGeorge Wilson 	int ioerr = zio->io_error;
218931d7e8faSGeorge Wilson 	zdb_cb_t *zcb = zio->io_private;
219031d7e8faSGeorge Wilson 	zbookmark_t *zb = &zio->io_bookmark;
219131d7e8faSGeorge Wilson 
219231d7e8faSGeorge Wilson 	zio_data_buf_free(zio->io_data, zio->io_size);
219331d7e8faSGeorge Wilson 
219431d7e8faSGeorge Wilson 	mutex_enter(&spa->spa_scrub_lock);
219531d7e8faSGeorge Wilson 	spa->spa_scrub_inflight--;
219631d7e8faSGeorge Wilson 	cv_broadcast(&spa->spa_scrub_io_cv);
219731d7e8faSGeorge Wilson 
219831d7e8faSGeorge Wilson 	if (ioerr && !(zio->io_flags & ZIO_FLAG_SPECULATIVE)) {
219931d7e8faSGeorge Wilson 		char blkbuf[BP_SPRINTF_LEN];
220031d7e8faSGeorge Wilson 
220131d7e8faSGeorge Wilson 		zcb->zcb_haderrors = 1;
220231d7e8faSGeorge Wilson 		zcb->zcb_errors[ioerr]++;
220331d7e8faSGeorge Wilson 
220431d7e8faSGeorge Wilson 		if (dump_opt['b'] >= 2)
220531d7e8faSGeorge Wilson 			sprintf_blkptr(blkbuf, bp);
220631d7e8faSGeorge Wilson 		else
220731d7e8faSGeorge Wilson 			blkbuf[0] = '\0';
220831d7e8faSGeorge Wilson 
220931d7e8faSGeorge Wilson 		(void) printf("zdb_blkptr_cb: "
221031d7e8faSGeorge Wilson 		    "Got error %d reading "
221131d7e8faSGeorge Wilson 		    "<%llu, %llu, %lld, %llx> %s -- skipping\n",
221231d7e8faSGeorge Wilson 		    ioerr,
221331d7e8faSGeorge Wilson 		    (u_longlong_t)zb->zb_objset,
221431d7e8faSGeorge Wilson 		    (u_longlong_t)zb->zb_object,
221531d7e8faSGeorge Wilson 		    (u_longlong_t)zb->zb_level,
221631d7e8faSGeorge Wilson 		    (u_longlong_t)zb->zb_blkid,
221731d7e8faSGeorge Wilson 		    blkbuf);
221831d7e8faSGeorge Wilson 	}
221931d7e8faSGeorge Wilson 	mutex_exit(&spa->spa_scrub_lock);
222031d7e8faSGeorge Wilson }
222131d7e8faSGeorge Wilson 
2222fa9e4066Sahrens static int
22231b912ec7SGeorge Wilson zdb_blkptr_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
2224b24ab676SJeff Bonwick     const zbookmark_t *zb, const dnode_phys_t *dnp, void *arg)
2225fa9e4066Sahrens {
2226fa9e4066Sahrens 	zdb_cb_t *zcb = arg;
2227fbabab8fSmaybee 	char blkbuf[BP_SPRINTF_LEN];
22286365109dSVictor Latushkin 	dmu_object_type_t type;
2229468c413aSTim Haley 	boolean_t is_metadata;
2230fa9e4066Sahrens 
223188b7b0f2SMatthew Ahrens 	if (bp == NULL)
223288b7b0f2SMatthew Ahrens 		return (0);
2233e14bb325SJeff Bonwick 
22346365109dSVictor Latushkin 	type = BP_GET_TYPE(bp);
2235e14bb325SJeff Bonwick 
2236ad135b5dSChristopher Siden 	zdb_count_block(zcb, zilog, bp,
2237ad135b5dSChristopher Siden 	    (type & DMU_OT_NEWTYPE) ? ZDB_OT_OTHER : type);
22386365109dSVictor Latushkin 
2239ad135b5dSChristopher Siden 	is_metadata = (BP_GET_LEVEL(bp) != 0 || DMU_OT_IS_METADATA(type));
22406365109dSVictor Latushkin 
2241b24ab676SJeff Bonwick 	if (dump_opt['c'] > 1 || (dump_opt['c'] && is_metadata)) {
2242468c413aSTim Haley 		size_t size = BP_GET_PSIZE(bp);
224331d7e8faSGeorge Wilson 		void *data = zio_data_buf_alloc(size);
2244b24ab676SJeff Bonwick 		int flags = ZIO_FLAG_CANFAIL | ZIO_FLAG_SCRUB | ZIO_FLAG_RAW;
2245b24ab676SJeff Bonwick 
2246b24ab676SJeff Bonwick 		/* If it's an intent log block, failure is expected. */
2247b24ab676SJeff Bonwick 		if (zb->zb_level == ZB_ZIL_LEVEL)
2248b24ab676SJeff Bonwick 			flags |= ZIO_FLAG_SPECULATIVE;
2249b24ab676SJeff Bonwick 
225031d7e8faSGeorge Wilson 		mutex_enter(&spa->spa_scrub_lock);
225131d7e8faSGeorge Wilson 		while (spa->spa_scrub_inflight > max_inflight)
225231d7e8faSGeorge Wilson 			cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock);
225331d7e8faSGeorge Wilson 		spa->spa_scrub_inflight++;
225431d7e8faSGeorge Wilson 		mutex_exit(&spa->spa_scrub_lock);
2255b24ab676SJeff Bonwick 
225631d7e8faSGeorge Wilson 		zio_nowait(zio_read(NULL, spa, bp, data, size,
225731d7e8faSGeorge Wilson 		    zdb_blkptr_done, zcb, ZIO_PRIORITY_ASYNC_READ, flags, zb));
2258fa9e4066Sahrens 	}
2259fa9e4066Sahrens 
2260fa9e4066Sahrens 	zcb->zcb_readfails = 0;
2261fa9e4066Sahrens 
2262490d05b9SMatthew Ahrens 	if (dump_opt['b'] >= 5) {
2263b24ab676SJeff Bonwick 		sprintf_blkptr(blkbuf, bp);
2264b24ab676SJeff Bonwick 		(void) printf("objset %llu object %llu "
2265b24ab676SJeff Bonwick 		    "level %lld offset 0x%llx %s\n",
2266fa9e4066Sahrens 		    (u_longlong_t)zb->zb_objset,
2267fa9e4066Sahrens 		    (u_longlong_t)zb->zb_object,
2268b24ab676SJeff Bonwick 		    (longlong_t)zb->zb_level,
2269b24ab676SJeff Bonwick 		    (u_longlong_t)blkid2offset(dnp, bp, zb),
227088b7b0f2SMatthew Ahrens 		    blkbuf);
2271fa9e4066Sahrens 	}
2272fa9e4066Sahrens 
2273490d05b9SMatthew Ahrens 	if (dump_opt['b'] < 5 && isatty(STDERR_FILENO) &&
2274490d05b9SMatthew Ahrens 	    gethrtime() > zcb->zcb_lastprint + NANOSEC) {
2275490d05b9SMatthew Ahrens 		uint64_t now = gethrtime();
2276490d05b9SMatthew Ahrens 		char buf[10];
2277490d05b9SMatthew Ahrens 		uint64_t bytes = zcb->zcb_type[ZB_TOTAL][ZDB_OT_TOTAL].zb_asize;
2278490d05b9SMatthew Ahrens 		int kb_per_sec =
2279490d05b9SMatthew Ahrens 		    1 + bytes / (1 + ((now - zcb->zcb_start) / 1000 / 1000));
2280490d05b9SMatthew Ahrens 		int sec_remaining =
2281490d05b9SMatthew Ahrens 		    (zcb->zcb_totalasize - bytes) / 1024 / kb_per_sec;
2282490d05b9SMatthew Ahrens 
2283490d05b9SMatthew Ahrens 		zfs_nicenum(bytes, buf, sizeof (buf));
2284490d05b9SMatthew Ahrens 		(void) fprintf(stderr,
2285490d05b9SMatthew Ahrens 		    "\r%5s completed (%4dMB/s) "
2286490d05b9SMatthew Ahrens 		    "estimated time remaining: %uhr %02umin %02usec        ",
2287490d05b9SMatthew Ahrens 		    buf, kb_per_sec / 1024,
2288490d05b9SMatthew Ahrens 		    sec_remaining / 60 / 60,
2289490d05b9SMatthew Ahrens 		    sec_remaining / 60 % 60,
2290490d05b9SMatthew Ahrens 		    sec_remaining % 60);
2291490d05b9SMatthew Ahrens 
2292490d05b9SMatthew Ahrens 		zcb->zcb_lastprint = now;
2293490d05b9SMatthew Ahrens 	}
2294490d05b9SMatthew Ahrens 
2295fa9e4066Sahrens 	return (0);
2296fa9e4066Sahrens }
2297fa9e4066Sahrens 
2298b24ab676SJeff Bonwick static void
22990713e232SGeorge Wilson zdb_leak(void *arg, uint64_t start, uint64_t size)
2300b24ab676SJeff Bonwick {
23010713e232SGeorge Wilson 	vdev_t *vd = arg;
2302b24ab676SJeff Bonwick 
2303b24ab676SJeff Bonwick 	(void) printf("leaked space: vdev %llu, offset 0x%llx, size %llu\n",
2304b24ab676SJeff Bonwick 	    (u_longlong_t)vd->vdev_id, (u_longlong_t)start, (u_longlong_t)size);
2305b24ab676SJeff Bonwick }
2306b24ab676SJeff Bonwick 
23070713e232SGeorge Wilson static metaslab_ops_t zdb_metaslab_ops = {
2308b24ab676SJeff Bonwick 	NULL,	/* alloc */
23090713e232SGeorge Wilson 	NULL	/* fragmented */
2310b24ab676SJeff Bonwick };
2311b24ab676SJeff Bonwick 
2312b24ab676SJeff Bonwick static void
2313bbfd46c4SJeff Bonwick zdb_ddt_leak_init(spa_t *spa, zdb_cb_t *zcb)
2314b24ab676SJeff Bonwick {
2315bbfd46c4SJeff Bonwick 	ddt_bookmark_t ddb = { 0 };
2316b24ab676SJeff Bonwick 	ddt_entry_t dde;
2317b24ab676SJeff Bonwick 	int error;
2318b24ab676SJeff Bonwick 
2319bbfd46c4SJeff Bonwick 	while ((error = ddt_walk(spa, &ddb, &dde)) == 0) {
2320b24ab676SJeff Bonwick 		blkptr_t blk;
2321b24ab676SJeff Bonwick 		ddt_phys_t *ddp = dde.dde_phys;
2322bbfd46c4SJeff Bonwick 
2323bbfd46c4SJeff Bonwick 		if (ddb.ddb_class == DDT_CLASS_UNIQUE)
2324bbfd46c4SJeff Bonwick 			return;
2325bbfd46c4SJeff Bonwick 
2326b24ab676SJeff Bonwick 		ASSERT(ddt_phys_total_refcnt(&dde) > 1);
2327bbfd46c4SJeff Bonwick 
2328b24ab676SJeff Bonwick 		for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
2329b24ab676SJeff Bonwick 			if (ddp->ddp_phys_birth == 0)
2330b24ab676SJeff Bonwick 				continue;
2331bbfd46c4SJeff Bonwick 			ddt_bp_create(ddb.ddb_checksum,
2332bbfd46c4SJeff Bonwick 			    &dde.dde_key, ddp, &blk);
2333b24ab676SJeff Bonwick 			if (p == DDT_PHYS_DITTO) {
2334cde58dbcSMatthew Ahrens 				zdb_count_block(zcb, NULL, &blk, ZDB_OT_DITTO);
2335b24ab676SJeff Bonwick 			} else {
2336b24ab676SJeff Bonwick 				zcb->zcb_dedup_asize +=
2337b24ab676SJeff Bonwick 				    BP_GET_ASIZE(&blk) * (ddp->ddp_refcnt - 1);
2338b24ab676SJeff Bonwick 				zcb->zcb_dedup_blocks++;
2339b24ab676SJeff Bonwick 			}
2340b24ab676SJeff Bonwick 		}
2341b24ab676SJeff Bonwick 		if (!dump_opt['L']) {
2342bbfd46c4SJeff Bonwick 			ddt_t *ddt = spa->spa_ddt[ddb.ddb_checksum];
2343b24ab676SJeff Bonwick 			ddt_enter(ddt);
2344b24ab676SJeff Bonwick 			VERIFY(ddt_lookup(ddt, &blk, B_TRUE) != NULL);
2345b24ab676SJeff Bonwick 			ddt_exit(ddt);
2346b24ab676SJeff Bonwick 		}
2347b24ab676SJeff Bonwick 	}
2348b24ab676SJeff Bonwick 
2349b24ab676SJeff Bonwick 	ASSERT(error == ENOENT);
2350b24ab676SJeff Bonwick }
2351b24ab676SJeff Bonwick 
2352b24ab676SJeff Bonwick static void
2353b24ab676SJeff Bonwick zdb_leak_init(spa_t *spa, zdb_cb_t *zcb)
2354b24ab676SJeff Bonwick {
2355cde58dbcSMatthew Ahrens 	zcb->zcb_spa = spa;
2356cde58dbcSMatthew Ahrens 
2357b24ab676SJeff Bonwick 	if (!dump_opt['L']) {
2358b24ab676SJeff Bonwick 		vdev_t *rvd = spa->spa_root_vdev;
2359b24ab676SJeff Bonwick 		for (int c = 0; c < rvd->vdev_children; c++) {
2360b24ab676SJeff Bonwick 			vdev_t *vd = rvd->vdev_child[c];
2361b24ab676SJeff Bonwick 			for (int m = 0; m < vd->vdev_ms_count; m++) {
2362b24ab676SJeff Bonwick 				metaslab_t *msp = vd->vdev_ms[m];
2363b24ab676SJeff Bonwick 				mutex_enter(&msp->ms_lock);
23640713e232SGeorge Wilson 				metaslab_unload(msp);
23650713e232SGeorge Wilson 
23660713e232SGeorge Wilson 				/*
23670713e232SGeorge Wilson 				 * For leak detection, we overload the metaslab
23680713e232SGeorge Wilson 				 * ms_tree to contain allocated segments
23690713e232SGeorge Wilson 				 * instead of free segments. As a result,
23700713e232SGeorge Wilson 				 * we can't use the normal metaslab_load/unload
23710713e232SGeorge Wilson 				 * interfaces.
23720713e232SGeorge Wilson 				 */
23730713e232SGeorge Wilson 				if (msp->ms_sm != NULL) {
23740713e232SGeorge Wilson 					msp->ms_ops = &zdb_metaslab_ops;
23750713e232SGeorge Wilson 					VERIFY0(space_map_load(msp->ms_sm,
23760713e232SGeorge Wilson 					    msp->ms_tree, SM_ALLOC));
23770713e232SGeorge Wilson 					msp->ms_loaded = B_TRUE;
23780713e232SGeorge Wilson 				}
2379b24ab676SJeff Bonwick 				mutex_exit(&msp->ms_lock);
2380b24ab676SJeff Bonwick 			}
2381b24ab676SJeff Bonwick 		}
2382b24ab676SJeff Bonwick 	}
2383b24ab676SJeff Bonwick 
2384b24ab676SJeff Bonwick 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
2385b24ab676SJeff Bonwick 
2386bbfd46c4SJeff Bonwick 	zdb_ddt_leak_init(spa, zcb);
2387b24ab676SJeff Bonwick 
2388b24ab676SJeff Bonwick 	spa_config_exit(spa, SCL_CONFIG, FTAG);
2389b24ab676SJeff Bonwick }
2390b24ab676SJeff Bonwick 
2391b24ab676SJeff Bonwick static void
2392b24ab676SJeff Bonwick zdb_leak_fini(spa_t *spa)
2393b24ab676SJeff Bonwick {
2394b24ab676SJeff Bonwick 	if (!dump_opt['L']) {
2395b24ab676SJeff Bonwick 		vdev_t *rvd = spa->spa_root_vdev;
2396b24ab676SJeff Bonwick 		for (int c = 0; c < rvd->vdev_children; c++) {
2397b24ab676SJeff Bonwick 			vdev_t *vd = rvd->vdev_child[c];
2398b24ab676SJeff Bonwick 			for (int m = 0; m < vd->vdev_ms_count; m++) {
2399b24ab676SJeff Bonwick 				metaslab_t *msp = vd->vdev_ms[m];
2400b24ab676SJeff Bonwick 				mutex_enter(&msp->ms_lock);
24010713e232SGeorge Wilson 
24020713e232SGeorge Wilson 				/*
24030713e232SGeorge Wilson 				 * The ms_tree has been overloaded to
24040713e232SGeorge Wilson 				 * contain allocated segments. Now that we
24050713e232SGeorge Wilson 				 * finished traversing all blocks, any
24060713e232SGeorge Wilson 				 * block that remains in the ms_tree
24070713e232SGeorge Wilson 				 * represents an allocated block that we
24080713e232SGeorge Wilson 				 * did not claim during the traversal.
24090713e232SGeorge Wilson 				 * Claimed blocks would have been removed
24100713e232SGeorge Wilson 				 * from the ms_tree.
24110713e232SGeorge Wilson 				 */
24120713e232SGeorge Wilson 				range_tree_vacate(msp->ms_tree, zdb_leak, vd);
24130713e232SGeorge Wilson 				msp->ms_loaded = B_FALSE;
24140713e232SGeorge Wilson 
2415b24ab676SJeff Bonwick 				mutex_exit(&msp->ms_lock);
2416b24ab676SJeff Bonwick 			}
2417b24ab676SJeff Bonwick 		}
2418b24ab676SJeff Bonwick 	}
2419b24ab676SJeff Bonwick }
2420b24ab676SJeff Bonwick 
2421cde58dbcSMatthew Ahrens /* ARGSUSED */
2422cde58dbcSMatthew Ahrens static int
2423cde58dbcSMatthew Ahrens count_block_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
2424cde58dbcSMatthew Ahrens {
2425cde58dbcSMatthew Ahrens 	zdb_cb_t *zcb = arg;
2426cde58dbcSMatthew Ahrens 
2427490d05b9SMatthew Ahrens 	if (dump_opt['b'] >= 5) {
2428cde58dbcSMatthew Ahrens 		char blkbuf[BP_SPRINTF_LEN];
2429cde58dbcSMatthew Ahrens 		sprintf_blkptr(blkbuf, bp);
2430cde58dbcSMatthew Ahrens 		(void) printf("[%s] %s\n",
2431cde58dbcSMatthew Ahrens 		    "deferred free", blkbuf);
2432cde58dbcSMatthew Ahrens 	}
2433cde58dbcSMatthew Ahrens 	zdb_count_block(zcb, NULL, bp, ZDB_OT_DEFERRED);
2434cde58dbcSMatthew Ahrens 	return (0);
2435cde58dbcSMatthew Ahrens }
2436cde58dbcSMatthew Ahrens 
2437fa9e4066Sahrens static int
2438fa9e4066Sahrens dump_block_stats(spa_t *spa)
2439fa9e4066Sahrens {
2440fa9e4066Sahrens 	zdb_cb_t zcb = { 0 };
2441fa9e4066Sahrens 	zdb_blkstats_t *zb, *tzb;
2442b24ab676SJeff Bonwick 	uint64_t norm_alloc, norm_space, total_alloc, total_found;
2443cd088ea4SVictor Latushkin 	int flags = TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA | TRAVERSE_HARD;
2444fa9e4066Sahrens 	int leaks = 0;
2445fa9e4066Sahrens 
2446490d05b9SMatthew Ahrens 	(void) printf("\nTraversing all blocks %s%s%s%s%s...\n\n",
2447b24ab676SJeff Bonwick 	    (dump_opt['c'] || !dump_opt['L']) ? "to verify " : "",
2448b24ab676SJeff Bonwick 	    (dump_opt['c'] == 1) ? "metadata " : "",
2449b24ab676SJeff Bonwick 	    dump_opt['c'] ? "checksums " : "",
2450b24ab676SJeff Bonwick 	    (dump_opt['c'] && !dump_opt['L']) ? "and verify " : "",
2451b24ab676SJeff Bonwick 	    !dump_opt['L'] ? "nothing leaked " : "");
2452fa9e4066Sahrens 
2453fa9e4066Sahrens 	/*
2454e14bb325SJeff Bonwick 	 * Load all space maps as SM_ALLOC maps, then traverse the pool
2455e14bb325SJeff Bonwick 	 * claiming each block we discover.  If the pool is perfectly
2456e14bb325SJeff Bonwick 	 * consistent, the space maps will be empty when we're done.
2457e14bb325SJeff Bonwick 	 * Anything left over is a leak; any block we can't claim (because
2458e14bb325SJeff Bonwick 	 * it's not part of any space map) is a double allocation,
2459e14bb325SJeff Bonwick 	 * reference to a freed block, or an unclaimed log block.
2460fa9e4066Sahrens 	 */
2461b24ab676SJeff Bonwick 	zdb_leak_init(spa, &zcb);
2462fa9e4066Sahrens 
2463fa9e4066Sahrens 	/*
2464fa9e4066Sahrens 	 * If there's a deferred-free bplist, process that first.
2465fa9e4066Sahrens 	 */
2466cde58dbcSMatthew Ahrens 	(void) bpobj_iterate_nofree(&spa->spa_deferred_bpobj,
2467cde58dbcSMatthew Ahrens 	    count_block_cb, &zcb, NULL);
24683b2aab18SMatthew Ahrens 	if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
24693b2aab18SMatthew Ahrens 		(void) bpobj_iterate_nofree(&spa->spa_dsl_pool->dp_free_bpobj,
24703b2aab18SMatthew Ahrens 		    count_block_cb, &zcb, NULL);
24713b2aab18SMatthew Ahrens 	}
2472*2acef22dSMatthew Ahrens 	if (spa_feature_is_active(spa, SPA_FEATURE_ASYNC_DESTROY)) {
2473b420f3adSRichard Lowe 		VERIFY3U(0, ==, bptree_iterate(spa->spa_meta_objset,
2474ad135b5dSChristopher Siden 		    spa->spa_dsl_pool->dp_bptree_obj, B_FALSE, count_block_cb,
2475ad135b5dSChristopher Siden 		    &zcb, NULL));
2476ad135b5dSChristopher Siden 	}
2477fa9e4066Sahrens 
2478bbfd46c4SJeff Bonwick 	if (dump_opt['c'] > 1)
2479bbfd46c4SJeff Bonwick 		flags |= TRAVERSE_PREFETCH_DATA;
2480bbfd46c4SJeff Bonwick 
2481490d05b9SMatthew Ahrens 	zcb.zcb_totalasize = metaslab_class_get_alloc(spa_normal_class(spa));
2482490d05b9SMatthew Ahrens 	zcb.zcb_start = zcb.zcb_lastprint = gethrtime();
2483bbfd46c4SJeff Bonwick 	zcb.zcb_haderrors |= traverse_pool(spa, 0, flags, zdb_blkptr_cb, &zcb);
2484fa9e4066Sahrens 
248531d7e8faSGeorge Wilson 	/*
248631d7e8faSGeorge Wilson 	 * If we've traversed the data blocks then we need to wait for those
248731d7e8faSGeorge Wilson 	 * I/Os to complete. We leverage "The Godfather" zio to wait on
248831d7e8faSGeorge Wilson 	 * all async I/Os to complete.
248931d7e8faSGeorge Wilson 	 */
249031d7e8faSGeorge Wilson 	if (dump_opt['c']) {
249131d7e8faSGeorge Wilson 		(void) zio_wait(spa->spa_async_zio_root);
249231d7e8faSGeorge Wilson 		spa->spa_async_zio_root = zio_root(spa, NULL, NULL,
249331d7e8faSGeorge Wilson 		    ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE |
249431d7e8faSGeorge Wilson 		    ZIO_FLAG_GODFATHER);
249531d7e8faSGeorge Wilson 	}
249631d7e8faSGeorge Wilson 
2497b24ab676SJeff Bonwick 	if (zcb.zcb_haderrors) {
2498fa9e4066Sahrens 		(void) printf("\nError counts:\n\n");
2499fa9e4066Sahrens 		(void) printf("\t%5s  %s\n", "errno", "count");
2500b24ab676SJeff Bonwick 		for (int e = 0; e < 256; e++) {
2501fa9e4066Sahrens 			if (zcb.zcb_errors[e] != 0) {
2502fa9e4066Sahrens 				(void) printf("\t%5d  %llu\n",
2503fa9e4066Sahrens 				    e, (u_longlong_t)zcb.zcb_errors[e]);
2504fa9e4066Sahrens 			}
2505fa9e4066Sahrens 		}
2506fa9e4066Sahrens 	}
2507fa9e4066Sahrens 
2508fa9e4066Sahrens 	/*
2509fa9e4066Sahrens 	 * Report any leaked segments.
2510fa9e4066Sahrens 	 */
2511b24ab676SJeff Bonwick 	zdb_leak_fini(spa);
2512fa9e4066Sahrens 
2513b24ab676SJeff Bonwick 	tzb = &zcb.zcb_type[ZB_TOTAL][ZDB_OT_TOTAL];
25148654d025Sperrin 
2515b24ab676SJeff Bonwick 	norm_alloc = metaslab_class_get_alloc(spa_normal_class(spa));
2516b24ab676SJeff Bonwick 	norm_space = metaslab_class_get_space(spa_normal_class(spa));
25178654d025Sperrin 
2518b24ab676SJeff Bonwick 	total_alloc = norm_alloc + metaslab_class_get_alloc(spa_log_class(spa));
2519b24ab676SJeff Bonwick 	total_found = tzb->zb_asize - zcb.zcb_dedup_asize;
2520fa9e4066Sahrens 
2521b24ab676SJeff Bonwick 	if (total_found == total_alloc) {
252282a0a985SVictor Latushkin 		if (!dump_opt['L'])
252382a0a985SVictor Latushkin 			(void) printf("\n\tNo leaks (block sum matches space"
252482a0a985SVictor Latushkin 			    " maps exactly)\n");
2525fa9e4066Sahrens 	} else {
2526fa9e4066Sahrens 		(void) printf("block traversal size %llu != alloc %llu "
252782a0a985SVictor Latushkin 		    "(%s %lld)\n",
2528b24ab676SJeff Bonwick 		    (u_longlong_t)total_found,
2529b24ab676SJeff Bonwick 		    (u_longlong_t)total_alloc,
253082a0a985SVictor Latushkin 		    (dump_opt['L']) ? "unreachable" : "leaked",
2531b24ab676SJeff Bonwick 		    (longlong_t)(total_alloc - total_found));
2532fa9e4066Sahrens 		leaks = 1;
2533fa9e4066Sahrens 	}
2534fa9e4066Sahrens 
2535fa9e4066Sahrens 	if (tzb->zb_count == 0)
2536fa9e4066Sahrens 		return (2);
2537fa9e4066Sahrens 
2538fa9e4066Sahrens 	(void) printf("\n");
2539fa9e4066Sahrens 	(void) printf("\tbp count:      %10llu\n",
2540fa9e4066Sahrens 	    (u_longlong_t)tzb->zb_count);
2541d5ee8a13SMatthew Ahrens 	(void) printf("\tganged count:  %10llu\n",
2542d5ee8a13SMatthew Ahrens 	    (longlong_t)tzb->zb_gangs);
2543b24ab676SJeff Bonwick 	(void) printf("\tbp logical:    %10llu      avg: %6llu\n",
2544fa9e4066Sahrens 	    (u_longlong_t)tzb->zb_lsize,
2545fa9e4066Sahrens 	    (u_longlong_t)(tzb->zb_lsize / tzb->zb_count));
2546b24ab676SJeff Bonwick 	(void) printf("\tbp physical:   %10llu      avg:"
2547b24ab676SJeff Bonwick 	    " %6llu     compression: %6.2f\n",
2548fa9e4066Sahrens 	    (u_longlong_t)tzb->zb_psize,
2549fa9e4066Sahrens 	    (u_longlong_t)(tzb->zb_psize / tzb->zb_count),
2550fa9e4066Sahrens 	    (double)tzb->zb_lsize / tzb->zb_psize);
2551b24ab676SJeff Bonwick 	(void) printf("\tbp allocated:  %10llu      avg:"
2552b24ab676SJeff Bonwick 	    " %6llu     compression: %6.2f\n",
2553fa9e4066Sahrens 	    (u_longlong_t)tzb->zb_asize,
2554fa9e4066Sahrens 	    (u_longlong_t)(tzb->zb_asize / tzb->zb_count),
2555fa9e4066Sahrens 	    (double)tzb->zb_lsize / tzb->zb_asize);
2556b24ab676SJeff Bonwick 	(void) printf("\tbp deduped:    %10llu    ref>1:"
2557b24ab676SJeff Bonwick 	    " %6llu   deduplication: %6.2f\n",
2558b24ab676SJeff Bonwick 	    (u_longlong_t)zcb.zcb_dedup_asize,
2559b24ab676SJeff Bonwick 	    (u_longlong_t)zcb.zcb_dedup_blocks,
2560b24ab676SJeff Bonwick 	    (double)zcb.zcb_dedup_asize / tzb->zb_asize + 1.0);
2561b24ab676SJeff Bonwick 	(void) printf("\tSPA allocated: %10llu     used: %5.2f%%\n",
2562b24ab676SJeff Bonwick 	    (u_longlong_t)norm_alloc, 100.0 * norm_alloc / norm_space);
2563fa9e4066Sahrens 
2564d5ee8a13SMatthew Ahrens 	if (tzb->zb_ditto_samevdev != 0) {
2565d5ee8a13SMatthew Ahrens 		(void) printf("\tDittoed blocks on same vdev: %llu\n",
2566d5ee8a13SMatthew Ahrens 		    (longlong_t)tzb->zb_ditto_samevdev);
2567d5ee8a13SMatthew Ahrens 	}
2568d5ee8a13SMatthew Ahrens 
2569fa9e4066Sahrens 	if (dump_opt['b'] >= 2) {
2570fa9e4066Sahrens 		int l, t, level;
2571fa9e4066Sahrens 		(void) printf("\nBlocks\tLSIZE\tPSIZE\tASIZE"
2572fa9e4066Sahrens 		    "\t  avg\t comp\t%%Total\tType\n");
2573fa9e4066Sahrens 
2574b24ab676SJeff Bonwick 		for (t = 0; t <= ZDB_OT_TOTAL; t++) {
25753f9d6ad7SLin Ling 			char csize[32], lsize[32], psize[32], asize[32];
2576d5ee8a13SMatthew Ahrens 			char avg[32], gang[32];
2577fa9e4066Sahrens 			char *typename;
2578fa9e4066Sahrens 
2579b24ab676SJeff Bonwick 			if (t < DMU_OT_NUMTYPES)
2580b24ab676SJeff Bonwick 				typename = dmu_ot[t].ot_name;
2581b24ab676SJeff Bonwick 			else
2582b24ab676SJeff Bonwick 				typename = zdb_ot_extname[t - DMU_OT_NUMTYPES];
2583fa9e4066Sahrens 
2584fa9e4066Sahrens 			if (zcb.zcb_type[ZB_TOTAL][t].zb_asize == 0) {
2585fa9e4066Sahrens 				(void) printf("%6s\t%5s\t%5s\t%5s"
2586fa9e4066Sahrens 				    "\t%5s\t%5s\t%6s\t%s\n",
2587fa9e4066Sahrens 				    "-",
2588fa9e4066Sahrens 				    "-",
2589fa9e4066Sahrens 				    "-",
2590fa9e4066Sahrens 				    "-",
2591fa9e4066Sahrens 				    "-",
2592fa9e4066Sahrens 				    "-",
2593fa9e4066Sahrens 				    "-",
2594fa9e4066Sahrens 				    typename);
2595fa9e4066Sahrens 				continue;
2596fa9e4066Sahrens 			}
2597fa9e4066Sahrens 
2598fa9e4066Sahrens 			for (l = ZB_TOTAL - 1; l >= -1; l--) {
2599fa9e4066Sahrens 				level = (l == -1 ? ZB_TOTAL : l);
2600fa9e4066Sahrens 				zb = &zcb.zcb_type[level][t];
2601fa9e4066Sahrens 
2602fa9e4066Sahrens 				if (zb->zb_asize == 0)
2603fa9e4066Sahrens 					continue;
2604fa9e4066Sahrens 
2605fa9e4066Sahrens 				if (dump_opt['b'] < 3 && level != ZB_TOTAL)
2606fa9e4066Sahrens 					continue;
2607fa9e4066Sahrens 
2608fa9e4066Sahrens 				if (level == 0 && zb->zb_asize ==
2609fa9e4066Sahrens 				    zcb.zcb_type[ZB_TOTAL][t].zb_asize)
2610fa9e4066Sahrens 					continue;
2611fa9e4066Sahrens 
26123f9d6ad7SLin Ling 				zdb_nicenum(zb->zb_count, csize);
26133f9d6ad7SLin Ling 				zdb_nicenum(zb->zb_lsize, lsize);
26143f9d6ad7SLin Ling 				zdb_nicenum(zb->zb_psize, psize);
26153f9d6ad7SLin Ling 				zdb_nicenum(zb->zb_asize, asize);
26163f9d6ad7SLin Ling 				zdb_nicenum(zb->zb_asize / zb->zb_count, avg);
2617d5ee8a13SMatthew Ahrens 				zdb_nicenum(zb->zb_gangs, gang);
2618fa9e4066Sahrens 
2619fa9e4066Sahrens 				(void) printf("%6s\t%5s\t%5s\t%5s\t%5s"
2620fa9e4066Sahrens 				    "\t%5.2f\t%6.2f\t",
2621fa9e4066Sahrens 				    csize, lsize, psize, asize, avg,
2622fa9e4066Sahrens 				    (double)zb->zb_lsize / zb->zb_psize,
2623fa9e4066Sahrens 				    100.0 * zb->zb_asize / tzb->zb_asize);
2624fa9e4066Sahrens 
2625fa9e4066Sahrens 				if (level == ZB_TOTAL)
2626fa9e4066Sahrens 					(void) printf("%s\n", typename);
2627fa9e4066Sahrens 				else
2628fa9e4066Sahrens 					(void) printf("    L%d %s\n",
2629fa9e4066Sahrens 					    level, typename);
2630490d05b9SMatthew Ahrens 
2631d5ee8a13SMatthew Ahrens 				if (dump_opt['b'] >= 3 && zb->zb_gangs > 0) {
2632d5ee8a13SMatthew Ahrens 					(void) printf("\t number of ganged "
2633d5ee8a13SMatthew Ahrens 					    "blocks: %s\n", gang);
2634d5ee8a13SMatthew Ahrens 				}
2635d5ee8a13SMatthew Ahrens 
2636490d05b9SMatthew Ahrens 				if (dump_opt['b'] >= 4) {
2637490d05b9SMatthew Ahrens 					(void) printf("psize "
2638490d05b9SMatthew Ahrens 					    "(in 512-byte sectors): "
2639490d05b9SMatthew Ahrens 					    "number of blocks\n");
2640490d05b9SMatthew Ahrens 					dump_histogram(zb->zb_psize_histogram,
26410713e232SGeorge Wilson 					    PSIZE_HISTO_SIZE, 0);
2642490d05b9SMatthew Ahrens 				}
2643fa9e4066Sahrens 			}
2644fa9e4066Sahrens 		}
2645fa9e4066Sahrens 	}
2646fa9e4066Sahrens 
2647fa9e4066Sahrens 	(void) printf("\n");
2648fa9e4066Sahrens 
2649fa9e4066Sahrens 	if (leaks)
2650fa9e4066Sahrens 		return (2);
2651fa9e4066Sahrens 
2652fa9e4066Sahrens 	if (zcb.zcb_haderrors)
2653fa9e4066Sahrens 		return (3);
2654fa9e4066Sahrens 
2655fa9e4066Sahrens 	return (0);
2656fa9e4066Sahrens }
2657fa9e4066Sahrens 
2658b24ab676SJeff Bonwick typedef struct zdb_ddt_entry {
2659b24ab676SJeff Bonwick 	ddt_key_t	zdde_key;
2660b24ab676SJeff Bonwick 	uint64_t	zdde_ref_blocks;
2661b24ab676SJeff Bonwick 	uint64_t	zdde_ref_lsize;
2662b24ab676SJeff Bonwick 	uint64_t	zdde_ref_psize;
2663b24ab676SJeff Bonwick 	uint64_t	zdde_ref_dsize;
2664b24ab676SJeff Bonwick 	avl_node_t	zdde_node;
2665b24ab676SJeff Bonwick } zdb_ddt_entry_t;
2666b24ab676SJeff Bonwick 
2667b24ab676SJeff Bonwick /* ARGSUSED */
2668b24ab676SJeff Bonwick static int
2669b24ab676SJeff Bonwick zdb_ddt_add_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
26701b912ec7SGeorge Wilson     const zbookmark_t *zb, const dnode_phys_t *dnp, void *arg)
2671b24ab676SJeff Bonwick {
2672b24ab676SJeff Bonwick 	avl_tree_t *t = arg;
2673b24ab676SJeff Bonwick 	avl_index_t where;
2674b24ab676SJeff Bonwick 	zdb_ddt_entry_t *zdde, zdde_search;
2675b24ab676SJeff Bonwick 
2676b24ab676SJeff Bonwick 	if (bp == NULL)
2677b24ab676SJeff Bonwick 		return (0);
2678b24ab676SJeff Bonwick 
2679b24ab676SJeff Bonwick 	if (dump_opt['S'] > 1 && zb->zb_level == ZB_ROOT_LEVEL) {
2680b24ab676SJeff Bonwick 		(void) printf("traversing objset %llu, %llu objects, "
2681b24ab676SJeff Bonwick 		    "%lu blocks so far\n",
2682b24ab676SJeff Bonwick 		    (u_longlong_t)zb->zb_objset,
2683b24ab676SJeff Bonwick 		    (u_longlong_t)bp->blk_fill,
2684b24ab676SJeff Bonwick 		    avl_numnodes(t));
2685b24ab676SJeff Bonwick 	}
2686b24ab676SJeff Bonwick 
2687bbfd46c4SJeff Bonwick 	if (BP_IS_HOLE(bp) || BP_GET_CHECKSUM(bp) == ZIO_CHECKSUM_OFF ||
2688ad135b5dSChristopher Siden 	    BP_GET_LEVEL(bp) > 0 || DMU_OT_IS_METADATA(BP_GET_TYPE(bp)))
2689b24ab676SJeff Bonwick 		return (0);
2690b24ab676SJeff Bonwick 
2691b24ab676SJeff Bonwick 	ddt_key_fill(&zdde_search.zdde_key, bp);
2692b24ab676SJeff Bonwick 
2693b24ab676SJeff Bonwick 	zdde = avl_find(t, &zdde_search, &where);
2694b24ab676SJeff Bonwick 
2695b24ab676SJeff Bonwick 	if (zdde == NULL) {
2696b24ab676SJeff Bonwick 		zdde = umem_zalloc(sizeof (*zdde), UMEM_NOFAIL);
2697b24ab676SJeff Bonwick 		zdde->zdde_key = zdde_search.zdde_key;
2698b24ab676SJeff Bonwick 		avl_insert(t, zdde, where);
2699b24ab676SJeff Bonwick 	}
2700b24ab676SJeff Bonwick 
2701b24ab676SJeff Bonwick 	zdde->zdde_ref_blocks += 1;
2702b24ab676SJeff Bonwick 	zdde->zdde_ref_lsize += BP_GET_LSIZE(bp);
2703b24ab676SJeff Bonwick 	zdde->zdde_ref_psize += BP_GET_PSIZE(bp);
2704b24ab676SJeff Bonwick 	zdde->zdde_ref_dsize += bp_get_dsize_sync(spa, bp);
2705b24ab676SJeff Bonwick 
2706b24ab676SJeff Bonwick 	return (0);
2707b24ab676SJeff Bonwick }
2708b24ab676SJeff Bonwick 
2709b24ab676SJeff Bonwick static void
2710b24ab676SJeff Bonwick dump_simulated_ddt(spa_t *spa)
2711b24ab676SJeff Bonwick {
2712b24ab676SJeff Bonwick 	avl_tree_t t;
2713b24ab676SJeff Bonwick 	void *cookie = NULL;
2714b24ab676SJeff Bonwick 	zdb_ddt_entry_t *zdde;
2715b24ab676SJeff Bonwick 	ddt_histogram_t ddh_total = { 0 };
2716b24ab676SJeff Bonwick 	ddt_stat_t dds_total = { 0 };
2717b24ab676SJeff Bonwick 
2718b24ab676SJeff Bonwick 	avl_create(&t, ddt_entry_compare,
2719b24ab676SJeff Bonwick 	    sizeof (zdb_ddt_entry_t), offsetof(zdb_ddt_entry_t, zdde_node));
2720b24ab676SJeff Bonwick 
2721b24ab676SJeff Bonwick 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
2722b24ab676SJeff Bonwick 
2723bbfd46c4SJeff Bonwick 	(void) traverse_pool(spa, 0, TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA,
2724bbfd46c4SJeff Bonwick 	    zdb_ddt_add_cb, &t);
2725b24ab676SJeff Bonwick 
2726b24ab676SJeff Bonwick 	spa_config_exit(spa, SCL_CONFIG, FTAG);
2727b24ab676SJeff Bonwick 
2728b24ab676SJeff Bonwick 	while ((zdde = avl_destroy_nodes(&t, &cookie)) != NULL) {
2729b24ab676SJeff Bonwick 		ddt_stat_t dds;
2730b24ab676SJeff Bonwick 		uint64_t refcnt = zdde->zdde_ref_blocks;
2731b24ab676SJeff Bonwick 		ASSERT(refcnt != 0);
2732b24ab676SJeff Bonwick 
2733b24ab676SJeff Bonwick 		dds.dds_blocks = zdde->zdde_ref_blocks / refcnt;
2734b24ab676SJeff Bonwick 		dds.dds_lsize = zdde->zdde_ref_lsize / refcnt;
2735b24ab676SJeff Bonwick 		dds.dds_psize = zdde->zdde_ref_psize / refcnt;
2736b24ab676SJeff Bonwick 		dds.dds_dsize = zdde->zdde_ref_dsize / refcnt;
2737b24ab676SJeff Bonwick 
2738b24ab676SJeff Bonwick 		dds.dds_ref_blocks = zdde->zdde_ref_blocks;
2739b24ab676SJeff Bonwick 		dds.dds_ref_lsize = zdde->zdde_ref_lsize;
2740b24ab676SJeff Bonwick 		dds.dds_ref_psize = zdde->zdde_ref_psize;
2741b24ab676SJeff Bonwick 		dds.dds_ref_dsize = zdde->zdde_ref_dsize;
2742b24ab676SJeff Bonwick 
2743b24ab676SJeff Bonwick 		ddt_stat_add(&ddh_total.ddh_stat[highbit(refcnt) - 1], &dds, 0);
2744b24ab676SJeff Bonwick 
2745b24ab676SJeff Bonwick 		umem_free(zdde, sizeof (*zdde));
2746b24ab676SJeff Bonwick 	}
2747b24ab676SJeff Bonwick 
2748b24ab676SJeff Bonwick 	avl_destroy(&t);
2749b24ab676SJeff Bonwick 
2750b24ab676SJeff Bonwick 	ddt_histogram_stat(&dds_total, &ddh_total);
2751b24ab676SJeff Bonwick 
2752b24ab676SJeff Bonwick 	(void) printf("Simulated DDT histogram:\n");
2753b24ab676SJeff Bonwick 
27549eb19f4dSGeorge Wilson 	zpool_dump_ddt(&dds_total, &ddh_total);
2755b24ab676SJeff Bonwick 
2756b24ab676SJeff Bonwick 	dump_dedup_ratio(&dds_total);
2757b24ab676SJeff Bonwick }
2758b24ab676SJeff Bonwick 
2759fa9e4066Sahrens static void
2760fa9e4066Sahrens dump_zpool(spa_t *spa)
2761fa9e4066Sahrens {
2762fa9e4066Sahrens 	dsl_pool_t *dp = spa_get_dsl(spa);
2763fa9e4066Sahrens 	int rc = 0;
2764fa9e4066Sahrens 
2765b24ab676SJeff Bonwick 	if (dump_opt['S']) {
2766b24ab676SJeff Bonwick 		dump_simulated_ddt(spa);
2767b24ab676SJeff Bonwick 		return;
2768b24ab676SJeff Bonwick 	}
2769b24ab676SJeff Bonwick 
277007428bdfSVictor Latushkin 	if (!dump_opt['e'] && dump_opt['C'] > 1) {
277107428bdfSVictor Latushkin 		(void) printf("\nCached configuration:\n");
277207428bdfSVictor Latushkin 		dump_nvlist(spa->spa_config, 8);
277307428bdfSVictor Latushkin 	}
277407428bdfSVictor Latushkin 
277507428bdfSVictor Latushkin 	if (dump_opt['C'])
277607428bdfSVictor Latushkin 		dump_config(spa);
277707428bdfSVictor Latushkin 
2778fa9e4066Sahrens 	if (dump_opt['u'])
277953b9a4a9SVictor Latushkin 		dump_uberblock(&spa->spa_uberblock, "\nUberblock:\n", "\n");
2780fa9e4066Sahrens 
2781b24ab676SJeff Bonwick 	if (dump_opt['D'])
2782b24ab676SJeff Bonwick 		dump_all_ddts(spa);
2783b24ab676SJeff Bonwick 
278487219db7SVictor Latushkin 	if (dump_opt['d'] > 2 || dump_opt['m'])
278587219db7SVictor Latushkin 		dump_metaslabs(spa);
278687219db7SVictor Latushkin 
278787219db7SVictor Latushkin 	if (dump_opt['d'] || dump_opt['i']) {
2788fa9e4066Sahrens 		dump_dir(dp->dp_meta_objset);
2789fa9e4066Sahrens 		if (dump_opt['d'] >= 3) {
2790d0475637SMatthew Ahrens 			dump_bpobj(&spa->spa_deferred_bpobj,
2791d0475637SMatthew Ahrens 			    "Deferred frees", 0);
2792cde58dbcSMatthew Ahrens 			if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
2793cde58dbcSMatthew Ahrens 				dump_bpobj(&spa->spa_dsl_pool->dp_free_bpobj,
2794d0475637SMatthew Ahrens 				    "Pool snapshot frees", 0);
2795ad135b5dSChristopher Siden 			}
2796ad135b5dSChristopher Siden 
2797ad135b5dSChristopher Siden 			if (spa_feature_is_active(spa,
2798*2acef22dSMatthew Ahrens 			    SPA_FEATURE_ASYNC_DESTROY)) {
2799ad135b5dSChristopher Siden 				dump_bptree(spa->spa_meta_objset,
2800ad135b5dSChristopher Siden 				    spa->spa_dsl_pool->dp_bptree_obj,
2801ad135b5dSChristopher Siden 				    "Pool dataset frees");
2802cde58dbcSMatthew Ahrens 			}
2803fa9e4066Sahrens 			dump_dtl(spa->spa_root_vdev, 0);
2804fa9e4066Sahrens 		}
280507428bdfSVictor Latushkin 		(void) dmu_objset_find(spa_name(spa), dump_one_dir,
280607428bdfSVictor Latushkin 		    NULL, DS_FIND_SNAPSHOTS | DS_FIND_CHILDREN);
2807fa9e4066Sahrens 	}
2808b24ab676SJeff Bonwick 	if (dump_opt['b'] || dump_opt['c'])
2809fa9e4066Sahrens 		rc = dump_block_stats(spa);
2810fa9e4066Sahrens 
28110713e232SGeorge Wilson 	if (rc == 0)
28120713e232SGeorge Wilson 		rc = verify_spacemap_refcounts(spa);
28130713e232SGeorge Wilson 
2814fa9e4066Sahrens 	if (dump_opt['s'])
2815fa9e4066Sahrens 		show_pool_stats(spa);
2816fa9e4066Sahrens 
28178f18d1faSGeorge Wilson 	if (dump_opt['h'])
28188f18d1faSGeorge Wilson 		dump_history(spa);
28198f18d1faSGeorge Wilson 
2820fa9e4066Sahrens 	if (rc != 0)
2821fa9e4066Sahrens 		exit(rc);
2822fa9e4066Sahrens }
2823fa9e4066Sahrens 
282444cd46caSbillm #define	ZDB_FLAG_CHECKSUM	0x0001
282544cd46caSbillm #define	ZDB_FLAG_DECOMPRESS	0x0002
282644cd46caSbillm #define	ZDB_FLAG_BSWAP		0x0004
282744cd46caSbillm #define	ZDB_FLAG_GBH		0x0008
282844cd46caSbillm #define	ZDB_FLAG_INDIRECT	0x0010
282944cd46caSbillm #define	ZDB_FLAG_PHYS		0x0020
283044cd46caSbillm #define	ZDB_FLAG_RAW		0x0040
283144cd46caSbillm #define	ZDB_FLAG_PRINT_BLKPTR	0x0080
283244cd46caSbillm 
283344cd46caSbillm int flagbits[256];
283444cd46caSbillm 
283544cd46caSbillm static void
283644cd46caSbillm zdb_print_blkptr(blkptr_t *bp, int flags)
283744cd46caSbillm {
2838b24ab676SJeff Bonwick 	char blkbuf[BP_SPRINTF_LEN];
283944cd46caSbillm 
284044cd46caSbillm 	if (flags & ZDB_FLAG_BSWAP)
284144cd46caSbillm 		byteswap_uint64_array((void *)bp, sizeof (blkptr_t));
2842b24ab676SJeff Bonwick 
2843b24ab676SJeff Bonwick 	sprintf_blkptr(blkbuf, bp);
2844b24ab676SJeff Bonwick 	(void) printf("%s\n", blkbuf);
284544cd46caSbillm }
284644cd46caSbillm 
284744cd46caSbillm static void
284844cd46caSbillm zdb_dump_indirect(blkptr_t *bp, int nbps, int flags)
284944cd46caSbillm {
285044cd46caSbillm 	int i;
285144cd46caSbillm 
285244cd46caSbillm 	for (i = 0; i < nbps; i++)
285344cd46caSbillm 		zdb_print_blkptr(&bp[i], flags);
285444cd46caSbillm }
285544cd46caSbillm 
285644cd46caSbillm static void
285744cd46caSbillm zdb_dump_gbh(void *buf, int flags)
285844cd46caSbillm {
285944cd46caSbillm 	zdb_dump_indirect((blkptr_t *)buf, SPA_GBH_NBLKPTRS, flags);
286044cd46caSbillm }
286144cd46caSbillm 
286244cd46caSbillm static void
286344cd46caSbillm zdb_dump_block_raw(void *buf, uint64_t size, int flags)
286444cd46caSbillm {
286544cd46caSbillm 	if (flags & ZDB_FLAG_BSWAP)
286644cd46caSbillm 		byteswap_uint64_array(buf, size);
2867b24ab676SJeff Bonwick 	(void) write(1, buf, size);
286844cd46caSbillm }
286944cd46caSbillm 
287044cd46caSbillm static void
287144cd46caSbillm zdb_dump_block(char *label, void *buf, uint64_t size, int flags)
287244cd46caSbillm {
287344cd46caSbillm 	uint64_t *d = (uint64_t *)buf;
287444cd46caSbillm 	int nwords = size / sizeof (uint64_t);
287544cd46caSbillm 	int do_bswap = !!(flags & ZDB_FLAG_BSWAP);
287644cd46caSbillm 	int i, j;
287744cd46caSbillm 	char *hdr, *c;
287844cd46caSbillm 
287944cd46caSbillm 
288044cd46caSbillm 	if (do_bswap)
288144cd46caSbillm 		hdr = " 7 6 5 4 3 2 1 0   f e d c b a 9 8";
288244cd46caSbillm 	else
288344cd46caSbillm 		hdr = " 0 1 2 3 4 5 6 7   8 9 a b c d e f";
288444cd46caSbillm 
288544cd46caSbillm 	(void) printf("\n%s\n%6s   %s  0123456789abcdef\n", label, "", hdr);
288644cd46caSbillm 
288744cd46caSbillm 	for (i = 0; i < nwords; i += 2) {
288844cd46caSbillm 		(void) printf("%06llx:  %016llx  %016llx  ",
288944cd46caSbillm 		    (u_longlong_t)(i * sizeof (uint64_t)),
289044cd46caSbillm 		    (u_longlong_t)(do_bswap ? BSWAP_64(d[i]) : d[i]),
289144cd46caSbillm 		    (u_longlong_t)(do_bswap ? BSWAP_64(d[i + 1]) : d[i + 1]));
289244cd46caSbillm 
289344cd46caSbillm 		c = (char *)&d[i];
289444cd46caSbillm 		for (j = 0; j < 2 * sizeof (uint64_t); j++)
289544cd46caSbillm 			(void) printf("%c", isprint(c[j]) ? c[j] : '.');
289644cd46caSbillm 		(void) printf("\n");
289744cd46caSbillm 	}
289844cd46caSbillm }
289944cd46caSbillm 
290044cd46caSbillm /*
290144cd46caSbillm  * There are two acceptable formats:
290244cd46caSbillm  *	leaf_name	  - For example: c1t0d0 or /tmp/ztest.0a
290344cd46caSbillm  *	child[.child]*    - For example: 0.1.1
290444cd46caSbillm  *
290544cd46caSbillm  * The second form can be used to specify arbitrary vdevs anywhere
290644cd46caSbillm  * in the heirarchy.  For example, in a pool with a mirror of
290744cd46caSbillm  * RAID-Zs, you can specify either RAID-Z vdev with 0.0 or 0.1 .
290844cd46caSbillm  */
290944cd46caSbillm static vdev_t *
291044cd46caSbillm zdb_vdev_lookup(vdev_t *vdev, char *path)
291144cd46caSbillm {
291244cd46caSbillm 	char *s, *p, *q;
291344cd46caSbillm 	int i;
291444cd46caSbillm 
291544cd46caSbillm 	if (vdev == NULL)
291644cd46caSbillm 		return (NULL);
291744cd46caSbillm 
291844cd46caSbillm 	/* First, assume the x.x.x.x format */
291944cd46caSbillm 	i = (int)strtoul(path, &s, 10);
292044cd46caSbillm 	if (s == path || (s && *s != '.' && *s != '\0'))
292144cd46caSbillm 		goto name;
292244cd46caSbillm 	if (i < 0 || i >= vdev->vdev_children)
292344cd46caSbillm 		return (NULL);
292444cd46caSbillm 
292544cd46caSbillm 	vdev = vdev->vdev_child[i];
292644cd46caSbillm 	if (*s == '\0')
292744cd46caSbillm 		return (vdev);
292844cd46caSbillm 	return (zdb_vdev_lookup(vdev, s+1));
292944cd46caSbillm 
293044cd46caSbillm name:
293144cd46caSbillm 	for (i = 0; i < vdev->vdev_children; i++) {
293244cd46caSbillm 		vdev_t *vc = vdev->vdev_child[i];
293344cd46caSbillm 
293444cd46caSbillm 		if (vc->vdev_path == NULL) {
293544cd46caSbillm 			vc = zdb_vdev_lookup(vc, path);
293644cd46caSbillm 			if (vc == NULL)
293744cd46caSbillm 				continue;
293844cd46caSbillm 			else
293944cd46caSbillm 				return (vc);
294044cd46caSbillm 		}
294144cd46caSbillm 
294244cd46caSbillm 		p = strrchr(vc->vdev_path, '/');
294344cd46caSbillm 		p = p ? p + 1 : vc->vdev_path;
294444cd46caSbillm 		q = &vc->vdev_path[strlen(vc->vdev_path) - 2];
294544cd46caSbillm 
294644cd46caSbillm 		if (strcmp(vc->vdev_path, path) == 0)
294744cd46caSbillm 			return (vc);
294844cd46caSbillm 		if (strcmp(p, path) == 0)
294944cd46caSbillm 			return (vc);
295044cd46caSbillm 		if (strcmp(q, "s0") == 0 && strncmp(p, path, q - p) == 0)
295144cd46caSbillm 			return (vc);
295244cd46caSbillm 	}
295344cd46caSbillm 
295444cd46caSbillm 	return (NULL);
295544cd46caSbillm }
295644cd46caSbillm 
295744cd46caSbillm /*
295844cd46caSbillm  * Read a block from a pool and print it out.  The syntax of the
295944cd46caSbillm  * block descriptor is:
296044cd46caSbillm  *
296144cd46caSbillm  *	pool:vdev_specifier:offset:size[:flags]
296244cd46caSbillm  *
296344cd46caSbillm  *	pool           - The name of the pool you wish to read from
296444cd46caSbillm  *	vdev_specifier - Which vdev (see comment for zdb_vdev_lookup)
296544cd46caSbillm  *	offset         - offset, in hex, in bytes
296644cd46caSbillm  *	size           - Amount of data to read, in hex, in bytes
296744cd46caSbillm  *	flags          - A string of characters specifying options
296844cd46caSbillm  *		 b: Decode a blkptr at given offset within block
296944cd46caSbillm  *		*c: Calculate and display checksums
2970b24ab676SJeff Bonwick  *		 d: Decompress data before dumping
297144cd46caSbillm  *		 e: Byteswap data before dumping
2972b24ab676SJeff Bonwick  *		 g: Display data as a gang block header
2973b24ab676SJeff Bonwick  *		 i: Display as an indirect block
297444cd46caSbillm  *		 p: Do I/O to physical offset
297544cd46caSbillm  *		 r: Dump raw data to stdout
297644cd46caSbillm  *
297744cd46caSbillm  *              * = not yet implemented
297844cd46caSbillm  */
297944cd46caSbillm static void
298007428bdfSVictor Latushkin zdb_read_block(char *thing, spa_t *spa)
298144cd46caSbillm {
2982b24ab676SJeff Bonwick 	blkptr_t blk, *bp = &blk;
2983b24ab676SJeff Bonwick 	dva_t *dva = bp->blk_dva;
298444cd46caSbillm 	int flags = 0;
2985b24ab676SJeff Bonwick 	uint64_t offset = 0, size = 0, psize = 0, lsize = 0, blkptr_offset = 0;
298644cd46caSbillm 	zio_t *zio;
298744cd46caSbillm 	vdev_t *vd;
2988b24ab676SJeff Bonwick 	void *pbuf, *lbuf, *buf;
298907428bdfSVictor Latushkin 	char *s, *p, *dup, *vdev, *flagstr;
2990b24ab676SJeff Bonwick 	int i, error;
299144cd46caSbillm 
299244cd46caSbillm 	dup = strdup(thing);
299344cd46caSbillm 	s = strtok(dup, ":");
299444cd46caSbillm 	vdev = s ? s : "";
299544cd46caSbillm 	s = strtok(NULL, ":");
299644cd46caSbillm 	offset = strtoull(s ? s : "", NULL, 16);
299744cd46caSbillm 	s = strtok(NULL, ":");
299844cd46caSbillm 	size = strtoull(s ? s : "", NULL, 16);
299944cd46caSbillm 	s = strtok(NULL, ":");
300044cd46caSbillm 	flagstr = s ? s : "";
300144cd46caSbillm 
300244cd46caSbillm 	s = NULL;
300344cd46caSbillm 	if (size == 0)
300444cd46caSbillm 		s = "size must not be zero";
300544cd46caSbillm 	if (!IS_P2ALIGNED(size, DEV_BSIZE))
300644cd46caSbillm 		s = "size must be a multiple of sector size";
300744cd46caSbillm 	if (!IS_P2ALIGNED(offset, DEV_BSIZE))
300844cd46caSbillm 		s = "offset must be a multiple of sector size";
300944cd46caSbillm 	if (s) {
301044cd46caSbillm 		(void) printf("Invalid block specifier: %s  - %s\n", thing, s);
301144cd46caSbillm 		free(dup);
301244cd46caSbillm 		return;
301344cd46caSbillm 	}
301444cd46caSbillm 
301544cd46caSbillm 	for (s = strtok(flagstr, ":"); s; s = strtok(NULL, ":")) {
301644cd46caSbillm 		for (i = 0; flagstr[i]; i++) {
30175ad82045Snd 			int bit = flagbits[(uchar_t)flagstr[i]];
301844cd46caSbillm 
301944cd46caSbillm 			if (bit == 0) {
302044cd46caSbillm 				(void) printf("***Invalid flag: %c\n",
302144cd46caSbillm 				    flagstr[i]);
302244cd46caSbillm 				continue;
302344cd46caSbillm 			}
302444cd46caSbillm 			flags |= bit;
302544cd46caSbillm 
302644cd46caSbillm 			/* If it's not something with an argument, keep going */
3027b24ab676SJeff Bonwick 			if ((bit & (ZDB_FLAG_CHECKSUM |
302844cd46caSbillm 			    ZDB_FLAG_PRINT_BLKPTR)) == 0)
302944cd46caSbillm 				continue;
303044cd46caSbillm 
303144cd46caSbillm 			p = &flagstr[i + 1];
303244cd46caSbillm 			if (bit == ZDB_FLAG_PRINT_BLKPTR)
303344cd46caSbillm 				blkptr_offset = strtoull(p, &p, 16);
303444cd46caSbillm 			if (*p != ':' && *p != '\0') {
303544cd46caSbillm 				(void) printf("***Invalid flag arg: '%s'\n", s);
303644cd46caSbillm 				free(dup);
303744cd46caSbillm 				return;
303844cd46caSbillm 			}
303944cd46caSbillm 		}
304044cd46caSbillm 	}
304144cd46caSbillm 
304244cd46caSbillm 	vd = zdb_vdev_lookup(spa->spa_root_vdev, vdev);
304344cd46caSbillm 	if (vd == NULL) {
304444cd46caSbillm 		(void) printf("***Invalid vdev: %s\n", vdev);
304544cd46caSbillm 		free(dup);
304644cd46caSbillm 		return;
304744cd46caSbillm 	} else {
304844cd46caSbillm 		if (vd->vdev_path)
3049b24ab676SJeff Bonwick 			(void) fprintf(stderr, "Found vdev: %s\n",
3050b24ab676SJeff Bonwick 			    vd->vdev_path);
305144cd46caSbillm 		else
3052b24ab676SJeff Bonwick 			(void) fprintf(stderr, "Found vdev type: %s\n",
305344cd46caSbillm 			    vd->vdev_ops->vdev_op_type);
305444cd46caSbillm 	}
305544cd46caSbillm 
3056b24ab676SJeff Bonwick 	psize = size;
3057b24ab676SJeff Bonwick 	lsize = size;
305844cd46caSbillm 
3059b24ab676SJeff Bonwick 	pbuf = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
3060b24ab676SJeff Bonwick 	lbuf = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
3061b24ab676SJeff Bonwick 
3062b24ab676SJeff Bonwick 	BP_ZERO(bp);
3063b24ab676SJeff Bonwick 
3064b24ab676SJeff Bonwick 	DVA_SET_VDEV(&dva[0], vd->vdev_id);
3065b24ab676SJeff Bonwick 	DVA_SET_OFFSET(&dva[0], offset);
3066b24ab676SJeff Bonwick 	DVA_SET_GANG(&dva[0], !!(flags & ZDB_FLAG_GBH));
3067b24ab676SJeff Bonwick 	DVA_SET_ASIZE(&dva[0], vdev_psize_to_asize(vd, psize));
3068b24ab676SJeff Bonwick 
3069b24ab676SJeff Bonwick 	BP_SET_BIRTH(bp, TXG_INITIAL, TXG_INITIAL);
3070b24ab676SJeff Bonwick 
3071b24ab676SJeff Bonwick 	BP_SET_LSIZE(bp, lsize);
3072b24ab676SJeff Bonwick 	BP_SET_PSIZE(bp, psize);
3073b24ab676SJeff Bonwick 	BP_SET_COMPRESS(bp, ZIO_COMPRESS_OFF);
3074b24ab676SJeff Bonwick 	BP_SET_CHECKSUM(bp, ZIO_CHECKSUM_OFF);
3075b24ab676SJeff Bonwick 	BP_SET_TYPE(bp, DMU_OT_NONE);
3076b24ab676SJeff Bonwick 	BP_SET_LEVEL(bp, 0);
3077b24ab676SJeff Bonwick 	BP_SET_DEDUP(bp, 0);
3078b24ab676SJeff Bonwick 	BP_SET_BYTEORDER(bp, ZFS_HOST_BYTEORDER);
307944cd46caSbillm 
3080e14bb325SJeff Bonwick 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
308144cd46caSbillm 	zio = zio_root(spa, NULL, NULL, 0);
3082b24ab676SJeff Bonwick 
3083b24ab676SJeff Bonwick 	if (vd == vd->vdev_top) {
3084b24ab676SJeff Bonwick 		/*
3085b24ab676SJeff Bonwick 		 * Treat this as a normal block read.
3086b24ab676SJeff Bonwick 		 */
3087b24ab676SJeff Bonwick 		zio_nowait(zio_read(zio, spa, bp, pbuf, psize, NULL, NULL,
3088b24ab676SJeff Bonwick 		    ZIO_PRIORITY_SYNC_READ,
3089b24ab676SJeff Bonwick 		    ZIO_FLAG_CANFAIL | ZIO_FLAG_RAW, NULL));
3090b24ab676SJeff Bonwick 	} else {
3091b24ab676SJeff Bonwick 		/*
3092b24ab676SJeff Bonwick 		 * Treat this as a vdev child I/O.
3093b24ab676SJeff Bonwick 		 */
3094b24ab676SJeff Bonwick 		zio_nowait(zio_vdev_child_io(zio, bp, vd, offset, pbuf, psize,
3095b24ab676SJeff Bonwick 		    ZIO_TYPE_READ, ZIO_PRIORITY_SYNC_READ,
3096b24ab676SJeff Bonwick 		    ZIO_FLAG_DONT_CACHE | ZIO_FLAG_DONT_QUEUE |
3097b24ab676SJeff Bonwick 		    ZIO_FLAG_DONT_PROPAGATE | ZIO_FLAG_DONT_RETRY |
3098b24ab676SJeff Bonwick 		    ZIO_FLAG_CANFAIL | ZIO_FLAG_RAW, NULL, NULL));
3099b24ab676SJeff Bonwick 	}
3100b24ab676SJeff Bonwick 
310144cd46caSbillm 	error = zio_wait(zio);
3102e14bb325SJeff Bonwick 	spa_config_exit(spa, SCL_STATE, FTAG);
310344cd46caSbillm 
310444cd46caSbillm 	if (error) {
310544cd46caSbillm 		(void) printf("Read of %s failed, error: %d\n", thing, error);
310644cd46caSbillm 		goto out;
310744cd46caSbillm 	}
310844cd46caSbillm 
3109b24ab676SJeff Bonwick 	if (flags & ZDB_FLAG_DECOMPRESS) {
3110b24ab676SJeff Bonwick 		/*
3111b24ab676SJeff Bonwick 		 * We don't know how the data was compressed, so just try
3112b24ab676SJeff Bonwick 		 * every decompress function at every inflated blocksize.
3113b24ab676SJeff Bonwick 		 */
3114b24ab676SJeff Bonwick 		enum zio_compress c;
3115b24ab676SJeff Bonwick 		void *pbuf2 = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
3116b24ab676SJeff Bonwick 		void *lbuf2 = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
3117b24ab676SJeff Bonwick 
3118b24ab676SJeff Bonwick 		bcopy(pbuf, pbuf2, psize);
3119b24ab676SJeff Bonwick 
3120b24ab676SJeff Bonwick 		VERIFY(random_get_pseudo_bytes((uint8_t *)pbuf + psize,
3121b24ab676SJeff Bonwick 		    SPA_MAXBLOCKSIZE - psize) == 0);
3122b24ab676SJeff Bonwick 
3123b24ab676SJeff Bonwick 		VERIFY(random_get_pseudo_bytes((uint8_t *)pbuf2 + psize,
3124b24ab676SJeff Bonwick 		    SPA_MAXBLOCKSIZE - psize) == 0);
3125b24ab676SJeff Bonwick 
3126b24ab676SJeff Bonwick 		for (lsize = SPA_MAXBLOCKSIZE; lsize > psize;
3127b24ab676SJeff Bonwick 		    lsize -= SPA_MINBLOCKSIZE) {
3128b24ab676SJeff Bonwick 			for (c = 0; c < ZIO_COMPRESS_FUNCTIONS; c++) {
3129b24ab676SJeff Bonwick 				if (zio_decompress_data(c, pbuf, lbuf,
3130b24ab676SJeff Bonwick 				    psize, lsize) == 0 &&
3131b24ab676SJeff Bonwick 				    zio_decompress_data(c, pbuf2, lbuf2,
3132b24ab676SJeff Bonwick 				    psize, lsize) == 0 &&
3133b24ab676SJeff Bonwick 				    bcmp(lbuf, lbuf2, lsize) == 0)
3134b24ab676SJeff Bonwick 					break;
3135b24ab676SJeff Bonwick 			}
3136b24ab676SJeff Bonwick 			if (c != ZIO_COMPRESS_FUNCTIONS)
3137b24ab676SJeff Bonwick 				break;
3138b24ab676SJeff Bonwick 			lsize -= SPA_MINBLOCKSIZE;
3139b24ab676SJeff Bonwick 		}
3140b24ab676SJeff Bonwick 
3141b24ab676SJeff Bonwick 		umem_free(pbuf2, SPA_MAXBLOCKSIZE);
3142b24ab676SJeff Bonwick 		umem_free(lbuf2, SPA_MAXBLOCKSIZE);
3143b24ab676SJeff Bonwick 
3144b24ab676SJeff Bonwick 		if (lsize <= psize) {
3145b24ab676SJeff Bonwick 			(void) printf("Decompress of %s failed\n", thing);
3146b24ab676SJeff Bonwick 			goto out;
3147b24ab676SJeff Bonwick 		}
3148b24ab676SJeff Bonwick 		buf = lbuf;
3149b24ab676SJeff Bonwick 		size = lsize;
3150b24ab676SJeff Bonwick 	} else {
3151b24ab676SJeff Bonwick 		buf = pbuf;
3152b24ab676SJeff Bonwick 		size = psize;
3153b24ab676SJeff Bonwick 	}
3154b24ab676SJeff Bonwick 
315544cd46caSbillm 	if (flags & ZDB_FLAG_PRINT_BLKPTR)
315644cd46caSbillm 		zdb_print_blkptr((blkptr_t *)(void *)
315744cd46caSbillm 		    ((uintptr_t)buf + (uintptr_t)blkptr_offset), flags);
315844cd46caSbillm 	else if (flags & ZDB_FLAG_RAW)
315944cd46caSbillm 		zdb_dump_block_raw(buf, size, flags);
316044cd46caSbillm 	else if (flags & ZDB_FLAG_INDIRECT)
316144cd46caSbillm 		zdb_dump_indirect((blkptr_t *)buf, size / sizeof (blkptr_t),
316244cd46caSbillm 		    flags);
316344cd46caSbillm 	else if (flags & ZDB_FLAG_GBH)
316444cd46caSbillm 		zdb_dump_gbh(buf, flags);
316544cd46caSbillm 	else
316644cd46caSbillm 		zdb_dump_block(thing, buf, size, flags);
316744cd46caSbillm 
316844cd46caSbillm out:
3169b24ab676SJeff Bonwick 	umem_free(pbuf, SPA_MAXBLOCKSIZE);
3170b24ab676SJeff Bonwick 	umem_free(lbuf, SPA_MAXBLOCKSIZE);
317144cd46caSbillm 	free(dup);
317244cd46caSbillm }
317344cd46caSbillm 
3174de6628f0Sck static boolean_t
31753ad6c7f9SVictor Latushkin pool_match(nvlist_t *cfg, char *tgt)
3176de6628f0Sck {
31773ad6c7f9SVictor Latushkin 	uint64_t v, guid = strtoull(tgt, NULL, 0);
3178de6628f0Sck 	char *s;
3179de6628f0Sck 
3180de6628f0Sck 	if (guid != 0) {
31813ad6c7f9SVictor Latushkin 		if (nvlist_lookup_uint64(cfg, ZPOOL_CONFIG_POOL_GUID, &v) == 0)
31823ad6c7f9SVictor Latushkin 			return (v == guid);
3183de6628f0Sck 	} else {
31843ad6c7f9SVictor Latushkin 		if (nvlist_lookup_string(cfg, ZPOOL_CONFIG_POOL_NAME, &s) == 0)
31853ad6c7f9SVictor Latushkin 			return (strcmp(s, tgt) == 0);
3186de6628f0Sck 	}
31873ad6c7f9SVictor Latushkin 	return (B_FALSE);
3188de6628f0Sck }
3189de6628f0Sck 
31903ad6c7f9SVictor Latushkin static char *
31913ad6c7f9SVictor Latushkin find_zpool(char **target, nvlist_t **configp, int dirc, char **dirv)
3192de6628f0Sck {
3193de6628f0Sck 	nvlist_t *pools;
3194de6628f0Sck 	nvlist_t *match = NULL;
31953ad6c7f9SVictor Latushkin 	char *name = NULL;
31963ad6c7f9SVictor Latushkin 	char *sepp = NULL;
31973ad6c7f9SVictor Latushkin 	char sep;
31983ad6c7f9SVictor Latushkin 	int count = 0;
3199d41c4376SMark J Musante 	importargs_t args = { 0 };
3200d41c4376SMark J Musante 
3201d41c4376SMark J Musante 	args.paths = dirc;
3202d41c4376SMark J Musante 	args.path = dirv;
3203d41c4376SMark J Musante 	args.can_be_active = B_TRUE;
3204de6628f0Sck 
32053ad6c7f9SVictor Latushkin 	if ((sepp = strpbrk(*target, "/@")) != NULL) {
32063ad6c7f9SVictor Latushkin 		sep = *sepp;
32073ad6c7f9SVictor Latushkin 		*sepp = '\0';
32083ad6c7f9SVictor Latushkin 	}
32093ad6c7f9SVictor Latushkin 
3210d41c4376SMark J Musante 	pools = zpool_search_import(g_zfs, &args);
3211de6628f0Sck 
3212de6628f0Sck 	if (pools != NULL) {
3213de6628f0Sck 		nvpair_t *elem = NULL;
3214de6628f0Sck 		while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) {
3215de6628f0Sck 			verify(nvpair_value_nvlist(elem, configp) == 0);
32163ad6c7f9SVictor Latushkin 			if (pool_match(*configp, *target)) {
32173ad6c7f9SVictor Latushkin 				count++;
3218de6628f0Sck 				if (match != NULL) {
32193ad6c7f9SVictor Latushkin 					/* print previously found config */
32203ad6c7f9SVictor Latushkin 					if (name != NULL) {
32213ad6c7f9SVictor Latushkin 						(void) printf("%s\n", name);
32223ad6c7f9SVictor Latushkin 						dump_nvlist(match, 8);
32233ad6c7f9SVictor Latushkin 						name = NULL;
32243ad6c7f9SVictor Latushkin 					}
32253ad6c7f9SVictor Latushkin 					(void) printf("%s\n",
32263ad6c7f9SVictor Latushkin 					    nvpair_name(elem));
32273ad6c7f9SVictor Latushkin 					dump_nvlist(*configp, 8);
3228de6628f0Sck 				} else {
3229de6628f0Sck 					match = *configp;
32303ad6c7f9SVictor Latushkin 					name = nvpair_name(elem);
3231de6628f0Sck 				}
3232de6628f0Sck 			}
3233de6628f0Sck 		}
3234de6628f0Sck 	}
32353ad6c7f9SVictor Latushkin 	if (count > 1)
32363ad6c7f9SVictor Latushkin 		(void) fatal("\tMatched %d pools - use pool GUID "
32373ad6c7f9SVictor Latushkin 		    "instead of pool name or \n"
32383ad6c7f9SVictor Latushkin 		    "\tpool name part of a dataset name to select pool", count);
32393ad6c7f9SVictor Latushkin 
32403ad6c7f9SVictor Latushkin 	if (sepp)
32413ad6c7f9SVictor Latushkin 		*sepp = sep;
32423ad6c7f9SVictor Latushkin 	/*
32433ad6c7f9SVictor Latushkin 	 * If pool GUID was specified for pool id, replace it with pool name
32443ad6c7f9SVictor Latushkin 	 */
32453ad6c7f9SVictor Latushkin 	if (name && (strstr(*target, name) != *target)) {
32463ad6c7f9SVictor Latushkin 		int sz = 1 + strlen(name) + ((sepp) ? strlen(sepp) : 0);
32473ad6c7f9SVictor Latushkin 
32483ad6c7f9SVictor Latushkin 		*target = umem_alloc(sz, UMEM_NOFAIL);
32493ad6c7f9SVictor Latushkin 		(void) snprintf(*target, sz, "%s%s", name, sepp ? sepp : "");
32503ad6c7f9SVictor Latushkin 	}
3251de6628f0Sck 
32523ad6c7f9SVictor Latushkin 	*configp = name ? match : NULL;
3253de6628f0Sck 
32543ad6c7f9SVictor Latushkin 	return (name);
3255de6628f0Sck }
3256de6628f0Sck 
3257fa9e4066Sahrens int
3258fa9e4066Sahrens main(int argc, char **argv)
3259fa9e4066Sahrens {
3260fa9e4066Sahrens 	int i, c;
3261fa9e4066Sahrens 	struct rlimit rl = { 1024, 1024 };
32623ad6c7f9SVictor Latushkin 	spa_t *spa = NULL;
3263fa9e4066Sahrens 	objset_t *os = NULL;
3264fa9e4066Sahrens 	int dump_all = 1;
3265fa9e4066Sahrens 	int verbose = 0;
3266c8ee1847SVictor Latushkin 	int error = 0;
32673ad6c7f9SVictor Latushkin 	char **searchdirs = NULL;
32683ad6c7f9SVictor Latushkin 	int nsearch = 0;
32693ad6c7f9SVictor Latushkin 	char *target;
3270468c413aSTim Haley 	nvlist_t *policy = NULL;
3271468c413aSTim Haley 	uint64_t max_txg = UINT64_MAX;
3272c8ee1847SVictor Latushkin 	int rewind = ZPOOL_NEVER_REWIND;
3273fa9e4066Sahrens 
3274fa9e4066Sahrens 	(void) setrlimit(RLIMIT_NOFILE, &rl);
3275004388ebScasper 	(void) enable_extended_FILE_stdio(-1, -1);
3276fa9e4066Sahrens 
3277fa9e4066Sahrens 	dprintf_setup(&argc, argv);
3278fa9e4066Sahrens 
327931d7e8faSGeorge Wilson 	while ((c = getopt(argc, argv, "bcdhilmM:suCDRSAFLXevp:t:U:P")) != -1) {
3280fa9e4066Sahrens 		switch (c) {
3281fa9e4066Sahrens 		case 'b':
3282fa9e4066Sahrens 		case 'c':
3283b24ab676SJeff Bonwick 		case 'd':
3284b24ab676SJeff Bonwick 		case 'h':
3285b24ab676SJeff Bonwick 		case 'i':
3286b24ab676SJeff Bonwick 		case 'l':
3287d6e555bdSGeorge Wilson 		case 'm':
3288fa9e4066Sahrens 		case 's':
3289b24ab676SJeff Bonwick 		case 'u':
3290fa9e4066Sahrens 		case 'C':
3291b24ab676SJeff Bonwick 		case 'D':
329244cd46caSbillm 		case 'R':
3293b24ab676SJeff Bonwick 		case 'S':
3294fa9e4066Sahrens 			dump_opt[c]++;
3295fa9e4066Sahrens 			dump_all = 0;
3296fa9e4066Sahrens 			break;
3297feef89cfSVictor Latushkin 		case 'A':
3298c8ee1847SVictor Latushkin 		case 'F':
329982a0a985SVictor Latushkin 		case 'L':
3300c8ee1847SVictor Latushkin 		case 'X':
33013ad6c7f9SVictor Latushkin 		case 'e':
33023f9d6ad7SLin Ling 		case 'P':
330382a0a985SVictor Latushkin 			dump_opt[c]++;
330482a0a985SVictor Latushkin 			break;
3305fa9e4066Sahrens 		case 'v':
3306fa9e4066Sahrens 			verbose++;
3307fa9e4066Sahrens 			break;
330831d7e8faSGeorge Wilson 		case 'M':
330931d7e8faSGeorge Wilson 			max_inflight = strtoull(optarg, NULL, 0);
331031d7e8faSGeorge Wilson 			if (max_inflight == 0) {
331131d7e8faSGeorge Wilson 				(void) fprintf(stderr, "maximum number "
331231d7e8faSGeorge Wilson 				    "of inflight I/Os must be greater "
331331d7e8faSGeorge Wilson 				    "than 0\n");
331431d7e8faSGeorge Wilson 				usage();
331531d7e8faSGeorge Wilson 			}
331631d7e8faSGeorge Wilson 			break;
3317de6628f0Sck 		case 'p':
33183ad6c7f9SVictor Latushkin 			if (searchdirs == NULL) {
33193ad6c7f9SVictor Latushkin 				searchdirs = umem_alloc(sizeof (char *),
33203ad6c7f9SVictor Latushkin 				    UMEM_NOFAIL);
33213ad6c7f9SVictor Latushkin 			} else {
33223ad6c7f9SVictor Latushkin 				char **tmp = umem_alloc((nsearch + 1) *
33233ad6c7f9SVictor Latushkin 				    sizeof (char *), UMEM_NOFAIL);
33243ad6c7f9SVictor Latushkin 				bcopy(searchdirs, tmp, nsearch *
33253ad6c7f9SVictor Latushkin 				    sizeof (char *));
33263ad6c7f9SVictor Latushkin 				umem_free(searchdirs,
33273ad6c7f9SVictor Latushkin 				    nsearch * sizeof (char *));
33283ad6c7f9SVictor Latushkin 				searchdirs = tmp;
33293ad6c7f9SVictor Latushkin 			}
33303ad6c7f9SVictor Latushkin 			searchdirs[nsearch++] = optarg;
3331de6628f0Sck 			break;
33322e551927SVictor Latushkin 		case 't':
3333468c413aSTim Haley 			max_txg = strtoull(optarg, NULL, 0);
3334468c413aSTim Haley 			if (max_txg < TXG_INITIAL) {
33352e551927SVictor Latushkin 				(void) fprintf(stderr, "incorrect txg "
33362e551927SVictor Latushkin 				    "specified: %s\n", optarg);
33372e551927SVictor Latushkin 				usage();
33382e551927SVictor Latushkin 			}
33392e551927SVictor Latushkin 			break;
3340b24ab676SJeff Bonwick 		case 'U':
3341b24ab676SJeff Bonwick 			spa_config_path = optarg;
3342b24ab676SJeff Bonwick 			break;
3343fa9e4066Sahrens 		default:
3344fa9e4066Sahrens 			usage();
3345fa9e4066Sahrens 			break;
3346fa9e4066Sahrens 		}
3347fa9e4066Sahrens 	}
3348fa9e4066Sahrens 
33493ad6c7f9SVictor Latushkin 	if (!dump_opt['e'] && searchdirs != NULL) {
335088b7b0f2SMatthew Ahrens 		(void) fprintf(stderr, "-p option requires use of -e\n");
335188b7b0f2SMatthew Ahrens 		usage();
335288b7b0f2SMatthew Ahrens 	}
3353de6628f0Sck 
3354fa9e4066Sahrens 	kernel_init(FREAD);
3355de6628f0Sck 	g_zfs = libzfs_init();
335691ebeef5Sahrens 	ASSERT(g_zfs != NULL);
3357fa9e4066Sahrens 
3358b24ab676SJeff Bonwick 	if (dump_all)
3359b24ab676SJeff Bonwick 		verbose = MAX(verbose, 1);
3360b24ab676SJeff Bonwick 
3361fa9e4066Sahrens 	for (c = 0; c < 256; c++) {
33623f9d6ad7SLin Ling 		if (dump_all && !strchr("elAFLRSXP", c))
3363fa9e4066Sahrens 			dump_opt[c] = 1;
3364fa9e4066Sahrens 		if (dump_opt[c])
3365fa9e4066Sahrens 			dump_opt[c] += verbose;
3366fa9e4066Sahrens 	}
3367fa9e4066Sahrens 
3368feef89cfSVictor Latushkin 	aok = (dump_opt['A'] == 1) || (dump_opt['A'] > 2);
3369feef89cfSVictor Latushkin 	zfs_recover = (dump_opt['A'] > 1);
3370feef89cfSVictor Latushkin 
3371fa9e4066Sahrens 	argc -= optind;
3372fa9e4066Sahrens 	argv += optind;
3373fa9e4066Sahrens 
337407428bdfSVictor Latushkin 	if (argc < 2 && dump_opt['R'])
337507428bdfSVictor Latushkin 		usage();
3376fa9e4066Sahrens 	if (argc < 1) {
33773ad6c7f9SVictor Latushkin 		if (!dump_opt['e'] && dump_opt['C']) {
3378e829d913Sck 			dump_cachefile(spa_config_path);
3379fa9e4066Sahrens 			return (0);
3380fa9e4066Sahrens 		}
3381fa9e4066Sahrens 		usage();
3382fa9e4066Sahrens 	}
3383fa9e4066Sahrens 
3384fa9e4066Sahrens 	if (dump_opt['l']) {
3385fa9e4066Sahrens 		dump_label(argv[0]);
3386fa9e4066Sahrens 		return (0);
3387fa9e4066Sahrens 	}
3388fa9e4066Sahrens 
3389c8ee1847SVictor Latushkin 	if (dump_opt['X'] || dump_opt['F'])
3390c8ee1847SVictor Latushkin 		rewind = ZPOOL_DO_REWIND |
3391c8ee1847SVictor Latushkin 		    (dump_opt['X'] ? ZPOOL_EXTREME_REWIND : 0);
3392c8ee1847SVictor Latushkin 
3393c8ee1847SVictor Latushkin 	if (nvlist_alloc(&policy, NV_UNIQUE_NAME_TYPE, 0) != 0 ||
3394c8ee1847SVictor Latushkin 	    nvlist_add_uint64(policy, ZPOOL_REWIND_REQUEST_TXG, max_txg) != 0 ||
3395c8ee1847SVictor Latushkin 	    nvlist_add_uint32(policy, ZPOOL_REWIND_REQUEST, rewind) != 0)
3396c8ee1847SVictor Latushkin 		fatal("internal error: %s", strerror(ENOMEM));
3397c8ee1847SVictor Latushkin 
3398c5904d13Seschrock 	error = 0;
33993ad6c7f9SVictor Latushkin 	target = argv[0];
3400990b4856Slling 
34013ad6c7f9SVictor Latushkin 	if (dump_opt['e']) {
34023ad6c7f9SVictor Latushkin 		nvlist_t *cfg = NULL;
34033ad6c7f9SVictor Latushkin 		char *name = find_zpool(&target, &cfg, nsearch, searchdirs);
3404990b4856Slling 
34053ad6c7f9SVictor Latushkin 		error = ENOENT;
34063ad6c7f9SVictor Latushkin 		if (name) {
340707428bdfSVictor Latushkin 			if (dump_opt['C'] > 1) {
340807428bdfSVictor Latushkin 				(void) printf("\nConfiguration for import:\n");
340907428bdfSVictor Latushkin 				dump_nvlist(cfg, 8);
341007428bdfSVictor Latushkin 			}
3411c8ee1847SVictor Latushkin 			if (nvlist_add_nvlist(cfg,
3412468c413aSTim Haley 			    ZPOOL_REWIND_POLICY, policy) != 0) {
3413468c413aSTim Haley 				fatal("can't open '%s': %s",
3414468c413aSTim Haley 				    target, strerror(ENOMEM));
3415468c413aSTim Haley 			}
34164b964adaSGeorge Wilson 			if ((error = spa_import(name, cfg, NULL,
34174b964adaSGeorge Wilson 			    ZFS_IMPORT_MISSING_LOG)) != 0) {
34184b964adaSGeorge Wilson 				error = spa_import(name, cfg, NULL,
34194b964adaSGeorge Wilson 				    ZFS_IMPORT_VERBATIM);
34204b964adaSGeorge Wilson 			}
3421de6628f0Sck 		}
3422c5904d13Seschrock 	}
3423c5904d13Seschrock 
3424c5904d13Seschrock 	if (error == 0) {
342507428bdfSVictor Latushkin 		if (strpbrk(target, "/@") == NULL || dump_opt['R']) {
342680eb36f2SGeorge Wilson 			error = spa_open_rewind(target, &spa, FTAG, policy,
342780eb36f2SGeorge Wilson 			    NULL);
34288f18d1faSGeorge Wilson 			if (error) {
34298f18d1faSGeorge Wilson 				/*
34308f18d1faSGeorge Wilson 				 * If we're missing the log device then
34318f18d1faSGeorge Wilson 				 * try opening the pool after clearing the
34328f18d1faSGeorge Wilson 				 * log state.
34338f18d1faSGeorge Wilson 				 */
34348f18d1faSGeorge Wilson 				mutex_enter(&spa_namespace_lock);
34353ad6c7f9SVictor Latushkin 				if ((spa = spa_lookup(target)) != NULL &&
34368f18d1faSGeorge Wilson 				    spa->spa_log_state == SPA_LOG_MISSING) {
34378f18d1faSGeorge Wilson 					spa->spa_log_state = SPA_LOG_CLEAR;
34388f18d1faSGeorge Wilson 					error = 0;
34398f18d1faSGeorge Wilson 				}
34408f18d1faSGeorge Wilson 				mutex_exit(&spa_namespace_lock);
34418f18d1faSGeorge Wilson 
344280eb36f2SGeorge Wilson 				if (!error) {
344380eb36f2SGeorge Wilson 					error = spa_open_rewind(target, &spa,
344480eb36f2SGeorge Wilson 					    FTAG, policy, NULL);
344580eb36f2SGeorge Wilson 				}
34468f18d1faSGeorge Wilson 			}
344707428bdfSVictor Latushkin 		} else {
344807428bdfSVictor Latushkin 			error = dmu_objset_own(target, DMU_OST_ANY,
344907428bdfSVictor Latushkin 			    B_TRUE, FTAG, &os);
3450c5904d13Seschrock 		}
3451fa9e4066Sahrens 	}
345280eb36f2SGeorge Wilson 	nvlist_free(policy);
345380eb36f2SGeorge Wilson 
3454fa9e4066Sahrens 	if (error)
34553ad6c7f9SVictor Latushkin 		fatal("can't open '%s': %s", target, strerror(error));
3456fa9e4066Sahrens 
3457fa9e4066Sahrens 	argv++;
345807428bdfSVictor Latushkin 	argc--;
345907428bdfSVictor Latushkin 	if (!dump_opt['R']) {
346007428bdfSVictor Latushkin 		if (argc > 0) {
346107428bdfSVictor Latushkin 			zopt_objects = argc;
346207428bdfSVictor Latushkin 			zopt_object = calloc(zopt_objects, sizeof (uint64_t));
346307428bdfSVictor Latushkin 			for (i = 0; i < zopt_objects; i++) {
346407428bdfSVictor Latushkin 				errno = 0;
346507428bdfSVictor Latushkin 				zopt_object[i] = strtoull(argv[i], NULL, 0);
346607428bdfSVictor Latushkin 				if (zopt_object[i] == 0 && errno != 0)
346787219db7SVictor Latushkin 					fatal("bad number %s: %s",
346807428bdfSVictor Latushkin 					    argv[i], strerror(errno));
346907428bdfSVictor Latushkin 			}
3470fa9e4066Sahrens 		}
3471e690fb27SChristopher Siden 		if (os != NULL) {
3472e690fb27SChristopher Siden 			dump_dir(os);
3473e690fb27SChristopher Siden 		} else if (zopt_objects > 0 && !dump_opt['m']) {
3474e690fb27SChristopher Siden 			dump_dir(spa->spa_meta_objset);
3475e690fb27SChristopher Siden 		} else {
3476e690fb27SChristopher Siden 			dump_zpool(spa);
3477e690fb27SChristopher Siden 		}
3478fa9e4066Sahrens 	} else {
347907428bdfSVictor Latushkin 		flagbits['b'] = ZDB_FLAG_PRINT_BLKPTR;
348007428bdfSVictor Latushkin 		flagbits['c'] = ZDB_FLAG_CHECKSUM;
348107428bdfSVictor Latushkin 		flagbits['d'] = ZDB_FLAG_DECOMPRESS;
348207428bdfSVictor Latushkin 		flagbits['e'] = ZDB_FLAG_BSWAP;
348307428bdfSVictor Latushkin 		flagbits['g'] = ZDB_FLAG_GBH;
348407428bdfSVictor Latushkin 		flagbits['i'] = ZDB_FLAG_INDIRECT;
348507428bdfSVictor Latushkin 		flagbits['p'] = ZDB_FLAG_PHYS;
348607428bdfSVictor Latushkin 		flagbits['r'] = ZDB_FLAG_RAW;
348707428bdfSVictor Latushkin 
348807428bdfSVictor Latushkin 		for (i = 0; i < argc; i++)
348907428bdfSVictor Latushkin 			zdb_read_block(argv[i], spa);
3490fa9e4066Sahrens 	}
3491fa9e4066Sahrens 
349207428bdfSVictor Latushkin 	(os != NULL) ? dmu_objset_disown(os, FTAG) : spa_close(spa, FTAG);
349307428bdfSVictor Latushkin 
3494e0d35c44Smarks 	fuid_table_destroy();
34950a586ceaSMark Shellenbaum 	sa_loaded = B_FALSE;
3496e0d35c44Smarks 
3497de6628f0Sck 	libzfs_fini(g_zfs);
3498fa9e4066Sahrens 	kernel_fini();
3499fa9e4066Sahrens 
3500fa9e4066Sahrens 	return (0);
3501fa9e4066Sahrens }
3502