xref: /illumos-gate/usr/src/cmd/zdb/zdb.c (revision cde58dbc6a23d4d38db7c8866312be83221c765f)
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  */
21fa9e4066Sahrens /*
228f2529deSMark Shellenbaum  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23fa9e4066Sahrens  */
24fa9e4066Sahrens 
25fa9e4066Sahrens #include <stdio.h>
26004388ebScasper #include <stdio_ext.h>
27fa9e4066Sahrens #include <stdlib.h>
2844cd46caSbillm #include <ctype.h>
29fa9e4066Sahrens #include <sys/zfs_context.h>
30fa9e4066Sahrens #include <sys/spa.h>
31fa9e4066Sahrens #include <sys/spa_impl.h>
32fa9e4066Sahrens #include <sys/dmu.h>
33fa9e4066Sahrens #include <sys/zap.h>
34fa9e4066Sahrens #include <sys/fs/zfs.h>
35fa9e4066Sahrens #include <sys/zfs_znode.h>
360a586ceaSMark Shellenbaum #include <sys/zfs_sa.h>
370a586ceaSMark Shellenbaum #include <sys/sa.h>
380a586ceaSMark Shellenbaum #include <sys/sa_impl.h>
39fa9e4066Sahrens #include <sys/vdev.h>
40fa9e4066Sahrens #include <sys/vdev_impl.h>
41fa9e4066Sahrens #include <sys/metaslab_impl.h>
42fa9e4066Sahrens #include <sys/dmu_objset.h>
43fa9e4066Sahrens #include <sys/dsl_dir.h>
44fa9e4066Sahrens #include <sys/dsl_dataset.h>
45fa9e4066Sahrens #include <sys/dsl_pool.h>
46fa9e4066Sahrens #include <sys/dbuf.h>
47fa9e4066Sahrens #include <sys/zil.h>
48fa9e4066Sahrens #include <sys/zil_impl.h>
49fa9e4066Sahrens #include <sys/stat.h>
50fa9e4066Sahrens #include <sys/resource.h>
51fa9e4066Sahrens #include <sys/dmu_traverse.h>
52fa9e4066Sahrens #include <sys/zio_checksum.h>
53fa9e4066Sahrens #include <sys/zio_compress.h>
54e0d35c44Smarks #include <sys/zfs_fuid.h>
5588b7b0f2SMatthew Ahrens #include <sys/arc.h>
56b24ab676SJeff Bonwick #include <sys/ddt.h>
57de6628f0Sck #undef ZFS_MAXNAMELEN
58de6628f0Sck #undef verify
59de6628f0Sck #include <libzfs.h>
60fa9e4066Sahrens 
616de8f417SVictor Latushkin #define	ZDB_COMPRESS_NAME(idx) ((idx) < ZIO_COMPRESS_FUNCTIONS ? \
626de8f417SVictor Latushkin     zio_compress_table[(idx)].ci_name : "UNKNOWN")
636de8f417SVictor Latushkin #define	ZDB_CHECKSUM_NAME(idx) ((idx) < ZIO_CHECKSUM_FUNCTIONS ? \
646de8f417SVictor Latushkin     zio_checksum_table[(idx)].ci_name : "UNKNOWN")
656de8f417SVictor Latushkin #define	ZDB_OT_NAME(idx) ((idx) < DMU_OT_NUMTYPES ? \
666de8f417SVictor Latushkin     dmu_ot[(idx)].ot_name : "UNKNOWN")
676de8f417SVictor Latushkin #define	ZDB_OT_TYPE(idx) ((idx) < DMU_OT_NUMTYPES ? (idx) : DMU_OT_NUMTYPES)
686de8f417SVictor Latushkin 
69feef89cfSVictor Latushkin #ifndef lint
70feef89cfSVictor Latushkin extern int zfs_recover;
71feef89cfSVictor Latushkin #else
72feef89cfSVictor Latushkin int zfs_recover;
73feef89cfSVictor Latushkin #endif
74feef89cfSVictor Latushkin 
75fa9e4066Sahrens const char cmdname[] = "zdb";
76fa9e4066Sahrens uint8_t dump_opt[256];
77fa9e4066Sahrens 
78fa9e4066Sahrens typedef void object_viewer_t(objset_t *, uint64_t, void *data, size_t size);
79fa9e4066Sahrens 
80fa9e4066Sahrens extern void dump_intent_log(zilog_t *);
81fa9e4066Sahrens uint64_t *zopt_object = NULL;
82fa9e4066Sahrens int zopt_objects = 0;
83de6628f0Sck libzfs_handle_t *g_zfs;
84fa9e4066Sahrens 
85fa9e4066Sahrens /*
86fa9e4066Sahrens  * These libumem hooks provide a reasonable set of defaults for the allocator's
87fa9e4066Sahrens  * debugging facilities.
88fa9e4066Sahrens  */
89fa9e4066Sahrens const char *
90fa9e4066Sahrens _umem_debug_init()
91fa9e4066Sahrens {
92fa9e4066Sahrens 	return ("default,verbose"); /* $UMEM_DEBUG setting */
93fa9e4066Sahrens }
94fa9e4066Sahrens 
95fa9e4066Sahrens const char *
96fa9e4066Sahrens _umem_logging_init(void)
97fa9e4066Sahrens {
98fa9e4066Sahrens 	return ("fail,contents"); /* $UMEM_LOGGING setting */
99fa9e4066Sahrens }
100fa9e4066Sahrens 
101fa9e4066Sahrens static void
102fa9e4066Sahrens usage(void)
103fa9e4066Sahrens {
104fa9e4066Sahrens 	(void) fprintf(stderr,
105f0ba89beSJeff Bonwick 	    "Usage: %s [-CumdibcsDvhL] poolname [object...]\n"
1063ad6c7f9SVictor Latushkin 	    "       %s [-div] dataset [object...]\n"
10787219db7SVictor Latushkin 	    "       %s -m [-L] poolname [vdev [metaslab...]]\n"
10807428bdfSVictor Latushkin 	    "       %s -R poolname vdev:offset:size[:flags]\n"
109bbfd46c4SJeff Bonwick 	    "       %s -S poolname\n"
11053b9a4a9SVictor Latushkin 	    "       %s -l [-u] device\n"
11107428bdfSVictor Latushkin 	    "       %s -C\n\n",
112bbfd46c4SJeff Bonwick 	    cmdname, cmdname, cmdname, cmdname, cmdname, cmdname, cmdname);
1133ad6c7f9SVictor Latushkin 
1143ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    Dataset name must include at least one "
1153ad6c7f9SVictor Latushkin 	    "separator character '/' or '@'\n");
1163ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    If dataset name is specified, only that "
1173ad6c7f9SVictor Latushkin 	    "dataset is dumped\n");
1183ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    If object numbers are specified, only "
1193ad6c7f9SVictor Latushkin 	    "those objects are dumped\n\n");
1203ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    Options to control amount of output:\n");
1213ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -u uberblock\n");
1223ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -d dataset(s)\n");
1233ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -i intent logs\n");
12407428bdfSVictor Latushkin 	(void) fprintf(stderr, "        -C config (or cachefile if alone)\n");
1258f18d1faSGeorge Wilson 	(void) fprintf(stderr, "        -h pool history\n");
1263ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -b block statistics\n");
1273ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -m metaslabs\n");
1283ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -c checksum all metadata (twice for "
1296365109dSVictor Latushkin 	    "all data) blocks\n");
1303ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -s report stats on zdb's I/O\n");
131f0ba89beSJeff Bonwick 	(void) fprintf(stderr, "        -D dedup statistics\n");
132b24ab676SJeff Bonwick 	(void) fprintf(stderr, "        -S simulate dedup to measure effect\n");
1333ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -v verbose (applies to all others)\n");
134fa9e4066Sahrens 	(void) fprintf(stderr, "        -l dump label contents\n");
13582a0a985SVictor Latushkin 	(void) fprintf(stderr, "        -L disable leak tracking (do not "
13682a0a985SVictor Latushkin 	    "load spacemaps)\n");
137d41e7643Sek 	(void) fprintf(stderr, "        -R read and display block from a "
1383ad6c7f9SVictor Latushkin 	    "device\n\n");
1393ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "    Below options are intended for use "
1403ad6c7f9SVictor Latushkin 	    "with other options (except -l):\n");
141feef89cfSVictor Latushkin 	(void) fprintf(stderr, "        -A ignore assertions (-A), enable "
142feef89cfSVictor Latushkin 	    "panic recovery (-AA) or both (-AAA)\n");
143c8ee1847SVictor Latushkin 	(void) fprintf(stderr, "        -F attempt automatic rewind within "
144c8ee1847SVictor Latushkin 	    "safe range of transaction groups\n");
1453ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -U <cachefile_path> -- use alternate "
1463ad6c7f9SVictor Latushkin 	    "cachefile\n");
147c8ee1847SVictor Latushkin 	(void) fprintf(stderr, "        -X attempt extreme rewind (does not "
148c8ee1847SVictor Latushkin 	    "work with dataset)\n");
1493ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -e pool is exported/destroyed/"
1503ad6c7f9SVictor Latushkin 	    "has altroot/not in a cachefile\n");
1513ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -p <path> -- use one or more with "
1523ad6c7f9SVictor Latushkin 	    "-e to specify path to vdev dir\n");
1533f9d6ad7SLin Ling 	(void) fprintf(stderr, "	-P print numbers parsable\n");
1543ad6c7f9SVictor Latushkin 	(void) fprintf(stderr, "        -t <txg> -- highest txg to use when "
1552e551927SVictor Latushkin 	    "searching for uberblocks\n");
156fa9e4066Sahrens 	(void) fprintf(stderr, "Specify an option more than once (e.g. -bb) "
157fa9e4066Sahrens 	    "to make only that option verbose\n");
158fa9e4066Sahrens 	(void) fprintf(stderr, "Default is to dump everything non-verbosely\n");
159fa9e4066Sahrens 	exit(1);
160fa9e4066Sahrens }
161fa9e4066Sahrens 
162ccba0801SRich Morris /*
163ccba0801SRich Morris  * Called for usage errors that are discovered after a call to spa_open(),
164ccba0801SRich Morris  * dmu_bonus_hold(), or pool_match().  abort() is called for other errors.
165ccba0801SRich Morris  */
166ccba0801SRich Morris 
167fa9e4066Sahrens static void
168fa9e4066Sahrens fatal(const char *fmt, ...)
169fa9e4066Sahrens {
170fa9e4066Sahrens 	va_list ap;
171fa9e4066Sahrens 
172fa9e4066Sahrens 	va_start(ap, fmt);
173fa9e4066Sahrens 	(void) fprintf(stderr, "%s: ", cmdname);
174fa9e4066Sahrens 	(void) vfprintf(stderr, fmt, ap);
175fa9e4066Sahrens 	va_end(ap);
176fa9e4066Sahrens 	(void) fprintf(stderr, "\n");
177fa9e4066Sahrens 
178ccba0801SRich Morris 	exit(1);
179fa9e4066Sahrens }
180fa9e4066Sahrens 
181fa9e4066Sahrens /* ARGSUSED */
182fa9e4066Sahrens static void
183fa9e4066Sahrens dump_packed_nvlist(objset_t *os, uint64_t object, void *data, size_t size)
184fa9e4066Sahrens {
185fa9e4066Sahrens 	nvlist_t *nv;
186fa9e4066Sahrens 	size_t nvsize = *(uint64_t *)data;
187fa9e4066Sahrens 	char *packed = umem_alloc(nvsize, UMEM_NOFAIL);
188fa9e4066Sahrens 
1897bfdf011SNeil Perrin 	VERIFY(0 == dmu_read(os, object, 0, nvsize, packed, DMU_READ_PREFETCH));
190fa9e4066Sahrens 
191fa9e4066Sahrens 	VERIFY(nvlist_unpack(packed, nvsize, &nv, 0) == 0);
192fa9e4066Sahrens 
193fa9e4066Sahrens 	umem_free(packed, nvsize);
194fa9e4066Sahrens 
195fa9e4066Sahrens 	dump_nvlist(nv, 8);
196fa9e4066Sahrens 
197fa9e4066Sahrens 	nvlist_free(nv);
198fa9e4066Sahrens }
199fa9e4066Sahrens 
2003f9d6ad7SLin Ling static void
2013f9d6ad7SLin Ling zdb_nicenum(uint64_t num, char *buf)
2023f9d6ad7SLin Ling {
2033f9d6ad7SLin Ling 	if (dump_opt['P'])
2043f9d6ad7SLin Ling 		(void) sprintf(buf, "%llu", (longlong_t)num);
2053f9d6ad7SLin Ling 	else
2063f9d6ad7SLin Ling 		nicenum(num, buf);
2073f9d6ad7SLin Ling }
2083f9d6ad7SLin Ling 
209fa9e4066Sahrens const char dump_zap_stars[] = "****************************************";
210fa9e4066Sahrens const int dump_zap_width = sizeof (dump_zap_stars) - 1;
211fa9e4066Sahrens 
212fa9e4066Sahrens static void
213fa9e4066Sahrens dump_zap_histogram(uint64_t histo[ZAP_HISTOGRAM_SIZE])
214fa9e4066Sahrens {
215fa9e4066Sahrens 	int i;
216fa9e4066Sahrens 	int minidx = ZAP_HISTOGRAM_SIZE - 1;
217fa9e4066Sahrens 	int maxidx = 0;
218fa9e4066Sahrens 	uint64_t max = 0;
219fa9e4066Sahrens 
220fa9e4066Sahrens 	for (i = 0; i < ZAP_HISTOGRAM_SIZE; i++) {
221fa9e4066Sahrens 		if (histo[i] > max)
222fa9e4066Sahrens 			max = histo[i];
223fa9e4066Sahrens 		if (histo[i] > 0 && i > maxidx)
224fa9e4066Sahrens 			maxidx = i;
225fa9e4066Sahrens 		if (histo[i] > 0 && i < minidx)
226fa9e4066Sahrens 			minidx = i;
227fa9e4066Sahrens 	}
228fa9e4066Sahrens 
229fa9e4066Sahrens 	if (max < dump_zap_width)
230fa9e4066Sahrens 		max = dump_zap_width;
231fa9e4066Sahrens 
232fa9e4066Sahrens 	for (i = minidx; i <= maxidx; i++)
233fa9e4066Sahrens 		(void) printf("\t\t\t%u: %6llu %s\n", i, (u_longlong_t)histo[i],
234fa9e4066Sahrens 		    &dump_zap_stars[(max - histo[i]) * dump_zap_width / max]);
235fa9e4066Sahrens }
236fa9e4066Sahrens 
237fa9e4066Sahrens static void
238fa9e4066Sahrens dump_zap_stats(objset_t *os, uint64_t object)
239fa9e4066Sahrens {
240fa9e4066Sahrens 	int error;
241fa9e4066Sahrens 	zap_stats_t zs;
242fa9e4066Sahrens 
243fa9e4066Sahrens 	error = zap_get_stats(os, object, &zs);
244fa9e4066Sahrens 	if (error)
245fa9e4066Sahrens 		return;
246fa9e4066Sahrens 
247fa9e4066Sahrens 	if (zs.zs_ptrtbl_len == 0) {
248fa9e4066Sahrens 		ASSERT(zs.zs_num_blocks == 1);
249fa9e4066Sahrens 		(void) printf("\tmicrozap: %llu bytes, %llu entries\n",
250fa9e4066Sahrens 		    (u_longlong_t)zs.zs_blocksize,
251fa9e4066Sahrens 		    (u_longlong_t)zs.zs_num_entries);
252fa9e4066Sahrens 		return;
253fa9e4066Sahrens 	}
254fa9e4066Sahrens 
255fa9e4066Sahrens 	(void) printf("\tFat ZAP stats:\n");
2568248818dSnd 
2578248818dSnd 	(void) printf("\t\tPointer table:\n");
2588248818dSnd 	(void) printf("\t\t\t%llu elements\n",
259fa9e4066Sahrens 	    (u_longlong_t)zs.zs_ptrtbl_len);
2608248818dSnd 	(void) printf("\t\t\tzt_blk: %llu\n",
2618248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_zt_blk);
2628248818dSnd 	(void) printf("\t\t\tzt_numblks: %llu\n",
2638248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_zt_numblks);
2648248818dSnd 	(void) printf("\t\t\tzt_shift: %llu\n",
2658248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_zt_shift);
2668248818dSnd 	(void) printf("\t\t\tzt_blks_copied: %llu\n",
2678248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_blks_copied);
2688248818dSnd 	(void) printf("\t\t\tzt_nextblk: %llu\n",
2698248818dSnd 	    (u_longlong_t)zs.zs_ptrtbl_nextblk);
2708248818dSnd 
271fa9e4066Sahrens 	(void) printf("\t\tZAP entries: %llu\n",
272fa9e4066Sahrens 	    (u_longlong_t)zs.zs_num_entries);
273fa9e4066Sahrens 	(void) printf("\t\tLeaf blocks: %llu\n",
274fa9e4066Sahrens 	    (u_longlong_t)zs.zs_num_leafs);
275fa9e4066Sahrens 	(void) printf("\t\tTotal blocks: %llu\n",
276fa9e4066Sahrens 	    (u_longlong_t)zs.zs_num_blocks);
2778248818dSnd 	(void) printf("\t\tzap_block_type: 0x%llx\n",
2788248818dSnd 	    (u_longlong_t)zs.zs_block_type);
2798248818dSnd 	(void) printf("\t\tzap_magic: 0x%llx\n",
2808248818dSnd 	    (u_longlong_t)zs.zs_magic);
2818248818dSnd 	(void) printf("\t\tzap_salt: 0x%llx\n",
2828248818dSnd 	    (u_longlong_t)zs.zs_salt);
283fa9e4066Sahrens 
284fa9e4066Sahrens 	(void) printf("\t\tLeafs with 2^n pointers:\n");
285fa9e4066Sahrens 	dump_zap_histogram(zs.zs_leafs_with_2n_pointers);
286fa9e4066Sahrens 
287fa9e4066Sahrens 	(void) printf("\t\tBlocks with n*5 entries:\n");
288fa9e4066Sahrens 	dump_zap_histogram(zs.zs_blocks_with_n5_entries);
289fa9e4066Sahrens 
290fa9e4066Sahrens 	(void) printf("\t\tBlocks n/10 full:\n");
291fa9e4066Sahrens 	dump_zap_histogram(zs.zs_blocks_n_tenths_full);
292fa9e4066Sahrens 
293fa9e4066Sahrens 	(void) printf("\t\tEntries with n chunks:\n");
294fa9e4066Sahrens 	dump_zap_histogram(zs.zs_entries_using_n_chunks);
295fa9e4066Sahrens 
296fa9e4066Sahrens 	(void) printf("\t\tBuckets with n entries:\n");
297fa9e4066Sahrens 	dump_zap_histogram(zs.zs_buckets_with_n_entries);
298fa9e4066Sahrens }
299fa9e4066Sahrens 
300fa9e4066Sahrens /*ARGSUSED*/
301fa9e4066Sahrens static void
302fa9e4066Sahrens dump_none(objset_t *os, uint64_t object, void *data, size_t size)
303fa9e4066Sahrens {
304fa9e4066Sahrens }
305fa9e4066Sahrens 
3066de8f417SVictor Latushkin /*ARGSUSED*/
3076de8f417SVictor Latushkin static void
3086de8f417SVictor Latushkin dump_unknown(objset_t *os, uint64_t object, void *data, size_t size)
3096de8f417SVictor Latushkin {
3106de8f417SVictor Latushkin 	(void) printf("\tUNKNOWN OBJECT TYPE\n");
3116de8f417SVictor Latushkin }
3126de8f417SVictor Latushkin 
313fa9e4066Sahrens /*ARGSUSED*/
314fa9e4066Sahrens void
315fa9e4066Sahrens dump_uint8(objset_t *os, uint64_t object, void *data, size_t size)
316fa9e4066Sahrens {
317fa9e4066Sahrens }
318fa9e4066Sahrens 
319fa9e4066Sahrens /*ARGSUSED*/
320fa9e4066Sahrens static void
321fa9e4066Sahrens dump_uint64(objset_t *os, uint64_t object, void *data, size_t size)
322fa9e4066Sahrens {
323fa9e4066Sahrens }
324fa9e4066Sahrens 
325fa9e4066Sahrens /*ARGSUSED*/
326fa9e4066Sahrens static void
327fa9e4066Sahrens dump_zap(objset_t *os, uint64_t object, void *data, size_t size)
328fa9e4066Sahrens {
329fa9e4066Sahrens 	zap_cursor_t zc;
330fa9e4066Sahrens 	zap_attribute_t attr;
331fa9e4066Sahrens 	void *prop;
332fa9e4066Sahrens 	int i;
333fa9e4066Sahrens 
334fa9e4066Sahrens 	dump_zap_stats(os, object);
335fa9e4066Sahrens 	(void) printf("\n");
336fa9e4066Sahrens 
337fa9e4066Sahrens 	for (zap_cursor_init(&zc, os, object);
338fa9e4066Sahrens 	    zap_cursor_retrieve(&zc, &attr) == 0;
339fa9e4066Sahrens 	    zap_cursor_advance(&zc)) {
340fa9e4066Sahrens 		(void) printf("\t\t%s = ", attr.za_name);
341fa9e4066Sahrens 		if (attr.za_num_integers == 0) {
342fa9e4066Sahrens 			(void) printf("\n");
343fa9e4066Sahrens 			continue;
344fa9e4066Sahrens 		}
345fa9e4066Sahrens 		prop = umem_zalloc(attr.za_num_integers *
346fa9e4066Sahrens 		    attr.za_integer_length, UMEM_NOFAIL);
347fa9e4066Sahrens 		(void) zap_lookup(os, object, attr.za_name,
348fa9e4066Sahrens 		    attr.za_integer_length, attr.za_num_integers, prop);
349fa9e4066Sahrens 		if (attr.za_integer_length == 1) {
350fa9e4066Sahrens 			(void) printf("%s", (char *)prop);
351fa9e4066Sahrens 		} else {
352fa9e4066Sahrens 			for (i = 0; i < attr.za_num_integers; i++) {
353fa9e4066Sahrens 				switch (attr.za_integer_length) {
354fa9e4066Sahrens 				case 2:
355fa9e4066Sahrens 					(void) printf("%u ",
356fa9e4066Sahrens 					    ((uint16_t *)prop)[i]);
357fa9e4066Sahrens 					break;
358fa9e4066Sahrens 				case 4:
359fa9e4066Sahrens 					(void) printf("%u ",
360fa9e4066Sahrens 					    ((uint32_t *)prop)[i]);
361fa9e4066Sahrens 					break;
362fa9e4066Sahrens 				case 8:
363fa9e4066Sahrens 					(void) printf("%lld ",
364fa9e4066Sahrens 					    (u_longlong_t)((int64_t *)prop)[i]);
365fa9e4066Sahrens 					break;
366fa9e4066Sahrens 				}
367fa9e4066Sahrens 			}
368fa9e4066Sahrens 		}
369fa9e4066Sahrens 		(void) printf("\n");
370fa9e4066Sahrens 		umem_free(prop, attr.za_num_integers * attr.za_integer_length);
371fa9e4066Sahrens 	}
37287e5029aSahrens 	zap_cursor_fini(&zc);
373fa9e4066Sahrens }
374fa9e4066Sahrens 
375486ae710SMatthew Ahrens /*ARGSUSED*/
376486ae710SMatthew Ahrens static void
377486ae710SMatthew Ahrens dump_ddt_zap(objset_t *os, uint64_t object, void *data, size_t size)
378486ae710SMatthew Ahrens {
379486ae710SMatthew Ahrens 	dump_zap_stats(os, object);
380486ae710SMatthew Ahrens 	/* contents are printed elsewhere, properly decoded */
381486ae710SMatthew Ahrens }
382486ae710SMatthew Ahrens 
3830a586ceaSMark Shellenbaum /*ARGSUSED*/
3840a586ceaSMark Shellenbaum static void
3850a586ceaSMark Shellenbaum dump_sa_attrs(objset_t *os, uint64_t object, void *data, size_t size)
3860a586ceaSMark Shellenbaum {
3870a586ceaSMark Shellenbaum 	zap_cursor_t zc;
3880a586ceaSMark Shellenbaum 	zap_attribute_t attr;
3890a586ceaSMark Shellenbaum 
3900a586ceaSMark Shellenbaum 	dump_zap_stats(os, object);
3910a586ceaSMark Shellenbaum 	(void) printf("\n");
3920a586ceaSMark Shellenbaum 
3930a586ceaSMark Shellenbaum 	for (zap_cursor_init(&zc, os, object);
3940a586ceaSMark Shellenbaum 	    zap_cursor_retrieve(&zc, &attr) == 0;
3950a586ceaSMark Shellenbaum 	    zap_cursor_advance(&zc)) {
3960a586ceaSMark Shellenbaum 		(void) printf("\t\t%s = ", attr.za_name);
3970a586ceaSMark Shellenbaum 		if (attr.za_num_integers == 0) {
3980a586ceaSMark Shellenbaum 			(void) printf("\n");
3990a586ceaSMark Shellenbaum 			continue;
4000a586ceaSMark Shellenbaum 		}
4010a586ceaSMark Shellenbaum 		(void) printf(" %llx : [%d:%d:%d]\n",
4020a586ceaSMark Shellenbaum 		    (u_longlong_t)attr.za_first_integer,
4030a586ceaSMark Shellenbaum 		    (int)ATTR_LENGTH(attr.za_first_integer),
4040a586ceaSMark Shellenbaum 		    (int)ATTR_BSWAP(attr.za_first_integer),
4050a586ceaSMark Shellenbaum 		    (int)ATTR_NUM(attr.za_first_integer));
4060a586ceaSMark Shellenbaum 	}
4070a586ceaSMark Shellenbaum 	zap_cursor_fini(&zc);
4080a586ceaSMark Shellenbaum }
4090a586ceaSMark Shellenbaum 
4100a586ceaSMark Shellenbaum /*ARGSUSED*/
4110a586ceaSMark Shellenbaum static void
4120a586ceaSMark Shellenbaum dump_sa_layouts(objset_t *os, uint64_t object, void *data, size_t size)
4130a586ceaSMark Shellenbaum {
4140a586ceaSMark Shellenbaum 	zap_cursor_t zc;
4150a586ceaSMark Shellenbaum 	zap_attribute_t attr;
4160a586ceaSMark Shellenbaum 	uint16_t *layout_attrs;
4170a586ceaSMark Shellenbaum 	int i;
4180a586ceaSMark Shellenbaum 
4190a586ceaSMark Shellenbaum 	dump_zap_stats(os, object);
4200a586ceaSMark Shellenbaum 	(void) printf("\n");
4210a586ceaSMark Shellenbaum 
4220a586ceaSMark Shellenbaum 	for (zap_cursor_init(&zc, os, object);
4230a586ceaSMark Shellenbaum 	    zap_cursor_retrieve(&zc, &attr) == 0;
4240a586ceaSMark Shellenbaum 	    zap_cursor_advance(&zc)) {
4250a586ceaSMark Shellenbaum 		(void) printf("\t\t%s = [", attr.za_name);
4260a586ceaSMark Shellenbaum 		if (attr.za_num_integers == 0) {
4270a586ceaSMark Shellenbaum 			(void) printf("\n");
4280a586ceaSMark Shellenbaum 			continue;
4290a586ceaSMark Shellenbaum 		}
4300a586ceaSMark Shellenbaum 
4310a586ceaSMark Shellenbaum 		VERIFY(attr.za_integer_length == 2);
4320a586ceaSMark Shellenbaum 		layout_attrs = umem_zalloc(attr.za_num_integers *
4330a586ceaSMark Shellenbaum 		    attr.za_integer_length, UMEM_NOFAIL);
4340a586ceaSMark Shellenbaum 
4350a586ceaSMark Shellenbaum 		VERIFY(zap_lookup(os, object, attr.za_name,
4360a586ceaSMark Shellenbaum 		    attr.za_integer_length,
4370a586ceaSMark Shellenbaum 		    attr.za_num_integers, layout_attrs) == 0);
4380a586ceaSMark Shellenbaum 
4390a586ceaSMark Shellenbaum 		for (i = 0; i != attr.za_num_integers; i++)
4400a586ceaSMark Shellenbaum 			(void) printf(" %d ", (int)layout_attrs[i]);
4410a586ceaSMark Shellenbaum 		(void) printf("]\n");
4420a586ceaSMark Shellenbaum 		umem_free(layout_attrs,
4430a586ceaSMark Shellenbaum 		    attr.za_num_integers * attr.za_integer_length);
4440a586ceaSMark Shellenbaum 	}
4450a586ceaSMark Shellenbaum 	zap_cursor_fini(&zc);
4460a586ceaSMark Shellenbaum }
4470a586ceaSMark Shellenbaum 
448e7437265Sahrens /*ARGSUSED*/
449e7437265Sahrens static void
450e7437265Sahrens dump_zpldir(objset_t *os, uint64_t object, void *data, size_t size)
451e7437265Sahrens {
452e7437265Sahrens 	zap_cursor_t zc;
453e7437265Sahrens 	zap_attribute_t attr;
454e7437265Sahrens 	const char *typenames[] = {
455e7437265Sahrens 		/* 0 */ "not specified",
456e7437265Sahrens 		/* 1 */ "FIFO",
457e7437265Sahrens 		/* 2 */ "Character Device",
458e7437265Sahrens 		/* 3 */ "3 (invalid)",
459e7437265Sahrens 		/* 4 */ "Directory",
460e7437265Sahrens 		/* 5 */ "5 (invalid)",
461e7437265Sahrens 		/* 6 */ "Block Device",
462e7437265Sahrens 		/* 7 */ "7 (invalid)",
463e7437265Sahrens 		/* 8 */ "Regular File",
464e7437265Sahrens 		/* 9 */ "9 (invalid)",
465e7437265Sahrens 		/* 10 */ "Symbolic Link",
466e7437265Sahrens 		/* 11 */ "11 (invalid)",
467e7437265Sahrens 		/* 12 */ "Socket",
468e7437265Sahrens 		/* 13 */ "Door",
469e7437265Sahrens 		/* 14 */ "Event Port",
470e7437265Sahrens 		/* 15 */ "15 (invalid)",
471e7437265Sahrens 	};
472e7437265Sahrens 
473e7437265Sahrens 	dump_zap_stats(os, object);
474e7437265Sahrens 	(void) printf("\n");
475e7437265Sahrens 
476e7437265Sahrens 	for (zap_cursor_init(&zc, os, object);
477e7437265Sahrens 	    zap_cursor_retrieve(&zc, &attr) == 0;
478e7437265Sahrens 	    zap_cursor_advance(&zc)) {
479e7437265Sahrens 		(void) printf("\t\t%s = %lld (type: %s)\n",
480e7437265Sahrens 		    attr.za_name, ZFS_DIRENT_OBJ(attr.za_first_integer),
481e7437265Sahrens 		    typenames[ZFS_DIRENT_TYPE(attr.za_first_integer)]);
482e7437265Sahrens 	}
483e7437265Sahrens 	zap_cursor_fini(&zc);
484e7437265Sahrens }
485e7437265Sahrens 
486fa9e4066Sahrens static void
487fa9e4066Sahrens dump_spacemap(objset_t *os, space_map_obj_t *smo, space_map_t *sm)
488fa9e4066Sahrens {
489fa9e4066Sahrens 	uint64_t alloc, offset, entry;
490ecc2d604Sbonwick 	uint8_t mapshift = sm->sm_shift;
491fa9e4066Sahrens 	uint64_t mapstart = sm->sm_start;
4928053a263Sck 	char *ddata[] = { "ALLOC", "FREE", "CONDENSE", "INVALID",
4938053a263Sck 			    "INVALID", "INVALID", "INVALID", "INVALID" };
494fa9e4066Sahrens 
495fa9e4066Sahrens 	if (smo->smo_object == 0)
496fa9e4066Sahrens 		return;
497fa9e4066Sahrens 
498fa9e4066Sahrens 	/*
499fa9e4066Sahrens 	 * Print out the freelist entries in both encoded and decoded form.
500fa9e4066Sahrens 	 */
501fa9e4066Sahrens 	alloc = 0;
502fa9e4066Sahrens 	for (offset = 0; offset < smo->smo_objsize; offset += sizeof (entry)) {
5033f9d6ad7SLin Ling 		VERIFY3U(0, ==, dmu_read(os, smo->smo_object, offset,
5047bfdf011SNeil Perrin 		    sizeof (entry), &entry, DMU_READ_PREFETCH));
505fa9e4066Sahrens 		if (SM_DEBUG_DECODE(entry)) {
50687219db7SVictor Latushkin 			(void) printf("\t    [%6llu] %s: txg %llu, pass %llu\n",
507fa9e4066Sahrens 			    (u_longlong_t)(offset / sizeof (entry)),
508fa9e4066Sahrens 			    ddata[SM_DEBUG_ACTION_DECODE(entry)],
5095ad82045Snd 			    (u_longlong_t)SM_DEBUG_TXG_DECODE(entry),
5105ad82045Snd 			    (u_longlong_t)SM_DEBUG_SYNCPASS_DECODE(entry));
511fa9e4066Sahrens 		} else {
51287219db7SVictor Latushkin 			(void) printf("\t    [%6llu]    %c  range:"
51387219db7SVictor Latushkin 			    " %010llx-%010llx  size: %06llx\n",
514fa9e4066Sahrens 			    (u_longlong_t)(offset / sizeof (entry)),
515fa9e4066Sahrens 			    SM_TYPE_DECODE(entry) == SM_ALLOC ? 'A' : 'F',
5165ad82045Snd 			    (u_longlong_t)((SM_OFFSET_DECODE(entry) <<
5175ad82045Snd 			    mapshift) + mapstart),
5185ad82045Snd 			    (u_longlong_t)((SM_OFFSET_DECODE(entry) <<
5195ad82045Snd 			    mapshift) + mapstart + (SM_RUN_DECODE(entry) <<
5205ad82045Snd 			    mapshift)),
5215ad82045Snd 			    (u_longlong_t)(SM_RUN_DECODE(entry) << mapshift));
522fa9e4066Sahrens 			if (SM_TYPE_DECODE(entry) == SM_ALLOC)
523fa9e4066Sahrens 				alloc += SM_RUN_DECODE(entry) << mapshift;
524fa9e4066Sahrens 			else
525fa9e4066Sahrens 				alloc -= SM_RUN_DECODE(entry) << mapshift;
526fa9e4066Sahrens 		}
527fa9e4066Sahrens 	}
528fa9e4066Sahrens 	if (alloc != smo->smo_alloc) {
529fa9e4066Sahrens 		(void) printf("space_map_object alloc (%llu) INCONSISTENT "
530fa9e4066Sahrens 		    "with space map summary (%llu)\n",
531fa9e4066Sahrens 		    (u_longlong_t)smo->smo_alloc, (u_longlong_t)alloc);
532fa9e4066Sahrens 	}
533fa9e4066Sahrens }
534fa9e4066Sahrens 
535d6e555bdSGeorge Wilson static void
536d6e555bdSGeorge Wilson dump_metaslab_stats(metaslab_t *msp)
537d6e555bdSGeorge Wilson {
5383f9d6ad7SLin Ling 	char maxbuf[32];
539d6e555bdSGeorge Wilson 	space_map_t *sm = &msp->ms_map;
540d6e555bdSGeorge Wilson 	avl_tree_t *t = sm->sm_pp_root;
541d6e555bdSGeorge Wilson 	int free_pct = sm->sm_space * 100 / sm->sm_size;
542d6e555bdSGeorge Wilson 
5433f9d6ad7SLin Ling 	zdb_nicenum(space_map_maxsize(sm), maxbuf);
544d6e555bdSGeorge Wilson 
54587219db7SVictor Latushkin 	(void) printf("\t %25s %10lu   %7s  %6s   %4s %4d%%\n",
546d6e555bdSGeorge Wilson 	    "segments", avl_numnodes(t), "maxsize", maxbuf,
547d6e555bdSGeorge Wilson 	    "freepct", free_pct);
548d6e555bdSGeorge Wilson }
549d6e555bdSGeorge Wilson 
550fa9e4066Sahrens static void
551fa9e4066Sahrens dump_metaslab(metaslab_t *msp)
552fa9e4066Sahrens {
553fa9e4066Sahrens 	vdev_t *vd = msp->ms_group->mg_vd;
554fa9e4066Sahrens 	spa_t *spa = vd->vdev_spa;
55580eb36f2SGeorge Wilson 	space_map_t *sm = &msp->ms_map;
55680eb36f2SGeorge Wilson 	space_map_obj_t *smo = &msp->ms_smo;
5573f9d6ad7SLin Ling 	char freebuf[32];
558fa9e4066Sahrens 
5593f9d6ad7SLin Ling 	zdb_nicenum(sm->sm_size - smo->smo_alloc, freebuf);
560fa9e4066Sahrens 
561fa9e4066Sahrens 	(void) printf(
56287219db7SVictor Latushkin 	    "\tmetaslab %6llu   offset %12llx   spacemap %6llu   free    %5s\n",
56380eb36f2SGeorge Wilson 	    (u_longlong_t)(sm->sm_start / sm->sm_size),
56480eb36f2SGeorge Wilson 	    (u_longlong_t)sm->sm_start, (u_longlong_t)smo->smo_object, freebuf);
565fa9e4066Sahrens 
56687219db7SVictor Latushkin 	if (dump_opt['m'] > 1 && !dump_opt['L']) {
567d6e555bdSGeorge Wilson 		mutex_enter(&msp->ms_lock);
56880eb36f2SGeorge Wilson 		space_map_load_wait(sm);
569bc3975b5SVictor Latushkin 		if (!sm->sm_loaded)
57080eb36f2SGeorge Wilson 			VERIFY(space_map_load(sm, zfs_metaslab_ops,
57180eb36f2SGeorge Wilson 			    SM_FREE, smo, spa->spa_meta_objset) == 0);
572bc3975b5SVictor Latushkin 		dump_metaslab_stats(msp);
573bc3975b5SVictor Latushkin 		space_map_unload(sm);
574d6e555bdSGeorge Wilson 		mutex_exit(&msp->ms_lock);
575d6e555bdSGeorge Wilson 	}
576d6e555bdSGeorge Wilson 
577d6e555bdSGeorge Wilson 	if (dump_opt['d'] > 5 || dump_opt['m'] > 2) {
57880eb36f2SGeorge Wilson 		ASSERT(sm->sm_size == (1ULL << vd->vdev_ms_shift));
579d6e555bdSGeorge Wilson 
580d6e555bdSGeorge Wilson 		mutex_enter(&msp->ms_lock);
58180eb36f2SGeorge Wilson 		dump_spacemap(spa->spa_meta_objset, smo, sm);
582d6e555bdSGeorge Wilson 		mutex_exit(&msp->ms_lock);
583d6e555bdSGeorge Wilson 	}
58487219db7SVictor Latushkin }
585fa9e4066Sahrens 
58687219db7SVictor Latushkin static void
58787219db7SVictor Latushkin print_vdev_metaslab_header(vdev_t *vd)
58887219db7SVictor Latushkin {
58987219db7SVictor Latushkin 	(void) printf("\tvdev %10llu\n\t%-10s%5llu   %-19s   %-15s   %-10s\n",
59087219db7SVictor Latushkin 	    (u_longlong_t)vd->vdev_id,
59187219db7SVictor Latushkin 	    "metaslabs", (u_longlong_t)vd->vdev_ms_count,
59287219db7SVictor Latushkin 	    "offset", "spacemap", "free");
59387219db7SVictor Latushkin 	(void) printf("\t%15s   %19s   %15s   %10s\n",
59487219db7SVictor Latushkin 	    "---------------", "-------------------",
59587219db7SVictor Latushkin 	    "---------------", "-------------");
596fa9e4066Sahrens }
597fa9e4066Sahrens 
598fa9e4066Sahrens static void
599fa9e4066Sahrens dump_metaslabs(spa_t *spa)
600fa9e4066Sahrens {
60187219db7SVictor Latushkin 	vdev_t *vd, *rvd = spa->spa_root_vdev;
60287219db7SVictor Latushkin 	uint64_t m, c = 0, children = rvd->vdev_children;
603fa9e4066Sahrens 
604fa9e4066Sahrens 	(void) printf("\nMetaslabs:\n");
605fa9e4066Sahrens 
60687219db7SVictor Latushkin 	if (!dump_opt['d'] && zopt_objects > 0) {
60787219db7SVictor Latushkin 		c = zopt_object[0];
60887219db7SVictor Latushkin 
60987219db7SVictor Latushkin 		if (c >= children)
61087219db7SVictor Latushkin 			(void) fatal("bad vdev id: %llu", (u_longlong_t)c);
611fa9e4066Sahrens 
61287219db7SVictor Latushkin 		if (zopt_objects > 1) {
61387219db7SVictor Latushkin 			vd = rvd->vdev_child[c];
61487219db7SVictor Latushkin 			print_vdev_metaslab_header(vd);
61587219db7SVictor Latushkin 
61687219db7SVictor Latushkin 			for (m = 1; m < zopt_objects; m++) {
61787219db7SVictor Latushkin 				if (zopt_object[m] < vd->vdev_ms_count)
61887219db7SVictor Latushkin 					dump_metaslab(
61987219db7SVictor Latushkin 					    vd->vdev_ms[zopt_object[m]]);
62087219db7SVictor Latushkin 				else
62187219db7SVictor Latushkin 					(void) fprintf(stderr, "bad metaslab "
62287219db7SVictor Latushkin 					    "number %llu\n",
62387219db7SVictor Latushkin 					    (u_longlong_t)zopt_object[m]);
62487219db7SVictor Latushkin 			}
62587219db7SVictor Latushkin 			(void) printf("\n");
62687219db7SVictor Latushkin 			return;
62787219db7SVictor Latushkin 		}
62887219db7SVictor Latushkin 		children = c + 1;
62987219db7SVictor Latushkin 	}
63087219db7SVictor Latushkin 	for (; c < children; c++) {
63187219db7SVictor Latushkin 		vd = rvd->vdev_child[c];
63287219db7SVictor Latushkin 		print_vdev_metaslab_header(vd);
633fa9e4066Sahrens 
634fa9e4066Sahrens 		for (m = 0; m < vd->vdev_ms_count; m++)
635fa9e4066Sahrens 			dump_metaslab(vd->vdev_ms[m]);
636fa9e4066Sahrens 		(void) printf("\n");
637fa9e4066Sahrens 	}
638fa9e4066Sahrens }
639fa9e4066Sahrens 
640b24ab676SJeff Bonwick static void
641b24ab676SJeff Bonwick dump_dde(const ddt_t *ddt, const ddt_entry_t *dde, uint64_t index)
642b24ab676SJeff Bonwick {
643b24ab676SJeff Bonwick 	const ddt_phys_t *ddp = dde->dde_phys;
644b24ab676SJeff Bonwick 	const ddt_key_t *ddk = &dde->dde_key;
645b24ab676SJeff Bonwick 	char *types[4] = { "ditto", "single", "double", "triple" };
646b24ab676SJeff Bonwick 	char blkbuf[BP_SPRINTF_LEN];
647b24ab676SJeff Bonwick 	blkptr_t blk;
648b24ab676SJeff Bonwick 
649b24ab676SJeff Bonwick 	for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
650b24ab676SJeff Bonwick 		if (ddp->ddp_phys_birth == 0)
651b24ab676SJeff Bonwick 			continue;
652bbfd46c4SJeff Bonwick 		ddt_bp_create(ddt->ddt_checksum, ddk, ddp, &blk);
653b24ab676SJeff Bonwick 		sprintf_blkptr(blkbuf, &blk);
654b24ab676SJeff Bonwick 		(void) printf("index %llx refcnt %llu %s %s\n",
655b24ab676SJeff Bonwick 		    (u_longlong_t)index, (u_longlong_t)ddp->ddp_refcnt,
656b24ab676SJeff Bonwick 		    types[p], blkbuf);
657b24ab676SJeff Bonwick 	}
658b24ab676SJeff Bonwick }
659b24ab676SJeff Bonwick 
660b24ab676SJeff Bonwick static void
661b24ab676SJeff Bonwick dump_dedup_ratio(const ddt_stat_t *dds)
662b24ab676SJeff Bonwick {
663b24ab676SJeff Bonwick 	double rL, rP, rD, D, dedup, compress, copies;
664b24ab676SJeff Bonwick 
665b24ab676SJeff Bonwick 	if (dds->dds_blocks == 0)
666b24ab676SJeff Bonwick 		return;
667b24ab676SJeff Bonwick 
668b24ab676SJeff Bonwick 	rL = (double)dds->dds_ref_lsize;
669b24ab676SJeff Bonwick 	rP = (double)dds->dds_ref_psize;
670b24ab676SJeff Bonwick 	rD = (double)dds->dds_ref_dsize;
671b24ab676SJeff Bonwick 	D = (double)dds->dds_dsize;
672b24ab676SJeff Bonwick 
673b24ab676SJeff Bonwick 	dedup = rD / D;
674b24ab676SJeff Bonwick 	compress = rL / rP;
675b24ab676SJeff Bonwick 	copies = rD / rP;
676b24ab676SJeff Bonwick 
677b24ab676SJeff Bonwick 	(void) printf("dedup = %.2f, compress = %.2f, copies = %.2f, "
678b24ab676SJeff Bonwick 	    "dedup * compress / copies = %.2f\n\n",
679b24ab676SJeff Bonwick 	    dedup, compress, copies, dedup * compress / copies);
680b24ab676SJeff Bonwick }
681b24ab676SJeff Bonwick 
682b24ab676SJeff Bonwick static void
683b24ab676SJeff Bonwick dump_ddt(ddt_t *ddt, enum ddt_type type, enum ddt_class class)
684b24ab676SJeff Bonwick {
685b24ab676SJeff Bonwick 	char name[DDT_NAMELEN];
686b24ab676SJeff Bonwick 	ddt_entry_t dde;
687b24ab676SJeff Bonwick 	uint64_t walk = 0;
688b24ab676SJeff Bonwick 	dmu_object_info_t doi;
689b24ab676SJeff Bonwick 	uint64_t count, dspace, mspace;
690b24ab676SJeff Bonwick 	int error;
691b24ab676SJeff Bonwick 
692b24ab676SJeff Bonwick 	error = ddt_object_info(ddt, type, class, &doi);
693b24ab676SJeff Bonwick 
694b24ab676SJeff Bonwick 	if (error == ENOENT)
695b24ab676SJeff Bonwick 		return;
696b24ab676SJeff Bonwick 	ASSERT(error == 0);
697b24ab676SJeff Bonwick 
698b24ab676SJeff Bonwick 	count = ddt_object_count(ddt, type, class);
699b24ab676SJeff Bonwick 	dspace = doi.doi_physical_blocks_512 << 9;
700b24ab676SJeff Bonwick 	mspace = doi.doi_fill_count * doi.doi_data_block_size;
701b24ab676SJeff Bonwick 
702b24ab676SJeff Bonwick 	ASSERT(count != 0);	/* we should have destroyed it */
703b24ab676SJeff Bonwick 
704b24ab676SJeff Bonwick 	ddt_object_name(ddt, type, class, name);
705b24ab676SJeff Bonwick 
706b24ab676SJeff Bonwick 	(void) printf("%s: %llu entries, size %llu on disk, %llu in core\n",
707b24ab676SJeff Bonwick 	    name,
708b24ab676SJeff Bonwick 	    (u_longlong_t)count,
709b24ab676SJeff Bonwick 	    (u_longlong_t)(dspace / count),
710b24ab676SJeff Bonwick 	    (u_longlong_t)(mspace / count));
711b24ab676SJeff Bonwick 
712b24ab676SJeff Bonwick 	if (dump_opt['D'] < 3)
713b24ab676SJeff Bonwick 		return;
714b24ab676SJeff Bonwick 
7159eb19f4dSGeorge Wilson 	zpool_dump_ddt(NULL, &ddt->ddt_histogram[type][class]);
716b24ab676SJeff Bonwick 
717b24ab676SJeff Bonwick 	if (dump_opt['D'] < 4)
718b24ab676SJeff Bonwick 		return;
719b24ab676SJeff Bonwick 
720b24ab676SJeff Bonwick 	if (dump_opt['D'] < 5 && class == DDT_CLASS_UNIQUE)
721b24ab676SJeff Bonwick 		return;
722b24ab676SJeff Bonwick 
723b24ab676SJeff Bonwick 	(void) printf("%s contents:\n\n", name);
724b24ab676SJeff Bonwick 
725bbfd46c4SJeff Bonwick 	while ((error = ddt_object_walk(ddt, type, class, &walk, &dde)) == 0)
726b24ab676SJeff Bonwick 		dump_dde(ddt, &dde, walk);
727b24ab676SJeff Bonwick 
728b24ab676SJeff Bonwick 	ASSERT(error == ENOENT);
729b24ab676SJeff Bonwick 
730b24ab676SJeff Bonwick 	(void) printf("\n");
731b24ab676SJeff Bonwick }
732b24ab676SJeff Bonwick 
733b24ab676SJeff Bonwick static void
734b24ab676SJeff Bonwick dump_all_ddts(spa_t *spa)
735b24ab676SJeff Bonwick {
736b24ab676SJeff Bonwick 	ddt_histogram_t ddh_total = { 0 };
737b24ab676SJeff Bonwick 	ddt_stat_t dds_total = { 0 };
738b24ab676SJeff Bonwick 
739b24ab676SJeff Bonwick 	for (enum zio_checksum c = 0; c < ZIO_CHECKSUM_FUNCTIONS; c++) {
740b24ab676SJeff Bonwick 		ddt_t *ddt = spa->spa_ddt[c];
741b24ab676SJeff Bonwick 		for (enum ddt_type type = 0; type < DDT_TYPES; type++) {
742b24ab676SJeff Bonwick 			for (enum ddt_class class = 0; class < DDT_CLASSES;
743b24ab676SJeff Bonwick 			    class++) {
744b24ab676SJeff Bonwick 				dump_ddt(ddt, type, class);
745b24ab676SJeff Bonwick 			}
746b24ab676SJeff Bonwick 		}
747b24ab676SJeff Bonwick 	}
748b24ab676SJeff Bonwick 
7499eb19f4dSGeorge Wilson 	ddt_get_dedup_stats(spa, &dds_total);
750b24ab676SJeff Bonwick 
751b24ab676SJeff Bonwick 	if (dds_total.dds_blocks == 0) {
752b24ab676SJeff Bonwick 		(void) printf("All DDTs are empty\n");
753b24ab676SJeff Bonwick 		return;
754b24ab676SJeff Bonwick 	}
755b24ab676SJeff Bonwick 
756b24ab676SJeff Bonwick 	(void) printf("\n");
757b24ab676SJeff Bonwick 
758b24ab676SJeff Bonwick 	if (dump_opt['D'] > 1) {
759b24ab676SJeff Bonwick 		(void) printf("DDT histogram (aggregated over all DDTs):\n");
7609eb19f4dSGeorge Wilson 		ddt_get_dedup_histogram(spa, &ddh_total);
7619eb19f4dSGeorge Wilson 		zpool_dump_ddt(&dds_total, &ddh_total);
762b24ab676SJeff Bonwick 	}
763b24ab676SJeff Bonwick 
764b24ab676SJeff Bonwick 	dump_dedup_ratio(&dds_total);
765b24ab676SJeff Bonwick }
766b24ab676SJeff Bonwick 
7678ad4d6ddSJeff Bonwick static void
7688ad4d6ddSJeff Bonwick dump_dtl_seg(space_map_t *sm, uint64_t start, uint64_t size)
7698ad4d6ddSJeff Bonwick {
7708ad4d6ddSJeff Bonwick 	char *prefix = (void *)sm;
7718ad4d6ddSJeff Bonwick 
7728ad4d6ddSJeff Bonwick 	(void) printf("%s [%llu,%llu) length %llu\n",
7738ad4d6ddSJeff Bonwick 	    prefix,
7748ad4d6ddSJeff Bonwick 	    (u_longlong_t)start,
7758ad4d6ddSJeff Bonwick 	    (u_longlong_t)(start + size),
7768ad4d6ddSJeff Bonwick 	    (u_longlong_t)(size));
7778ad4d6ddSJeff Bonwick }
7788ad4d6ddSJeff Bonwick 
779fa9e4066Sahrens static void
780fa9e4066Sahrens dump_dtl(vdev_t *vd, int indent)
781fa9e4066Sahrens {
7828ad4d6ddSJeff Bonwick 	spa_t *spa = vd->vdev_spa;
7838ad4d6ddSJeff Bonwick 	boolean_t required;
7848ad4d6ddSJeff Bonwick 	char *name[DTL_TYPES] = { "missing", "partial", "scrub", "outage" };
7858ad4d6ddSJeff Bonwick 	char prefix[256];
7868ad4d6ddSJeff Bonwick 
7878f18d1faSGeorge Wilson 	spa_vdev_state_enter(spa, SCL_NONE);
7888ad4d6ddSJeff Bonwick 	required = vdev_dtl_required(vd);
7898ad4d6ddSJeff Bonwick 	(void) spa_vdev_state_exit(spa, NULL, 0);
790fa9e4066Sahrens 
791fa9e4066Sahrens 	if (indent == 0)
792fa9e4066Sahrens 		(void) printf("\nDirty time logs:\n\n");
793fa9e4066Sahrens 
7948ad4d6ddSJeff Bonwick 	(void) printf("\t%*s%s [%s]\n", indent, "",
795e14bb325SJeff Bonwick 	    vd->vdev_path ? vd->vdev_path :
7968ad4d6ddSJeff Bonwick 	    vd->vdev_parent ? vd->vdev_ops->vdev_op_type : spa_name(spa),
7978ad4d6ddSJeff Bonwick 	    required ? "DTL-required" : "DTL-expendable");
798fa9e4066Sahrens 
7998ad4d6ddSJeff Bonwick 	for (int t = 0; t < DTL_TYPES; t++) {
8008ad4d6ddSJeff Bonwick 		space_map_t *sm = &vd->vdev_dtl[t];
8018ad4d6ddSJeff Bonwick 		if (sm->sm_space == 0)
8028ad4d6ddSJeff Bonwick 			continue;
8038ad4d6ddSJeff Bonwick 		(void) snprintf(prefix, sizeof (prefix), "\t%*s%s",
8048ad4d6ddSJeff Bonwick 		    indent + 2, "", name[t]);
8058ad4d6ddSJeff Bonwick 		mutex_enter(sm->sm_lock);
8068ad4d6ddSJeff Bonwick 		space_map_walk(sm, dump_dtl_seg, (void *)prefix);
8078ad4d6ddSJeff Bonwick 		mutex_exit(sm->sm_lock);
8088ad4d6ddSJeff Bonwick 		if (dump_opt['d'] > 5 && vd->vdev_children == 0)
8098ad4d6ddSJeff Bonwick 			dump_spacemap(spa->spa_meta_objset,
8108ad4d6ddSJeff Bonwick 			    &vd->vdev_dtl_smo, sm);
811fa9e4066Sahrens 	}
812fa9e4066Sahrens 
8138ad4d6ddSJeff Bonwick 	for (int c = 0; c < vd->vdev_children; c++)
814fa9e4066Sahrens 		dump_dtl(vd->vdev_child[c], indent + 4);
815fa9e4066Sahrens }
816fa9e4066Sahrens 
8178f18d1faSGeorge Wilson static void
8188f18d1faSGeorge Wilson dump_history(spa_t *spa)
8198f18d1faSGeorge Wilson {
8208f18d1faSGeorge Wilson 	nvlist_t **events = NULL;
8218f18d1faSGeorge Wilson 	char buf[SPA_MAXBLOCKSIZE];
822e4161df6SVictor Latushkin 	uint64_t resid, len, off = 0;
8238f18d1faSGeorge Wilson 	uint_t num = 0;
8248f18d1faSGeorge Wilson 	int error;
8258f18d1faSGeorge Wilson 	time_t tsec;
8268f18d1faSGeorge Wilson 	struct tm t;
8278f18d1faSGeorge Wilson 	char tbuf[30];
8288f18d1faSGeorge Wilson 	char internalstr[MAXPATHLEN];
8298f18d1faSGeorge Wilson 
8308f18d1faSGeorge Wilson 	do {
831e4161df6SVictor Latushkin 		len = sizeof (buf);
832e4161df6SVictor Latushkin 
8338f18d1faSGeorge Wilson 		if ((error = spa_history_get(spa, &off, &len, buf)) != 0) {
8348f18d1faSGeorge Wilson 			(void) fprintf(stderr, "Unable to read history: "
8358f18d1faSGeorge Wilson 			    "error %d\n", error);
8368f18d1faSGeorge Wilson 			return;
8378f18d1faSGeorge Wilson 		}
8388f18d1faSGeorge Wilson 
8398f18d1faSGeorge Wilson 		if (zpool_history_unpack(buf, len, &resid, &events, &num) != 0)
8408f18d1faSGeorge Wilson 			break;
8418f18d1faSGeorge Wilson 
8428f18d1faSGeorge Wilson 		off -= resid;
8438f18d1faSGeorge Wilson 	} while (len != 0);
8448f18d1faSGeorge Wilson 
8458f18d1faSGeorge Wilson 	(void) printf("\nHistory:\n");
8468f18d1faSGeorge Wilson 	for (int i = 0; i < num; i++) {
8478f18d1faSGeorge Wilson 		uint64_t time, txg, ievent;
8488f18d1faSGeorge Wilson 		char *cmd, *intstr;
8498f18d1faSGeorge Wilson 
8508f18d1faSGeorge Wilson 		if (nvlist_lookup_uint64(events[i], ZPOOL_HIST_TIME,
8518f18d1faSGeorge Wilson 		    &time) != 0)
8528f18d1faSGeorge Wilson 			continue;
8538f18d1faSGeorge Wilson 		if (nvlist_lookup_string(events[i], ZPOOL_HIST_CMD,
8548f18d1faSGeorge Wilson 		    &cmd) != 0) {
8558f18d1faSGeorge Wilson 			if (nvlist_lookup_uint64(events[i],
8568f18d1faSGeorge Wilson 			    ZPOOL_HIST_INT_EVENT, &ievent) != 0)
8578f18d1faSGeorge Wilson 				continue;
8588f18d1faSGeorge Wilson 			verify(nvlist_lookup_uint64(events[i],
8598f18d1faSGeorge Wilson 			    ZPOOL_HIST_TXG, &txg) == 0);
8608f18d1faSGeorge Wilson 			verify(nvlist_lookup_string(events[i],
8618f18d1faSGeorge Wilson 			    ZPOOL_HIST_INT_STR, &intstr) == 0);
8628f18d1faSGeorge Wilson 			if (ievent >= LOG_END)
8638f18d1faSGeorge Wilson 				continue;
8648f18d1faSGeorge Wilson 
8658f18d1faSGeorge Wilson 			(void) snprintf(internalstr,
8668f18d1faSGeorge Wilson 			    sizeof (internalstr),
8678f18d1faSGeorge Wilson 			    "[internal %s txg:%lld] %s",
8683f9d6ad7SLin Ling 			    zfs_history_event_names[ievent], txg,
8698f18d1faSGeorge Wilson 			    intstr);
8708f18d1faSGeorge Wilson 			cmd = internalstr;
8718f18d1faSGeorge Wilson 		}
8728f18d1faSGeorge Wilson 		tsec = time;
8738f18d1faSGeorge Wilson 		(void) localtime_r(&tsec, &t);
8748f18d1faSGeorge Wilson 		(void) strftime(tbuf, sizeof (tbuf), "%F.%T", &t);
8758f18d1faSGeorge Wilson 		(void) printf("%s %s\n", tbuf, cmd);
8768f18d1faSGeorge Wilson 	}
8778f18d1faSGeorge Wilson }
8788f18d1faSGeorge Wilson 
879fa9e4066Sahrens /*ARGSUSED*/
880fa9e4066Sahrens static void
881fa9e4066Sahrens dump_dnode(objset_t *os, uint64_t object, void *data, size_t size)
882fa9e4066Sahrens {
883fa9e4066Sahrens }
884fa9e4066Sahrens 
885fa9e4066Sahrens static uint64_t
886b24ab676SJeff Bonwick blkid2offset(const dnode_phys_t *dnp, const blkptr_t *bp, const zbookmark_t *zb)
887fa9e4066Sahrens {
888b24ab676SJeff Bonwick 	if (dnp == NULL) {
889b24ab676SJeff Bonwick 		ASSERT(zb->zb_level < 0);
890b24ab676SJeff Bonwick 		if (zb->zb_object == 0)
891b24ab676SJeff Bonwick 			return (zb->zb_blkid);
892b24ab676SJeff Bonwick 		return (zb->zb_blkid * BP_GET_LSIZE(bp));
893b24ab676SJeff Bonwick 	}
894b24ab676SJeff Bonwick 
895b24ab676SJeff Bonwick 	ASSERT(zb->zb_level >= 0);
896fa9e4066Sahrens 
897b24ab676SJeff Bonwick 	return ((zb->zb_blkid <<
898b24ab676SJeff Bonwick 	    (zb->zb_level * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT))) *
899fa9e4066Sahrens 	    dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT);
900fa9e4066Sahrens }
901fa9e4066Sahrens 
90244cd46caSbillm static void
903*cde58dbcSMatthew Ahrens sprintf_blkptr_compact(char *blkbuf, const blkptr_t *bp)
90444cd46caSbillm {
905*cde58dbcSMatthew Ahrens 	const dva_t *dva = bp->blk_dva;
906b24ab676SJeff Bonwick 	int ndvas = dump_opt['d'] > 5 ? BP_GET_NDVAS(bp) : 1;
907b24ab676SJeff Bonwick 
908b24ab676SJeff Bonwick 	if (dump_opt['b'] >= 5) {
909b24ab676SJeff Bonwick 		sprintf_blkptr(blkbuf, bp);
910b24ab676SJeff Bonwick 		return;
911b24ab676SJeff Bonwick 	}
91244cd46caSbillm 
91344cd46caSbillm 	blkbuf[0] = '\0';
91444cd46caSbillm 
915b24ab676SJeff Bonwick 	for (int i = 0; i < ndvas; i++)
91644cd46caSbillm 		(void) sprintf(blkbuf + strlen(blkbuf), "%llu:%llx:%llx ",
91744cd46caSbillm 		    (u_longlong_t)DVA_GET_VDEV(&dva[i]),
91844cd46caSbillm 		    (u_longlong_t)DVA_GET_OFFSET(&dva[i]),
91944cd46caSbillm 		    (u_longlong_t)DVA_GET_ASIZE(&dva[i]));
92044cd46caSbillm 
921b24ab676SJeff Bonwick 	(void) sprintf(blkbuf + strlen(blkbuf),
922b24ab676SJeff Bonwick 	    "%llxL/%llxP F=%llu B=%llu/%llu",
92344cd46caSbillm 	    (u_longlong_t)BP_GET_LSIZE(bp),
92444cd46caSbillm 	    (u_longlong_t)BP_GET_PSIZE(bp),
92544cd46caSbillm 	    (u_longlong_t)bp->blk_fill,
926b24ab676SJeff Bonwick 	    (u_longlong_t)bp->blk_birth,
927b24ab676SJeff Bonwick 	    (u_longlong_t)BP_PHYSICAL_BIRTH(bp));
92844cd46caSbillm }
92944cd46caSbillm 
93088b7b0f2SMatthew Ahrens static void
93188b7b0f2SMatthew Ahrens print_indirect(blkptr_t *bp, const zbookmark_t *zb,
93288b7b0f2SMatthew Ahrens     const dnode_phys_t *dnp)
933fa9e4066Sahrens {
93488b7b0f2SMatthew Ahrens 	char blkbuf[BP_SPRINTF_LEN];
935fa9e4066Sahrens 	int l;
936fa9e4066Sahrens 
93788b7b0f2SMatthew Ahrens 	ASSERT3U(BP_GET_TYPE(bp), ==, dnp->dn_type);
93888b7b0f2SMatthew Ahrens 	ASSERT3U(BP_GET_LEVEL(bp), ==, zb->zb_level);
939fa9e4066Sahrens 
940b24ab676SJeff Bonwick 	(void) printf("%16llx ", (u_longlong_t)blkid2offset(dnp, bp, zb));
941fa9e4066Sahrens 
942fa9e4066Sahrens 	ASSERT(zb->zb_level >= 0);
943fa9e4066Sahrens 
944fa9e4066Sahrens 	for (l = dnp->dn_nlevels - 1; l >= -1; l--) {
945fa9e4066Sahrens 		if (l == zb->zb_level) {
94688b7b0f2SMatthew Ahrens 			(void) printf("L%llx", (u_longlong_t)zb->zb_level);
947fa9e4066Sahrens 		} else {
94888b7b0f2SMatthew Ahrens 			(void) printf(" ");
949fa9e4066Sahrens 		}
950fa9e4066Sahrens 	}
951fa9e4066Sahrens 
952b24ab676SJeff Bonwick 	sprintf_blkptr_compact(blkbuf, bp);
95388b7b0f2SMatthew Ahrens 	(void) printf("%s\n", blkbuf);
95488b7b0f2SMatthew Ahrens }
95588b7b0f2SMatthew Ahrens 
95688b7b0f2SMatthew Ahrens static int
95788b7b0f2SMatthew Ahrens visit_indirect(spa_t *spa, const dnode_phys_t *dnp,
95888b7b0f2SMatthew Ahrens     blkptr_t *bp, const zbookmark_t *zb)
95988b7b0f2SMatthew Ahrens {
960e4161df6SVictor Latushkin 	int err = 0;
96188b7b0f2SMatthew Ahrens 
96288b7b0f2SMatthew Ahrens 	if (bp->blk_birth == 0)
96388b7b0f2SMatthew Ahrens 		return (0);
96488b7b0f2SMatthew Ahrens 
96588b7b0f2SMatthew Ahrens 	print_indirect(bp, zb, dnp);
96688b7b0f2SMatthew Ahrens 
96788b7b0f2SMatthew Ahrens 	if (BP_GET_LEVEL(bp) > 0) {
96888b7b0f2SMatthew Ahrens 		uint32_t flags = ARC_WAIT;
96988b7b0f2SMatthew Ahrens 		int i;
97088b7b0f2SMatthew Ahrens 		blkptr_t *cbp;
97188b7b0f2SMatthew Ahrens 		int epb = BP_GET_LSIZE(bp) >> SPA_BLKPTRSHIFT;
97288b7b0f2SMatthew Ahrens 		arc_buf_t *buf;
97388b7b0f2SMatthew Ahrens 		uint64_t fill = 0;
97488b7b0f2SMatthew Ahrens 
97588b7b0f2SMatthew Ahrens 		err = arc_read_nolock(NULL, spa, bp, arc_getbuf_func, &buf,
97688b7b0f2SMatthew Ahrens 		    ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, zb);
97788b7b0f2SMatthew Ahrens 		if (err)
97888b7b0f2SMatthew Ahrens 			return (err);
9793f9d6ad7SLin Ling 		ASSERT(buf->b_data);
98088b7b0f2SMatthew Ahrens 
98188b7b0f2SMatthew Ahrens 		/* recursively visit blocks below this */
98288b7b0f2SMatthew Ahrens 		cbp = buf->b_data;
98388b7b0f2SMatthew Ahrens 		for (i = 0; i < epb; i++, cbp++) {
98488b7b0f2SMatthew Ahrens 			zbookmark_t czb;
98588b7b0f2SMatthew Ahrens 
98688b7b0f2SMatthew Ahrens 			SET_BOOKMARK(&czb, zb->zb_objset, zb->zb_object,
98788b7b0f2SMatthew Ahrens 			    zb->zb_level - 1,
98888b7b0f2SMatthew Ahrens 			    zb->zb_blkid * epb + i);
98988b7b0f2SMatthew Ahrens 			err = visit_indirect(spa, dnp, cbp, &czb);
99088b7b0f2SMatthew Ahrens 			if (err)
99188b7b0f2SMatthew Ahrens 				break;
99288b7b0f2SMatthew Ahrens 			fill += cbp->blk_fill;
99388b7b0f2SMatthew Ahrens 		}
9948ad4d6ddSJeff Bonwick 		if (!err)
9958ad4d6ddSJeff Bonwick 			ASSERT3U(fill, ==, bp->blk_fill);
99688b7b0f2SMatthew Ahrens 		(void) arc_buf_remove_ref(buf, &buf);
997fa9e4066Sahrens 	}
998fa9e4066Sahrens 
99988b7b0f2SMatthew Ahrens 	return (err);
1000fa9e4066Sahrens }
1001fa9e4066Sahrens 
1002fa9e4066Sahrens /*ARGSUSED*/
1003fa9e4066Sahrens static void
100488b7b0f2SMatthew Ahrens dump_indirect(dnode_t *dn)
1005fa9e4066Sahrens {
100688b7b0f2SMatthew Ahrens 	dnode_phys_t *dnp = dn->dn_phys;
100788b7b0f2SMatthew Ahrens 	int j;
100888b7b0f2SMatthew Ahrens 	zbookmark_t czb;
1009fa9e4066Sahrens 
1010fa9e4066Sahrens 	(void) printf("Indirect blocks:\n");
1011fa9e4066Sahrens 
1012503ad85cSMatthew Ahrens 	SET_BOOKMARK(&czb, dmu_objset_id(dn->dn_objset),
101388b7b0f2SMatthew Ahrens 	    dn->dn_object, dnp->dn_nlevels - 1, 0);
101488b7b0f2SMatthew Ahrens 	for (j = 0; j < dnp->dn_nblkptr; j++) {
101588b7b0f2SMatthew Ahrens 		czb.zb_blkid = j;
1016503ad85cSMatthew Ahrens 		(void) visit_indirect(dmu_objset_spa(dn->dn_objset), dnp,
101788b7b0f2SMatthew Ahrens 		    &dnp->dn_blkptr[j], &czb);
101888b7b0f2SMatthew Ahrens 	}
1019fa9e4066Sahrens 
1020fa9e4066Sahrens 	(void) printf("\n");
1021fa9e4066Sahrens }
1022fa9e4066Sahrens 
1023fa9e4066Sahrens /*ARGSUSED*/
1024fa9e4066Sahrens static void
1025fa9e4066Sahrens dump_dsl_dir(objset_t *os, uint64_t object, void *data, size_t size)
1026fa9e4066Sahrens {
1027fa9e4066Sahrens 	dsl_dir_phys_t *dd = data;
1028fa9e4066Sahrens 	time_t crtime;
10293f9d6ad7SLin Ling 	char nice[32];
1030fa9e4066Sahrens 
1031fa9e4066Sahrens 	if (dd == NULL)
1032fa9e4066Sahrens 		return;
1033fa9e4066Sahrens 
1034da6c28aaSamw 	ASSERT3U(size, >=, sizeof (dsl_dir_phys_t));
1035fa9e4066Sahrens 
1036fa9e4066Sahrens 	crtime = dd->dd_creation_time;
1037fa9e4066Sahrens 	(void) printf("\t\tcreation_time = %s", ctime(&crtime));
1038fa9e4066Sahrens 	(void) printf("\t\thead_dataset_obj = %llu\n",
1039fa9e4066Sahrens 	    (u_longlong_t)dd->dd_head_dataset_obj);
1040fa9e4066Sahrens 	(void) printf("\t\tparent_dir_obj = %llu\n",
1041fa9e4066Sahrens 	    (u_longlong_t)dd->dd_parent_obj);
10423cb34c60Sahrens 	(void) printf("\t\torigin_obj = %llu\n",
10433cb34c60Sahrens 	    (u_longlong_t)dd->dd_origin_obj);
1044fa9e4066Sahrens 	(void) printf("\t\tchild_dir_zapobj = %llu\n",
1045fa9e4066Sahrens 	    (u_longlong_t)dd->dd_child_dir_zapobj);
10463f9d6ad7SLin Ling 	zdb_nicenum(dd->dd_used_bytes, nice);
104774e7dc98SMatthew Ahrens 	(void) printf("\t\tused_bytes = %s\n", nice);
10483f9d6ad7SLin Ling 	zdb_nicenum(dd->dd_compressed_bytes, nice);
104974e7dc98SMatthew Ahrens 	(void) printf("\t\tcompressed_bytes = %s\n", nice);
10503f9d6ad7SLin Ling 	zdb_nicenum(dd->dd_uncompressed_bytes, nice);
105174e7dc98SMatthew Ahrens 	(void) printf("\t\tuncompressed_bytes = %s\n", nice);
10523f9d6ad7SLin Ling 	zdb_nicenum(dd->dd_quota, nice);
105374e7dc98SMatthew Ahrens 	(void) printf("\t\tquota = %s\n", nice);
10543f9d6ad7SLin Ling 	zdb_nicenum(dd->dd_reserved, nice);
105574e7dc98SMatthew Ahrens 	(void) printf("\t\treserved = %s\n", nice);
1056fa9e4066Sahrens 	(void) printf("\t\tprops_zapobj = %llu\n",
1057fa9e4066Sahrens 	    (u_longlong_t)dd->dd_props_zapobj);
1058ecd6cf80Smarks 	(void) printf("\t\tdeleg_zapobj = %llu\n",
1059ecd6cf80Smarks 	    (u_longlong_t)dd->dd_deleg_zapobj);
106074e7dc98SMatthew Ahrens 	(void) printf("\t\tflags = %llx\n",
106174e7dc98SMatthew Ahrens 	    (u_longlong_t)dd->dd_flags);
106274e7dc98SMatthew Ahrens 
106374e7dc98SMatthew Ahrens #define	DO(which) \
10643f9d6ad7SLin Ling 	zdb_nicenum(dd->dd_used_breakdown[DD_USED_ ## which], nice); \
106574e7dc98SMatthew Ahrens 	(void) printf("\t\tused_breakdown[" #which "] = %s\n", nice)
106674e7dc98SMatthew Ahrens 	DO(HEAD);
106774e7dc98SMatthew Ahrens 	DO(SNAP);
106874e7dc98SMatthew Ahrens 	DO(CHILD);
106974e7dc98SMatthew Ahrens 	DO(CHILD_RSRV);
107074e7dc98SMatthew Ahrens 	DO(REFRSRV);
107174e7dc98SMatthew Ahrens #undef DO
1072fa9e4066Sahrens }
1073fa9e4066Sahrens 
1074fa9e4066Sahrens /*ARGSUSED*/
1075fa9e4066Sahrens static void
1076fa9e4066Sahrens dump_dsl_dataset(objset_t *os, uint64_t object, void *data, size_t size)
1077fa9e4066Sahrens {
1078fa9e4066Sahrens 	dsl_dataset_phys_t *ds = data;
1079fa9e4066Sahrens 	time_t crtime;
10803f9d6ad7SLin Ling 	char used[32], compressed[32], uncompressed[32], unique[32];
1081fbabab8fSmaybee 	char blkbuf[BP_SPRINTF_LEN];
1082fa9e4066Sahrens 
1083fa9e4066Sahrens 	if (ds == NULL)
1084fa9e4066Sahrens 		return;
1085fa9e4066Sahrens 
1086fa9e4066Sahrens 	ASSERT(size == sizeof (*ds));
1087fa9e4066Sahrens 	crtime = ds->ds_creation_time;
10883f9d6ad7SLin Ling 	zdb_nicenum(ds->ds_used_bytes, used);
10893f9d6ad7SLin Ling 	zdb_nicenum(ds->ds_compressed_bytes, compressed);
10903f9d6ad7SLin Ling 	zdb_nicenum(ds->ds_uncompressed_bytes, uncompressed);
10913f9d6ad7SLin Ling 	zdb_nicenum(ds->ds_unique_bytes, unique);
1092b24ab676SJeff Bonwick 	sprintf_blkptr(blkbuf, &ds->ds_bp);
1093fa9e4066Sahrens 
1094088f3894Sahrens 	(void) printf("\t\tdir_obj = %llu\n",
1095fa9e4066Sahrens 	    (u_longlong_t)ds->ds_dir_obj);
1096fa9e4066Sahrens 	(void) printf("\t\tprev_snap_obj = %llu\n",
1097fa9e4066Sahrens 	    (u_longlong_t)ds->ds_prev_snap_obj);
1098fa9e4066Sahrens 	(void) printf("\t\tprev_snap_txg = %llu\n",
1099fa9e4066Sahrens 	    (u_longlong_t)ds->ds_prev_snap_txg);
1100fa9e4066Sahrens 	(void) printf("\t\tnext_snap_obj = %llu\n",
1101fa9e4066Sahrens 	    (u_longlong_t)ds->ds_next_snap_obj);
1102fa9e4066Sahrens 	(void) printf("\t\tsnapnames_zapobj = %llu\n",
1103fa9e4066Sahrens 	    (u_longlong_t)ds->ds_snapnames_zapobj);
1104fa9e4066Sahrens 	(void) printf("\t\tnum_children = %llu\n",
1105fa9e4066Sahrens 	    (u_longlong_t)ds->ds_num_children);
1106842727c2SChris Kirby 	(void) printf("\t\tuserrefs_obj = %llu\n",
1107842727c2SChris Kirby 	    (u_longlong_t)ds->ds_userrefs_obj);
1108fa9e4066Sahrens 	(void) printf("\t\tcreation_time = %s", ctime(&crtime));
1109fa9e4066Sahrens 	(void) printf("\t\tcreation_txg = %llu\n",
1110fa9e4066Sahrens 	    (u_longlong_t)ds->ds_creation_txg);
1111fa9e4066Sahrens 	(void) printf("\t\tdeadlist_obj = %llu\n",
1112fa9e4066Sahrens 	    (u_longlong_t)ds->ds_deadlist_obj);
1113fa9e4066Sahrens 	(void) printf("\t\tused_bytes = %s\n", used);
1114fa9e4066Sahrens 	(void) printf("\t\tcompressed_bytes = %s\n", compressed);
1115fa9e4066Sahrens 	(void) printf("\t\tuncompressed_bytes = %s\n", uncompressed);
1116fa9e4066Sahrens 	(void) printf("\t\tunique = %s\n", unique);
1117fa9e4066Sahrens 	(void) printf("\t\tfsid_guid = %llu\n",
1118fa9e4066Sahrens 	    (u_longlong_t)ds->ds_fsid_guid);
1119fa9e4066Sahrens 	(void) printf("\t\tguid = %llu\n",
1120fa9e4066Sahrens 	    (u_longlong_t)ds->ds_guid);
112199653d4eSeschrock 	(void) printf("\t\tflags = %llx\n",
112299653d4eSeschrock 	    (u_longlong_t)ds->ds_flags);
1123088f3894Sahrens 	(void) printf("\t\tnext_clones_obj = %llu\n",
1124088f3894Sahrens 	    (u_longlong_t)ds->ds_next_clones_obj);
1125bb0ade09Sahrens 	(void) printf("\t\tprops_obj = %llu\n",
1126bb0ade09Sahrens 	    (u_longlong_t)ds->ds_props_obj);
1127fa9e4066Sahrens 	(void) printf("\t\tbp = %s\n", blkbuf);
1128fa9e4066Sahrens }
1129fa9e4066Sahrens 
1130*cde58dbcSMatthew Ahrens /* ARGSUSED */
1131*cde58dbcSMatthew Ahrens static int
1132*cde58dbcSMatthew Ahrens dump_bpobj_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
1133*cde58dbcSMatthew Ahrens {
1134*cde58dbcSMatthew Ahrens 	char blkbuf[BP_SPRINTF_LEN];
1135*cde58dbcSMatthew Ahrens 
1136*cde58dbcSMatthew Ahrens 	ASSERT(bp->blk_birth != 0);
1137*cde58dbcSMatthew Ahrens 	sprintf_blkptr_compact(blkbuf, bp);
1138*cde58dbcSMatthew Ahrens 	(void) printf("\t%s\n", blkbuf);
1139*cde58dbcSMatthew Ahrens 	return (0);
1140*cde58dbcSMatthew Ahrens }
1141*cde58dbcSMatthew Ahrens 
1142fa9e4066Sahrens static void
1143*cde58dbcSMatthew Ahrens dump_bpobj(bpobj_t *bpo, char *name)
1144fa9e4066Sahrens {
11453f9d6ad7SLin Ling 	char bytes[32];
11463f9d6ad7SLin Ling 	char comp[32];
11473f9d6ad7SLin Ling 	char uncomp[32];
1148fa9e4066Sahrens 
1149fa9e4066Sahrens 	if (dump_opt['d'] < 3)
1150fa9e4066Sahrens 		return;
1151fa9e4066Sahrens 
1152*cde58dbcSMatthew Ahrens 	zdb_nicenum(bpo->bpo_phys->bpo_bytes, bytes);
1153*cde58dbcSMatthew Ahrens 	if (bpo->bpo_havesubobj) {
1154*cde58dbcSMatthew Ahrens 		zdb_nicenum(bpo->bpo_phys->bpo_comp, comp);
1155*cde58dbcSMatthew Ahrens 		zdb_nicenum(bpo->bpo_phys->bpo_uncomp, uncomp);
1156*cde58dbcSMatthew Ahrens 		(void) printf("\n    %s: %llu local blkptrs, %llu subobjs, "
1157*cde58dbcSMatthew Ahrens 		    "%s (%s/%s comp)\n",
1158*cde58dbcSMatthew Ahrens 		    name, (u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
1159*cde58dbcSMatthew Ahrens 		    (u_longlong_t)bpo->bpo_phys->bpo_num_subobjs,
116099653d4eSeschrock 		    bytes, comp, uncomp);
116199653d4eSeschrock 	} else {
1162*cde58dbcSMatthew Ahrens 		(void) printf("\n    %s: %llu blkptrs, %s\n",
1163*cde58dbcSMatthew Ahrens 		    name, (u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs, bytes);
116499653d4eSeschrock 	}
1165fa9e4066Sahrens 
1166*cde58dbcSMatthew Ahrens 	if (dump_opt['d'] < 5)
1167fa9e4066Sahrens 		return;
1168fa9e4066Sahrens 
1169fa9e4066Sahrens 	(void) printf("\n");
1170fa9e4066Sahrens 
1171*cde58dbcSMatthew Ahrens 	(void) bpobj_iterate_nofree(bpo, dump_bpobj_cb, NULL, NULL);
1172*cde58dbcSMatthew Ahrens }
117344cd46caSbillm 
1174*cde58dbcSMatthew Ahrens static void
1175*cde58dbcSMatthew Ahrens dump_deadlist(dsl_deadlist_t *dl)
1176*cde58dbcSMatthew Ahrens {
1177*cde58dbcSMatthew Ahrens 	dsl_deadlist_entry_t *dle;
1178*cde58dbcSMatthew Ahrens 	char bytes[32];
1179*cde58dbcSMatthew Ahrens 	char comp[32];
1180*cde58dbcSMatthew Ahrens 	char uncomp[32];
1181*cde58dbcSMatthew Ahrens 
1182*cde58dbcSMatthew Ahrens 	if (dump_opt['d'] < 3)
1183*cde58dbcSMatthew Ahrens 		return;
1184*cde58dbcSMatthew Ahrens 
1185*cde58dbcSMatthew Ahrens 	zdb_nicenum(dl->dl_phys->dl_used, bytes);
1186*cde58dbcSMatthew Ahrens 	zdb_nicenum(dl->dl_phys->dl_comp, comp);
1187*cde58dbcSMatthew Ahrens 	zdb_nicenum(dl->dl_phys->dl_uncomp, uncomp);
1188*cde58dbcSMatthew Ahrens 	(void) printf("\n    Deadlist: %s (%s/%s comp)\n",
1189*cde58dbcSMatthew Ahrens 	    bytes, comp, uncomp);
1190*cde58dbcSMatthew Ahrens 
1191*cde58dbcSMatthew Ahrens 	if (dump_opt['d'] < 4)
1192*cde58dbcSMatthew Ahrens 		return;
1193*cde58dbcSMatthew Ahrens 
1194*cde58dbcSMatthew Ahrens 	(void) printf("\n");
1195*cde58dbcSMatthew Ahrens 
1196*cde58dbcSMatthew Ahrens 	for (dle = avl_first(&dl->dl_tree); dle;
1197*cde58dbcSMatthew Ahrens 	    dle = AVL_NEXT(&dl->dl_tree, dle)) {
1198*cde58dbcSMatthew Ahrens 		(void) printf("      mintxg %llu -> obj %llu\n",
1199*cde58dbcSMatthew Ahrens 		    (longlong_t)dle->dle_mintxg,
1200*cde58dbcSMatthew Ahrens 		    (longlong_t)dle->dle_bpobj.bpo_object);
1201fa9e4066Sahrens 
1202*cde58dbcSMatthew Ahrens 		if (dump_opt['d'] >= 5)
1203*cde58dbcSMatthew Ahrens 			dump_bpobj(&dle->dle_bpobj, "");
1204*cde58dbcSMatthew Ahrens 	}
1205fa9e4066Sahrens }
1206fa9e4066Sahrens 
1207e0d35c44Smarks static avl_tree_t idx_tree;
1208e0d35c44Smarks static avl_tree_t domain_tree;
1209e0d35c44Smarks static boolean_t fuid_table_loaded;
12100a586ceaSMark Shellenbaum static boolean_t sa_loaded;
12110a586ceaSMark Shellenbaum sa_attr_type_t *sa_attr_table;
1212e0d35c44Smarks 
1213e0d35c44Smarks static void
1214e0d35c44Smarks fuid_table_destroy()
1215e0d35c44Smarks {
1216e0d35c44Smarks 	if (fuid_table_loaded) {
1217e0d35c44Smarks 		zfs_fuid_table_destroy(&idx_tree, &domain_tree);
1218e0d35c44Smarks 		fuid_table_loaded = B_FALSE;
1219e0d35c44Smarks 	}
1220e0d35c44Smarks }
1221e0d35c44Smarks 
1222e0d35c44Smarks /*
1223e0d35c44Smarks  * print uid or gid information.
1224e0d35c44Smarks  * For normal POSIX id just the id is printed in decimal format.
1225e0d35c44Smarks  * For CIFS files with FUID the fuid is printed in hex followed by
1226e0d35c44Smarks  * the doman-rid string.
1227e0d35c44Smarks  */
1228e0d35c44Smarks static void
1229e0d35c44Smarks print_idstr(uint64_t id, const char *id_type)
1230e0d35c44Smarks {
1231e0d35c44Smarks 	if (FUID_INDEX(id)) {
1232e0d35c44Smarks 		char *domain;
1233e0d35c44Smarks 
1234e0d35c44Smarks 		domain = zfs_fuid_idx_domain(&idx_tree, FUID_INDEX(id));
1235e0d35c44Smarks 		(void) printf("\t%s     %llx [%s-%d]\n", id_type,
1236e0d35c44Smarks 		    (u_longlong_t)id, domain, (int)FUID_RID(id));
1237e0d35c44Smarks 	} else {
1238e0d35c44Smarks 		(void) printf("\t%s     %llu\n", id_type, (u_longlong_t)id);
1239e0d35c44Smarks 	}
1240e0d35c44Smarks 
1241e0d35c44Smarks }
1242e0d35c44Smarks 
1243e0d35c44Smarks static void
12440a586ceaSMark Shellenbaum dump_uidgid(objset_t *os, uint64_t uid, uint64_t gid)
1245e0d35c44Smarks {
1246e0d35c44Smarks 	uint32_t uid_idx, gid_idx;
1247e0d35c44Smarks 
12480a586ceaSMark Shellenbaum 	uid_idx = FUID_INDEX(uid);
12490a586ceaSMark Shellenbaum 	gid_idx = FUID_INDEX(gid);
1250e0d35c44Smarks 
1251e0d35c44Smarks 	/* Load domain table, if not already loaded */
1252e0d35c44Smarks 	if (!fuid_table_loaded && (uid_idx || gid_idx)) {
1253e0d35c44Smarks 		uint64_t fuid_obj;
1254e0d35c44Smarks 
1255e0d35c44Smarks 		/* first find the fuid object.  It lives in the master node */
1256e0d35c44Smarks 		VERIFY(zap_lookup(os, MASTER_NODE_OBJ, ZFS_FUID_TABLES,
1257e0d35c44Smarks 		    8, 1, &fuid_obj) == 0);
125889459e17SMark Shellenbaum 		zfs_fuid_avl_tree_create(&idx_tree, &domain_tree);
1259e0d35c44Smarks 		(void) zfs_fuid_table_load(os, fuid_obj,
1260e0d35c44Smarks 		    &idx_tree, &domain_tree);
1261e0d35c44Smarks 		fuid_table_loaded = B_TRUE;
1262e0d35c44Smarks 	}
1263e0d35c44Smarks 
12640a586ceaSMark Shellenbaum 	print_idstr(uid, "uid");
12650a586ceaSMark Shellenbaum 	print_idstr(gid, "gid");
1266e0d35c44Smarks }
1267e0d35c44Smarks 
1268fa9e4066Sahrens /*ARGSUSED*/
1269fa9e4066Sahrens static void
1270fa9e4066Sahrens dump_znode(objset_t *os, uint64_t object, void *data, size_t size)
1271fa9e4066Sahrens {
1272fa9e4066Sahrens 	char path[MAXPATHLEN * 2];	/* allow for xattr and failure prefix */
12730a586ceaSMark Shellenbaum 	sa_handle_t *hdl;
12740a586ceaSMark Shellenbaum 	uint64_t xattr, rdev, gen;
12750a586ceaSMark Shellenbaum 	uint64_t uid, gid, mode, fsize, parent, links;
12768f2529deSMark Shellenbaum 	uint64_t pflags;
12770a586ceaSMark Shellenbaum 	uint64_t acctm[2], modtm[2], chgtm[2], crtm[2];
12780a586ceaSMark Shellenbaum 	time_t z_crtime, z_atime, z_mtime, z_ctime;
12798f2529deSMark Shellenbaum 	sa_bulk_attr_t bulk[12];
12800a586ceaSMark Shellenbaum 	int idx = 0;
128155434c77Sek 	int error;
1282fa9e4066Sahrens 
12830a586ceaSMark Shellenbaum 	if (!sa_loaded) {
12840a586ceaSMark Shellenbaum 		uint64_t sa_attrs = 0;
12850a586ceaSMark Shellenbaum 		uint64_t version;
12860a586ceaSMark Shellenbaum 
12870a586ceaSMark Shellenbaum 		VERIFY(zap_lookup(os, MASTER_NODE_OBJ, ZPL_VERSION_STR,
12880a586ceaSMark Shellenbaum 		    8, 1, &version) == 0);
12890a586ceaSMark Shellenbaum 		if (version >= ZPL_VERSION_SA) {
12900a586ceaSMark Shellenbaum 			VERIFY(zap_lookup(os, MASTER_NODE_OBJ, ZFS_SA_ATTRS,
12910a586ceaSMark Shellenbaum 			    8, 1, &sa_attrs) == 0);
12920a586ceaSMark Shellenbaum 		}
12930a586ceaSMark Shellenbaum 		sa_attr_table = sa_setup(os, sa_attrs,
12940a586ceaSMark Shellenbaum 		    zfs_attr_table, ZPL_END);
12950a586ceaSMark Shellenbaum 		sa_loaded = B_TRUE;
12960a586ceaSMark Shellenbaum 	}
12970a586ceaSMark Shellenbaum 
12980a586ceaSMark Shellenbaum 	if (sa_handle_get(os, object, NULL, SA_HDL_PRIVATE, &hdl)) {
12990a586ceaSMark Shellenbaum 		(void) printf("Failed to get handle for SA znode\n");
13000a586ceaSMark Shellenbaum 		return;
13010a586ceaSMark Shellenbaum 	}
13020a586ceaSMark Shellenbaum 
13030a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_UID], NULL, &uid, 8);
13040a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_GID], NULL, &gid, 8);
13050a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_LINKS], NULL,
13060a586ceaSMark Shellenbaum 	    &links, 8);
13070a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_GEN], NULL, &gen, 8);
13080a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_MODE], NULL,
13090a586ceaSMark Shellenbaum 	    &mode, 8);
13100a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_PARENT],
13110a586ceaSMark Shellenbaum 	    NULL, &parent, 8);
13120a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_SIZE], NULL,
13130a586ceaSMark Shellenbaum 	    &fsize, 8);
13140a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_ATIME], NULL,
13150a586ceaSMark Shellenbaum 	    acctm, 16);
13160a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_MTIME], NULL,
13170a586ceaSMark Shellenbaum 	    modtm, 16);
13180a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_CRTIME], NULL,
13190a586ceaSMark Shellenbaum 	    crtm, 16);
13200a586ceaSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_CTIME], NULL,
13210a586ceaSMark Shellenbaum 	    chgtm, 16);
13228f2529deSMark Shellenbaum 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_FLAGS], NULL,
13238f2529deSMark Shellenbaum 	    &pflags, 8);
13240a586ceaSMark Shellenbaum 
13250a586ceaSMark Shellenbaum 	if (sa_bulk_lookup(hdl, bulk, idx)) {
13260a586ceaSMark Shellenbaum 		(void) sa_handle_destroy(hdl);
13270a586ceaSMark Shellenbaum 		return;
13280a586ceaSMark Shellenbaum 	}
1329fa9e4066Sahrens 
133055434c77Sek 	error = zfs_obj_to_path(os, object, path, sizeof (path));
133155434c77Sek 	if (error != 0) {
133255434c77Sek 		(void) snprintf(path, sizeof (path), "\?\?\?<object#%llu>",
133355434c77Sek 		    (u_longlong_t)object);
133455434c77Sek 	}
1335fa9e4066Sahrens 	if (dump_opt['d'] < 3) {
133655434c77Sek 		(void) printf("\t%s\n", path);
13370a586ceaSMark Shellenbaum 		(void) sa_handle_destroy(hdl);
1338fa9e4066Sahrens 		return;
1339fa9e4066Sahrens 	}
1340fa9e4066Sahrens 
13410a586ceaSMark Shellenbaum 	z_crtime = (time_t)crtm[0];
13420a586ceaSMark Shellenbaum 	z_atime = (time_t)acctm[0];
13430a586ceaSMark Shellenbaum 	z_mtime = (time_t)modtm[0];
13440a586ceaSMark Shellenbaum 	z_ctime = (time_t)chgtm[0];
1345fa9e4066Sahrens 
134655434c77Sek 	(void) printf("\tpath	%s\n", path);
13470a586ceaSMark Shellenbaum 	dump_uidgid(os, uid, gid);
1348fa9e4066Sahrens 	(void) printf("\tatime	%s", ctime(&z_atime));
1349fa9e4066Sahrens 	(void) printf("\tmtime	%s", ctime(&z_mtime));
1350fa9e4066Sahrens 	(void) printf("\tctime	%s", ctime(&z_ctime));
1351fa9e4066Sahrens 	(void) printf("\tcrtime	%s", ctime(&z_crtime));
13520a586ceaSMark Shellenbaum 	(void) printf("\tgen	%llu\n", (u_longlong_t)gen);
13530a586ceaSMark Shellenbaum 	(void) printf("\tmode	%llo\n", (u_longlong_t)mode);
13540a586ceaSMark Shellenbaum 	(void) printf("\tsize	%llu\n", (u_longlong_t)fsize);
13550a586ceaSMark Shellenbaum 	(void) printf("\tparent	%llu\n", (u_longlong_t)parent);
13560a586ceaSMark Shellenbaum 	(void) printf("\tlinks	%llu\n", (u_longlong_t)links);
13578f2529deSMark Shellenbaum 	(void) printf("\tpflags	%llx\n", (u_longlong_t)pflags);
13580a586ceaSMark Shellenbaum 	if (sa_lookup(hdl, sa_attr_table[ZPL_XATTR], &xattr,
13590a586ceaSMark Shellenbaum 	    sizeof (uint64_t)) == 0)
13600a586ceaSMark Shellenbaum 		(void) printf("\txattr	%llu\n", (u_longlong_t)xattr);
13610a586ceaSMark Shellenbaum 	if (sa_lookup(hdl, sa_attr_table[ZPL_RDEV], &rdev,
13620a586ceaSMark Shellenbaum 	    sizeof (uint64_t)) == 0)
13630a586ceaSMark Shellenbaum 		(void) printf("\trdev	0x%016llx\n", (u_longlong_t)rdev);
13640a586ceaSMark Shellenbaum 	sa_handle_destroy(hdl);
1365fa9e4066Sahrens }
1366fa9e4066Sahrens 
1367fa9e4066Sahrens /*ARGSUSED*/
1368fa9e4066Sahrens static void
1369fa9e4066Sahrens dump_acl(objset_t *os, uint64_t object, void *data, size_t size)
1370fa9e4066Sahrens {
1371fa9e4066Sahrens }
1372fa9e4066Sahrens 
1373fa9e4066Sahrens /*ARGSUSED*/
1374fa9e4066Sahrens static void
1375fa9e4066Sahrens dump_dmu_objset(objset_t *os, uint64_t object, void *data, size_t size)
1376fa9e4066Sahrens {
1377fa9e4066Sahrens }
1378fa9e4066Sahrens 
13796de8f417SVictor Latushkin static object_viewer_t *object_viewer[DMU_OT_NUMTYPES + 1] = {
1380fa9e4066Sahrens 	dump_none,		/* unallocated			*/
1381fa9e4066Sahrens 	dump_zap,		/* object directory		*/
1382fa9e4066Sahrens 	dump_uint64,		/* object array			*/
1383fa9e4066Sahrens 	dump_none,		/* packed nvlist		*/
1384fa9e4066Sahrens 	dump_packed_nvlist,	/* packed nvlist size		*/
1385fa9e4066Sahrens 	dump_none,		/* bplist			*/
1386fa9e4066Sahrens 	dump_none,		/* bplist header		*/
1387fa9e4066Sahrens 	dump_none,		/* SPA space map header		*/
1388fa9e4066Sahrens 	dump_none,		/* SPA space map		*/
1389fa9e4066Sahrens 	dump_none,		/* ZIL intent log		*/
1390fa9e4066Sahrens 	dump_dnode,		/* DMU dnode			*/
1391fa9e4066Sahrens 	dump_dmu_objset,	/* DMU objset			*/
1392ea8dc4b6Seschrock 	dump_dsl_dir,		/* DSL directory		*/
1393fa9e4066Sahrens 	dump_zap,		/* DSL directory child map	*/
1394fa9e4066Sahrens 	dump_zap,		/* DSL dataset snap map		*/
1395fa9e4066Sahrens 	dump_zap,		/* DSL props			*/
1396fa9e4066Sahrens 	dump_dsl_dataset,	/* DSL dataset			*/
1397fa9e4066Sahrens 	dump_znode,		/* ZFS znode			*/
1398da6c28aaSamw 	dump_acl,		/* ZFS V0 ACL			*/
1399fa9e4066Sahrens 	dump_uint8,		/* ZFS plain file		*/
1400e7437265Sahrens 	dump_zpldir,		/* ZFS directory		*/
1401fa9e4066Sahrens 	dump_zap,		/* ZFS master node		*/
1402fa9e4066Sahrens 	dump_zap,		/* ZFS delete queue		*/
1403fa9e4066Sahrens 	dump_uint8,		/* zvol object			*/
1404fa9e4066Sahrens 	dump_zap,		/* zvol prop			*/
1405fa9e4066Sahrens 	dump_uint8,		/* other uint8[]		*/
1406fa9e4066Sahrens 	dump_uint64,		/* other uint64[]		*/
1407fa9e4066Sahrens 	dump_zap,		/* other ZAP			*/
1408ea8dc4b6Seschrock 	dump_zap,		/* persistent error log		*/
140906eeb2adSek 	dump_uint8,		/* SPA history			*/
141006eeb2adSek 	dump_uint64,		/* SPA history offsets		*/
1411b1b8ab34Slling 	dump_zap,		/* Pool properties		*/
1412ecd6cf80Smarks 	dump_zap,		/* DSL permissions		*/
1413da6c28aaSamw 	dump_acl,		/* ZFS ACL			*/
1414da6c28aaSamw 	dump_uint8,		/* ZFS SYSACL			*/
1415da6c28aaSamw 	dump_none,		/* FUID nvlist			*/
1416da6c28aaSamw 	dump_packed_nvlist,	/* FUID nvlist size		*/
1417088f3894Sahrens 	dump_zap,		/* DSL dataset next clones	*/
1418088f3894Sahrens 	dump_zap,		/* DSL scrub queue		*/
141914843421SMatthew Ahrens 	dump_zap,		/* ZFS user/group used		*/
142014843421SMatthew Ahrens 	dump_zap,		/* ZFS user/group quota		*/
1421842727c2SChris Kirby 	dump_zap,		/* snapshot refcount tags	*/
1422486ae710SMatthew Ahrens 	dump_ddt_zap,		/* DDT ZAP object		*/
1423b24ab676SJeff Bonwick 	dump_zap,		/* DDT statistics		*/
14240a586ceaSMark Shellenbaum 	dump_znode,		/* SA object			*/
14250a586ceaSMark Shellenbaum 	dump_zap,		/* SA Master Node		*/
14260a586ceaSMark Shellenbaum 	dump_sa_attrs,		/* SA attribute registration	*/
14270a586ceaSMark Shellenbaum 	dump_sa_layouts,	/* SA attribute layouts		*/
14283f9d6ad7SLin Ling 	dump_zap,		/* DSL scrub translations	*/
14293f9d6ad7SLin Ling 	dump_none,		/* fake dedup BP		*/
1430*cde58dbcSMatthew Ahrens 	dump_zap,		/* deadlist			*/
1431*cde58dbcSMatthew Ahrens 	dump_none,		/* deadlist hdr			*/
1432*cde58dbcSMatthew Ahrens 	dump_zap,		/* dsl clones			*/
1433*cde58dbcSMatthew Ahrens 	dump_none,		/* bpobj subobjs		*/
14340a586ceaSMark Shellenbaum 	dump_unknown,		/* Unknown type, must be last	*/
1435fa9e4066Sahrens };
1436fa9e4066Sahrens 
1437fa9e4066Sahrens static void
1438fa9e4066Sahrens dump_object(objset_t *os, uint64_t object, int verbosity, int *print_header)
1439fa9e4066Sahrens {
1440fa9e4066Sahrens 	dmu_buf_t *db = NULL;
1441fa9e4066Sahrens 	dmu_object_info_t doi;
1442fa9e4066Sahrens 	dnode_t *dn;
1443fa9e4066Sahrens 	void *bonus = NULL;
1444fa9e4066Sahrens 	size_t bsize = 0;
14453f9d6ad7SLin Ling 	char iblk[32], dblk[32], lsize[32], asize[32], fill[32];
14463f9d6ad7SLin Ling 	char bonus_size[32];
1447fa9e4066Sahrens 	char aux[50];
1448fa9e4066Sahrens 	int error;
1449fa9e4066Sahrens 
1450fa9e4066Sahrens 	if (*print_header) {
1451b24ab676SJeff Bonwick 		(void) printf("\n%10s  %3s  %5s  %5s  %5s  %5s  %6s  %s\n",
1452b24ab676SJeff Bonwick 		    "Object", "lvl", "iblk", "dblk", "dsize", "lsize",
1453b24ab676SJeff Bonwick 		    "%full", "type");
1454fa9e4066Sahrens 		*print_header = 0;
1455fa9e4066Sahrens 	}
1456fa9e4066Sahrens 
1457fa9e4066Sahrens 	if (object == 0) {
1458503ad85cSMatthew Ahrens 		dn = os->os_meta_dnode;
1459fa9e4066Sahrens 	} else {
1460ea8dc4b6Seschrock 		error = dmu_bonus_hold(os, object, FTAG, &db);
1461ea8dc4b6Seschrock 		if (error)
1462ea8dc4b6Seschrock 			fatal("dmu_bonus_hold(%llu) failed, errno %u",
1463ea8dc4b6Seschrock 			    object, error);
1464fa9e4066Sahrens 		bonus = db->db_data;
1465fa9e4066Sahrens 		bsize = db->db_size;
1466fa9e4066Sahrens 		dn = ((dmu_buf_impl_t *)db)->db_dnode;
1467fa9e4066Sahrens 	}
1468fa9e4066Sahrens 	dmu_object_info_from_dnode(dn, &doi);
1469fa9e4066Sahrens 
14703f9d6ad7SLin Ling 	zdb_nicenum(doi.doi_metadata_block_size, iblk);
14713f9d6ad7SLin Ling 	zdb_nicenum(doi.doi_data_block_size, dblk);
14723f9d6ad7SLin Ling 	zdb_nicenum(doi.doi_max_offset, lsize);
14733f9d6ad7SLin Ling 	zdb_nicenum(doi.doi_physical_blocks_512 << 9, asize);
14743f9d6ad7SLin Ling 	zdb_nicenum(doi.doi_bonus_size, bonus_size);
1475b24ab676SJeff Bonwick 	(void) sprintf(fill, "%6.2f", 100.0 * doi.doi_fill_count *
1476bbfd46c4SJeff Bonwick 	    doi.doi_data_block_size / (object == 0 ? DNODES_PER_BLOCK : 1) /
1477bbfd46c4SJeff Bonwick 	    doi.doi_max_offset);
1478fa9e4066Sahrens 
1479fa9e4066Sahrens 	aux[0] = '\0';
1480fa9e4066Sahrens 
1481e7437265Sahrens 	if (doi.doi_checksum != ZIO_CHECKSUM_INHERIT || verbosity >= 6) {
1482fa9e4066Sahrens 		(void) snprintf(aux + strlen(aux), sizeof (aux), " (K=%s)",
14836de8f417SVictor Latushkin 		    ZDB_CHECKSUM_NAME(doi.doi_checksum));
1484e7437265Sahrens 	}
1485fa9e4066Sahrens 
1486e7437265Sahrens 	if (doi.doi_compress != ZIO_COMPRESS_INHERIT || verbosity >= 6) {
1487fa9e4066Sahrens 		(void) snprintf(aux + strlen(aux), sizeof (aux), " (Z=%s)",
14886de8f417SVictor Latushkin 		    ZDB_COMPRESS_NAME(doi.doi_compress));
1489e7437265Sahrens 	}
1490fa9e4066Sahrens 
1491b24ab676SJeff Bonwick 	(void) printf("%10lld  %3u  %5s  %5s  %5s  %5s  %6s  %s%s\n",
1492b24ab676SJeff Bonwick 	    (u_longlong_t)object, doi.doi_indirection, iblk, dblk,
1493b24ab676SJeff Bonwick 	    asize, lsize, fill, ZDB_OT_NAME(doi.doi_type), aux);
1494fa9e4066Sahrens 
1495fa9e4066Sahrens 	if (doi.doi_bonus_type != DMU_OT_NONE && verbosity > 3) {
1496b24ab676SJeff Bonwick 		(void) printf("%10s  %3s  %5s  %5s  %5s  %5s  %6s  %s\n",
1497b24ab676SJeff Bonwick 		    "", "", "", "", "", bonus_size, "bonus",
14986de8f417SVictor Latushkin 		    ZDB_OT_NAME(doi.doi_bonus_type));
1499fa9e4066Sahrens 	}
1500fa9e4066Sahrens 
1501fa9e4066Sahrens 	if (verbosity >= 4) {
15020a586ceaSMark Shellenbaum 		(void) printf("\tdnode flags: %s%s%s\n",
150314843421SMatthew Ahrens 		    (dn->dn_phys->dn_flags & DNODE_FLAG_USED_BYTES) ?
150414843421SMatthew Ahrens 		    "USED_BYTES " : "",
150514843421SMatthew Ahrens 		    (dn->dn_phys->dn_flags & DNODE_FLAG_USERUSED_ACCOUNTED) ?
15060a586ceaSMark Shellenbaum 		    "USERUSED_ACCOUNTED " : "",
15070a586ceaSMark Shellenbaum 		    (dn->dn_phys->dn_flags & DNODE_FLAG_SPILL_BLKPTR) ?
15080a586ceaSMark Shellenbaum 		    "SPILL_BLKPTR" : "");
150914843421SMatthew Ahrens 		(void) printf("\tdnode maxblkid: %llu\n",
151014843421SMatthew Ahrens 		    (longlong_t)dn->dn_phys->dn_maxblkid);
151114843421SMatthew Ahrens 
15126de8f417SVictor Latushkin 		object_viewer[ZDB_OT_TYPE(doi.doi_bonus_type)](os, object,
15136de8f417SVictor Latushkin 		    bonus, bsize);
15146de8f417SVictor Latushkin 		object_viewer[ZDB_OT_TYPE(doi.doi_type)](os, object, NULL, 0);
1515fa9e4066Sahrens 		*print_header = 1;
1516fa9e4066Sahrens 	}
1517fa9e4066Sahrens 
1518fa9e4066Sahrens 	if (verbosity >= 5)
151988b7b0f2SMatthew Ahrens 		dump_indirect(dn);
1520fa9e4066Sahrens 
1521fa9e4066Sahrens 	if (verbosity >= 5) {
1522fa9e4066Sahrens 		/*
1523fa9e4066Sahrens 		 * Report the list of segments that comprise the object.
1524fa9e4066Sahrens 		 */
1525fa9e4066Sahrens 		uint64_t start = 0;
1526fa9e4066Sahrens 		uint64_t end;
1527fa9e4066Sahrens 		uint64_t blkfill = 1;
1528fa9e4066Sahrens 		int minlvl = 1;
1529fa9e4066Sahrens 
1530fa9e4066Sahrens 		if (dn->dn_type == DMU_OT_DNODE) {
1531fa9e4066Sahrens 			minlvl = 0;
1532fa9e4066Sahrens 			blkfill = DNODES_PER_BLOCK;
1533fa9e4066Sahrens 		}
1534fa9e4066Sahrens 
1535fa9e4066Sahrens 		for (;;) {
15363f9d6ad7SLin Ling 			char segsize[32];
1537cdb0ab79Smaybee 			error = dnode_next_offset(dn,
1538cdb0ab79Smaybee 			    0, &start, minlvl, blkfill, 0);
1539fa9e4066Sahrens 			if (error)
1540fa9e4066Sahrens 				break;
1541fa9e4066Sahrens 			end = start;
1542cdb0ab79Smaybee 			error = dnode_next_offset(dn,
1543cdb0ab79Smaybee 			    DNODE_FIND_HOLE, &end, minlvl, blkfill, 0);
15443f9d6ad7SLin Ling 			zdb_nicenum(end - start, segsize);
1545fa9e4066Sahrens 			(void) printf("\t\tsegment [%016llx, %016llx)"
1546fa9e4066Sahrens 			    " size %5s\n", (u_longlong_t)start,
1547fa9e4066Sahrens 			    (u_longlong_t)end, segsize);
1548fa9e4066Sahrens 			if (error)
1549fa9e4066Sahrens 				break;
1550fa9e4066Sahrens 			start = end;
1551fa9e4066Sahrens 		}
1552fa9e4066Sahrens 	}
1553fa9e4066Sahrens 
1554fa9e4066Sahrens 	if (db != NULL)
1555ea8dc4b6Seschrock 		dmu_buf_rele(db, FTAG);
1556fa9e4066Sahrens }
1557fa9e4066Sahrens 
1558fa9e4066Sahrens static char *objset_types[DMU_OST_NUMTYPES] = {
1559fa9e4066Sahrens 	"NONE", "META", "ZPL", "ZVOL", "OTHER", "ANY" };
1560fa9e4066Sahrens 
1561fa9e4066Sahrens static void
1562fa9e4066Sahrens dump_dir(objset_t *os)
1563fa9e4066Sahrens {
1564fa9e4066Sahrens 	dmu_objset_stats_t dds;
1565fa9e4066Sahrens 	uint64_t object, object_count;
1566a2eea2e1Sahrens 	uint64_t refdbytes, usedobjs, scratch;
15673f9d6ad7SLin Ling 	char numbuf[32];
156814843421SMatthew Ahrens 	char blkbuf[BP_SPRINTF_LEN + 20];
1569fa9e4066Sahrens 	char osname[MAXNAMELEN];
1570fa9e4066Sahrens 	char *type = "UNKNOWN";
1571fa9e4066Sahrens 	int verbosity = dump_opt['d'];
1572fa9e4066Sahrens 	int print_header = 1;
1573fa9e4066Sahrens 	int i, error;
1574fa9e4066Sahrens 
1575a2eea2e1Sahrens 	dmu_objset_fast_stat(os, &dds);
1576fa9e4066Sahrens 
1577fa9e4066Sahrens 	if (dds.dds_type < DMU_OST_NUMTYPES)
1578fa9e4066Sahrens 		type = objset_types[dds.dds_type];
1579fa9e4066Sahrens 
1580fa9e4066Sahrens 	if (dds.dds_type == DMU_OST_META) {
1581fa9e4066Sahrens 		dds.dds_creation_txg = TXG_INITIAL;
1582503ad85cSMatthew Ahrens 		usedobjs = os->os_rootbp->blk_fill;
1583503ad85cSMatthew Ahrens 		refdbytes = os->os_spa->spa_dsl_pool->
158474e7dc98SMatthew Ahrens 		    dp_mos_dir->dd_phys->dd_used_bytes;
1585a2eea2e1Sahrens 	} else {
1586a2eea2e1Sahrens 		dmu_objset_space(os, &refdbytes, &scratch, &usedobjs, &scratch);
1587fa9e4066Sahrens 	}
1588fa9e4066Sahrens 
1589503ad85cSMatthew Ahrens 	ASSERT3U(usedobjs, ==, os->os_rootbp->blk_fill);
1590fa9e4066Sahrens 
15913f9d6ad7SLin Ling 	zdb_nicenum(refdbytes, numbuf);
1592fa9e4066Sahrens 
1593fa9e4066Sahrens 	if (verbosity >= 4) {
1594e4161df6SVictor Latushkin 		(void) sprintf(blkbuf, ", rootbp ");
1595b24ab676SJeff Bonwick 		(void) sprintf_blkptr(blkbuf + strlen(blkbuf), os->os_rootbp);
1596fa9e4066Sahrens 	} else {
1597fa9e4066Sahrens 		blkbuf[0] = '\0';
1598fa9e4066Sahrens 	}
1599fa9e4066Sahrens 
1600fa9e4066Sahrens 	dmu_objset_name(os, osname);
1601fa9e4066Sahrens 
1602a2eea2e1Sahrens 	(void) printf("Dataset %s [%s], ID %llu, cr_txg %llu, "
1603fa9e4066Sahrens 	    "%s, %llu objects%s\n",
1604fa9e4066Sahrens 	    osname, type, (u_longlong_t)dmu_objset_id(os),
1605fa9e4066Sahrens 	    (u_longlong_t)dds.dds_creation_txg,
1606a2eea2e1Sahrens 	    numbuf, (u_longlong_t)usedobjs, blkbuf);
1607fa9e4066Sahrens 
1608b24ab676SJeff Bonwick 	if (zopt_objects != 0) {
1609b24ab676SJeff Bonwick 		for (i = 0; i < zopt_objects; i++)
1610b24ab676SJeff Bonwick 			dump_object(os, zopt_object[i], verbosity,
1611b24ab676SJeff Bonwick 			    &print_header);
1612b24ab676SJeff Bonwick 		(void) printf("\n");
1613b24ab676SJeff Bonwick 		return;
1614b24ab676SJeff Bonwick 	}
1615b24ab676SJeff Bonwick 
1616b24ab676SJeff Bonwick 	if (dump_opt['i'] != 0 || verbosity >= 2)
1617b24ab676SJeff Bonwick 		dump_intent_log(dmu_objset_zil(os));
1618fa9e4066Sahrens 
1619fa9e4066Sahrens 	if (dmu_objset_ds(os) != NULL)
1620*cde58dbcSMatthew Ahrens 		dump_deadlist(&dmu_objset_ds(os)->ds_deadlist);
1621fa9e4066Sahrens 
1622fa9e4066Sahrens 	if (verbosity < 2)
1623fa9e4066Sahrens 		return;
1624fa9e4066Sahrens 
1625503ad85cSMatthew Ahrens 	if (os->os_rootbp->blk_birth == 0)
1626088f3894Sahrens 		return;
1627088f3894Sahrens 
1628fa9e4066Sahrens 	dump_object(os, 0, verbosity, &print_header);
162914843421SMatthew Ahrens 	object_count = 0;
1630503ad85cSMatthew Ahrens 	if (os->os_userused_dnode &&
1631503ad85cSMatthew Ahrens 	    os->os_userused_dnode->dn_type != 0) {
163214843421SMatthew Ahrens 		dump_object(os, DMU_USERUSED_OBJECT, verbosity, &print_header);
163314843421SMatthew Ahrens 		dump_object(os, DMU_GROUPUSED_OBJECT, verbosity, &print_header);
163414843421SMatthew Ahrens 	}
1635fa9e4066Sahrens 
1636fa9e4066Sahrens 	object = 0;
16376754306eSahrens 	while ((error = dmu_object_next(os, &object, B_FALSE, 0)) == 0) {
1638fa9e4066Sahrens 		dump_object(os, object, verbosity, &print_header);
1639fa9e4066Sahrens 		object_count++;
1640fa9e4066Sahrens 	}
1641fa9e4066Sahrens 
1642a2eea2e1Sahrens 	ASSERT3U(object_count, ==, usedobjs);
1643fa9e4066Sahrens 
1644fa9e4066Sahrens 	(void) printf("\n");
1645fa9e4066Sahrens 
1646ccba0801SRich Morris 	if (error != ESRCH) {
1647ccba0801SRich Morris 		(void) fprintf(stderr, "dmu_object_next() = %d\n", error);
1648ccba0801SRich Morris 		abort();
1649ccba0801SRich Morris 	}
1650fa9e4066Sahrens }
1651fa9e4066Sahrens 
1652fa9e4066Sahrens static void
165353b9a4a9SVictor Latushkin dump_uberblock(uberblock_t *ub, const char *header, const char *footer)
1654fa9e4066Sahrens {
1655fa9e4066Sahrens 	time_t timestamp = ub->ub_timestamp;
1656fa9e4066Sahrens 
165753b9a4a9SVictor Latushkin 	(void) printf(header ? header : "");
1658fa9e4066Sahrens 	(void) printf("\tmagic = %016llx\n", (u_longlong_t)ub->ub_magic);
1659fa9e4066Sahrens 	(void) printf("\tversion = %llu\n", (u_longlong_t)ub->ub_version);
1660fa9e4066Sahrens 	(void) printf("\ttxg = %llu\n", (u_longlong_t)ub->ub_txg);
1661fa9e4066Sahrens 	(void) printf("\tguid_sum = %llu\n", (u_longlong_t)ub->ub_guid_sum);
1662fa9e4066Sahrens 	(void) printf("\ttimestamp = %llu UTC = %s",
1663fa9e4066Sahrens 	    (u_longlong_t)ub->ub_timestamp, asctime(localtime(&timestamp)));
1664fa9e4066Sahrens 	if (dump_opt['u'] >= 3) {
1665fbabab8fSmaybee 		char blkbuf[BP_SPRINTF_LEN];
1666b24ab676SJeff Bonwick 		sprintf_blkptr(blkbuf, &ub->ub_rootbp);
1667fa9e4066Sahrens 		(void) printf("\trootbp = %s\n", blkbuf);
1668fa9e4066Sahrens 	}
166953b9a4a9SVictor Latushkin 	(void) printf(footer ? footer : "");
1670fa9e4066Sahrens }
1671fa9e4066Sahrens 
1672fa9e4066Sahrens static void
167307428bdfSVictor Latushkin dump_config(spa_t *spa)
1674fa9e4066Sahrens {
167507428bdfSVictor Latushkin 	dmu_buf_t *db;
167607428bdfSVictor Latushkin 	size_t nvsize = 0;
167707428bdfSVictor Latushkin 	int error = 0;
167807428bdfSVictor Latushkin 
1679fa9e4066Sahrens 
168007428bdfSVictor Latushkin 	error = dmu_bonus_hold(spa->spa_meta_objset,
168107428bdfSVictor Latushkin 	    spa->spa_config_object, FTAG, &db);
168207428bdfSVictor Latushkin 
168307428bdfSVictor Latushkin 	if (error == 0) {
168407428bdfSVictor Latushkin 		nvsize = *(uint64_t *)db->db_data;
168507428bdfSVictor Latushkin 		dmu_buf_rele(db, FTAG);
168607428bdfSVictor Latushkin 
168707428bdfSVictor Latushkin 		(void) printf("\nMOS Configuration:\n");
168807428bdfSVictor Latushkin 		dump_packed_nvlist(spa->spa_meta_objset,
168907428bdfSVictor Latushkin 		    spa->spa_config_object, (void *)&nvsize, 1);
169007428bdfSVictor Latushkin 	} else {
169107428bdfSVictor Latushkin 		(void) fprintf(stderr, "dmu_bonus_hold(%llu) failed, errno %d",
169207428bdfSVictor Latushkin 		    (u_longlong_t)spa->spa_config_object, error);
1693fa9e4066Sahrens 	}
1694fa9e4066Sahrens }
1695fa9e4066Sahrens 
1696c5904d13Seschrock static void
1697c5904d13Seschrock dump_cachefile(const char *cachefile)
1698c5904d13Seschrock {
1699c5904d13Seschrock 	int fd;
1700c5904d13Seschrock 	struct stat64 statbuf;
1701c5904d13Seschrock 	char *buf;
1702c5904d13Seschrock 	nvlist_t *config;
1703c5904d13Seschrock 
1704c5904d13Seschrock 	if ((fd = open64(cachefile, O_RDONLY)) < 0) {
1705c5904d13Seschrock 		(void) printf("cannot open '%s': %s\n", cachefile,
1706c5904d13Seschrock 		    strerror(errno));
1707c5904d13Seschrock 		exit(1);
1708c5904d13Seschrock 	}
1709c5904d13Seschrock 
1710c5904d13Seschrock 	if (fstat64(fd, &statbuf) != 0) {
1711c5904d13Seschrock 		(void) printf("failed to stat '%s': %s\n", cachefile,
1712c5904d13Seschrock 		    strerror(errno));
1713c5904d13Seschrock 		exit(1);
1714c5904d13Seschrock 	}
1715c5904d13Seschrock 
1716c5904d13Seschrock 	if ((buf = malloc(statbuf.st_size)) == NULL) {
1717c5904d13Seschrock 		(void) fprintf(stderr, "failed to allocate %llu bytes\n",
1718c5904d13Seschrock 		    (u_longlong_t)statbuf.st_size);
1719c5904d13Seschrock 		exit(1);
1720c5904d13Seschrock 	}
1721c5904d13Seschrock 
1722c5904d13Seschrock 	if (read(fd, buf, statbuf.st_size) != statbuf.st_size) {
1723c5904d13Seschrock 		(void) fprintf(stderr, "failed to read %llu bytes\n",
1724c5904d13Seschrock 		    (u_longlong_t)statbuf.st_size);
1725c5904d13Seschrock 		exit(1);
1726c5904d13Seschrock 	}
1727c5904d13Seschrock 
1728c5904d13Seschrock 	(void) close(fd);
1729c5904d13Seschrock 
1730c5904d13Seschrock 	if (nvlist_unpack(buf, statbuf.st_size, &config, 0) != 0) {
1731c5904d13Seschrock 		(void) fprintf(stderr, "failed to unpack nvlist\n");
1732c5904d13Seschrock 		exit(1);
1733c5904d13Seschrock 	}
1734c5904d13Seschrock 
1735c5904d13Seschrock 	free(buf);
1736c5904d13Seschrock 
1737c5904d13Seschrock 	dump_nvlist(config, 0);
1738c5904d13Seschrock 
1739c5904d13Seschrock 	nvlist_free(config);
1740c5904d13Seschrock }
1741c5904d13Seschrock 
174253b9a4a9SVictor Latushkin #define	ZDB_MAX_UB_HEADER_SIZE 32
174353b9a4a9SVictor Latushkin 
174453b9a4a9SVictor Latushkin static void
174553b9a4a9SVictor Latushkin dump_label_uberblocks(vdev_label_t *lbl, uint64_t ashift)
174653b9a4a9SVictor Latushkin {
174753b9a4a9SVictor Latushkin 	vdev_t vd;
174853b9a4a9SVictor Latushkin 	vdev_t *vdp = &vd;
174953b9a4a9SVictor Latushkin 	char header[ZDB_MAX_UB_HEADER_SIZE];
175053b9a4a9SVictor Latushkin 
175153b9a4a9SVictor Latushkin 	vd.vdev_ashift = ashift;
175253b9a4a9SVictor Latushkin 	vdp->vdev_top = vdp;
175353b9a4a9SVictor Latushkin 
175453b9a4a9SVictor Latushkin 	for (int i = 0; i < VDEV_UBERBLOCK_COUNT(vdp); i++) {
175553b9a4a9SVictor Latushkin 		uint64_t uoff = VDEV_UBERBLOCK_OFFSET(vdp, i);
175653b9a4a9SVictor Latushkin 		uberblock_t *ub = (void *)((char *)lbl + uoff);
175753b9a4a9SVictor Latushkin 
175853b9a4a9SVictor Latushkin 		if (uberblock_verify(ub))
175953b9a4a9SVictor Latushkin 			continue;
176053b9a4a9SVictor Latushkin 		(void) snprintf(header, ZDB_MAX_UB_HEADER_SIZE,
176153b9a4a9SVictor Latushkin 		    "Uberblock[%d]\n", i);
176253b9a4a9SVictor Latushkin 		dump_uberblock(ub, header, "");
176353b9a4a9SVictor Latushkin 	}
176453b9a4a9SVictor Latushkin }
176553b9a4a9SVictor Latushkin 
1766fa9e4066Sahrens static void
1767fa9e4066Sahrens dump_label(const char *dev)
1768fa9e4066Sahrens {
1769fa9e4066Sahrens 	int fd;
1770fa9e4066Sahrens 	vdev_label_t label;
1771c6065d0fSGeorge Wilson 	char *path, *buf = label.vl_vdev_phys.vp_nvlist;
1772fa9e4066Sahrens 	size_t buflen = sizeof (label.vl_vdev_phys.vp_nvlist);
1773fa9e4066Sahrens 	struct stat64 statbuf;
177453b9a4a9SVictor Latushkin 	uint64_t psize, ashift;
1775c6065d0fSGeorge Wilson 	int len = strlen(dev) + 1;
1776fa9e4066Sahrens 
1777c6065d0fSGeorge Wilson 	if (strncmp(dev, "/dev/dsk/", 9) == 0) {
1778c6065d0fSGeorge Wilson 		len++;
1779c6065d0fSGeorge Wilson 		path = malloc(len);
1780c6065d0fSGeorge Wilson 		(void) snprintf(path, len, "%s%s", "/dev/rdsk/", dev + 9);
1781c6065d0fSGeorge Wilson 	} else {
1782c6065d0fSGeorge Wilson 		path = strdup(dev);
1783c6065d0fSGeorge Wilson 	}
1784c6065d0fSGeorge Wilson 
1785c6065d0fSGeorge Wilson 	if ((fd = open64(path, O_RDONLY)) < 0) {
1786c6065d0fSGeorge Wilson 		(void) printf("cannot open '%s': %s\n", path, strerror(errno));
1787c6065d0fSGeorge Wilson 		free(path);
1788fa9e4066Sahrens 		exit(1);
1789fa9e4066Sahrens 	}
1790fa9e4066Sahrens 
1791fa9e4066Sahrens 	if (fstat64(fd, &statbuf) != 0) {
1792c6065d0fSGeorge Wilson 		(void) printf("failed to stat '%s': %s\n", path,
1793fa9e4066Sahrens 		    strerror(errno));
1794c6065d0fSGeorge Wilson 		free(path);
1795c6065d0fSGeorge Wilson 		(void) close(fd);
1796c6065d0fSGeorge Wilson 		exit(1);
1797c6065d0fSGeorge Wilson 	}
1798c6065d0fSGeorge Wilson 
1799c6065d0fSGeorge Wilson 	if (S_ISBLK(statbuf.st_mode)) {
1800c6065d0fSGeorge Wilson 		(void) printf("cannot use '%s': character device required\n",
1801c6065d0fSGeorge Wilson 		    path);
1802c6065d0fSGeorge Wilson 		free(path);
1803c6065d0fSGeorge Wilson 		(void) close(fd);
1804c6065d0fSGeorge Wilson 		exit(1);
1805fa9e4066Sahrens 	}
1806fa9e4066Sahrens 
1807fa9e4066Sahrens 	psize = statbuf.st_size;
1808fa9e4066Sahrens 	psize = P2ALIGN(psize, (uint64_t)sizeof (vdev_label_t));
1809fa9e4066Sahrens 
181053b9a4a9SVictor Latushkin 	for (int l = 0; l < VDEV_LABELS; l++) {
1811fa9e4066Sahrens 		nvlist_t *config = NULL;
1812fa9e4066Sahrens 
1813fa9e4066Sahrens 		(void) printf("--------------------------------------------\n");
1814fa9e4066Sahrens 		(void) printf("LABEL %d\n", l);
1815fa9e4066Sahrens 		(void) printf("--------------------------------------------\n");
1816fa9e4066Sahrens 
18170d981225Seschrock 		if (pread64(fd, &label, sizeof (label),
1818fa9e4066Sahrens 		    vdev_label_offset(psize, l, 0)) != sizeof (label)) {
1819fa9e4066Sahrens 			(void) printf("failed to read label %d\n", l);
1820fa9e4066Sahrens 			continue;
1821fa9e4066Sahrens 		}
1822fa9e4066Sahrens 
1823fa9e4066Sahrens 		if (nvlist_unpack(buf, buflen, &config, 0) != 0) {
1824fa9e4066Sahrens 			(void) printf("failed to unpack label %d\n", l);
182553b9a4a9SVictor Latushkin 			ashift = SPA_MINBLOCKSHIFT;
182653b9a4a9SVictor Latushkin 		} else {
182753b9a4a9SVictor Latushkin 			nvlist_t *vdev_tree = NULL;
182853b9a4a9SVictor Latushkin 
182953b9a4a9SVictor Latushkin 			dump_nvlist(config, 4);
183053b9a4a9SVictor Latushkin 			if ((nvlist_lookup_nvlist(config,
183153b9a4a9SVictor Latushkin 			    ZPOOL_CONFIG_VDEV_TREE, &vdev_tree) != 0) ||
183253b9a4a9SVictor Latushkin 			    (nvlist_lookup_uint64(vdev_tree,
183353b9a4a9SVictor Latushkin 			    ZPOOL_CONFIG_ASHIFT, &ashift) != 0))
183453b9a4a9SVictor Latushkin 				ashift = SPA_MINBLOCKSHIFT;
183553b9a4a9SVictor Latushkin 			nvlist_free(config);
1836fa9e4066Sahrens 		}
183753b9a4a9SVictor Latushkin 		if (dump_opt['u'])
183853b9a4a9SVictor Latushkin 			dump_label_uberblocks(&label, ashift);
1839fa9e4066Sahrens 	}
1840c6065d0fSGeorge Wilson 
1841c6065d0fSGeorge Wilson 	free(path);
1842c6065d0fSGeorge Wilson 	(void) close(fd);
1843fa9e4066Sahrens }
1844fa9e4066Sahrens 
1845fa9e4066Sahrens /*ARGSUSED*/
18461d452cf5Sahrens static int
1847fd136879SMatthew Ahrens dump_one_dir(const char *dsname, void *arg)
1848fa9e4066Sahrens {
1849fa9e4066Sahrens 	int error;
1850fa9e4066Sahrens 	objset_t *os;
1851fa9e4066Sahrens 
1852503ad85cSMatthew Ahrens 	error = dmu_objset_own(dsname, DMU_OST_ANY, B_TRUE, FTAG, &os);
1853fa9e4066Sahrens 	if (error) {
1854b24ab676SJeff Bonwick 		(void) printf("Could not open %s, error %d\n", dsname, error);
18551d452cf5Sahrens 		return (0);
1856fa9e4066Sahrens 	}
1857fa9e4066Sahrens 	dump_dir(os);
1858503ad85cSMatthew Ahrens 	dmu_objset_disown(os, FTAG);
1859e0d35c44Smarks 	fuid_table_destroy();
18600a586ceaSMark Shellenbaum 	sa_loaded = B_FALSE;
18611d452cf5Sahrens 	return (0);
1862fa9e4066Sahrens }
1863fa9e4066Sahrens 
1864fa9e4066Sahrens /*
1865b24ab676SJeff Bonwick  * Block statistics.
1866fa9e4066Sahrens  */
1867fa9e4066Sahrens typedef struct zdb_blkstats {
1868fa9e4066Sahrens 	uint64_t	zb_asize;
1869fa9e4066Sahrens 	uint64_t	zb_lsize;
1870fa9e4066Sahrens 	uint64_t	zb_psize;
1871fa9e4066Sahrens 	uint64_t	zb_count;
1872fa9e4066Sahrens } zdb_blkstats_t;
1873fa9e4066Sahrens 
1874b24ab676SJeff Bonwick /*
1875b24ab676SJeff Bonwick  * Extended object types to report deferred frees and dedup auto-ditto blocks.
1876b24ab676SJeff Bonwick  */
1877b24ab676SJeff Bonwick #define	ZDB_OT_DEFERRED	(DMU_OT_NUMTYPES + 0)
1878b24ab676SJeff Bonwick #define	ZDB_OT_DITTO	(DMU_OT_NUMTYPES + 1)
1879b24ab676SJeff Bonwick #define	ZDB_OT_TOTAL	(DMU_OT_NUMTYPES + 2)
1880b24ab676SJeff Bonwick 
1881b24ab676SJeff Bonwick static char *zdb_ot_extname[] = {
1882b24ab676SJeff Bonwick 	"deferred free",
1883b24ab676SJeff Bonwick 	"dedup ditto",
1884b24ab676SJeff Bonwick 	"Total",
1885b24ab676SJeff Bonwick };
1886fa9e4066Sahrens 
188788b7b0f2SMatthew Ahrens #define	ZB_TOTAL	DN_MAX_LEVELS
1888fa9e4066Sahrens 
1889fa9e4066Sahrens typedef struct zdb_cb {
1890b24ab676SJeff Bonwick 	zdb_blkstats_t	zcb_type[ZB_TOTAL + 1][ZDB_OT_TOTAL + 1];
1891b24ab676SJeff Bonwick 	uint64_t	zcb_dedup_asize;
1892b24ab676SJeff Bonwick 	uint64_t	zcb_dedup_blocks;
1893fa9e4066Sahrens 	uint64_t	zcb_errors[256];
1894fa9e4066Sahrens 	int		zcb_readfails;
1895fa9e4066Sahrens 	int		zcb_haderrors;
1896*cde58dbcSMatthew Ahrens 	spa_t		*zcb_spa;
1897fa9e4066Sahrens } zdb_cb_t;
1898fa9e4066Sahrens 
1899fa9e4066Sahrens static void
1900*cde58dbcSMatthew Ahrens zdb_count_block(zdb_cb_t *zcb, zilog_t *zilog, const blkptr_t *bp,
1901b24ab676SJeff Bonwick     dmu_object_type_t type)
1902fa9e4066Sahrens {
1903b24ab676SJeff Bonwick 	uint64_t refcnt = 0;
1904b24ab676SJeff Bonwick 
1905b24ab676SJeff Bonwick 	ASSERT(type < ZDB_OT_TOTAL);
1906b24ab676SJeff Bonwick 
1907b24ab676SJeff Bonwick 	if (zilog && zil_bp_tree_add(zilog, bp) != 0)
1908b24ab676SJeff Bonwick 		return;
1909b24ab676SJeff Bonwick 
1910e14bb325SJeff Bonwick 	for (int i = 0; i < 4; i++) {
1911fa9e4066Sahrens 		int l = (i < 2) ? BP_GET_LEVEL(bp) : ZB_TOTAL;
1912b24ab676SJeff Bonwick 		int t = (i & 1) ? type : ZDB_OT_TOTAL;
1913fa9e4066Sahrens 		zdb_blkstats_t *zb = &zcb->zcb_type[l][t];
1914fa9e4066Sahrens 
1915fa9e4066Sahrens 		zb->zb_asize += BP_GET_ASIZE(bp);
1916fa9e4066Sahrens 		zb->zb_lsize += BP_GET_LSIZE(bp);
1917fa9e4066Sahrens 		zb->zb_psize += BP_GET_PSIZE(bp);
1918fa9e4066Sahrens 		zb->zb_count++;
1919fa9e4066Sahrens 	}
1920fa9e4066Sahrens 
1921b24ab676SJeff Bonwick 	if (dump_opt['L'])
1922b24ab676SJeff Bonwick 		return;
1923b24ab676SJeff Bonwick 
1924b24ab676SJeff Bonwick 	if (BP_GET_DEDUP(bp)) {
1925b24ab676SJeff Bonwick 		ddt_t *ddt;
1926b24ab676SJeff Bonwick 		ddt_entry_t *dde;
1927b24ab676SJeff Bonwick 
1928*cde58dbcSMatthew Ahrens 		ddt = ddt_select(zcb->zcb_spa, bp);
1929b24ab676SJeff Bonwick 		ddt_enter(ddt);
1930b24ab676SJeff Bonwick 		dde = ddt_lookup(ddt, bp, B_FALSE);
1931b24ab676SJeff Bonwick 
1932b24ab676SJeff Bonwick 		if (dde == NULL) {
1933b24ab676SJeff Bonwick 			refcnt = 0;
1934b24ab676SJeff Bonwick 		} else {
1935b24ab676SJeff Bonwick 			ddt_phys_t *ddp = ddt_phys_select(dde, bp);
1936b24ab676SJeff Bonwick 			ddt_phys_decref(ddp);
1937b24ab676SJeff Bonwick 			refcnt = ddp->ddp_refcnt;
1938b24ab676SJeff Bonwick 			if (ddt_phys_total_refcnt(dde) == 0)
1939b24ab676SJeff Bonwick 				ddt_remove(ddt, dde);
1940d41e7643Sek 		}
1941b24ab676SJeff Bonwick 		ddt_exit(ddt);
1942d41e7643Sek 	}
1943d41e7643Sek 
1944*cde58dbcSMatthew Ahrens 	VERIFY3U(zio_wait(zio_claim(NULL, zcb->zcb_spa,
1945*cde58dbcSMatthew Ahrens 	    refcnt ? 0 : spa_first_txg(zcb->zcb_spa),
1946b24ab676SJeff Bonwick 	    bp, NULL, NULL, ZIO_FLAG_CANFAIL)), ==, 0);
1947fa9e4066Sahrens }
1948fa9e4066Sahrens 
19493f9d6ad7SLin Ling /* ARGSUSED */
1950fa9e4066Sahrens static int
19513f9d6ad7SLin Ling zdb_blkptr_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp, arc_buf_t *pbuf,
1952b24ab676SJeff Bonwick     const zbookmark_t *zb, const dnode_phys_t *dnp, void *arg)
1953fa9e4066Sahrens {
1954fa9e4066Sahrens 	zdb_cb_t *zcb = arg;
1955fbabab8fSmaybee 	char blkbuf[BP_SPRINTF_LEN];
19566365109dSVictor Latushkin 	dmu_object_type_t type;
1957468c413aSTim Haley 	boolean_t is_metadata;
1958fa9e4066Sahrens 
195988b7b0f2SMatthew Ahrens 	if (bp == NULL)
196088b7b0f2SMatthew Ahrens 		return (0);
1961e14bb325SJeff Bonwick 
19626365109dSVictor Latushkin 	type = BP_GET_TYPE(bp);
1963e14bb325SJeff Bonwick 
1964*cde58dbcSMatthew Ahrens 	zdb_count_block(zcb, zilog, bp, type);
19656365109dSVictor Latushkin 
1966468c413aSTim Haley 	is_metadata = (BP_GET_LEVEL(bp) != 0 || dmu_ot[type].ot_metadata);
19676365109dSVictor Latushkin 
1968b24ab676SJeff Bonwick 	if (dump_opt['c'] > 1 || (dump_opt['c'] && is_metadata)) {
1969b24ab676SJeff Bonwick 		int ioerr;
1970468c413aSTim Haley 		size_t size = BP_GET_PSIZE(bp);
1971468c413aSTim Haley 		void *data = malloc(size);
1972b24ab676SJeff Bonwick 		int flags = ZIO_FLAG_CANFAIL | ZIO_FLAG_SCRUB | ZIO_FLAG_RAW;
1973b24ab676SJeff Bonwick 
1974b24ab676SJeff Bonwick 		/* If it's an intent log block, failure is expected. */
1975b24ab676SJeff Bonwick 		if (zb->zb_level == ZB_ZIL_LEVEL)
1976b24ab676SJeff Bonwick 			flags |= ZIO_FLAG_SPECULATIVE;
1977b24ab676SJeff Bonwick 
1978b24ab676SJeff Bonwick 		ioerr = zio_wait(zio_read(NULL, spa, bp, data, size,
1979b24ab676SJeff Bonwick 		    NULL, NULL, ZIO_PRIORITY_ASYNC_READ, flags, zb));
1980b24ab676SJeff Bonwick 
198188b7b0f2SMatthew Ahrens 		free(data);
198288b7b0f2SMatthew Ahrens 
1983b24ab676SJeff Bonwick 		if (ioerr && !(flags & ZIO_FLAG_SPECULATIVE)) {
1984fa9e4066Sahrens 			zcb->zcb_haderrors = 1;
198588b7b0f2SMatthew Ahrens 			zcb->zcb_errors[ioerr]++;
1986fa9e4066Sahrens 
198788b7b0f2SMatthew Ahrens 			if (dump_opt['b'] >= 2)
1988b24ab676SJeff Bonwick 				sprintf_blkptr(blkbuf, bp);
198988b7b0f2SMatthew Ahrens 			else
199088b7b0f2SMatthew Ahrens 				blkbuf[0] = '\0';
199188b7b0f2SMatthew Ahrens 
1992b24ab676SJeff Bonwick 			(void) printf("zdb_blkptr_cb: "
1993b24ab676SJeff Bonwick 			    "Got error %d reading "
1994b24ab676SJeff Bonwick 			    "<%llu, %llu, %lld, %llx> %s -- skipping\n",
1995b24ab676SJeff Bonwick 			    ioerr,
1996b24ab676SJeff Bonwick 			    (u_longlong_t)zb->zb_objset,
1997b24ab676SJeff Bonwick 			    (u_longlong_t)zb->zb_object,
1998b24ab676SJeff Bonwick 			    (u_longlong_t)zb->zb_level,
1999b24ab676SJeff Bonwick 			    (u_longlong_t)zb->zb_blkid,
2000b24ab676SJeff Bonwick 			    blkbuf);
2001d41e7643Sek 		}
2002fa9e4066Sahrens 	}
2003fa9e4066Sahrens 
2004fa9e4066Sahrens 	zcb->zcb_readfails = 0;
2005fa9e4066Sahrens 
2006fa9e4066Sahrens 	if (dump_opt['b'] >= 4) {
2007b24ab676SJeff Bonwick 		sprintf_blkptr(blkbuf, bp);
2008b24ab676SJeff Bonwick 		(void) printf("objset %llu object %llu "
2009b24ab676SJeff Bonwick 		    "level %lld offset 0x%llx %s\n",
2010fa9e4066Sahrens 		    (u_longlong_t)zb->zb_objset,
2011fa9e4066Sahrens 		    (u_longlong_t)zb->zb_object,
2012b24ab676SJeff Bonwick 		    (longlong_t)zb->zb_level,
2013b24ab676SJeff Bonwick 		    (u_longlong_t)blkid2offset(dnp, bp, zb),
201488b7b0f2SMatthew Ahrens 		    blkbuf);
2015fa9e4066Sahrens 	}
2016fa9e4066Sahrens 
2017fa9e4066Sahrens 	return (0);
2018fa9e4066Sahrens }
2019fa9e4066Sahrens 
2020b24ab676SJeff Bonwick static void
2021b24ab676SJeff Bonwick zdb_leak(space_map_t *sm, uint64_t start, uint64_t size)
2022b24ab676SJeff Bonwick {
2023b24ab676SJeff Bonwick 	vdev_t *vd = sm->sm_ppd;
2024b24ab676SJeff Bonwick 
2025b24ab676SJeff Bonwick 	(void) printf("leaked space: vdev %llu, offset 0x%llx, size %llu\n",
2026b24ab676SJeff Bonwick 	    (u_longlong_t)vd->vdev_id, (u_longlong_t)start, (u_longlong_t)size);
2027b24ab676SJeff Bonwick }
2028b24ab676SJeff Bonwick 
2029b24ab676SJeff Bonwick /* ARGSUSED */
2030b24ab676SJeff Bonwick static void
2031b24ab676SJeff Bonwick zdb_space_map_load(space_map_t *sm)
2032b24ab676SJeff Bonwick {
2033b24ab676SJeff Bonwick }
2034b24ab676SJeff Bonwick 
2035b24ab676SJeff Bonwick static void
2036b24ab676SJeff Bonwick zdb_space_map_unload(space_map_t *sm)
2037b24ab676SJeff Bonwick {
2038b24ab676SJeff Bonwick 	space_map_vacate(sm, zdb_leak, sm);
2039b24ab676SJeff Bonwick }
2040b24ab676SJeff Bonwick 
2041b24ab676SJeff Bonwick /* ARGSUSED */
2042b24ab676SJeff Bonwick static void
2043b24ab676SJeff Bonwick zdb_space_map_claim(space_map_t *sm, uint64_t start, uint64_t size)
2044b24ab676SJeff Bonwick {
2045b24ab676SJeff Bonwick }
2046b24ab676SJeff Bonwick 
2047b24ab676SJeff Bonwick static space_map_ops_t zdb_space_map_ops = {
2048b24ab676SJeff Bonwick 	zdb_space_map_load,
2049b24ab676SJeff Bonwick 	zdb_space_map_unload,
2050b24ab676SJeff Bonwick 	NULL,	/* alloc */
2051b24ab676SJeff Bonwick 	zdb_space_map_claim,
2052b24ab676SJeff Bonwick 	NULL,	/* free */
2053b24ab676SJeff Bonwick 	NULL	/* maxsize */
2054b24ab676SJeff Bonwick };
2055b24ab676SJeff Bonwick 
2056b24ab676SJeff Bonwick static void
2057bbfd46c4SJeff Bonwick zdb_ddt_leak_init(spa_t *spa, zdb_cb_t *zcb)
2058b24ab676SJeff Bonwick {
2059bbfd46c4SJeff Bonwick 	ddt_bookmark_t ddb = { 0 };
2060b24ab676SJeff Bonwick 	ddt_entry_t dde;
2061b24ab676SJeff Bonwick 	int error;
2062b24ab676SJeff Bonwick 
2063bbfd46c4SJeff Bonwick 	while ((error = ddt_walk(spa, &ddb, &dde)) == 0) {
2064b24ab676SJeff Bonwick 		blkptr_t blk;
2065b24ab676SJeff Bonwick 		ddt_phys_t *ddp = dde.dde_phys;
2066bbfd46c4SJeff Bonwick 
2067bbfd46c4SJeff Bonwick 		if (ddb.ddb_class == DDT_CLASS_UNIQUE)
2068bbfd46c4SJeff Bonwick 			return;
2069bbfd46c4SJeff Bonwick 
2070b24ab676SJeff Bonwick 		ASSERT(ddt_phys_total_refcnt(&dde) > 1);
2071bbfd46c4SJeff Bonwick 
2072b24ab676SJeff Bonwick 		for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
2073b24ab676SJeff Bonwick 			if (ddp->ddp_phys_birth == 0)
2074b24ab676SJeff Bonwick 				continue;
2075bbfd46c4SJeff Bonwick 			ddt_bp_create(ddb.ddb_checksum,
2076bbfd46c4SJeff Bonwick 			    &dde.dde_key, ddp, &blk);
2077b24ab676SJeff Bonwick 			if (p == DDT_PHYS_DITTO) {
2078*cde58dbcSMatthew Ahrens 				zdb_count_block(zcb, NULL, &blk, ZDB_OT_DITTO);
2079b24ab676SJeff Bonwick 			} else {
2080b24ab676SJeff Bonwick 				zcb->zcb_dedup_asize +=
2081b24ab676SJeff Bonwick 				    BP_GET_ASIZE(&blk) * (ddp->ddp_refcnt - 1);
2082b24ab676SJeff Bonwick 				zcb->zcb_dedup_blocks++;
2083b24ab676SJeff Bonwick 			}
2084b24ab676SJeff Bonwick 		}
2085b24ab676SJeff Bonwick 		if (!dump_opt['L']) {
2086bbfd46c4SJeff Bonwick 			ddt_t *ddt = spa->spa_ddt[ddb.ddb_checksum];
2087b24ab676SJeff Bonwick 			ddt_enter(ddt);
2088b24ab676SJeff Bonwick 			VERIFY(ddt_lookup(ddt, &blk, B_TRUE) != NULL);
2089b24ab676SJeff Bonwick 			ddt_exit(ddt);
2090b24ab676SJeff Bonwick 		}
2091b24ab676SJeff Bonwick 	}
2092b24ab676SJeff Bonwick 
2093b24ab676SJeff Bonwick 	ASSERT(error == ENOENT);
2094b24ab676SJeff Bonwick }
2095b24ab676SJeff Bonwick 
2096b24ab676SJeff Bonwick static void
2097b24ab676SJeff Bonwick zdb_leak_init(spa_t *spa, zdb_cb_t *zcb)
2098b24ab676SJeff Bonwick {
2099*cde58dbcSMatthew Ahrens 	zcb->zcb_spa = spa;
2100*cde58dbcSMatthew Ahrens 
2101b24ab676SJeff Bonwick 	if (!dump_opt['L']) {
2102b24ab676SJeff Bonwick 		vdev_t *rvd = spa->spa_root_vdev;
2103b24ab676SJeff Bonwick 		for (int c = 0; c < rvd->vdev_children; c++) {
2104b24ab676SJeff Bonwick 			vdev_t *vd = rvd->vdev_child[c];
2105b24ab676SJeff Bonwick 			for (int m = 0; m < vd->vdev_ms_count; m++) {
2106b24ab676SJeff Bonwick 				metaslab_t *msp = vd->vdev_ms[m];
2107b24ab676SJeff Bonwick 				mutex_enter(&msp->ms_lock);
2108b24ab676SJeff Bonwick 				space_map_unload(&msp->ms_map);
2109b24ab676SJeff Bonwick 				VERIFY(space_map_load(&msp->ms_map,
2110b24ab676SJeff Bonwick 				    &zdb_space_map_ops, SM_ALLOC, &msp->ms_smo,
2111b24ab676SJeff Bonwick 				    spa->spa_meta_objset) == 0);
2112b24ab676SJeff Bonwick 				msp->ms_map.sm_ppd = vd;
2113b24ab676SJeff Bonwick 				mutex_exit(&msp->ms_lock);
2114b24ab676SJeff Bonwick 			}
2115b24ab676SJeff Bonwick 		}
2116b24ab676SJeff Bonwick 	}
2117b24ab676SJeff Bonwick 
2118b24ab676SJeff Bonwick 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
2119b24ab676SJeff Bonwick 
2120bbfd46c4SJeff Bonwick 	zdb_ddt_leak_init(spa, zcb);
2121b24ab676SJeff Bonwick 
2122b24ab676SJeff Bonwick 	spa_config_exit(spa, SCL_CONFIG, FTAG);
2123b24ab676SJeff Bonwick }
2124b24ab676SJeff Bonwick 
2125b24ab676SJeff Bonwick static void
2126b24ab676SJeff Bonwick zdb_leak_fini(spa_t *spa)
2127b24ab676SJeff Bonwick {
2128b24ab676SJeff Bonwick 	if (!dump_opt['L']) {
2129b24ab676SJeff Bonwick 		vdev_t *rvd = spa->spa_root_vdev;
2130b24ab676SJeff Bonwick 		for (int c = 0; c < rvd->vdev_children; c++) {
2131b24ab676SJeff Bonwick 			vdev_t *vd = rvd->vdev_child[c];
2132b24ab676SJeff Bonwick 			for (int m = 0; m < vd->vdev_ms_count; m++) {
2133b24ab676SJeff Bonwick 				metaslab_t *msp = vd->vdev_ms[m];
2134b24ab676SJeff Bonwick 				mutex_enter(&msp->ms_lock);
2135b24ab676SJeff Bonwick 				space_map_unload(&msp->ms_map);
2136b24ab676SJeff Bonwick 				mutex_exit(&msp->ms_lock);
2137b24ab676SJeff Bonwick 			}
2138b24ab676SJeff Bonwick 		}
2139b24ab676SJeff Bonwick 	}
2140b24ab676SJeff Bonwick }
2141b24ab676SJeff Bonwick 
2142*cde58dbcSMatthew Ahrens /* ARGSUSED */
2143*cde58dbcSMatthew Ahrens static int
2144*cde58dbcSMatthew Ahrens count_block_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
2145*cde58dbcSMatthew Ahrens {
2146*cde58dbcSMatthew Ahrens 	zdb_cb_t *zcb = arg;
2147*cde58dbcSMatthew Ahrens 
2148*cde58dbcSMatthew Ahrens 	if (dump_opt['b'] >= 4) {
2149*cde58dbcSMatthew Ahrens 		char blkbuf[BP_SPRINTF_LEN];
2150*cde58dbcSMatthew Ahrens 		sprintf_blkptr(blkbuf, bp);
2151*cde58dbcSMatthew Ahrens 		(void) printf("[%s] %s\n",
2152*cde58dbcSMatthew Ahrens 		    "deferred free", blkbuf);
2153*cde58dbcSMatthew Ahrens 	}
2154*cde58dbcSMatthew Ahrens 	zdb_count_block(zcb, NULL, bp, ZDB_OT_DEFERRED);
2155*cde58dbcSMatthew Ahrens 	return (0);
2156*cde58dbcSMatthew Ahrens }
2157*cde58dbcSMatthew Ahrens 
2158fa9e4066Sahrens static int
2159fa9e4066Sahrens dump_block_stats(spa_t *spa)
2160fa9e4066Sahrens {
2161fa9e4066Sahrens 	zdb_cb_t zcb = { 0 };
2162fa9e4066Sahrens 	zdb_blkstats_t *zb, *tzb;
2163b24ab676SJeff Bonwick 	uint64_t norm_alloc, norm_space, total_alloc, total_found;
2164cd088ea4SVictor Latushkin 	int flags = TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA | TRAVERSE_HARD;
2165fa9e4066Sahrens 	int leaks = 0;
2166fa9e4066Sahrens 
2167b24ab676SJeff Bonwick 	(void) printf("\nTraversing all blocks %s%s%s%s%s...\n",
2168b24ab676SJeff Bonwick 	    (dump_opt['c'] || !dump_opt['L']) ? "to verify " : "",
2169b24ab676SJeff Bonwick 	    (dump_opt['c'] == 1) ? "metadata " : "",
2170b24ab676SJeff Bonwick 	    dump_opt['c'] ? "checksums " : "",
2171b24ab676SJeff Bonwick 	    (dump_opt['c'] && !dump_opt['L']) ? "and verify " : "",
2172b24ab676SJeff Bonwick 	    !dump_opt['L'] ? "nothing leaked " : "");
2173fa9e4066Sahrens 
2174fa9e4066Sahrens 	/*
2175e14bb325SJeff Bonwick 	 * Load all space maps as SM_ALLOC maps, then traverse the pool
2176e14bb325SJeff Bonwick 	 * claiming each block we discover.  If the pool is perfectly
2177e14bb325SJeff Bonwick 	 * consistent, the space maps will be empty when we're done.
2178e14bb325SJeff Bonwick 	 * Anything left over is a leak; any block we can't claim (because
2179e14bb325SJeff Bonwick 	 * it's not part of any space map) is a double allocation,
2180e14bb325SJeff Bonwick 	 * reference to a freed block, or an unclaimed log block.
2181fa9e4066Sahrens 	 */
2182b24ab676SJeff Bonwick 	zdb_leak_init(spa, &zcb);
2183fa9e4066Sahrens 
2184fa9e4066Sahrens 	/*
2185fa9e4066Sahrens 	 * If there's a deferred-free bplist, process that first.
2186fa9e4066Sahrens 	 */
2187*cde58dbcSMatthew Ahrens 	(void) bpobj_iterate_nofree(&spa->spa_deferred_bpobj,
2188*cde58dbcSMatthew Ahrens 	    count_block_cb, &zcb, NULL);
2189*cde58dbcSMatthew Ahrens 	(void) bpobj_iterate_nofree(&spa->spa_dsl_pool->dp_free_bpobj,
2190*cde58dbcSMatthew Ahrens 	    count_block_cb, &zcb, NULL);
2191fa9e4066Sahrens 
2192bbfd46c4SJeff Bonwick 	if (dump_opt['c'] > 1)
2193bbfd46c4SJeff Bonwick 		flags |= TRAVERSE_PREFETCH_DATA;
2194bbfd46c4SJeff Bonwick 
2195bbfd46c4SJeff Bonwick 	zcb.zcb_haderrors |= traverse_pool(spa, 0, flags, zdb_blkptr_cb, &zcb);
2196fa9e4066Sahrens 
2197b24ab676SJeff Bonwick 	if (zcb.zcb_haderrors) {
2198fa9e4066Sahrens 		(void) printf("\nError counts:\n\n");
2199fa9e4066Sahrens 		(void) printf("\t%5s  %s\n", "errno", "count");
2200b24ab676SJeff Bonwick 		for (int e = 0; e < 256; e++) {
2201fa9e4066Sahrens 			if (zcb.zcb_errors[e] != 0) {
2202fa9e4066Sahrens 				(void) printf("\t%5d  %llu\n",
2203fa9e4066Sahrens 				    e, (u_longlong_t)zcb.zcb_errors[e]);
2204fa9e4066Sahrens 			}
2205fa9e4066Sahrens 		}
2206fa9e4066Sahrens 	}
2207fa9e4066Sahrens 
2208fa9e4066Sahrens 	/*
2209fa9e4066Sahrens 	 * Report any leaked segments.
2210fa9e4066Sahrens 	 */
2211b24ab676SJeff Bonwick 	zdb_leak_fini(spa);
2212fa9e4066Sahrens 
2213b24ab676SJeff Bonwick 	tzb = &zcb.zcb_type[ZB_TOTAL][ZDB_OT_TOTAL];
22148654d025Sperrin 
2215b24ab676SJeff Bonwick 	norm_alloc = metaslab_class_get_alloc(spa_normal_class(spa));
2216b24ab676SJeff Bonwick 	norm_space = metaslab_class_get_space(spa_normal_class(spa));
22178654d025Sperrin 
2218b24ab676SJeff Bonwick 	total_alloc = norm_alloc + metaslab_class_get_alloc(spa_log_class(spa));
2219b24ab676SJeff Bonwick 	total_found = tzb->zb_asize - zcb.zcb_dedup_asize;
2220fa9e4066Sahrens 
2221b24ab676SJeff Bonwick 	if (total_found == total_alloc) {
222282a0a985SVictor Latushkin 		if (!dump_opt['L'])
222382a0a985SVictor Latushkin 			(void) printf("\n\tNo leaks (block sum matches space"
222482a0a985SVictor Latushkin 			    " maps exactly)\n");
2225fa9e4066Sahrens 	} else {
2226fa9e4066Sahrens 		(void) printf("block traversal size %llu != alloc %llu "
222782a0a985SVictor Latushkin 		    "(%s %lld)\n",
2228b24ab676SJeff Bonwick 		    (u_longlong_t)total_found,
2229b24ab676SJeff Bonwick 		    (u_longlong_t)total_alloc,
223082a0a985SVictor Latushkin 		    (dump_opt['L']) ? "unreachable" : "leaked",
2231b24ab676SJeff Bonwick 		    (longlong_t)(total_alloc - total_found));
2232fa9e4066Sahrens 		leaks = 1;
2233fa9e4066Sahrens 	}
2234fa9e4066Sahrens 
2235fa9e4066Sahrens 	if (tzb->zb_count == 0)
2236fa9e4066Sahrens 		return (2);
2237fa9e4066Sahrens 
2238fa9e4066Sahrens 	(void) printf("\n");
2239fa9e4066Sahrens 	(void) printf("\tbp count:      %10llu\n",
2240fa9e4066Sahrens 	    (u_longlong_t)tzb->zb_count);
2241b24ab676SJeff Bonwick 	(void) printf("\tbp logical:    %10llu      avg: %6llu\n",
2242fa9e4066Sahrens 	    (u_longlong_t)tzb->zb_lsize,
2243fa9e4066Sahrens 	    (u_longlong_t)(tzb->zb_lsize / tzb->zb_count));
2244b24ab676SJeff Bonwick 	(void) printf("\tbp physical:   %10llu      avg:"
2245b24ab676SJeff Bonwick 	    " %6llu     compression: %6.2f\n",
2246fa9e4066Sahrens 	    (u_longlong_t)tzb->zb_psize,
2247fa9e4066Sahrens 	    (u_longlong_t)(tzb->zb_psize / tzb->zb_count),
2248fa9e4066Sahrens 	    (double)tzb->zb_lsize / tzb->zb_psize);
2249b24ab676SJeff Bonwick 	(void) printf("\tbp allocated:  %10llu      avg:"
2250b24ab676SJeff Bonwick 	    " %6llu     compression: %6.2f\n",
2251fa9e4066Sahrens 	    (u_longlong_t)tzb->zb_asize,
2252fa9e4066Sahrens 	    (u_longlong_t)(tzb->zb_asize / tzb->zb_count),
2253fa9e4066Sahrens 	    (double)tzb->zb_lsize / tzb->zb_asize);
2254b24ab676SJeff Bonwick 	(void) printf("\tbp deduped:    %10llu    ref>1:"
2255b24ab676SJeff Bonwick 	    " %6llu   deduplication: %6.2f\n",
2256b24ab676SJeff Bonwick 	    (u_longlong_t)zcb.zcb_dedup_asize,
2257b24ab676SJeff Bonwick 	    (u_longlong_t)zcb.zcb_dedup_blocks,
2258b24ab676SJeff Bonwick 	    (double)zcb.zcb_dedup_asize / tzb->zb_asize + 1.0);
2259b24ab676SJeff Bonwick 	(void) printf("\tSPA allocated: %10llu     used: %5.2f%%\n",
2260b24ab676SJeff Bonwick 	    (u_longlong_t)norm_alloc, 100.0 * norm_alloc / norm_space);
2261fa9e4066Sahrens 
2262fa9e4066Sahrens 	if (dump_opt['b'] >= 2) {
2263fa9e4066Sahrens 		int l, t, level;
2264fa9e4066Sahrens 		(void) printf("\nBlocks\tLSIZE\tPSIZE\tASIZE"
2265fa9e4066Sahrens 		    "\t  avg\t comp\t%%Total\tType\n");
2266fa9e4066Sahrens 
2267b24ab676SJeff Bonwick 		for (t = 0; t <= ZDB_OT_TOTAL; t++) {
22683f9d6ad7SLin Ling 			char csize[32], lsize[32], psize[32], asize[32];
22693f9d6ad7SLin Ling 			char avg[32];
2270fa9e4066Sahrens 			char *typename;
2271fa9e4066Sahrens 
2272b24ab676SJeff Bonwick 			if (t < DMU_OT_NUMTYPES)
2273b24ab676SJeff Bonwick 				typename = dmu_ot[t].ot_name;
2274b24ab676SJeff Bonwick 			else
2275b24ab676SJeff Bonwick 				typename = zdb_ot_extname[t - DMU_OT_NUMTYPES];
2276fa9e4066Sahrens 
2277fa9e4066Sahrens 			if (zcb.zcb_type[ZB_TOTAL][t].zb_asize == 0) {
2278fa9e4066Sahrens 				(void) printf("%6s\t%5s\t%5s\t%5s"
2279fa9e4066Sahrens 				    "\t%5s\t%5s\t%6s\t%s\n",
2280fa9e4066Sahrens 				    "-",
2281fa9e4066Sahrens 				    "-",
2282fa9e4066Sahrens 				    "-",
2283fa9e4066Sahrens 				    "-",
2284fa9e4066Sahrens 				    "-",
2285fa9e4066Sahrens 				    "-",
2286fa9e4066Sahrens 				    "-",
2287fa9e4066Sahrens 				    typename);
2288fa9e4066Sahrens 				continue;
2289fa9e4066Sahrens 			}
2290fa9e4066Sahrens 
2291fa9e4066Sahrens 			for (l = ZB_TOTAL - 1; l >= -1; l--) {
2292fa9e4066Sahrens 				level = (l == -1 ? ZB_TOTAL : l);
2293fa9e4066Sahrens 				zb = &zcb.zcb_type[level][t];
2294fa9e4066Sahrens 
2295fa9e4066Sahrens 				if (zb->zb_asize == 0)
2296fa9e4066Sahrens 					continue;
2297fa9e4066Sahrens 
2298fa9e4066Sahrens 				if (dump_opt['b'] < 3 && level != ZB_TOTAL)
2299fa9e4066Sahrens 					continue;
2300fa9e4066Sahrens 
2301fa9e4066Sahrens 				if (level == 0 && zb->zb_asize ==
2302fa9e4066Sahrens 				    zcb.zcb_type[ZB_TOTAL][t].zb_asize)
2303fa9e4066Sahrens 					continue;
2304fa9e4066Sahrens 
23053f9d6ad7SLin Ling 				zdb_nicenum(zb->zb_count, csize);
23063f9d6ad7SLin Ling 				zdb_nicenum(zb->zb_lsize, lsize);
23073f9d6ad7SLin Ling 				zdb_nicenum(zb->zb_psize, psize);
23083f9d6ad7SLin Ling 				zdb_nicenum(zb->zb_asize, asize);
23093f9d6ad7SLin Ling 				zdb_nicenum(zb->zb_asize / zb->zb_count, avg);
2310fa9e4066Sahrens 
2311fa9e4066Sahrens 				(void) printf("%6s\t%5s\t%5s\t%5s\t%5s"
2312fa9e4066Sahrens 				    "\t%5.2f\t%6.2f\t",
2313fa9e4066Sahrens 				    csize, lsize, psize, asize, avg,
2314fa9e4066Sahrens 				    (double)zb->zb_lsize / zb->zb_psize,
2315fa9e4066Sahrens 				    100.0 * zb->zb_asize / tzb->zb_asize);
2316fa9e4066Sahrens 
2317fa9e4066Sahrens 				if (level == ZB_TOTAL)
2318fa9e4066Sahrens 					(void) printf("%s\n", typename);
2319fa9e4066Sahrens 				else
2320fa9e4066Sahrens 					(void) printf("    L%d %s\n",
2321fa9e4066Sahrens 					    level, typename);
2322fa9e4066Sahrens 			}
2323fa9e4066Sahrens 		}
2324fa9e4066Sahrens 	}
2325fa9e4066Sahrens 
2326fa9e4066Sahrens 	(void) printf("\n");
2327fa9e4066Sahrens 
2328fa9e4066Sahrens 	if (leaks)
2329fa9e4066Sahrens 		return (2);
2330fa9e4066Sahrens 
2331fa9e4066Sahrens 	if (zcb.zcb_haderrors)
2332fa9e4066Sahrens 		return (3);
2333fa9e4066Sahrens 
2334fa9e4066Sahrens 	return (0);
2335fa9e4066Sahrens }
2336fa9e4066Sahrens 
2337b24ab676SJeff Bonwick typedef struct zdb_ddt_entry {
2338b24ab676SJeff Bonwick 	ddt_key_t	zdde_key;
2339b24ab676SJeff Bonwick 	uint64_t	zdde_ref_blocks;
2340b24ab676SJeff Bonwick 	uint64_t	zdde_ref_lsize;
2341b24ab676SJeff Bonwick 	uint64_t	zdde_ref_psize;
2342b24ab676SJeff Bonwick 	uint64_t	zdde_ref_dsize;
2343b24ab676SJeff Bonwick 	avl_node_t	zdde_node;
2344b24ab676SJeff Bonwick } zdb_ddt_entry_t;
2345b24ab676SJeff Bonwick 
2346b24ab676SJeff Bonwick /* ARGSUSED */
2347b24ab676SJeff Bonwick static int
2348b24ab676SJeff Bonwick zdb_ddt_add_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
23493f9d6ad7SLin Ling     arc_buf_t *pbuf, const zbookmark_t *zb, const dnode_phys_t *dnp, void *arg)
2350b24ab676SJeff Bonwick {
2351b24ab676SJeff Bonwick 	avl_tree_t *t = arg;
2352b24ab676SJeff Bonwick 	avl_index_t where;
2353b24ab676SJeff Bonwick 	zdb_ddt_entry_t *zdde, zdde_search;
2354b24ab676SJeff Bonwick 
2355b24ab676SJeff Bonwick 	if (bp == NULL)
2356b24ab676SJeff Bonwick 		return (0);
2357b24ab676SJeff Bonwick 
2358b24ab676SJeff Bonwick 	if (dump_opt['S'] > 1 && zb->zb_level == ZB_ROOT_LEVEL) {
2359b24ab676SJeff Bonwick 		(void) printf("traversing objset %llu, %llu objects, "
2360b24ab676SJeff Bonwick 		    "%lu blocks so far\n",
2361b24ab676SJeff Bonwick 		    (u_longlong_t)zb->zb_objset,
2362b24ab676SJeff Bonwick 		    (u_longlong_t)bp->blk_fill,
2363b24ab676SJeff Bonwick 		    avl_numnodes(t));
2364b24ab676SJeff Bonwick 	}
2365b24ab676SJeff Bonwick 
2366bbfd46c4SJeff Bonwick 	if (BP_IS_HOLE(bp) || BP_GET_CHECKSUM(bp) == ZIO_CHECKSUM_OFF ||
2367bbfd46c4SJeff Bonwick 	    BP_GET_LEVEL(bp) > 0 || dmu_ot[BP_GET_TYPE(bp)].ot_metadata)
2368b24ab676SJeff Bonwick 		return (0);
2369b24ab676SJeff Bonwick 
2370b24ab676SJeff Bonwick 	ddt_key_fill(&zdde_search.zdde_key, bp);
2371b24ab676SJeff Bonwick 
2372b24ab676SJeff Bonwick 	zdde = avl_find(t, &zdde_search, &where);
2373b24ab676SJeff Bonwick 
2374b24ab676SJeff Bonwick 	if (zdde == NULL) {
2375b24ab676SJeff Bonwick 		zdde = umem_zalloc(sizeof (*zdde), UMEM_NOFAIL);
2376b24ab676SJeff Bonwick 		zdde->zdde_key = zdde_search.zdde_key;
2377b24ab676SJeff Bonwick 		avl_insert(t, zdde, where);
2378b24ab676SJeff Bonwick 	}
2379b24ab676SJeff Bonwick 
2380b24ab676SJeff Bonwick 	zdde->zdde_ref_blocks += 1;
2381b24ab676SJeff Bonwick 	zdde->zdde_ref_lsize += BP_GET_LSIZE(bp);
2382b24ab676SJeff Bonwick 	zdde->zdde_ref_psize += BP_GET_PSIZE(bp);
2383b24ab676SJeff Bonwick 	zdde->zdde_ref_dsize += bp_get_dsize_sync(spa, bp);
2384b24ab676SJeff Bonwick 
2385b24ab676SJeff Bonwick 	return (0);
2386b24ab676SJeff Bonwick }
2387b24ab676SJeff Bonwick 
2388b24ab676SJeff Bonwick static void
2389b24ab676SJeff Bonwick dump_simulated_ddt(spa_t *spa)
2390b24ab676SJeff Bonwick {
2391b24ab676SJeff Bonwick 	avl_tree_t t;
2392b24ab676SJeff Bonwick 	void *cookie = NULL;
2393b24ab676SJeff Bonwick 	zdb_ddt_entry_t *zdde;
2394b24ab676SJeff Bonwick 	ddt_histogram_t ddh_total = { 0 };
2395b24ab676SJeff Bonwick 	ddt_stat_t dds_total = { 0 };
2396b24ab676SJeff Bonwick 
2397b24ab676SJeff Bonwick 	avl_create(&t, ddt_entry_compare,
2398b24ab676SJeff Bonwick 	    sizeof (zdb_ddt_entry_t), offsetof(zdb_ddt_entry_t, zdde_node));
2399b24ab676SJeff Bonwick 
2400b24ab676SJeff Bonwick 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
2401b24ab676SJeff Bonwick 
2402bbfd46c4SJeff Bonwick 	(void) traverse_pool(spa, 0, TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA,
2403bbfd46c4SJeff Bonwick 	    zdb_ddt_add_cb, &t);
2404b24ab676SJeff Bonwick 
2405b24ab676SJeff Bonwick 	spa_config_exit(spa, SCL_CONFIG, FTAG);
2406b24ab676SJeff Bonwick 
2407b24ab676SJeff Bonwick 	while ((zdde = avl_destroy_nodes(&t, &cookie)) != NULL) {
2408b24ab676SJeff Bonwick 		ddt_stat_t dds;
2409b24ab676SJeff Bonwick 		uint64_t refcnt = zdde->zdde_ref_blocks;
2410b24ab676SJeff Bonwick 		ASSERT(refcnt != 0);
2411b24ab676SJeff Bonwick 
2412b24ab676SJeff Bonwick 		dds.dds_blocks = zdde->zdde_ref_blocks / refcnt;
2413b24ab676SJeff Bonwick 		dds.dds_lsize = zdde->zdde_ref_lsize / refcnt;
2414b24ab676SJeff Bonwick 		dds.dds_psize = zdde->zdde_ref_psize / refcnt;
2415b24ab676SJeff Bonwick 		dds.dds_dsize = zdde->zdde_ref_dsize / refcnt;
2416b24ab676SJeff Bonwick 
2417b24ab676SJeff Bonwick 		dds.dds_ref_blocks = zdde->zdde_ref_blocks;
2418b24ab676SJeff Bonwick 		dds.dds_ref_lsize = zdde->zdde_ref_lsize;
2419b24ab676SJeff Bonwick 		dds.dds_ref_psize = zdde->zdde_ref_psize;
2420b24ab676SJeff Bonwick 		dds.dds_ref_dsize = zdde->zdde_ref_dsize;
2421b24ab676SJeff Bonwick 
2422b24ab676SJeff Bonwick 		ddt_stat_add(&ddh_total.ddh_stat[highbit(refcnt) - 1], &dds, 0);
2423b24ab676SJeff Bonwick 
2424b24ab676SJeff Bonwick 		umem_free(zdde, sizeof (*zdde));
2425b24ab676SJeff Bonwick 	}
2426b24ab676SJeff Bonwick 
2427b24ab676SJeff Bonwick 	avl_destroy(&t);
2428b24ab676SJeff Bonwick 
2429b24ab676SJeff Bonwick 	ddt_histogram_stat(&dds_total, &ddh_total);
2430b24ab676SJeff Bonwick 
2431b24ab676SJeff Bonwick 	(void) printf("Simulated DDT histogram:\n");
2432b24ab676SJeff Bonwick 
24339eb19f4dSGeorge Wilson 	zpool_dump_ddt(&dds_total, &ddh_total);
2434b24ab676SJeff Bonwick 
2435b24ab676SJeff Bonwick 	dump_dedup_ratio(&dds_total);
2436b24ab676SJeff Bonwick }
2437b24ab676SJeff Bonwick 
2438fa9e4066Sahrens static void
2439fa9e4066Sahrens dump_zpool(spa_t *spa)
2440fa9e4066Sahrens {
2441fa9e4066Sahrens 	dsl_pool_t *dp = spa_get_dsl(spa);
2442fa9e4066Sahrens 	int rc = 0;
2443fa9e4066Sahrens 
2444b24ab676SJeff Bonwick 	if (dump_opt['S']) {
2445b24ab676SJeff Bonwick 		dump_simulated_ddt(spa);
2446b24ab676SJeff Bonwick 		return;
2447b24ab676SJeff Bonwick 	}
2448b24ab676SJeff Bonwick 
244907428bdfSVictor Latushkin 	if (!dump_opt['e'] && dump_opt['C'] > 1) {
245007428bdfSVictor Latushkin 		(void) printf("\nCached configuration:\n");
245107428bdfSVictor Latushkin 		dump_nvlist(spa->spa_config, 8);
245207428bdfSVictor Latushkin 	}
245307428bdfSVictor Latushkin 
245407428bdfSVictor Latushkin 	if (dump_opt['C'])
245507428bdfSVictor Latushkin 		dump_config(spa);
245607428bdfSVictor Latushkin 
2457fa9e4066Sahrens 	if (dump_opt['u'])
245853b9a4a9SVictor Latushkin 		dump_uberblock(&spa->spa_uberblock, "\nUberblock:\n", "\n");
2459fa9e4066Sahrens 
2460b24ab676SJeff Bonwick 	if (dump_opt['D'])
2461b24ab676SJeff Bonwick 		dump_all_ddts(spa);
2462b24ab676SJeff Bonwick 
246387219db7SVictor Latushkin 	if (dump_opt['d'] > 2 || dump_opt['m'])
246487219db7SVictor Latushkin 		dump_metaslabs(spa);
246587219db7SVictor Latushkin 
246687219db7SVictor Latushkin 	if (dump_opt['d'] || dump_opt['i']) {
2467fa9e4066Sahrens 		dump_dir(dp->dp_meta_objset);
2468fa9e4066Sahrens 		if (dump_opt['d'] >= 3) {
2469*cde58dbcSMatthew Ahrens 			dump_bpobj(&spa->spa_deferred_bpobj, "Deferred frees");
2470*cde58dbcSMatthew Ahrens 			if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
2471*cde58dbcSMatthew Ahrens 				dump_bpobj(&spa->spa_dsl_pool->dp_free_bpobj,
2472*cde58dbcSMatthew Ahrens 				    "Pool frees");
2473*cde58dbcSMatthew Ahrens 			}
2474fa9e4066Sahrens 			dump_dtl(spa->spa_root_vdev, 0);
2475fa9e4066Sahrens 		}
247607428bdfSVictor Latushkin 		(void) dmu_objset_find(spa_name(spa), dump_one_dir,
247707428bdfSVictor Latushkin 		    NULL, DS_FIND_SNAPSHOTS | DS_FIND_CHILDREN);
2478fa9e4066Sahrens 	}
2479b24ab676SJeff Bonwick 	if (dump_opt['b'] || dump_opt['c'])
2480fa9e4066Sahrens 		rc = dump_block_stats(spa);
2481fa9e4066Sahrens 
2482fa9e4066Sahrens 	if (dump_opt['s'])
2483fa9e4066Sahrens 		show_pool_stats(spa);
2484fa9e4066Sahrens 
24858f18d1faSGeorge Wilson 	if (dump_opt['h'])
24868f18d1faSGeorge Wilson 		dump_history(spa);
24878f18d1faSGeorge Wilson 
2488fa9e4066Sahrens 	if (rc != 0)
2489fa9e4066Sahrens 		exit(rc);
2490fa9e4066Sahrens }
2491fa9e4066Sahrens 
249244cd46caSbillm #define	ZDB_FLAG_CHECKSUM	0x0001
249344cd46caSbillm #define	ZDB_FLAG_DECOMPRESS	0x0002
249444cd46caSbillm #define	ZDB_FLAG_BSWAP		0x0004
249544cd46caSbillm #define	ZDB_FLAG_GBH		0x0008
249644cd46caSbillm #define	ZDB_FLAG_INDIRECT	0x0010
249744cd46caSbillm #define	ZDB_FLAG_PHYS		0x0020
249844cd46caSbillm #define	ZDB_FLAG_RAW		0x0040
249944cd46caSbillm #define	ZDB_FLAG_PRINT_BLKPTR	0x0080
250044cd46caSbillm 
250144cd46caSbillm int flagbits[256];
250244cd46caSbillm 
250344cd46caSbillm static void
250444cd46caSbillm zdb_print_blkptr(blkptr_t *bp, int flags)
250544cd46caSbillm {
2506b24ab676SJeff Bonwick 	char blkbuf[BP_SPRINTF_LEN];
250744cd46caSbillm 
250844cd46caSbillm 	if (flags & ZDB_FLAG_BSWAP)
250944cd46caSbillm 		byteswap_uint64_array((void *)bp, sizeof (blkptr_t));
2510b24ab676SJeff Bonwick 
2511b24ab676SJeff Bonwick 	sprintf_blkptr(blkbuf, bp);
2512b24ab676SJeff Bonwick 	(void) printf("%s\n", blkbuf);
251344cd46caSbillm }
251444cd46caSbillm 
251544cd46caSbillm static void
251644cd46caSbillm zdb_dump_indirect(blkptr_t *bp, int nbps, int flags)
251744cd46caSbillm {
251844cd46caSbillm 	int i;
251944cd46caSbillm 
252044cd46caSbillm 	for (i = 0; i < nbps; i++)
252144cd46caSbillm 		zdb_print_blkptr(&bp[i], flags);
252244cd46caSbillm }
252344cd46caSbillm 
252444cd46caSbillm static void
252544cd46caSbillm zdb_dump_gbh(void *buf, int flags)
252644cd46caSbillm {
252744cd46caSbillm 	zdb_dump_indirect((blkptr_t *)buf, SPA_GBH_NBLKPTRS, flags);
252844cd46caSbillm }
252944cd46caSbillm 
253044cd46caSbillm static void
253144cd46caSbillm zdb_dump_block_raw(void *buf, uint64_t size, int flags)
253244cd46caSbillm {
253344cd46caSbillm 	if (flags & ZDB_FLAG_BSWAP)
253444cd46caSbillm 		byteswap_uint64_array(buf, size);
2535b24ab676SJeff Bonwick 	(void) write(1, buf, size);
253644cd46caSbillm }
253744cd46caSbillm 
253844cd46caSbillm static void
253944cd46caSbillm zdb_dump_block(char *label, void *buf, uint64_t size, int flags)
254044cd46caSbillm {
254144cd46caSbillm 	uint64_t *d = (uint64_t *)buf;
254244cd46caSbillm 	int nwords = size / sizeof (uint64_t);
254344cd46caSbillm 	int do_bswap = !!(flags & ZDB_FLAG_BSWAP);
254444cd46caSbillm 	int i, j;
254544cd46caSbillm 	char *hdr, *c;
254644cd46caSbillm 
254744cd46caSbillm 
254844cd46caSbillm 	if (do_bswap)
254944cd46caSbillm 		hdr = " 7 6 5 4 3 2 1 0   f e d c b a 9 8";
255044cd46caSbillm 	else
255144cd46caSbillm 		hdr = " 0 1 2 3 4 5 6 7   8 9 a b c d e f";
255244cd46caSbillm 
255344cd46caSbillm 	(void) printf("\n%s\n%6s   %s  0123456789abcdef\n", label, "", hdr);
255444cd46caSbillm 
255544cd46caSbillm 	for (i = 0; i < nwords; i += 2) {
255644cd46caSbillm 		(void) printf("%06llx:  %016llx  %016llx  ",
255744cd46caSbillm 		    (u_longlong_t)(i * sizeof (uint64_t)),
255844cd46caSbillm 		    (u_longlong_t)(do_bswap ? BSWAP_64(d[i]) : d[i]),
255944cd46caSbillm 		    (u_longlong_t)(do_bswap ? BSWAP_64(d[i + 1]) : d[i + 1]));
256044cd46caSbillm 
256144cd46caSbillm 		c = (char *)&d[i];
256244cd46caSbillm 		for (j = 0; j < 2 * sizeof (uint64_t); j++)
256344cd46caSbillm 			(void) printf("%c", isprint(c[j]) ? c[j] : '.');
256444cd46caSbillm 		(void) printf("\n");
256544cd46caSbillm 	}
256644cd46caSbillm }
256744cd46caSbillm 
256844cd46caSbillm /*
256944cd46caSbillm  * There are two acceptable formats:
257044cd46caSbillm  *	leaf_name	  - For example: c1t0d0 or /tmp/ztest.0a
257144cd46caSbillm  *	child[.child]*    - For example: 0.1.1
257244cd46caSbillm  *
257344cd46caSbillm  * The second form can be used to specify arbitrary vdevs anywhere
257444cd46caSbillm  * in the heirarchy.  For example, in a pool with a mirror of
257544cd46caSbillm  * RAID-Zs, you can specify either RAID-Z vdev with 0.0 or 0.1 .
257644cd46caSbillm  */
257744cd46caSbillm static vdev_t *
257844cd46caSbillm zdb_vdev_lookup(vdev_t *vdev, char *path)
257944cd46caSbillm {
258044cd46caSbillm 	char *s, *p, *q;
258144cd46caSbillm 	int i;
258244cd46caSbillm 
258344cd46caSbillm 	if (vdev == NULL)
258444cd46caSbillm 		return (NULL);
258544cd46caSbillm 
258644cd46caSbillm 	/* First, assume the x.x.x.x format */
258744cd46caSbillm 	i = (int)strtoul(path, &s, 10);
258844cd46caSbillm 	if (s == path || (s && *s != '.' && *s != '\0'))
258944cd46caSbillm 		goto name;
259044cd46caSbillm 	if (i < 0 || i >= vdev->vdev_children)
259144cd46caSbillm 		return (NULL);
259244cd46caSbillm 
259344cd46caSbillm 	vdev = vdev->vdev_child[i];
259444cd46caSbillm 	if (*s == '\0')
259544cd46caSbillm 		return (vdev);
259644cd46caSbillm 	return (zdb_vdev_lookup(vdev, s+1));
259744cd46caSbillm 
259844cd46caSbillm name:
259944cd46caSbillm 	for (i = 0; i < vdev->vdev_children; i++) {
260044cd46caSbillm 		vdev_t *vc = vdev->vdev_child[i];
260144cd46caSbillm 
260244cd46caSbillm 		if (vc->vdev_path == NULL) {
260344cd46caSbillm 			vc = zdb_vdev_lookup(vc, path);
260444cd46caSbillm 			if (vc == NULL)
260544cd46caSbillm 				continue;
260644cd46caSbillm 			else
260744cd46caSbillm 				return (vc);
260844cd46caSbillm 		}
260944cd46caSbillm 
261044cd46caSbillm 		p = strrchr(vc->vdev_path, '/');
261144cd46caSbillm 		p = p ? p + 1 : vc->vdev_path;
261244cd46caSbillm 		q = &vc->vdev_path[strlen(vc->vdev_path) - 2];
261344cd46caSbillm 
261444cd46caSbillm 		if (strcmp(vc->vdev_path, path) == 0)
261544cd46caSbillm 			return (vc);
261644cd46caSbillm 		if (strcmp(p, path) == 0)
261744cd46caSbillm 			return (vc);
261844cd46caSbillm 		if (strcmp(q, "s0") == 0 && strncmp(p, path, q - p) == 0)
261944cd46caSbillm 			return (vc);
262044cd46caSbillm 	}
262144cd46caSbillm 
262244cd46caSbillm 	return (NULL);
262344cd46caSbillm }
262444cd46caSbillm 
262544cd46caSbillm /*
262644cd46caSbillm  * Read a block from a pool and print it out.  The syntax of the
262744cd46caSbillm  * block descriptor is:
262844cd46caSbillm  *
262944cd46caSbillm  *	pool:vdev_specifier:offset:size[:flags]
263044cd46caSbillm  *
263144cd46caSbillm  *	pool           - The name of the pool you wish to read from
263244cd46caSbillm  *	vdev_specifier - Which vdev (see comment for zdb_vdev_lookup)
263344cd46caSbillm  *	offset         - offset, in hex, in bytes
263444cd46caSbillm  *	size           - Amount of data to read, in hex, in bytes
263544cd46caSbillm  *	flags          - A string of characters specifying options
263644cd46caSbillm  *		 b: Decode a blkptr at given offset within block
263744cd46caSbillm  *		*c: Calculate and display checksums
2638b24ab676SJeff Bonwick  *		 d: Decompress data before dumping
263944cd46caSbillm  *		 e: Byteswap data before dumping
2640b24ab676SJeff Bonwick  *		 g: Display data as a gang block header
2641b24ab676SJeff Bonwick  *		 i: Display as an indirect block
264244cd46caSbillm  *		 p: Do I/O to physical offset
264344cd46caSbillm  *		 r: Dump raw data to stdout
264444cd46caSbillm  *
264544cd46caSbillm  *              * = not yet implemented
264644cd46caSbillm  */
264744cd46caSbillm static void
264807428bdfSVictor Latushkin zdb_read_block(char *thing, spa_t *spa)
264944cd46caSbillm {
2650b24ab676SJeff Bonwick 	blkptr_t blk, *bp = &blk;
2651b24ab676SJeff Bonwick 	dva_t *dva = bp->blk_dva;
265244cd46caSbillm 	int flags = 0;
2653b24ab676SJeff Bonwick 	uint64_t offset = 0, size = 0, psize = 0, lsize = 0, blkptr_offset = 0;
265444cd46caSbillm 	zio_t *zio;
265544cd46caSbillm 	vdev_t *vd;
2656b24ab676SJeff Bonwick 	void *pbuf, *lbuf, *buf;
265707428bdfSVictor Latushkin 	char *s, *p, *dup, *vdev, *flagstr;
2658b24ab676SJeff Bonwick 	int i, error;
265944cd46caSbillm 
266044cd46caSbillm 	dup = strdup(thing);
266144cd46caSbillm 	s = strtok(dup, ":");
266244cd46caSbillm 	vdev = s ? s : "";
266344cd46caSbillm 	s = strtok(NULL, ":");
266444cd46caSbillm 	offset = strtoull(s ? s : "", NULL, 16);
266544cd46caSbillm 	s = strtok(NULL, ":");
266644cd46caSbillm 	size = strtoull(s ? s : "", NULL, 16);
266744cd46caSbillm 	s = strtok(NULL, ":");
266844cd46caSbillm 	flagstr = s ? s : "";
266944cd46caSbillm 
267044cd46caSbillm 	s = NULL;
267144cd46caSbillm 	if (size == 0)
267244cd46caSbillm 		s = "size must not be zero";
267344cd46caSbillm 	if (!IS_P2ALIGNED(size, DEV_BSIZE))
267444cd46caSbillm 		s = "size must be a multiple of sector size";
267544cd46caSbillm 	if (!IS_P2ALIGNED(offset, DEV_BSIZE))
267644cd46caSbillm 		s = "offset must be a multiple of sector size";
267744cd46caSbillm 	if (s) {
267844cd46caSbillm 		(void) printf("Invalid block specifier: %s  - %s\n", thing, s);
267944cd46caSbillm 		free(dup);
268044cd46caSbillm 		return;
268144cd46caSbillm 	}
268244cd46caSbillm 
268344cd46caSbillm 	for (s = strtok(flagstr, ":"); s; s = strtok(NULL, ":")) {
268444cd46caSbillm 		for (i = 0; flagstr[i]; i++) {
26855ad82045Snd 			int bit = flagbits[(uchar_t)flagstr[i]];
268644cd46caSbillm 
268744cd46caSbillm 			if (bit == 0) {
268844cd46caSbillm 				(void) printf("***Invalid flag: %c\n",
268944cd46caSbillm 				    flagstr[i]);
269044cd46caSbillm 				continue;
269144cd46caSbillm 			}
269244cd46caSbillm 			flags |= bit;
269344cd46caSbillm 
269444cd46caSbillm 			/* If it's not something with an argument, keep going */
2695b24ab676SJeff Bonwick 			if ((bit & (ZDB_FLAG_CHECKSUM |
269644cd46caSbillm 			    ZDB_FLAG_PRINT_BLKPTR)) == 0)
269744cd46caSbillm 				continue;
269844cd46caSbillm 
269944cd46caSbillm 			p = &flagstr[i + 1];
270044cd46caSbillm 			if (bit == ZDB_FLAG_PRINT_BLKPTR)
270144cd46caSbillm 				blkptr_offset = strtoull(p, &p, 16);
270244cd46caSbillm 			if (*p != ':' && *p != '\0') {
270344cd46caSbillm 				(void) printf("***Invalid flag arg: '%s'\n", s);
270444cd46caSbillm 				free(dup);
270544cd46caSbillm 				return;
270644cd46caSbillm 			}
270744cd46caSbillm 		}
270844cd46caSbillm 	}
270944cd46caSbillm 
271044cd46caSbillm 	vd = zdb_vdev_lookup(spa->spa_root_vdev, vdev);
271144cd46caSbillm 	if (vd == NULL) {
271244cd46caSbillm 		(void) printf("***Invalid vdev: %s\n", vdev);
271344cd46caSbillm 		free(dup);
271444cd46caSbillm 		return;
271544cd46caSbillm 	} else {
271644cd46caSbillm 		if (vd->vdev_path)
2717b24ab676SJeff Bonwick 			(void) fprintf(stderr, "Found vdev: %s\n",
2718b24ab676SJeff Bonwick 			    vd->vdev_path);
271944cd46caSbillm 		else
2720b24ab676SJeff Bonwick 			(void) fprintf(stderr, "Found vdev type: %s\n",
272144cd46caSbillm 			    vd->vdev_ops->vdev_op_type);
272244cd46caSbillm 	}
272344cd46caSbillm 
2724b24ab676SJeff Bonwick 	psize = size;
2725b24ab676SJeff Bonwick 	lsize = size;
272644cd46caSbillm 
2727b24ab676SJeff Bonwick 	pbuf = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
2728b24ab676SJeff Bonwick 	lbuf = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
2729b24ab676SJeff Bonwick 
2730b24ab676SJeff Bonwick 	BP_ZERO(bp);
2731b24ab676SJeff Bonwick 
2732b24ab676SJeff Bonwick 	DVA_SET_VDEV(&dva[0], vd->vdev_id);
2733b24ab676SJeff Bonwick 	DVA_SET_OFFSET(&dva[0], offset);
2734b24ab676SJeff Bonwick 	DVA_SET_GANG(&dva[0], !!(flags & ZDB_FLAG_GBH));
2735b24ab676SJeff Bonwick 	DVA_SET_ASIZE(&dva[0], vdev_psize_to_asize(vd, psize));
2736b24ab676SJeff Bonwick 
2737b24ab676SJeff Bonwick 	BP_SET_BIRTH(bp, TXG_INITIAL, TXG_INITIAL);
2738b24ab676SJeff Bonwick 
2739b24ab676SJeff Bonwick 	BP_SET_LSIZE(bp, lsize);
2740b24ab676SJeff Bonwick 	BP_SET_PSIZE(bp, psize);
2741b24ab676SJeff Bonwick 	BP_SET_COMPRESS(bp, ZIO_COMPRESS_OFF);
2742b24ab676SJeff Bonwick 	BP_SET_CHECKSUM(bp, ZIO_CHECKSUM_OFF);
2743b24ab676SJeff Bonwick 	BP_SET_TYPE(bp, DMU_OT_NONE);
2744b24ab676SJeff Bonwick 	BP_SET_LEVEL(bp, 0);
2745b24ab676SJeff Bonwick 	BP_SET_DEDUP(bp, 0);
2746b24ab676SJeff Bonwick 	BP_SET_BYTEORDER(bp, ZFS_HOST_BYTEORDER);
274744cd46caSbillm 
2748e14bb325SJeff Bonwick 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
274944cd46caSbillm 	zio = zio_root(spa, NULL, NULL, 0);
2750b24ab676SJeff Bonwick 
2751b24ab676SJeff Bonwick 	if (vd == vd->vdev_top) {
2752b24ab676SJeff Bonwick 		/*
2753b24ab676SJeff Bonwick 		 * Treat this as a normal block read.
2754b24ab676SJeff Bonwick 		 */
2755b24ab676SJeff Bonwick 		zio_nowait(zio_read(zio, spa, bp, pbuf, psize, NULL, NULL,
2756b24ab676SJeff Bonwick 		    ZIO_PRIORITY_SYNC_READ,
2757b24ab676SJeff Bonwick 		    ZIO_FLAG_CANFAIL | ZIO_FLAG_RAW, NULL));
2758b24ab676SJeff Bonwick 	} else {
2759b24ab676SJeff Bonwick 		/*
2760b24ab676SJeff Bonwick 		 * Treat this as a vdev child I/O.
2761b24ab676SJeff Bonwick 		 */
2762b24ab676SJeff Bonwick 		zio_nowait(zio_vdev_child_io(zio, bp, vd, offset, pbuf, psize,
2763b24ab676SJeff Bonwick 		    ZIO_TYPE_READ, ZIO_PRIORITY_SYNC_READ,
2764b24ab676SJeff Bonwick 		    ZIO_FLAG_DONT_CACHE | ZIO_FLAG_DONT_QUEUE |
2765b24ab676SJeff Bonwick 		    ZIO_FLAG_DONT_PROPAGATE | ZIO_FLAG_DONT_RETRY |
2766b24ab676SJeff Bonwick 		    ZIO_FLAG_CANFAIL | ZIO_FLAG_RAW, NULL, NULL));
2767b24ab676SJeff Bonwick 	}
2768b24ab676SJeff Bonwick 
276944cd46caSbillm 	error = zio_wait(zio);
2770e14bb325SJeff Bonwick 	spa_config_exit(spa, SCL_STATE, FTAG);
277144cd46caSbillm 
277244cd46caSbillm 	if (error) {
277344cd46caSbillm 		(void) printf("Read of %s failed, error: %d\n", thing, error);
277444cd46caSbillm 		goto out;
277544cd46caSbillm 	}
277644cd46caSbillm 
2777b24ab676SJeff Bonwick 	if (flags & ZDB_FLAG_DECOMPRESS) {
2778b24ab676SJeff Bonwick 		/*
2779b24ab676SJeff Bonwick 		 * We don't know how the data was compressed, so just try
2780b24ab676SJeff Bonwick 		 * every decompress function at every inflated blocksize.
2781b24ab676SJeff Bonwick 		 */
2782b24ab676SJeff Bonwick 		enum zio_compress c;
2783b24ab676SJeff Bonwick 		void *pbuf2 = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
2784b24ab676SJeff Bonwick 		void *lbuf2 = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
2785b24ab676SJeff Bonwick 
2786b24ab676SJeff Bonwick 		bcopy(pbuf, pbuf2, psize);
2787b24ab676SJeff Bonwick 
2788b24ab676SJeff Bonwick 		VERIFY(random_get_pseudo_bytes((uint8_t *)pbuf + psize,
2789b24ab676SJeff Bonwick 		    SPA_MAXBLOCKSIZE - psize) == 0);
2790b24ab676SJeff Bonwick 
2791b24ab676SJeff Bonwick 		VERIFY(random_get_pseudo_bytes((uint8_t *)pbuf2 + psize,
2792b24ab676SJeff Bonwick 		    SPA_MAXBLOCKSIZE - psize) == 0);
2793b24ab676SJeff Bonwick 
2794b24ab676SJeff Bonwick 		for (lsize = SPA_MAXBLOCKSIZE; lsize > psize;
2795b24ab676SJeff Bonwick 		    lsize -= SPA_MINBLOCKSIZE) {
2796b24ab676SJeff Bonwick 			for (c = 0; c < ZIO_COMPRESS_FUNCTIONS; c++) {
2797b24ab676SJeff Bonwick 				if (zio_decompress_data(c, pbuf, lbuf,
2798b24ab676SJeff Bonwick 				    psize, lsize) == 0 &&
2799b24ab676SJeff Bonwick 				    zio_decompress_data(c, pbuf2, lbuf2,
2800b24ab676SJeff Bonwick 				    psize, lsize) == 0 &&
2801b24ab676SJeff Bonwick 				    bcmp(lbuf, lbuf2, lsize) == 0)
2802b24ab676SJeff Bonwick 					break;
2803b24ab676SJeff Bonwick 			}
2804b24ab676SJeff Bonwick 			if (c != ZIO_COMPRESS_FUNCTIONS)
2805b24ab676SJeff Bonwick 				break;
2806b24ab676SJeff Bonwick 			lsize -= SPA_MINBLOCKSIZE;
2807b24ab676SJeff Bonwick 		}
2808b24ab676SJeff Bonwick 
2809b24ab676SJeff Bonwick 		umem_free(pbuf2, SPA_MAXBLOCKSIZE);
2810b24ab676SJeff Bonwick 		umem_free(lbuf2, SPA_MAXBLOCKSIZE);
2811b24ab676SJeff Bonwick 
2812b24ab676SJeff Bonwick 		if (lsize <= psize) {
2813b24ab676SJeff Bonwick 			(void) printf("Decompress of %s failed\n", thing);
2814b24ab676SJeff Bonwick 			goto out;
2815b24ab676SJeff Bonwick 		}
2816b24ab676SJeff Bonwick 		buf = lbuf;
2817b24ab676SJeff Bonwick 		size = lsize;
2818b24ab676SJeff Bonwick 	} else {
2819b24ab676SJeff Bonwick 		buf = pbuf;
2820b24ab676SJeff Bonwick 		size = psize;
2821b24ab676SJeff Bonwick 	}
2822b24ab676SJeff Bonwick 
282344cd46caSbillm 	if (flags & ZDB_FLAG_PRINT_BLKPTR)
282444cd46caSbillm 		zdb_print_blkptr((blkptr_t *)(void *)
282544cd46caSbillm 		    ((uintptr_t)buf + (uintptr_t)blkptr_offset), flags);
282644cd46caSbillm 	else if (flags & ZDB_FLAG_RAW)
282744cd46caSbillm 		zdb_dump_block_raw(buf, size, flags);
282844cd46caSbillm 	else if (flags & ZDB_FLAG_INDIRECT)
282944cd46caSbillm 		zdb_dump_indirect((blkptr_t *)buf, size / sizeof (blkptr_t),
283044cd46caSbillm 		    flags);
283144cd46caSbillm 	else if (flags & ZDB_FLAG_GBH)
283244cd46caSbillm 		zdb_dump_gbh(buf, flags);
283344cd46caSbillm 	else
283444cd46caSbillm 		zdb_dump_block(thing, buf, size, flags);
283544cd46caSbillm 
283644cd46caSbillm out:
2837b24ab676SJeff Bonwick 	umem_free(pbuf, SPA_MAXBLOCKSIZE);
2838b24ab676SJeff Bonwick 	umem_free(lbuf, SPA_MAXBLOCKSIZE);
283944cd46caSbillm 	free(dup);
284044cd46caSbillm }
284144cd46caSbillm 
2842de6628f0Sck static boolean_t
28433ad6c7f9SVictor Latushkin pool_match(nvlist_t *cfg, char *tgt)
2844de6628f0Sck {
28453ad6c7f9SVictor Latushkin 	uint64_t v, guid = strtoull(tgt, NULL, 0);
2846de6628f0Sck 	char *s;
2847de6628f0Sck 
2848de6628f0Sck 	if (guid != 0) {
28493ad6c7f9SVictor Latushkin 		if (nvlist_lookup_uint64(cfg, ZPOOL_CONFIG_POOL_GUID, &v) == 0)
28503ad6c7f9SVictor Latushkin 			return (v == guid);
2851de6628f0Sck 	} else {
28523ad6c7f9SVictor Latushkin 		if (nvlist_lookup_string(cfg, ZPOOL_CONFIG_POOL_NAME, &s) == 0)
28533ad6c7f9SVictor Latushkin 			return (strcmp(s, tgt) == 0);
2854de6628f0Sck 	}
28553ad6c7f9SVictor Latushkin 	return (B_FALSE);
2856de6628f0Sck }
2857de6628f0Sck 
28583ad6c7f9SVictor Latushkin static char *
28593ad6c7f9SVictor Latushkin find_zpool(char **target, nvlist_t **configp, int dirc, char **dirv)
2860de6628f0Sck {
2861de6628f0Sck 	nvlist_t *pools;
2862de6628f0Sck 	nvlist_t *match = NULL;
28633ad6c7f9SVictor Latushkin 	char *name = NULL;
28643ad6c7f9SVictor Latushkin 	char *sepp = NULL;
28653ad6c7f9SVictor Latushkin 	char sep;
28663ad6c7f9SVictor Latushkin 	int count = 0;
2867d41c4376SMark J Musante 	importargs_t args = { 0 };
2868d41c4376SMark J Musante 
2869d41c4376SMark J Musante 	args.paths = dirc;
2870d41c4376SMark J Musante 	args.path = dirv;
2871d41c4376SMark J Musante 	args.can_be_active = B_TRUE;
2872de6628f0Sck 
28733ad6c7f9SVictor Latushkin 	if ((sepp = strpbrk(*target, "/@")) != NULL) {
28743ad6c7f9SVictor Latushkin 		sep = *sepp;
28753ad6c7f9SVictor Latushkin 		*sepp = '\0';
28763ad6c7f9SVictor Latushkin 	}
28773ad6c7f9SVictor Latushkin 
2878d41c4376SMark J Musante 	pools = zpool_search_import(g_zfs, &args);
2879de6628f0Sck 
2880de6628f0Sck 	if (pools != NULL) {
2881de6628f0Sck 		nvpair_t *elem = NULL;
2882de6628f0Sck 		while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) {
2883de6628f0Sck 			verify(nvpair_value_nvlist(elem, configp) == 0);
28843ad6c7f9SVictor Latushkin 			if (pool_match(*configp, *target)) {
28853ad6c7f9SVictor Latushkin 				count++;
2886de6628f0Sck 				if (match != NULL) {
28873ad6c7f9SVictor Latushkin 					/* print previously found config */
28883ad6c7f9SVictor Latushkin 					if (name != NULL) {
28893ad6c7f9SVictor Latushkin 						(void) printf("%s\n", name);
28903ad6c7f9SVictor Latushkin 						dump_nvlist(match, 8);
28913ad6c7f9SVictor Latushkin 						name = NULL;
28923ad6c7f9SVictor Latushkin 					}
28933ad6c7f9SVictor Latushkin 					(void) printf("%s\n",
28943ad6c7f9SVictor Latushkin 					    nvpair_name(elem));
28953ad6c7f9SVictor Latushkin 					dump_nvlist(*configp, 8);
2896de6628f0Sck 				} else {
2897de6628f0Sck 					match = *configp;
28983ad6c7f9SVictor Latushkin 					name = nvpair_name(elem);
2899de6628f0Sck 				}
2900de6628f0Sck 			}
2901de6628f0Sck 		}
2902de6628f0Sck 	}
29033ad6c7f9SVictor Latushkin 	if (count > 1)
29043ad6c7f9SVictor Latushkin 		(void) fatal("\tMatched %d pools - use pool GUID "
29053ad6c7f9SVictor Latushkin 		    "instead of pool name or \n"
29063ad6c7f9SVictor Latushkin 		    "\tpool name part of a dataset name to select pool", count);
29073ad6c7f9SVictor Latushkin 
29083ad6c7f9SVictor Latushkin 	if (sepp)
29093ad6c7f9SVictor Latushkin 		*sepp = sep;
29103ad6c7f9SVictor Latushkin 	/*
29113ad6c7f9SVictor Latushkin 	 * If pool GUID was specified for pool id, replace it with pool name
29123ad6c7f9SVictor Latushkin 	 */
29133ad6c7f9SVictor Latushkin 	if (name && (strstr(*target, name) != *target)) {
29143ad6c7f9SVictor Latushkin 		int sz = 1 + strlen(name) + ((sepp) ? strlen(sepp) : 0);
29153ad6c7f9SVictor Latushkin 
29163ad6c7f9SVictor Latushkin 		*target = umem_alloc(sz, UMEM_NOFAIL);
29173ad6c7f9SVictor Latushkin 		(void) snprintf(*target, sz, "%s%s", name, sepp ? sepp : "");
29183ad6c7f9SVictor Latushkin 	}
2919de6628f0Sck 
29203ad6c7f9SVictor Latushkin 	*configp = name ? match : NULL;
2921de6628f0Sck 
29223ad6c7f9SVictor Latushkin 	return (name);
2923de6628f0Sck }
2924de6628f0Sck 
2925fa9e4066Sahrens int
2926fa9e4066Sahrens main(int argc, char **argv)
2927fa9e4066Sahrens {
2928fa9e4066Sahrens 	int i, c;
2929fa9e4066Sahrens 	struct rlimit rl = { 1024, 1024 };
29303ad6c7f9SVictor Latushkin 	spa_t *spa = NULL;
2931fa9e4066Sahrens 	objset_t *os = NULL;
2932fa9e4066Sahrens 	int dump_all = 1;
2933fa9e4066Sahrens 	int verbose = 0;
2934c8ee1847SVictor Latushkin 	int error = 0;
29353ad6c7f9SVictor Latushkin 	char **searchdirs = NULL;
29363ad6c7f9SVictor Latushkin 	int nsearch = 0;
29373ad6c7f9SVictor Latushkin 	char *target;
2938468c413aSTim Haley 	nvlist_t *policy = NULL;
2939468c413aSTim Haley 	uint64_t max_txg = UINT64_MAX;
2940c8ee1847SVictor Latushkin 	int rewind = ZPOOL_NEVER_REWIND;
2941fa9e4066Sahrens 
2942fa9e4066Sahrens 	(void) setrlimit(RLIMIT_NOFILE, &rl);
2943004388ebScasper 	(void) enable_extended_FILE_stdio(-1, -1);
2944fa9e4066Sahrens 
2945fa9e4066Sahrens 	dprintf_setup(&argc, argv);
2946fa9e4066Sahrens 
29473f9d6ad7SLin Ling 	while ((c = getopt(argc, argv, "bcdhilmsuCDRSAFLXevp:t:U:P")) != -1) {
2948fa9e4066Sahrens 		switch (c) {
2949fa9e4066Sahrens 		case 'b':
2950fa9e4066Sahrens 		case 'c':
2951b24ab676SJeff Bonwick 		case 'd':
2952b24ab676SJeff Bonwick 		case 'h':
2953b24ab676SJeff Bonwick 		case 'i':
2954b24ab676SJeff Bonwick 		case 'l':
2955d6e555bdSGeorge Wilson 		case 'm':
2956fa9e4066Sahrens 		case 's':
2957b24ab676SJeff Bonwick 		case 'u':
2958fa9e4066Sahrens 		case 'C':
2959b24ab676SJeff Bonwick 		case 'D':
296044cd46caSbillm 		case 'R':
2961b24ab676SJeff Bonwick 		case 'S':
2962fa9e4066Sahrens 			dump_opt[c]++;
2963fa9e4066Sahrens 			dump_all = 0;
2964fa9e4066Sahrens 			break;
2965feef89cfSVictor Latushkin 		case 'A':
2966c8ee1847SVictor Latushkin 		case 'F':
296782a0a985SVictor Latushkin 		case 'L':
2968c8ee1847SVictor Latushkin 		case 'X':
29693ad6c7f9SVictor Latushkin 		case 'e':
29703f9d6ad7SLin Ling 		case 'P':
297182a0a985SVictor Latushkin 			dump_opt[c]++;
297282a0a985SVictor Latushkin 			break;
2973fa9e4066Sahrens 		case 'v':
2974fa9e4066Sahrens 			verbose++;
2975fa9e4066Sahrens 			break;
2976de6628f0Sck 		case 'p':
29773ad6c7f9SVictor Latushkin 			if (searchdirs == NULL) {
29783ad6c7f9SVictor Latushkin 				searchdirs = umem_alloc(sizeof (char *),
29793ad6c7f9SVictor Latushkin 				    UMEM_NOFAIL);
29803ad6c7f9SVictor Latushkin 			} else {
29813ad6c7f9SVictor Latushkin 				char **tmp = umem_alloc((nsearch + 1) *
29823ad6c7f9SVictor Latushkin 				    sizeof (char *), UMEM_NOFAIL);
29833ad6c7f9SVictor Latushkin 				bcopy(searchdirs, tmp, nsearch *
29843ad6c7f9SVictor Latushkin 				    sizeof (char *));
29853ad6c7f9SVictor Latushkin 				umem_free(searchdirs,
29863ad6c7f9SVictor Latushkin 				    nsearch * sizeof (char *));
29873ad6c7f9SVictor Latushkin 				searchdirs = tmp;
29883ad6c7f9SVictor Latushkin 			}
29893ad6c7f9SVictor Latushkin 			searchdirs[nsearch++] = optarg;
2990de6628f0Sck 			break;
29912e551927SVictor Latushkin 		case 't':
2992468c413aSTim Haley 			max_txg = strtoull(optarg, NULL, 0);
2993468c413aSTim Haley 			if (max_txg < TXG_INITIAL) {
29942e551927SVictor Latushkin 				(void) fprintf(stderr, "incorrect txg "
29952e551927SVictor Latushkin 				    "specified: %s\n", optarg);
29962e551927SVictor Latushkin 				usage();
29972e551927SVictor Latushkin 			}
29982e551927SVictor Latushkin 			break;
2999b24ab676SJeff Bonwick 		case 'U':
3000b24ab676SJeff Bonwick 			spa_config_path = optarg;
3001b24ab676SJeff Bonwick 			break;
3002fa9e4066Sahrens 		default:
3003fa9e4066Sahrens 			usage();
3004fa9e4066Sahrens 			break;
3005fa9e4066Sahrens 		}
3006fa9e4066Sahrens 	}
3007fa9e4066Sahrens 
30083ad6c7f9SVictor Latushkin 	if (!dump_opt['e'] && searchdirs != NULL) {
300988b7b0f2SMatthew Ahrens 		(void) fprintf(stderr, "-p option requires use of -e\n");
301088b7b0f2SMatthew Ahrens 		usage();
301188b7b0f2SMatthew Ahrens 	}
3012de6628f0Sck 
3013fa9e4066Sahrens 	kernel_init(FREAD);
3014de6628f0Sck 	g_zfs = libzfs_init();
301591ebeef5Sahrens 	ASSERT(g_zfs != NULL);
3016fa9e4066Sahrens 
3017b24ab676SJeff Bonwick 	if (dump_all)
3018b24ab676SJeff Bonwick 		verbose = MAX(verbose, 1);
3019b24ab676SJeff Bonwick 
3020fa9e4066Sahrens 	for (c = 0; c < 256; c++) {
30213f9d6ad7SLin Ling 		if (dump_all && !strchr("elAFLRSXP", c))
3022fa9e4066Sahrens 			dump_opt[c] = 1;
3023fa9e4066Sahrens 		if (dump_opt[c])
3024fa9e4066Sahrens 			dump_opt[c] += verbose;
3025fa9e4066Sahrens 	}
3026fa9e4066Sahrens 
3027feef89cfSVictor Latushkin 	aok = (dump_opt['A'] == 1) || (dump_opt['A'] > 2);
3028feef89cfSVictor Latushkin 	zfs_recover = (dump_opt['A'] > 1);
3029feef89cfSVictor Latushkin 
3030fa9e4066Sahrens 	argc -= optind;
3031fa9e4066Sahrens 	argv += optind;
3032fa9e4066Sahrens 
303307428bdfSVictor Latushkin 	if (argc < 2 && dump_opt['R'])
303407428bdfSVictor Latushkin 		usage();
3035fa9e4066Sahrens 	if (argc < 1) {
30363ad6c7f9SVictor Latushkin 		if (!dump_opt['e'] && dump_opt['C']) {
3037e829d913Sck 			dump_cachefile(spa_config_path);
3038fa9e4066Sahrens 			return (0);
3039fa9e4066Sahrens 		}
3040fa9e4066Sahrens 		usage();
3041fa9e4066Sahrens 	}
3042fa9e4066Sahrens 
3043fa9e4066Sahrens 	if (dump_opt['l']) {
3044fa9e4066Sahrens 		dump_label(argv[0]);
3045fa9e4066Sahrens 		return (0);
3046fa9e4066Sahrens 	}
3047fa9e4066Sahrens 
3048c8ee1847SVictor Latushkin 	if (dump_opt['X'] || dump_opt['F'])
3049c8ee1847SVictor Latushkin 		rewind = ZPOOL_DO_REWIND |
3050c8ee1847SVictor Latushkin 		    (dump_opt['X'] ? ZPOOL_EXTREME_REWIND : 0);
3051c8ee1847SVictor Latushkin 
3052c8ee1847SVictor Latushkin 	if (nvlist_alloc(&policy, NV_UNIQUE_NAME_TYPE, 0) != 0 ||
3053c8ee1847SVictor Latushkin 	    nvlist_add_uint64(policy, ZPOOL_REWIND_REQUEST_TXG, max_txg) != 0 ||
3054c8ee1847SVictor Latushkin 	    nvlist_add_uint32(policy, ZPOOL_REWIND_REQUEST, rewind) != 0)
3055c8ee1847SVictor Latushkin 		fatal("internal error: %s", strerror(ENOMEM));
3056c8ee1847SVictor Latushkin 
3057c5904d13Seschrock 	error = 0;
30583ad6c7f9SVictor Latushkin 	target = argv[0];
3059990b4856Slling 
30603ad6c7f9SVictor Latushkin 	if (dump_opt['e']) {
30613ad6c7f9SVictor Latushkin 		nvlist_t *cfg = NULL;
30623ad6c7f9SVictor Latushkin 		char *name = find_zpool(&target, &cfg, nsearch, searchdirs);
3063990b4856Slling 
30643ad6c7f9SVictor Latushkin 		error = ENOENT;
30653ad6c7f9SVictor Latushkin 		if (name) {
306607428bdfSVictor Latushkin 			if (dump_opt['C'] > 1) {
306707428bdfSVictor Latushkin 				(void) printf("\nConfiguration for import:\n");
306807428bdfSVictor Latushkin 				dump_nvlist(cfg, 8);
306907428bdfSVictor Latushkin 			}
3070c8ee1847SVictor Latushkin 			if (nvlist_add_nvlist(cfg,
3071468c413aSTim Haley 			    ZPOOL_REWIND_POLICY, policy) != 0) {
3072468c413aSTim Haley 				fatal("can't open '%s': %s",
3073468c413aSTim Haley 				    target, strerror(ENOMEM));
3074468c413aSTim Haley 			}
30753ad6c7f9SVictor Latushkin 			if ((error = spa_import(name, cfg, NULL)) != 0)
30763ad6c7f9SVictor Latushkin 				error = spa_import_verbatim(name, cfg, NULL);
3077de6628f0Sck 		}
3078c5904d13Seschrock 	}
3079c5904d13Seschrock 
3080c5904d13Seschrock 	if (error == 0) {
308107428bdfSVictor Latushkin 		if (strpbrk(target, "/@") == NULL || dump_opt['R']) {
308280eb36f2SGeorge Wilson 			error = spa_open_rewind(target, &spa, FTAG, policy,
308380eb36f2SGeorge Wilson 			    NULL);
30848f18d1faSGeorge Wilson 			if (error) {
30858f18d1faSGeorge Wilson 				/*
30868f18d1faSGeorge Wilson 				 * If we're missing the log device then
30878f18d1faSGeorge Wilson 				 * try opening the pool after clearing the
30888f18d1faSGeorge Wilson 				 * log state.
30898f18d1faSGeorge Wilson 				 */
30908f18d1faSGeorge Wilson 				mutex_enter(&spa_namespace_lock);
30913ad6c7f9SVictor Latushkin 				if ((spa = spa_lookup(target)) != NULL &&
30928f18d1faSGeorge Wilson 				    spa->spa_log_state == SPA_LOG_MISSING) {
30938f18d1faSGeorge Wilson 					spa->spa_log_state = SPA_LOG_CLEAR;
30948f18d1faSGeorge Wilson 					error = 0;
30958f18d1faSGeorge Wilson 				}
30968f18d1faSGeorge Wilson 				mutex_exit(&spa_namespace_lock);
30978f18d1faSGeorge Wilson 
309880eb36f2SGeorge Wilson 				if (!error) {
309980eb36f2SGeorge Wilson 					error = spa_open_rewind(target, &spa,
310080eb36f2SGeorge Wilson 					    FTAG, policy, NULL);
310180eb36f2SGeorge Wilson 				}
31028f18d1faSGeorge Wilson 			}
310307428bdfSVictor Latushkin 		} else {
310407428bdfSVictor Latushkin 			error = dmu_objset_own(target, DMU_OST_ANY,
310507428bdfSVictor Latushkin 			    B_TRUE, FTAG, &os);
3106c5904d13Seschrock 		}
3107fa9e4066Sahrens 	}
310880eb36f2SGeorge Wilson 	nvlist_free(policy);
310980eb36f2SGeorge Wilson 
3110fa9e4066Sahrens 	if (error)
31113ad6c7f9SVictor Latushkin 		fatal("can't open '%s': %s", target, strerror(error));
3112fa9e4066Sahrens 
3113fa9e4066Sahrens 	argv++;
311407428bdfSVictor Latushkin 	argc--;
311507428bdfSVictor Latushkin 	if (!dump_opt['R']) {
311607428bdfSVictor Latushkin 		if (argc > 0) {
311707428bdfSVictor Latushkin 			zopt_objects = argc;
311807428bdfSVictor Latushkin 			zopt_object = calloc(zopt_objects, sizeof (uint64_t));
311907428bdfSVictor Latushkin 			for (i = 0; i < zopt_objects; i++) {
312007428bdfSVictor Latushkin 				errno = 0;
312107428bdfSVictor Latushkin 				zopt_object[i] = strtoull(argv[i], NULL, 0);
312207428bdfSVictor Latushkin 				if (zopt_object[i] == 0 && errno != 0)
312387219db7SVictor Latushkin 					fatal("bad number %s: %s",
312407428bdfSVictor Latushkin 					    argv[i], strerror(errno));
312507428bdfSVictor Latushkin 			}
3126fa9e4066Sahrens 		}
312707428bdfSVictor Latushkin 		(os != NULL) ? dump_dir(os) : dump_zpool(spa);
3128fa9e4066Sahrens 	} else {
312907428bdfSVictor Latushkin 		flagbits['b'] = ZDB_FLAG_PRINT_BLKPTR;
313007428bdfSVictor Latushkin 		flagbits['c'] = ZDB_FLAG_CHECKSUM;
313107428bdfSVictor Latushkin 		flagbits['d'] = ZDB_FLAG_DECOMPRESS;
313207428bdfSVictor Latushkin 		flagbits['e'] = ZDB_FLAG_BSWAP;
313307428bdfSVictor Latushkin 		flagbits['g'] = ZDB_FLAG_GBH;
313407428bdfSVictor Latushkin 		flagbits['i'] = ZDB_FLAG_INDIRECT;
313507428bdfSVictor Latushkin 		flagbits['p'] = ZDB_FLAG_PHYS;
313607428bdfSVictor Latushkin 		flagbits['r'] = ZDB_FLAG_RAW;
313707428bdfSVictor Latushkin 
313807428bdfSVictor Latushkin 		for (i = 0; i < argc; i++)
313907428bdfSVictor Latushkin 			zdb_read_block(argv[i], spa);
3140fa9e4066Sahrens 	}
3141fa9e4066Sahrens 
314207428bdfSVictor Latushkin 	(os != NULL) ? dmu_objset_disown(os, FTAG) : spa_close(spa, FTAG);
314307428bdfSVictor Latushkin 
3144e0d35c44Smarks 	fuid_table_destroy();
31450a586ceaSMark Shellenbaum 	sa_loaded = B_FALSE;
3146e0d35c44Smarks 
3147de6628f0Sck 	libzfs_fini(g_zfs);
3148fa9e4066Sahrens 	kernel_fini();
3149fa9e4066Sahrens 
3150fa9e4066Sahrens 	return (0);
3151fa9e4066Sahrens }
3152