zdb.c revision ae24175b2b25e9fb4bfd9ac0648b57e0735b6651
1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
23 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright (c) 2011, 2015 by Delphix. All rights reserved.
25 */
26
27#include <stdio.h>
28#include <unistd.h>
29#include <stdio_ext.h>
30#include <stdlib.h>
31#include <ctype.h>
32#include <sys/zfs_context.h>
33#include <sys/spa.h>
34#include <sys/spa_impl.h>
35#include <sys/dmu.h>
36#include <sys/zap.h>
37#include <sys/fs/zfs.h>
38#include <sys/zfs_znode.h>
39#include <sys/zfs_sa.h>
40#include <sys/sa.h>
41#include <sys/sa_impl.h>
42#include <sys/vdev.h>
43#include <sys/vdev_impl.h>
44#include <sys/metaslab_impl.h>
45#include <sys/dmu_objset.h>
46#include <sys/dsl_dir.h>
47#include <sys/dsl_dataset.h>
48#include <sys/dsl_pool.h>
49#include <sys/dbuf.h>
50#include <sys/zil.h>
51#include <sys/zil_impl.h>
52#include <sys/stat.h>
53#include <sys/resource.h>
54#include <sys/dmu_traverse.h>
55#include <sys/zio_checksum.h>
56#include <sys/zio_compress.h>
57#include <sys/zfs_fuid.h>
58#include <sys/arc.h>
59#include <sys/ddt.h>
60#include <sys/zfeature.h>
61#include <zfs_comutil.h>
62#undef ZFS_MAXNAMELEN
63#undef verify
64#include <libzfs.h>
65
66#define	ZDB_COMPRESS_NAME(idx) ((idx) < ZIO_COMPRESS_FUNCTIONS ?	\
67	zio_compress_table[(idx)].ci_name : "UNKNOWN")
68#define	ZDB_CHECKSUM_NAME(idx) ((idx) < ZIO_CHECKSUM_FUNCTIONS ?	\
69	zio_checksum_table[(idx)].ci_name : "UNKNOWN")
70#define	ZDB_OT_NAME(idx) ((idx) < DMU_OT_NUMTYPES ?	\
71	dmu_ot[(idx)].ot_name : DMU_OT_IS_VALID(idx) ?	\
72	dmu_ot_byteswap[DMU_OT_BYTESWAP(idx)].ob_name : "UNKNOWN")
73#define	ZDB_OT_TYPE(idx) ((idx) < DMU_OT_NUMTYPES ? (idx) :		\
74	(((idx) == DMU_OTN_ZAP_DATA || (idx) == DMU_OTN_ZAP_METADATA) ?	\
75	DMU_OT_ZAP_OTHER : DMU_OT_NUMTYPES))
76
77#ifndef lint
78extern boolean_t zfs_recover;
79extern uint64_t zfs_arc_max, zfs_arc_meta_limit;
80extern int zfs_vdev_async_read_max_active;
81#else
82boolean_t zfs_recover;
83uint64_t zfs_arc_max, zfs_arc_meta_limit;
84int zfs_vdev_async_read_max_active;
85#endif
86
87const char cmdname[] = "zdb";
88uint8_t dump_opt[256];
89
90typedef void object_viewer_t(objset_t *, uint64_t, void *data, size_t size);
91
92extern void dump_intent_log(zilog_t *);
93uint64_t *zopt_object = NULL;
94int zopt_objects = 0;
95libzfs_handle_t *g_zfs;
96uint64_t max_inflight = 1000;
97
98static void snprintf_blkptr_compact(char *, size_t, const blkptr_t *);
99
100/*
101 * These libumem hooks provide a reasonable set of defaults for the allocator's
102 * debugging facilities.
103 */
104const char *
105_umem_debug_init()
106{
107	return ("default,verbose"); /* $UMEM_DEBUG setting */
108}
109
110const char *
111_umem_logging_init(void)
112{
113	return ("fail,contents"); /* $UMEM_LOGGING setting */
114}
115
116static void
117usage(void)
118{
119	(void) fprintf(stderr,
120	    "Usage: %s [-CumMdibcsDvhLXFPA] [-t txg] [-e [-p path...]] "
121	    "[-U config] [-I inflight I/Os] [-x dumpdir] poolname [object...]\n"
122	    "       %s [-divPA] [-e -p path...] [-U config] dataset "
123	    "[object...]\n"
124	    "       %s -mM [-LXFPA] [-t txg] [-e [-p path...]] [-U config] "
125	    "poolname [vdev [metaslab...]]\n"
126	    "       %s -R [-A] [-e [-p path...]] poolname "
127	    "vdev:offset:size[:flags]\n"
128	    "       %s -S [-PA] [-e [-p path...]] [-U config] poolname\n"
129	    "       %s -l [-uA] device\n"
130	    "       %s -C [-A] [-U config]\n\n",
131	    cmdname, cmdname, cmdname, cmdname, cmdname, cmdname, cmdname);
132
133	(void) fprintf(stderr, "    Dataset name must include at least one "
134	    "separator character '/' or '@'\n");
135	(void) fprintf(stderr, "    If dataset name is specified, only that "
136	    "dataset is dumped\n");
137	(void) fprintf(stderr, "    If object numbers are specified, only "
138	    "those objects are dumped\n\n");
139	(void) fprintf(stderr, "    Options to control amount of output:\n");
140	(void) fprintf(stderr, "        -u uberblock\n");
141	(void) fprintf(stderr, "        -d dataset(s)\n");
142	(void) fprintf(stderr, "        -i intent logs\n");
143	(void) fprintf(stderr, "        -C config (or cachefile if alone)\n");
144	(void) fprintf(stderr, "        -h pool history\n");
145	(void) fprintf(stderr, "        -b block statistics\n");
146	(void) fprintf(stderr, "        -m metaslabs\n");
147	(void) fprintf(stderr, "        -M metaslab groups\n");
148	(void) fprintf(stderr, "        -c checksum all metadata (twice for "
149	    "all data) blocks\n");
150	(void) fprintf(stderr, "        -s report stats on zdb's I/O\n");
151	(void) fprintf(stderr, "        -D dedup statistics\n");
152	(void) fprintf(stderr, "        -S simulate dedup to measure effect\n");
153	(void) fprintf(stderr, "        -v verbose (applies to all others)\n");
154	(void) fprintf(stderr, "        -l dump label contents\n");
155	(void) fprintf(stderr, "        -L disable leak tracking (do not "
156	    "load spacemaps)\n");
157	(void) fprintf(stderr, "        -R read and display block from a "
158	    "device\n\n");
159	(void) fprintf(stderr, "    Below options are intended for use "
160	    "with other options:\n");
161	(void) fprintf(stderr, "        -A ignore assertions (-A), enable "
162	    "panic recovery (-AA) or both (-AAA)\n");
163	(void) fprintf(stderr, "        -F attempt automatic rewind within "
164	    "safe range of transaction groups\n");
165	(void) fprintf(stderr, "        -U <cachefile_path> -- use alternate "
166	    "cachefile\n");
167	(void) fprintf(stderr, "        -X attempt extreme rewind (does not "
168	    "work with dataset)\n");
169	(void) fprintf(stderr, "        -e pool is exported/destroyed/"
170	    "has altroot/not in a cachefile\n");
171	(void) fprintf(stderr, "        -p <path> -- use one or more with "
172	    "-e to specify path to vdev dir\n");
173	(void) fprintf(stderr, "        -x <dumpdir> -- "
174	    "dump all read blocks into specified directory\n");
175	(void) fprintf(stderr, "        -P print numbers in parseable form\n");
176	(void) fprintf(stderr, "        -t <txg> -- highest txg to use when "
177	    "searching for uberblocks\n");
178	(void) fprintf(stderr, "        -I <number of inflight I/Os> -- "
179	    "specify the maximum number of "
180	    "checksumming I/Os [default is 200]\n");
181	(void) fprintf(stderr, "Specify an option more than once (e.g. -bb) "
182	    "to make only that option verbose\n");
183	(void) fprintf(stderr, "Default is to dump everything non-verbosely\n");
184	exit(1);
185}
186
187/*
188 * Called for usage errors that are discovered after a call to spa_open(),
189 * dmu_bonus_hold(), or pool_match().  abort() is called for other errors.
190 */
191
192static void
193fatal(const char *fmt, ...)
194{
195	va_list ap;
196
197	va_start(ap, fmt);
198	(void) fprintf(stderr, "%s: ", cmdname);
199	(void) vfprintf(stderr, fmt, ap);
200	va_end(ap);
201	(void) fprintf(stderr, "\n");
202
203	exit(1);
204}
205
206/* ARGSUSED */
207static void
208dump_packed_nvlist(objset_t *os, uint64_t object, void *data, size_t size)
209{
210	nvlist_t *nv;
211	size_t nvsize = *(uint64_t *)data;
212	char *packed = umem_alloc(nvsize, UMEM_NOFAIL);
213
214	VERIFY(0 == dmu_read(os, object, 0, nvsize, packed, DMU_READ_PREFETCH));
215
216	VERIFY(nvlist_unpack(packed, nvsize, &nv, 0) == 0);
217
218	umem_free(packed, nvsize);
219
220	dump_nvlist(nv, 8);
221
222	nvlist_free(nv);
223}
224
225/* ARGSUSED */
226static void
227dump_history_offsets(objset_t *os, uint64_t object, void *data, size_t size)
228{
229	spa_history_phys_t *shp = data;
230
231	if (shp == NULL)
232		return;
233
234	(void) printf("\t\tpool_create_len = %llu\n",
235	    (u_longlong_t)shp->sh_pool_create_len);
236	(void) printf("\t\tphys_max_off = %llu\n",
237	    (u_longlong_t)shp->sh_phys_max_off);
238	(void) printf("\t\tbof = %llu\n",
239	    (u_longlong_t)shp->sh_bof);
240	(void) printf("\t\teof = %llu\n",
241	    (u_longlong_t)shp->sh_eof);
242	(void) printf("\t\trecords_lost = %llu\n",
243	    (u_longlong_t)shp->sh_records_lost);
244}
245
246static void
247zdb_nicenum(uint64_t num, char *buf)
248{
249	if (dump_opt['P'])
250		(void) sprintf(buf, "%llu", (longlong_t)num);
251	else
252		nicenum(num, buf);
253}
254
255const char histo_stars[] = "****************************************";
256const int histo_width = sizeof (histo_stars) - 1;
257
258static void
259dump_histogram(const uint64_t *histo, int size, int offset)
260{
261	int i;
262	int minidx = size - 1;
263	int maxidx = 0;
264	uint64_t max = 0;
265
266	for (i = 0; i < size; i++) {
267		if (histo[i] > max)
268			max = histo[i];
269		if (histo[i] > 0 && i > maxidx)
270			maxidx = i;
271		if (histo[i] > 0 && i < minidx)
272			minidx = i;
273	}
274
275	if (max < histo_width)
276		max = histo_width;
277
278	for (i = minidx; i <= maxidx; i++) {
279		(void) printf("\t\t\t%3u: %6llu %s\n",
280		    i + offset, (u_longlong_t)histo[i],
281		    &histo_stars[(max - histo[i]) * histo_width / max]);
282	}
283}
284
285static void
286dump_zap_stats(objset_t *os, uint64_t object)
287{
288	int error;
289	zap_stats_t zs;
290
291	error = zap_get_stats(os, object, &zs);
292	if (error)
293		return;
294
295	if (zs.zs_ptrtbl_len == 0) {
296		ASSERT(zs.zs_num_blocks == 1);
297		(void) printf("\tmicrozap: %llu bytes, %llu entries\n",
298		    (u_longlong_t)zs.zs_blocksize,
299		    (u_longlong_t)zs.zs_num_entries);
300		return;
301	}
302
303	(void) printf("\tFat ZAP stats:\n");
304
305	(void) printf("\t\tPointer table:\n");
306	(void) printf("\t\t\t%llu elements\n",
307	    (u_longlong_t)zs.zs_ptrtbl_len);
308	(void) printf("\t\t\tzt_blk: %llu\n",
309	    (u_longlong_t)zs.zs_ptrtbl_zt_blk);
310	(void) printf("\t\t\tzt_numblks: %llu\n",
311	    (u_longlong_t)zs.zs_ptrtbl_zt_numblks);
312	(void) printf("\t\t\tzt_shift: %llu\n",
313	    (u_longlong_t)zs.zs_ptrtbl_zt_shift);
314	(void) printf("\t\t\tzt_blks_copied: %llu\n",
315	    (u_longlong_t)zs.zs_ptrtbl_blks_copied);
316	(void) printf("\t\t\tzt_nextblk: %llu\n",
317	    (u_longlong_t)zs.zs_ptrtbl_nextblk);
318
319	(void) printf("\t\tZAP entries: %llu\n",
320	    (u_longlong_t)zs.zs_num_entries);
321	(void) printf("\t\tLeaf blocks: %llu\n",
322	    (u_longlong_t)zs.zs_num_leafs);
323	(void) printf("\t\tTotal blocks: %llu\n",
324	    (u_longlong_t)zs.zs_num_blocks);
325	(void) printf("\t\tzap_block_type: 0x%llx\n",
326	    (u_longlong_t)zs.zs_block_type);
327	(void) printf("\t\tzap_magic: 0x%llx\n",
328	    (u_longlong_t)zs.zs_magic);
329	(void) printf("\t\tzap_salt: 0x%llx\n",
330	    (u_longlong_t)zs.zs_salt);
331
332	(void) printf("\t\tLeafs with 2^n pointers:\n");
333	dump_histogram(zs.zs_leafs_with_2n_pointers, ZAP_HISTOGRAM_SIZE, 0);
334
335	(void) printf("\t\tBlocks with n*5 entries:\n");
336	dump_histogram(zs.zs_blocks_with_n5_entries, ZAP_HISTOGRAM_SIZE, 0);
337
338	(void) printf("\t\tBlocks n/10 full:\n");
339	dump_histogram(zs.zs_blocks_n_tenths_full, ZAP_HISTOGRAM_SIZE, 0);
340
341	(void) printf("\t\tEntries with n chunks:\n");
342	dump_histogram(zs.zs_entries_using_n_chunks, ZAP_HISTOGRAM_SIZE, 0);
343
344	(void) printf("\t\tBuckets with n entries:\n");
345	dump_histogram(zs.zs_buckets_with_n_entries, ZAP_HISTOGRAM_SIZE, 0);
346}
347
348/*ARGSUSED*/
349static void
350dump_none(objset_t *os, uint64_t object, void *data, size_t size)
351{
352}
353
354/*ARGSUSED*/
355static void
356dump_unknown(objset_t *os, uint64_t object, void *data, size_t size)
357{
358	(void) printf("\tUNKNOWN OBJECT TYPE\n");
359}
360
361/*ARGSUSED*/
362void
363dump_uint8(objset_t *os, uint64_t object, void *data, size_t size)
364{
365}
366
367/*ARGSUSED*/
368static void
369dump_uint64(objset_t *os, uint64_t object, void *data, size_t size)
370{
371}
372
373/*ARGSUSED*/
374static void
375dump_zap(objset_t *os, uint64_t object, void *data, size_t size)
376{
377	zap_cursor_t zc;
378	zap_attribute_t attr;
379	void *prop;
380	int i;
381
382	dump_zap_stats(os, object);
383	(void) printf("\n");
384
385	for (zap_cursor_init(&zc, os, object);
386	    zap_cursor_retrieve(&zc, &attr) == 0;
387	    zap_cursor_advance(&zc)) {
388		(void) printf("\t\t%s = ", attr.za_name);
389		if (attr.za_num_integers == 0) {
390			(void) printf("\n");
391			continue;
392		}
393		prop = umem_zalloc(attr.za_num_integers *
394		    attr.za_integer_length, UMEM_NOFAIL);
395		(void) zap_lookup(os, object, attr.za_name,
396		    attr.za_integer_length, attr.za_num_integers, prop);
397		if (attr.za_integer_length == 1) {
398			(void) printf("%s", (char *)prop);
399		} else {
400			for (i = 0; i < attr.za_num_integers; i++) {
401				switch (attr.za_integer_length) {
402				case 2:
403					(void) printf("%u ",
404					    ((uint16_t *)prop)[i]);
405					break;
406				case 4:
407					(void) printf("%u ",
408					    ((uint32_t *)prop)[i]);
409					break;
410				case 8:
411					(void) printf("%lld ",
412					    (u_longlong_t)((int64_t *)prop)[i]);
413					break;
414				}
415			}
416		}
417		(void) printf("\n");
418		umem_free(prop, attr.za_num_integers * attr.za_integer_length);
419	}
420	zap_cursor_fini(&zc);
421}
422
423static void
424dump_bpobj(objset_t *os, uint64_t object, void *data, size_t size)
425{
426	bpobj_phys_t *bpop = data;
427	char bytes[32], comp[32], uncomp[32];
428
429	if (bpop == NULL)
430		return;
431
432	zdb_nicenum(bpop->bpo_bytes, bytes);
433	zdb_nicenum(bpop->bpo_comp, comp);
434	zdb_nicenum(bpop->bpo_uncomp, uncomp);
435
436	(void) printf("\t\tnum_blkptrs = %llu\n",
437	    (u_longlong_t)bpop->bpo_num_blkptrs);
438	(void) printf("\t\tbytes = %s\n", bytes);
439	if (size >= BPOBJ_SIZE_V1) {
440		(void) printf("\t\tcomp = %s\n", comp);
441		(void) printf("\t\tuncomp = %s\n", uncomp);
442	}
443	if (size >= sizeof (*bpop)) {
444		(void) printf("\t\tsubobjs = %llu\n",
445		    (u_longlong_t)bpop->bpo_subobjs);
446		(void) printf("\t\tnum_subobjs = %llu\n",
447		    (u_longlong_t)bpop->bpo_num_subobjs);
448	}
449
450	if (dump_opt['d'] < 5)
451		return;
452
453	for (uint64_t i = 0; i < bpop->bpo_num_blkptrs; i++) {
454		char blkbuf[BP_SPRINTF_LEN];
455		blkptr_t bp;
456
457		int err = dmu_read(os, object,
458		    i * sizeof (bp), sizeof (bp), &bp, 0);
459		if (err != 0) {
460			(void) printf("got error %u from dmu_read\n", err);
461			break;
462		}
463		snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), &bp);
464		(void) printf("\t%s\n", blkbuf);
465	}
466}
467
468/* ARGSUSED */
469static void
470dump_bpobj_subobjs(objset_t *os, uint64_t object, void *data, size_t size)
471{
472	dmu_object_info_t doi;
473
474	VERIFY0(dmu_object_info(os, object, &doi));
475	uint64_t *subobjs = kmem_alloc(doi.doi_max_offset, KM_SLEEP);
476
477	int err = dmu_read(os, object, 0, doi.doi_max_offset, subobjs, 0);
478	if (err != 0) {
479		(void) printf("got error %u from dmu_read\n", err);
480		kmem_free(subobjs, doi.doi_max_offset);
481		return;
482	}
483
484	int64_t last_nonzero = -1;
485	for (uint64_t i = 0; i < doi.doi_max_offset / 8; i++) {
486		if (subobjs[i] != 0)
487			last_nonzero = i;
488	}
489
490	for (int64_t i = 0; i <= last_nonzero; i++) {
491		(void) printf("\t%llu\n", (longlong_t)subobjs[i]);
492	}
493	kmem_free(subobjs, doi.doi_max_offset);
494}
495
496/*ARGSUSED*/
497static void
498dump_ddt_zap(objset_t *os, uint64_t object, void *data, size_t size)
499{
500	dump_zap_stats(os, object);
501	/* contents are printed elsewhere, properly decoded */
502}
503
504/*ARGSUSED*/
505static void
506dump_sa_attrs(objset_t *os, uint64_t object, void *data, size_t size)
507{
508	zap_cursor_t zc;
509	zap_attribute_t attr;
510
511	dump_zap_stats(os, object);
512	(void) printf("\n");
513
514	for (zap_cursor_init(&zc, os, object);
515	    zap_cursor_retrieve(&zc, &attr) == 0;
516	    zap_cursor_advance(&zc)) {
517		(void) printf("\t\t%s = ", attr.za_name);
518		if (attr.za_num_integers == 0) {
519			(void) printf("\n");
520			continue;
521		}
522		(void) printf(" %llx : [%d:%d:%d]\n",
523		    (u_longlong_t)attr.za_first_integer,
524		    (int)ATTR_LENGTH(attr.za_first_integer),
525		    (int)ATTR_BSWAP(attr.za_first_integer),
526		    (int)ATTR_NUM(attr.za_first_integer));
527	}
528	zap_cursor_fini(&zc);
529}
530
531/*ARGSUSED*/
532static void
533dump_sa_layouts(objset_t *os, uint64_t object, void *data, size_t size)
534{
535	zap_cursor_t zc;
536	zap_attribute_t attr;
537	uint16_t *layout_attrs;
538	int i;
539
540	dump_zap_stats(os, object);
541	(void) printf("\n");
542
543	for (zap_cursor_init(&zc, os, object);
544	    zap_cursor_retrieve(&zc, &attr) == 0;
545	    zap_cursor_advance(&zc)) {
546		(void) printf("\t\t%s = [", attr.za_name);
547		if (attr.za_num_integers == 0) {
548			(void) printf("\n");
549			continue;
550		}
551
552		VERIFY(attr.za_integer_length == 2);
553		layout_attrs = umem_zalloc(attr.za_num_integers *
554		    attr.za_integer_length, UMEM_NOFAIL);
555
556		VERIFY(zap_lookup(os, object, attr.za_name,
557		    attr.za_integer_length,
558		    attr.za_num_integers, layout_attrs) == 0);
559
560		for (i = 0; i != attr.za_num_integers; i++)
561			(void) printf(" %d ", (int)layout_attrs[i]);
562		(void) printf("]\n");
563		umem_free(layout_attrs,
564		    attr.za_num_integers * attr.za_integer_length);
565	}
566	zap_cursor_fini(&zc);
567}
568
569/*ARGSUSED*/
570static void
571dump_zpldir(objset_t *os, uint64_t object, void *data, size_t size)
572{
573	zap_cursor_t zc;
574	zap_attribute_t attr;
575	const char *typenames[] = {
576		/* 0 */ "not specified",
577		/* 1 */ "FIFO",
578		/* 2 */ "Character Device",
579		/* 3 */ "3 (invalid)",
580		/* 4 */ "Directory",
581		/* 5 */ "5 (invalid)",
582		/* 6 */ "Block Device",
583		/* 7 */ "7 (invalid)",
584		/* 8 */ "Regular File",
585		/* 9 */ "9 (invalid)",
586		/* 10 */ "Symbolic Link",
587		/* 11 */ "11 (invalid)",
588		/* 12 */ "Socket",
589		/* 13 */ "Door",
590		/* 14 */ "Event Port",
591		/* 15 */ "15 (invalid)",
592	};
593
594	dump_zap_stats(os, object);
595	(void) printf("\n");
596
597	for (zap_cursor_init(&zc, os, object);
598	    zap_cursor_retrieve(&zc, &attr) == 0;
599	    zap_cursor_advance(&zc)) {
600		(void) printf("\t\t%s = %lld (type: %s)\n",
601		    attr.za_name, ZFS_DIRENT_OBJ(attr.za_first_integer),
602		    typenames[ZFS_DIRENT_TYPE(attr.za_first_integer)]);
603	}
604	zap_cursor_fini(&zc);
605}
606
607int
608get_dtl_refcount(vdev_t *vd)
609{
610	int refcount = 0;
611
612	if (vd->vdev_ops->vdev_op_leaf) {
613		space_map_t *sm = vd->vdev_dtl_sm;
614
615		if (sm != NULL &&
616		    sm->sm_dbuf->db_size == sizeof (space_map_phys_t))
617			return (1);
618		return (0);
619	}
620
621	for (int c = 0; c < vd->vdev_children; c++)
622		refcount += get_dtl_refcount(vd->vdev_child[c]);
623	return (refcount);
624}
625
626int
627get_metaslab_refcount(vdev_t *vd)
628{
629	int refcount = 0;
630
631	if (vd->vdev_top == vd && !vd->vdev_removing) {
632		for (int m = 0; m < vd->vdev_ms_count; m++) {
633			space_map_t *sm = vd->vdev_ms[m]->ms_sm;
634
635			if (sm != NULL &&
636			    sm->sm_dbuf->db_size == sizeof (space_map_phys_t))
637				refcount++;
638		}
639	}
640	for (int c = 0; c < vd->vdev_children; c++)
641		refcount += get_metaslab_refcount(vd->vdev_child[c]);
642
643	return (refcount);
644}
645
646static int
647verify_spacemap_refcounts(spa_t *spa)
648{
649	uint64_t expected_refcount = 0;
650	uint64_t actual_refcount;
651
652	(void) feature_get_refcount(spa,
653	    &spa_feature_table[SPA_FEATURE_SPACEMAP_HISTOGRAM],
654	    &expected_refcount);
655	actual_refcount = get_dtl_refcount(spa->spa_root_vdev);
656	actual_refcount += get_metaslab_refcount(spa->spa_root_vdev);
657
658	if (expected_refcount != actual_refcount) {
659		(void) printf("space map refcount mismatch: expected %lld != "
660		    "actual %lld\n",
661		    (longlong_t)expected_refcount,
662		    (longlong_t)actual_refcount);
663		return (2);
664	}
665	return (0);
666}
667
668static void
669dump_spacemap(objset_t *os, space_map_t *sm)
670{
671	uint64_t alloc, offset, entry;
672	char *ddata[] = { "ALLOC", "FREE", "CONDENSE", "INVALID",
673			    "INVALID", "INVALID", "INVALID", "INVALID" };
674
675	if (sm == NULL)
676		return;
677
678	/*
679	 * Print out the freelist entries in both encoded and decoded form.
680	 */
681	alloc = 0;
682	for (offset = 0; offset < space_map_length(sm);
683	    offset += sizeof (entry)) {
684		uint8_t mapshift = sm->sm_shift;
685
686		VERIFY0(dmu_read(os, space_map_object(sm), offset,
687		    sizeof (entry), &entry, DMU_READ_PREFETCH));
688		if (SM_DEBUG_DECODE(entry)) {
689
690			(void) printf("\t    [%6llu] %s: txg %llu, pass %llu\n",
691			    (u_longlong_t)(offset / sizeof (entry)),
692			    ddata[SM_DEBUG_ACTION_DECODE(entry)],
693			    (u_longlong_t)SM_DEBUG_TXG_DECODE(entry),
694			    (u_longlong_t)SM_DEBUG_SYNCPASS_DECODE(entry));
695		} else {
696			(void) printf("\t    [%6llu]    %c  range:"
697			    " %010llx-%010llx  size: %06llx\n",
698			    (u_longlong_t)(offset / sizeof (entry)),
699			    SM_TYPE_DECODE(entry) == SM_ALLOC ? 'A' : 'F',
700			    (u_longlong_t)((SM_OFFSET_DECODE(entry) <<
701			    mapshift) + sm->sm_start),
702			    (u_longlong_t)((SM_OFFSET_DECODE(entry) <<
703			    mapshift) + sm->sm_start +
704			    (SM_RUN_DECODE(entry) << mapshift)),
705			    (u_longlong_t)(SM_RUN_DECODE(entry) << mapshift));
706			if (SM_TYPE_DECODE(entry) == SM_ALLOC)
707				alloc += SM_RUN_DECODE(entry) << mapshift;
708			else
709				alloc -= SM_RUN_DECODE(entry) << mapshift;
710		}
711	}
712	if (alloc != space_map_allocated(sm)) {
713		(void) printf("space_map_object alloc (%llu) INCONSISTENT "
714		    "with space map summary (%llu)\n",
715		    (u_longlong_t)space_map_allocated(sm), (u_longlong_t)alloc);
716	}
717}
718
719static void
720dump_metaslab_stats(metaslab_t *msp)
721{
722	char maxbuf[32];
723	range_tree_t *rt = msp->ms_tree;
724	avl_tree_t *t = &msp->ms_size_tree;
725	int free_pct = range_tree_space(rt) * 100 / msp->ms_size;
726
727	zdb_nicenum(metaslab_block_maxsize(msp), maxbuf);
728
729	(void) printf("\t %25s %10lu   %7s  %6s   %4s %4d%%\n",
730	    "segments", avl_numnodes(t), "maxsize", maxbuf,
731	    "freepct", free_pct);
732	(void) printf("\tIn-memory histogram:\n");
733	dump_histogram(rt->rt_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
734}
735
736static void
737dump_metaslab(metaslab_t *msp)
738{
739	vdev_t *vd = msp->ms_group->mg_vd;
740	spa_t *spa = vd->vdev_spa;
741	space_map_t *sm = msp->ms_sm;
742	char freebuf[32];
743
744	zdb_nicenum(msp->ms_size - space_map_allocated(sm), freebuf);
745
746	(void) printf(
747	    "\tmetaslab %6llu   offset %12llx   spacemap %6llu   free    %5s\n",
748	    (u_longlong_t)msp->ms_id, (u_longlong_t)msp->ms_start,
749	    (u_longlong_t)space_map_object(sm), freebuf);
750
751	if (dump_opt['m'] > 2 && !dump_opt['L']) {
752		mutex_enter(&msp->ms_lock);
753		metaslab_load_wait(msp);
754		if (!msp->ms_loaded) {
755			VERIFY0(metaslab_load(msp));
756			range_tree_stat_verify(msp->ms_tree);
757		}
758		dump_metaslab_stats(msp);
759		metaslab_unload(msp);
760		mutex_exit(&msp->ms_lock);
761	}
762
763	if (dump_opt['m'] > 1 && sm != NULL &&
764	    spa_feature_is_active(spa, SPA_FEATURE_SPACEMAP_HISTOGRAM)) {
765		/*
766		 * The space map histogram represents free space in chunks
767		 * of sm_shift (i.e. bucket 0 refers to 2^sm_shift).
768		 */
769		(void) printf("\tOn-disk histogram:\t\tfragmentation %llu\n",
770		    (u_longlong_t)msp->ms_fragmentation);
771		dump_histogram(sm->sm_phys->smp_histogram,
772		    SPACE_MAP_HISTOGRAM_SIZE, sm->sm_shift);
773	}
774
775	if (dump_opt['d'] > 5 || dump_opt['m'] > 3) {
776		ASSERT(msp->ms_size == (1ULL << vd->vdev_ms_shift));
777
778		mutex_enter(&msp->ms_lock);
779		dump_spacemap(spa->spa_meta_objset, msp->ms_sm);
780		mutex_exit(&msp->ms_lock);
781	}
782}
783
784static void
785print_vdev_metaslab_header(vdev_t *vd)
786{
787	(void) printf("\tvdev %10llu\n\t%-10s%5llu   %-19s   %-15s   %-10s\n",
788	    (u_longlong_t)vd->vdev_id,
789	    "metaslabs", (u_longlong_t)vd->vdev_ms_count,
790	    "offset", "spacemap", "free");
791	(void) printf("\t%15s   %19s   %15s   %10s\n",
792	    "---------------", "-------------------",
793	    "---------------", "-------------");
794}
795
796static void
797dump_metaslab_groups(spa_t *spa)
798{
799	vdev_t *rvd = spa->spa_root_vdev;
800	metaslab_class_t *mc = spa_normal_class(spa);
801	uint64_t fragmentation;
802
803	metaslab_class_histogram_verify(mc);
804
805	for (int c = 0; c < rvd->vdev_children; c++) {
806		vdev_t *tvd = rvd->vdev_child[c];
807		metaslab_group_t *mg = tvd->vdev_mg;
808
809		if (mg->mg_class != mc)
810			continue;
811
812		metaslab_group_histogram_verify(mg);
813		mg->mg_fragmentation = metaslab_group_fragmentation(mg);
814
815		(void) printf("\tvdev %10llu\t\tmetaslabs%5llu\t\t"
816		    "fragmentation",
817		    (u_longlong_t)tvd->vdev_id,
818		    (u_longlong_t)tvd->vdev_ms_count);
819		if (mg->mg_fragmentation == ZFS_FRAG_INVALID) {
820			(void) printf("%3s\n", "-");
821		} else {
822			(void) printf("%3llu%%\n",
823			    (u_longlong_t)mg->mg_fragmentation);
824		}
825		dump_histogram(mg->mg_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
826	}
827
828	(void) printf("\tpool %s\tfragmentation", spa_name(spa));
829	fragmentation = metaslab_class_fragmentation(mc);
830	if (fragmentation == ZFS_FRAG_INVALID)
831		(void) printf("\t%3s\n", "-");
832	else
833		(void) printf("\t%3llu%%\n", (u_longlong_t)fragmentation);
834	dump_histogram(mc->mc_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
835}
836
837static void
838dump_metaslabs(spa_t *spa)
839{
840	vdev_t *vd, *rvd = spa->spa_root_vdev;
841	uint64_t m, c = 0, children = rvd->vdev_children;
842
843	(void) printf("\nMetaslabs:\n");
844
845	if (!dump_opt['d'] && zopt_objects > 0) {
846		c = zopt_object[0];
847
848		if (c >= children)
849			(void) fatal("bad vdev id: %llu", (u_longlong_t)c);
850
851		if (zopt_objects > 1) {
852			vd = rvd->vdev_child[c];
853			print_vdev_metaslab_header(vd);
854
855			for (m = 1; m < zopt_objects; m++) {
856				if (zopt_object[m] < vd->vdev_ms_count)
857					dump_metaslab(
858					    vd->vdev_ms[zopt_object[m]]);
859				else
860					(void) fprintf(stderr, "bad metaslab "
861					    "number %llu\n",
862					    (u_longlong_t)zopt_object[m]);
863			}
864			(void) printf("\n");
865			return;
866		}
867		children = c + 1;
868	}
869	for (; c < children; c++) {
870		vd = rvd->vdev_child[c];
871		print_vdev_metaslab_header(vd);
872
873		for (m = 0; m < vd->vdev_ms_count; m++)
874			dump_metaslab(vd->vdev_ms[m]);
875		(void) printf("\n");
876	}
877}
878
879static void
880dump_dde(const ddt_t *ddt, const ddt_entry_t *dde, uint64_t index)
881{
882	const ddt_phys_t *ddp = dde->dde_phys;
883	const ddt_key_t *ddk = &dde->dde_key;
884	char *types[4] = { "ditto", "single", "double", "triple" };
885	char blkbuf[BP_SPRINTF_LEN];
886	blkptr_t blk;
887
888	for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
889		if (ddp->ddp_phys_birth == 0)
890			continue;
891		ddt_bp_create(ddt->ddt_checksum, ddk, ddp, &blk);
892		snprintf_blkptr(blkbuf, sizeof (blkbuf), &blk);
893		(void) printf("index %llx refcnt %llu %s %s\n",
894		    (u_longlong_t)index, (u_longlong_t)ddp->ddp_refcnt,
895		    types[p], blkbuf);
896	}
897}
898
899static void
900dump_dedup_ratio(const ddt_stat_t *dds)
901{
902	double rL, rP, rD, D, dedup, compress, copies;
903
904	if (dds->dds_blocks == 0)
905		return;
906
907	rL = (double)dds->dds_ref_lsize;
908	rP = (double)dds->dds_ref_psize;
909	rD = (double)dds->dds_ref_dsize;
910	D = (double)dds->dds_dsize;
911
912	dedup = rD / D;
913	compress = rL / rP;
914	copies = rD / rP;
915
916	(void) printf("dedup = %.2f, compress = %.2f, copies = %.2f, "
917	    "dedup * compress / copies = %.2f\n\n",
918	    dedup, compress, copies, dedup * compress / copies);
919}
920
921static void
922dump_ddt(ddt_t *ddt, enum ddt_type type, enum ddt_class class)
923{
924	char name[DDT_NAMELEN];
925	ddt_entry_t dde;
926	uint64_t walk = 0;
927	dmu_object_info_t doi;
928	uint64_t count, dspace, mspace;
929	int error;
930
931	error = ddt_object_info(ddt, type, class, &doi);
932
933	if (error == ENOENT)
934		return;
935	ASSERT(error == 0);
936
937	if ((count = ddt_object_count(ddt, type, class)) == 0)
938		return;
939
940	dspace = doi.doi_physical_blocks_512 << 9;
941	mspace = doi.doi_fill_count * doi.doi_data_block_size;
942
943	ddt_object_name(ddt, type, class, name);
944
945	(void) printf("%s: %llu entries, size %llu on disk, %llu in core\n",
946	    name,
947	    (u_longlong_t)count,
948	    (u_longlong_t)(dspace / count),
949	    (u_longlong_t)(mspace / count));
950
951	if (dump_opt['D'] < 3)
952		return;
953
954	zpool_dump_ddt(NULL, &ddt->ddt_histogram[type][class]);
955
956	if (dump_opt['D'] < 4)
957		return;
958
959	if (dump_opt['D'] < 5 && class == DDT_CLASS_UNIQUE)
960		return;
961
962	(void) printf("%s contents:\n\n", name);
963
964	while ((error = ddt_object_walk(ddt, type, class, &walk, &dde)) == 0)
965		dump_dde(ddt, &dde, walk);
966
967	ASSERT(error == ENOENT);
968
969	(void) printf("\n");
970}
971
972static void
973dump_all_ddts(spa_t *spa)
974{
975	ddt_histogram_t ddh_total = { 0 };
976	ddt_stat_t dds_total = { 0 };
977
978	for (enum zio_checksum c = 0; c < ZIO_CHECKSUM_FUNCTIONS; c++) {
979		ddt_t *ddt = spa->spa_ddt[c];
980		for (enum ddt_type type = 0; type < DDT_TYPES; type++) {
981			for (enum ddt_class class = 0; class < DDT_CLASSES;
982			    class++) {
983				dump_ddt(ddt, type, class);
984			}
985		}
986	}
987
988	ddt_get_dedup_stats(spa, &dds_total);
989
990	if (dds_total.dds_blocks == 0) {
991		(void) printf("All DDTs are empty\n");
992		return;
993	}
994
995	(void) printf("\n");
996
997	if (dump_opt['D'] > 1) {
998		(void) printf("DDT histogram (aggregated over all DDTs):\n");
999		ddt_get_dedup_histogram(spa, &ddh_total);
1000		zpool_dump_ddt(&dds_total, &ddh_total);
1001	}
1002
1003	dump_dedup_ratio(&dds_total);
1004}
1005
1006static void
1007dump_dtl_seg(void *arg, uint64_t start, uint64_t size)
1008{
1009	char *prefix = arg;
1010
1011	(void) printf("%s [%llu,%llu) length %llu\n",
1012	    prefix,
1013	    (u_longlong_t)start,
1014	    (u_longlong_t)(start + size),
1015	    (u_longlong_t)(size));
1016}
1017
1018static void
1019dump_dtl(vdev_t *vd, int indent)
1020{
1021	spa_t *spa = vd->vdev_spa;
1022	boolean_t required;
1023	char *name[DTL_TYPES] = { "missing", "partial", "scrub", "outage" };
1024	char prefix[256];
1025
1026	spa_vdev_state_enter(spa, SCL_NONE);
1027	required = vdev_dtl_required(vd);
1028	(void) spa_vdev_state_exit(spa, NULL, 0);
1029
1030	if (indent == 0)
1031		(void) printf("\nDirty time logs:\n\n");
1032
1033	(void) printf("\t%*s%s [%s]\n", indent, "",
1034	    vd->vdev_path ? vd->vdev_path :
1035	    vd->vdev_parent ? vd->vdev_ops->vdev_op_type : spa_name(spa),
1036	    required ? "DTL-required" : "DTL-expendable");
1037
1038	for (int t = 0; t < DTL_TYPES; t++) {
1039		range_tree_t *rt = vd->vdev_dtl[t];
1040		if (range_tree_space(rt) == 0)
1041			continue;
1042		(void) snprintf(prefix, sizeof (prefix), "\t%*s%s",
1043		    indent + 2, "", name[t]);
1044		mutex_enter(rt->rt_lock);
1045		range_tree_walk(rt, dump_dtl_seg, prefix);
1046		mutex_exit(rt->rt_lock);
1047		if (dump_opt['d'] > 5 && vd->vdev_children == 0)
1048			dump_spacemap(spa->spa_meta_objset, vd->vdev_dtl_sm);
1049	}
1050
1051	for (int c = 0; c < vd->vdev_children; c++)
1052		dump_dtl(vd->vdev_child[c], indent + 4);
1053}
1054
1055static void
1056dump_history(spa_t *spa)
1057{
1058	nvlist_t **events = NULL;
1059	uint64_t resid, len, off = 0;
1060	uint_t num = 0;
1061	int error;
1062	time_t tsec;
1063	struct tm t;
1064	char tbuf[30];
1065	char internalstr[MAXPATHLEN];
1066
1067	char *buf = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
1068	do {
1069		len = SPA_MAXBLOCKSIZE;
1070
1071		if ((error = spa_history_get(spa, &off, &len, buf)) != 0) {
1072			(void) fprintf(stderr, "Unable to read history: "
1073			    "error %d\n", error);
1074			umem_free(buf, SPA_MAXBLOCKSIZE);
1075			return;
1076		}
1077
1078		if (zpool_history_unpack(buf, len, &resid, &events, &num) != 0)
1079			break;
1080
1081		off -= resid;
1082	} while (len != 0);
1083	umem_free(buf, SPA_MAXBLOCKSIZE);
1084
1085	(void) printf("\nHistory:\n");
1086	for (int i = 0; i < num; i++) {
1087		uint64_t time, txg, ievent;
1088		char *cmd, *intstr;
1089		boolean_t printed = B_FALSE;
1090
1091		if (nvlist_lookup_uint64(events[i], ZPOOL_HIST_TIME,
1092		    &time) != 0)
1093			goto next;
1094		if (nvlist_lookup_string(events[i], ZPOOL_HIST_CMD,
1095		    &cmd) != 0) {
1096			if (nvlist_lookup_uint64(events[i],
1097			    ZPOOL_HIST_INT_EVENT, &ievent) != 0)
1098				goto next;
1099			verify(nvlist_lookup_uint64(events[i],
1100			    ZPOOL_HIST_TXG, &txg) == 0);
1101			verify(nvlist_lookup_string(events[i],
1102			    ZPOOL_HIST_INT_STR, &intstr) == 0);
1103			if (ievent >= ZFS_NUM_LEGACY_HISTORY_EVENTS)
1104				goto next;
1105
1106			(void) snprintf(internalstr,
1107			    sizeof (internalstr),
1108			    "[internal %s txg:%lld] %s",
1109			    zfs_history_event_names[ievent], txg,
1110			    intstr);
1111			cmd = internalstr;
1112		}
1113		tsec = time;
1114		(void) localtime_r(&tsec, &t);
1115		(void) strftime(tbuf, sizeof (tbuf), "%F.%T", &t);
1116		(void) printf("%s %s\n", tbuf, cmd);
1117		printed = B_TRUE;
1118
1119next:
1120		if (dump_opt['h'] > 1) {
1121			if (!printed)
1122				(void) printf("unrecognized record:\n");
1123			dump_nvlist(events[i], 2);
1124		}
1125	}
1126}
1127
1128/*ARGSUSED*/
1129static void
1130dump_dnode(objset_t *os, uint64_t object, void *data, size_t size)
1131{
1132}
1133
1134static uint64_t
1135blkid2offset(const dnode_phys_t *dnp, const blkptr_t *bp,
1136    const zbookmark_phys_t *zb)
1137{
1138	if (dnp == NULL) {
1139		ASSERT(zb->zb_level < 0);
1140		if (zb->zb_object == 0)
1141			return (zb->zb_blkid);
1142		return (zb->zb_blkid * BP_GET_LSIZE(bp));
1143	}
1144
1145	ASSERT(zb->zb_level >= 0);
1146
1147	return ((zb->zb_blkid <<
1148	    (zb->zb_level * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT))) *
1149	    dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT);
1150}
1151
1152static void
1153snprintf_blkptr_compact(char *blkbuf, size_t buflen, const blkptr_t *bp)
1154{
1155	const dva_t *dva = bp->blk_dva;
1156	int ndvas = dump_opt['d'] > 5 ? BP_GET_NDVAS(bp) : 1;
1157
1158	if (dump_opt['b'] >= 6) {
1159		snprintf_blkptr(blkbuf, buflen, bp);
1160		return;
1161	}
1162
1163	if (BP_IS_EMBEDDED(bp)) {
1164		(void) sprintf(blkbuf,
1165		    "EMBEDDED et=%u %llxL/%llxP B=%llu",
1166		    (int)BPE_GET_ETYPE(bp),
1167		    (u_longlong_t)BPE_GET_LSIZE(bp),
1168		    (u_longlong_t)BPE_GET_PSIZE(bp),
1169		    (u_longlong_t)bp->blk_birth);
1170		return;
1171	}
1172
1173	blkbuf[0] = '\0';
1174	for (int i = 0; i < ndvas; i++)
1175		(void) snprintf(blkbuf + strlen(blkbuf),
1176		    buflen - strlen(blkbuf), "%llu:%llx:%llx ",
1177		    (u_longlong_t)DVA_GET_VDEV(&dva[i]),
1178		    (u_longlong_t)DVA_GET_OFFSET(&dva[i]),
1179		    (u_longlong_t)DVA_GET_ASIZE(&dva[i]));
1180
1181	if (BP_IS_HOLE(bp)) {
1182		(void) snprintf(blkbuf + strlen(blkbuf),
1183		    buflen - strlen(blkbuf),
1184		    "%llxL B=%llu",
1185		    (u_longlong_t)BP_GET_LSIZE(bp),
1186		    (u_longlong_t)bp->blk_birth);
1187	} else {
1188		(void) snprintf(blkbuf + strlen(blkbuf),
1189		    buflen - strlen(blkbuf),
1190		    "%llxL/%llxP F=%llu B=%llu/%llu",
1191		    (u_longlong_t)BP_GET_LSIZE(bp),
1192		    (u_longlong_t)BP_GET_PSIZE(bp),
1193		    (u_longlong_t)BP_GET_FILL(bp),
1194		    (u_longlong_t)bp->blk_birth,
1195		    (u_longlong_t)BP_PHYSICAL_BIRTH(bp));
1196	}
1197}
1198
1199static void
1200print_indirect(blkptr_t *bp, const zbookmark_phys_t *zb,
1201    const dnode_phys_t *dnp)
1202{
1203	char blkbuf[BP_SPRINTF_LEN];
1204	int l;
1205
1206	if (!BP_IS_EMBEDDED(bp)) {
1207		ASSERT3U(BP_GET_TYPE(bp), ==, dnp->dn_type);
1208		ASSERT3U(BP_GET_LEVEL(bp), ==, zb->zb_level);
1209	}
1210
1211	(void) printf("%16llx ", (u_longlong_t)blkid2offset(dnp, bp, zb));
1212
1213	ASSERT(zb->zb_level >= 0);
1214
1215	for (l = dnp->dn_nlevels - 1; l >= -1; l--) {
1216		if (l == zb->zb_level) {
1217			(void) printf("L%llx", (u_longlong_t)zb->zb_level);
1218		} else {
1219			(void) printf(" ");
1220		}
1221	}
1222
1223	snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), bp);
1224	(void) printf("%s\n", blkbuf);
1225}
1226
1227static int
1228visit_indirect(spa_t *spa, const dnode_phys_t *dnp,
1229    blkptr_t *bp, const zbookmark_phys_t *zb)
1230{
1231	int err = 0;
1232
1233	if (bp->blk_birth == 0)
1234		return (0);
1235
1236	print_indirect(bp, zb, dnp);
1237
1238	if (BP_GET_LEVEL(bp) > 0 && !BP_IS_HOLE(bp)) {
1239		arc_flags_t flags = ARC_FLAG_WAIT;
1240		int i;
1241		blkptr_t *cbp;
1242		int epb = BP_GET_LSIZE(bp) >> SPA_BLKPTRSHIFT;
1243		arc_buf_t *buf;
1244		uint64_t fill = 0;
1245
1246		err = arc_read(NULL, spa, bp, arc_getbuf_func, &buf,
1247		    ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, zb);
1248		if (err)
1249			return (err);
1250		ASSERT(buf->b_data);
1251
1252		/* recursively visit blocks below this */
1253		cbp = buf->b_data;
1254		for (i = 0; i < epb; i++, cbp++) {
1255			zbookmark_phys_t czb;
1256
1257			SET_BOOKMARK(&czb, zb->zb_objset, zb->zb_object,
1258			    zb->zb_level - 1,
1259			    zb->zb_blkid * epb + i);
1260			err = visit_indirect(spa, dnp, cbp, &czb);
1261			if (err)
1262				break;
1263			fill += BP_GET_FILL(cbp);
1264		}
1265		if (!err)
1266			ASSERT3U(fill, ==, BP_GET_FILL(bp));
1267		(void) arc_buf_remove_ref(buf, &buf);
1268	}
1269
1270	return (err);
1271}
1272
1273/*ARGSUSED*/
1274static void
1275dump_indirect(dnode_t *dn)
1276{
1277	dnode_phys_t *dnp = dn->dn_phys;
1278	int j;
1279	zbookmark_phys_t czb;
1280
1281	(void) printf("Indirect blocks:\n");
1282
1283	SET_BOOKMARK(&czb, dmu_objset_id(dn->dn_objset),
1284	    dn->dn_object, dnp->dn_nlevels - 1, 0);
1285	for (j = 0; j < dnp->dn_nblkptr; j++) {
1286		czb.zb_blkid = j;
1287		(void) visit_indirect(dmu_objset_spa(dn->dn_objset), dnp,
1288		    &dnp->dn_blkptr[j], &czb);
1289	}
1290
1291	(void) printf("\n");
1292}
1293
1294/*ARGSUSED*/
1295static void
1296dump_dsl_dir(objset_t *os, uint64_t object, void *data, size_t size)
1297{
1298	dsl_dir_phys_t *dd = data;
1299	time_t crtime;
1300	char nice[32];
1301
1302	if (dd == NULL)
1303		return;
1304
1305	ASSERT3U(size, >=, sizeof (dsl_dir_phys_t));
1306
1307	crtime = dd->dd_creation_time;
1308	(void) printf("\t\tcreation_time = %s", ctime(&crtime));
1309	(void) printf("\t\thead_dataset_obj = %llu\n",
1310	    (u_longlong_t)dd->dd_head_dataset_obj);
1311	(void) printf("\t\tparent_dir_obj = %llu\n",
1312	    (u_longlong_t)dd->dd_parent_obj);
1313	(void) printf("\t\torigin_obj = %llu\n",
1314	    (u_longlong_t)dd->dd_origin_obj);
1315	(void) printf("\t\tchild_dir_zapobj = %llu\n",
1316	    (u_longlong_t)dd->dd_child_dir_zapobj);
1317	zdb_nicenum(dd->dd_used_bytes, nice);
1318	(void) printf("\t\tused_bytes = %s\n", nice);
1319	zdb_nicenum(dd->dd_compressed_bytes, nice);
1320	(void) printf("\t\tcompressed_bytes = %s\n", nice);
1321	zdb_nicenum(dd->dd_uncompressed_bytes, nice);
1322	(void) printf("\t\tuncompressed_bytes = %s\n", nice);
1323	zdb_nicenum(dd->dd_quota, nice);
1324	(void) printf("\t\tquota = %s\n", nice);
1325	zdb_nicenum(dd->dd_reserved, nice);
1326	(void) printf("\t\treserved = %s\n", nice);
1327	(void) printf("\t\tprops_zapobj = %llu\n",
1328	    (u_longlong_t)dd->dd_props_zapobj);
1329	(void) printf("\t\tdeleg_zapobj = %llu\n",
1330	    (u_longlong_t)dd->dd_deleg_zapobj);
1331	(void) printf("\t\tflags = %llx\n",
1332	    (u_longlong_t)dd->dd_flags);
1333
1334#define	DO(which) \
1335	zdb_nicenum(dd->dd_used_breakdown[DD_USED_ ## which], nice); \
1336	(void) printf("\t\tused_breakdown[" #which "] = %s\n", nice)
1337	DO(HEAD);
1338	DO(SNAP);
1339	DO(CHILD);
1340	DO(CHILD_RSRV);
1341	DO(REFRSRV);
1342#undef DO
1343}
1344
1345/*ARGSUSED*/
1346static void
1347dump_dsl_dataset(objset_t *os, uint64_t object, void *data, size_t size)
1348{
1349	dsl_dataset_phys_t *ds = data;
1350	time_t crtime;
1351	char used[32], compressed[32], uncompressed[32], unique[32];
1352	char blkbuf[BP_SPRINTF_LEN];
1353
1354	if (ds == NULL)
1355		return;
1356
1357	ASSERT(size == sizeof (*ds));
1358	crtime = ds->ds_creation_time;
1359	zdb_nicenum(ds->ds_referenced_bytes, used);
1360	zdb_nicenum(ds->ds_compressed_bytes, compressed);
1361	zdb_nicenum(ds->ds_uncompressed_bytes, uncompressed);
1362	zdb_nicenum(ds->ds_unique_bytes, unique);
1363	snprintf_blkptr(blkbuf, sizeof (blkbuf), &ds->ds_bp);
1364
1365	(void) printf("\t\tdir_obj = %llu\n",
1366	    (u_longlong_t)ds->ds_dir_obj);
1367	(void) printf("\t\tprev_snap_obj = %llu\n",
1368	    (u_longlong_t)ds->ds_prev_snap_obj);
1369	(void) printf("\t\tprev_snap_txg = %llu\n",
1370	    (u_longlong_t)ds->ds_prev_snap_txg);
1371	(void) printf("\t\tnext_snap_obj = %llu\n",
1372	    (u_longlong_t)ds->ds_next_snap_obj);
1373	(void) printf("\t\tsnapnames_zapobj = %llu\n",
1374	    (u_longlong_t)ds->ds_snapnames_zapobj);
1375	(void) printf("\t\tnum_children = %llu\n",
1376	    (u_longlong_t)ds->ds_num_children);
1377	(void) printf("\t\tuserrefs_obj = %llu\n",
1378	    (u_longlong_t)ds->ds_userrefs_obj);
1379	(void) printf("\t\tcreation_time = %s", ctime(&crtime));
1380	(void) printf("\t\tcreation_txg = %llu\n",
1381	    (u_longlong_t)ds->ds_creation_txg);
1382	(void) printf("\t\tdeadlist_obj = %llu\n",
1383	    (u_longlong_t)ds->ds_deadlist_obj);
1384	(void) printf("\t\tused_bytes = %s\n", used);
1385	(void) printf("\t\tcompressed_bytes = %s\n", compressed);
1386	(void) printf("\t\tuncompressed_bytes = %s\n", uncompressed);
1387	(void) printf("\t\tunique = %s\n", unique);
1388	(void) printf("\t\tfsid_guid = %llu\n",
1389	    (u_longlong_t)ds->ds_fsid_guid);
1390	(void) printf("\t\tguid = %llu\n",
1391	    (u_longlong_t)ds->ds_guid);
1392	(void) printf("\t\tflags = %llx\n",
1393	    (u_longlong_t)ds->ds_flags);
1394	(void) printf("\t\tnext_clones_obj = %llu\n",
1395	    (u_longlong_t)ds->ds_next_clones_obj);
1396	(void) printf("\t\tprops_obj = %llu\n",
1397	    (u_longlong_t)ds->ds_props_obj);
1398	(void) printf("\t\tbp = %s\n", blkbuf);
1399}
1400
1401/* ARGSUSED */
1402static int
1403dump_bptree_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
1404{
1405	char blkbuf[BP_SPRINTF_LEN];
1406
1407	if (bp->blk_birth != 0) {
1408		snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
1409		(void) printf("\t%s\n", blkbuf);
1410	}
1411	return (0);
1412}
1413
1414static void
1415dump_bptree(objset_t *os, uint64_t obj, char *name)
1416{
1417	char bytes[32];
1418	bptree_phys_t *bt;
1419	dmu_buf_t *db;
1420
1421	if (dump_opt['d'] < 3)
1422		return;
1423
1424	VERIFY3U(0, ==, dmu_bonus_hold(os, obj, FTAG, &db));
1425	bt = db->db_data;
1426	zdb_nicenum(bt->bt_bytes, bytes);
1427	(void) printf("\n    %s: %llu datasets, %s\n",
1428	    name, (unsigned long long)(bt->bt_end - bt->bt_begin), bytes);
1429	dmu_buf_rele(db, FTAG);
1430
1431	if (dump_opt['d'] < 5)
1432		return;
1433
1434	(void) printf("\n");
1435
1436	(void) bptree_iterate(os, obj, B_FALSE, dump_bptree_cb, NULL, NULL);
1437}
1438
1439/* ARGSUSED */
1440static int
1441dump_bpobj_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
1442{
1443	char blkbuf[BP_SPRINTF_LEN];
1444
1445	ASSERT(bp->blk_birth != 0);
1446	snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), bp);
1447	(void) printf("\t%s\n", blkbuf);
1448	return (0);
1449}
1450
1451static void
1452dump_full_bpobj(bpobj_t *bpo, char *name, int indent)
1453{
1454	char bytes[32];
1455	char comp[32];
1456	char uncomp[32];
1457
1458	if (dump_opt['d'] < 3)
1459		return;
1460
1461	zdb_nicenum(bpo->bpo_phys->bpo_bytes, bytes);
1462	if (bpo->bpo_havesubobj && bpo->bpo_phys->bpo_subobjs != 0) {
1463		zdb_nicenum(bpo->bpo_phys->bpo_comp, comp);
1464		zdb_nicenum(bpo->bpo_phys->bpo_uncomp, uncomp);
1465		(void) printf("    %*s: object %llu, %llu local blkptrs, "
1466		    "%llu subobjs in object %llu, %s (%s/%s comp)\n",
1467		    indent * 8, name,
1468		    (u_longlong_t)bpo->bpo_object,
1469		    (u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
1470		    (u_longlong_t)bpo->bpo_phys->bpo_num_subobjs,
1471		    (u_longlong_t)bpo->bpo_phys->bpo_subobjs,
1472		    bytes, comp, uncomp);
1473
1474		for (uint64_t i = 0; i < bpo->bpo_phys->bpo_num_subobjs; i++) {
1475			uint64_t subobj;
1476			bpobj_t subbpo;
1477			int error;
1478			VERIFY0(dmu_read(bpo->bpo_os,
1479			    bpo->bpo_phys->bpo_subobjs,
1480			    i * sizeof (subobj), sizeof (subobj), &subobj, 0));
1481			error = bpobj_open(&subbpo, bpo->bpo_os, subobj);
1482			if (error != 0) {
1483				(void) printf("ERROR %u while trying to open "
1484				    "subobj id %llu\n",
1485				    error, (u_longlong_t)subobj);
1486				continue;
1487			}
1488			dump_full_bpobj(&subbpo, "subobj", indent + 1);
1489			bpobj_close(&subbpo);
1490		}
1491	} else {
1492		(void) printf("    %*s: object %llu, %llu blkptrs, %s\n",
1493		    indent * 8, name,
1494		    (u_longlong_t)bpo->bpo_object,
1495		    (u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
1496		    bytes);
1497	}
1498
1499	if (dump_opt['d'] < 5)
1500		return;
1501
1502
1503	if (indent == 0) {
1504		(void) bpobj_iterate_nofree(bpo, dump_bpobj_cb, NULL, NULL);
1505		(void) printf("\n");
1506	}
1507}
1508
1509static void
1510dump_deadlist(dsl_deadlist_t *dl)
1511{
1512	dsl_deadlist_entry_t *dle;
1513	uint64_t unused;
1514	char bytes[32];
1515	char comp[32];
1516	char uncomp[32];
1517
1518	if (dump_opt['d'] < 3)
1519		return;
1520
1521	if (dl->dl_oldfmt) {
1522		dump_full_bpobj(&dl->dl_bpobj, "old-format deadlist", 0);
1523		return;
1524	}
1525
1526	zdb_nicenum(dl->dl_phys->dl_used, bytes);
1527	zdb_nicenum(dl->dl_phys->dl_comp, comp);
1528	zdb_nicenum(dl->dl_phys->dl_uncomp, uncomp);
1529	(void) printf("\n    Deadlist: %s (%s/%s comp)\n",
1530	    bytes, comp, uncomp);
1531
1532	if (dump_opt['d'] < 4)
1533		return;
1534
1535	(void) printf("\n");
1536
1537	/* force the tree to be loaded */
1538	dsl_deadlist_space_range(dl, 0, UINT64_MAX, &unused, &unused, &unused);
1539
1540	for (dle = avl_first(&dl->dl_tree); dle;
1541	    dle = AVL_NEXT(&dl->dl_tree, dle)) {
1542		if (dump_opt['d'] >= 5) {
1543			char buf[128];
1544			(void) snprintf(buf, sizeof (buf), "mintxg %llu -> ",
1545			    (longlong_t)dle->dle_mintxg,
1546			    (longlong_t)dle->dle_bpobj.bpo_object);
1547
1548			dump_full_bpobj(&dle->dle_bpobj, buf, 0);
1549		} else {
1550			(void) printf("mintxg %llu -> obj %llu\n",
1551			    (longlong_t)dle->dle_mintxg,
1552			    (longlong_t)dle->dle_bpobj.bpo_object);
1553
1554		}
1555	}
1556}
1557
1558static avl_tree_t idx_tree;
1559static avl_tree_t domain_tree;
1560static boolean_t fuid_table_loaded;
1561static boolean_t sa_loaded;
1562sa_attr_type_t *sa_attr_table;
1563
1564static void
1565fuid_table_destroy()
1566{
1567	if (fuid_table_loaded) {
1568		zfs_fuid_table_destroy(&idx_tree, &domain_tree);
1569		fuid_table_loaded = B_FALSE;
1570	}
1571}
1572
1573/*
1574 * print uid or gid information.
1575 * For normal POSIX id just the id is printed in decimal format.
1576 * For CIFS files with FUID the fuid is printed in hex followed by
1577 * the domain-rid string.
1578 */
1579static void
1580print_idstr(uint64_t id, const char *id_type)
1581{
1582	if (FUID_INDEX(id)) {
1583		char *domain;
1584
1585		domain = zfs_fuid_idx_domain(&idx_tree, FUID_INDEX(id));
1586		(void) printf("\t%s     %llx [%s-%d]\n", id_type,
1587		    (u_longlong_t)id, domain, (int)FUID_RID(id));
1588	} else {
1589		(void) printf("\t%s     %llu\n", id_type, (u_longlong_t)id);
1590	}
1591
1592}
1593
1594static void
1595dump_uidgid(objset_t *os, uint64_t uid, uint64_t gid)
1596{
1597	uint32_t uid_idx, gid_idx;
1598
1599	uid_idx = FUID_INDEX(uid);
1600	gid_idx = FUID_INDEX(gid);
1601
1602	/* Load domain table, if not already loaded */
1603	if (!fuid_table_loaded && (uid_idx || gid_idx)) {
1604		uint64_t fuid_obj;
1605
1606		/* first find the fuid object.  It lives in the master node */
1607		VERIFY(zap_lookup(os, MASTER_NODE_OBJ, ZFS_FUID_TABLES,
1608		    8, 1, &fuid_obj) == 0);
1609		zfs_fuid_avl_tree_create(&idx_tree, &domain_tree);
1610		(void) zfs_fuid_table_load(os, fuid_obj,
1611		    &idx_tree, &domain_tree);
1612		fuid_table_loaded = B_TRUE;
1613	}
1614
1615	print_idstr(uid, "uid");
1616	print_idstr(gid, "gid");
1617}
1618
1619/*ARGSUSED*/
1620static void
1621dump_znode(objset_t *os, uint64_t object, void *data, size_t size)
1622{
1623	char path[MAXPATHLEN * 2];	/* allow for xattr and failure prefix */
1624	sa_handle_t *hdl;
1625	uint64_t xattr, rdev, gen;
1626	uint64_t uid, gid, mode, fsize, parent, links;
1627	uint64_t pflags;
1628	uint64_t acctm[2], modtm[2], chgtm[2], crtm[2];
1629	time_t z_crtime, z_atime, z_mtime, z_ctime;
1630	sa_bulk_attr_t bulk[12];
1631	int idx = 0;
1632	int error;
1633
1634	if (!sa_loaded) {
1635		uint64_t sa_attrs = 0;
1636		uint64_t version;
1637
1638		VERIFY(zap_lookup(os, MASTER_NODE_OBJ, ZPL_VERSION_STR,
1639		    8, 1, &version) == 0);
1640		if (version >= ZPL_VERSION_SA) {
1641			VERIFY(zap_lookup(os, MASTER_NODE_OBJ, ZFS_SA_ATTRS,
1642			    8, 1, &sa_attrs) == 0);
1643		}
1644		if ((error = sa_setup(os, sa_attrs, zfs_attr_table,
1645		    ZPL_END, &sa_attr_table)) != 0) {
1646			(void) printf("sa_setup failed errno %d, can't "
1647			    "display znode contents\n", error);
1648			return;
1649		}
1650		sa_loaded = B_TRUE;
1651	}
1652
1653	if (sa_handle_get(os, object, NULL, SA_HDL_PRIVATE, &hdl)) {
1654		(void) printf("Failed to get handle for SA znode\n");
1655		return;
1656	}
1657
1658	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_UID], NULL, &uid, 8);
1659	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_GID], NULL, &gid, 8);
1660	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_LINKS], NULL,
1661	    &links, 8);
1662	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_GEN], NULL, &gen, 8);
1663	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_MODE], NULL,
1664	    &mode, 8);
1665	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_PARENT],
1666	    NULL, &parent, 8);
1667	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_SIZE], NULL,
1668	    &fsize, 8);
1669	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_ATIME], NULL,
1670	    acctm, 16);
1671	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_MTIME], NULL,
1672	    modtm, 16);
1673	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_CRTIME], NULL,
1674	    crtm, 16);
1675	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_CTIME], NULL,
1676	    chgtm, 16);
1677	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_FLAGS], NULL,
1678	    &pflags, 8);
1679
1680	if (sa_bulk_lookup(hdl, bulk, idx)) {
1681		(void) sa_handle_destroy(hdl);
1682		return;
1683	}
1684
1685	error = zfs_obj_to_path(os, object, path, sizeof (path));
1686	if (error != 0) {
1687		(void) snprintf(path, sizeof (path), "\?\?\?<object#%llu>",
1688		    (u_longlong_t)object);
1689	}
1690	if (dump_opt['d'] < 3) {
1691		(void) printf("\t%s\n", path);
1692		(void) sa_handle_destroy(hdl);
1693		return;
1694	}
1695
1696	z_crtime = (time_t)crtm[0];
1697	z_atime = (time_t)acctm[0];
1698	z_mtime = (time_t)modtm[0];
1699	z_ctime = (time_t)chgtm[0];
1700
1701	(void) printf("\tpath	%s\n", path);
1702	dump_uidgid(os, uid, gid);
1703	(void) printf("\tatime	%s", ctime(&z_atime));
1704	(void) printf("\tmtime	%s", ctime(&z_mtime));
1705	(void) printf("\tctime	%s", ctime(&z_ctime));
1706	(void) printf("\tcrtime	%s", ctime(&z_crtime));
1707	(void) printf("\tgen	%llu\n", (u_longlong_t)gen);
1708	(void) printf("\tmode	%llo\n", (u_longlong_t)mode);
1709	(void) printf("\tsize	%llu\n", (u_longlong_t)fsize);
1710	(void) printf("\tparent	%llu\n", (u_longlong_t)parent);
1711	(void) printf("\tlinks	%llu\n", (u_longlong_t)links);
1712	(void) printf("\tpflags	%llx\n", (u_longlong_t)pflags);
1713	if (sa_lookup(hdl, sa_attr_table[ZPL_XATTR], &xattr,
1714	    sizeof (uint64_t)) == 0)
1715		(void) printf("\txattr	%llu\n", (u_longlong_t)xattr);
1716	if (sa_lookup(hdl, sa_attr_table[ZPL_RDEV], &rdev,
1717	    sizeof (uint64_t)) == 0)
1718		(void) printf("\trdev	0x%016llx\n", (u_longlong_t)rdev);
1719	sa_handle_destroy(hdl);
1720}
1721
1722/*ARGSUSED*/
1723static void
1724dump_acl(objset_t *os, uint64_t object, void *data, size_t size)
1725{
1726}
1727
1728/*ARGSUSED*/
1729static void
1730dump_dmu_objset(objset_t *os, uint64_t object, void *data, size_t size)
1731{
1732}
1733
1734static object_viewer_t *object_viewer[DMU_OT_NUMTYPES + 1] = {
1735	dump_none,		/* unallocated			*/
1736	dump_zap,		/* object directory		*/
1737	dump_uint64,		/* object array			*/
1738	dump_none,		/* packed nvlist		*/
1739	dump_packed_nvlist,	/* packed nvlist size		*/
1740	dump_none,		/* bpobj			*/
1741	dump_bpobj,		/* bpobj header			*/
1742	dump_none,		/* SPA space map header		*/
1743	dump_none,		/* SPA space map		*/
1744	dump_none,		/* ZIL intent log		*/
1745	dump_dnode,		/* DMU dnode			*/
1746	dump_dmu_objset,	/* DMU objset			*/
1747	dump_dsl_dir,		/* DSL directory		*/
1748	dump_zap,		/* DSL directory child map	*/
1749	dump_zap,		/* DSL dataset snap map		*/
1750	dump_zap,		/* DSL props			*/
1751	dump_dsl_dataset,	/* DSL dataset			*/
1752	dump_znode,		/* ZFS znode			*/
1753	dump_acl,		/* ZFS V0 ACL			*/
1754	dump_uint8,		/* ZFS plain file		*/
1755	dump_zpldir,		/* ZFS directory		*/
1756	dump_zap,		/* ZFS master node		*/
1757	dump_zap,		/* ZFS delete queue		*/
1758	dump_uint8,		/* zvol object			*/
1759	dump_zap,		/* zvol prop			*/
1760	dump_uint8,		/* other uint8[]		*/
1761	dump_uint64,		/* other uint64[]		*/
1762	dump_zap,		/* other ZAP			*/
1763	dump_zap,		/* persistent error log		*/
1764	dump_uint8,		/* SPA history			*/
1765	dump_history_offsets,	/* SPA history offsets		*/
1766	dump_zap,		/* Pool properties		*/
1767	dump_zap,		/* DSL permissions		*/
1768	dump_acl,		/* ZFS ACL			*/
1769	dump_uint8,		/* ZFS SYSACL			*/
1770	dump_none,		/* FUID nvlist			*/
1771	dump_packed_nvlist,	/* FUID nvlist size		*/
1772	dump_zap,		/* DSL dataset next clones	*/
1773	dump_zap,		/* DSL scrub queue		*/
1774	dump_zap,		/* ZFS user/group used		*/
1775	dump_zap,		/* ZFS user/group quota		*/
1776	dump_zap,		/* snapshot refcount tags	*/
1777	dump_ddt_zap,		/* DDT ZAP object		*/
1778	dump_zap,		/* DDT statistics		*/
1779	dump_znode,		/* SA object			*/
1780	dump_zap,		/* SA Master Node		*/
1781	dump_sa_attrs,		/* SA attribute registration	*/
1782	dump_sa_layouts,	/* SA attribute layouts		*/
1783	dump_zap,		/* DSL scrub translations	*/
1784	dump_none,		/* fake dedup BP		*/
1785	dump_zap,		/* deadlist			*/
1786	dump_none,		/* deadlist hdr			*/
1787	dump_zap,		/* dsl clones			*/
1788	dump_bpobj_subobjs,	/* bpobj subobjs		*/
1789	dump_unknown,		/* Unknown type, must be last	*/
1790};
1791
1792static void
1793dump_object(objset_t *os, uint64_t object, int verbosity, int *print_header)
1794{
1795	dmu_buf_t *db = NULL;
1796	dmu_object_info_t doi;
1797	dnode_t *dn;
1798	void *bonus = NULL;
1799	size_t bsize = 0;
1800	char iblk[32], dblk[32], lsize[32], asize[32], fill[32];
1801	char bonus_size[32];
1802	char aux[50];
1803	int error;
1804
1805	if (*print_header) {
1806		(void) printf("\n%10s  %3s  %5s  %5s  %5s  %5s  %6s  %s\n",
1807		    "Object", "lvl", "iblk", "dblk", "dsize", "lsize",
1808		    "%full", "type");
1809		*print_header = 0;
1810	}
1811
1812	if (object == 0) {
1813		dn = DMU_META_DNODE(os);
1814	} else {
1815		error = dmu_bonus_hold(os, object, FTAG, &db);
1816		if (error)
1817			fatal("dmu_bonus_hold(%llu) failed, errno %u",
1818			    object, error);
1819		bonus = db->db_data;
1820		bsize = db->db_size;
1821		dn = DB_DNODE((dmu_buf_impl_t *)db);
1822	}
1823	dmu_object_info_from_dnode(dn, &doi);
1824
1825	zdb_nicenum(doi.doi_metadata_block_size, iblk);
1826	zdb_nicenum(doi.doi_data_block_size, dblk);
1827	zdb_nicenum(doi.doi_max_offset, lsize);
1828	zdb_nicenum(doi.doi_physical_blocks_512 << 9, asize);
1829	zdb_nicenum(doi.doi_bonus_size, bonus_size);
1830	(void) sprintf(fill, "%6.2f", 100.0 * doi.doi_fill_count *
1831	    doi.doi_data_block_size / (object == 0 ? DNODES_PER_BLOCK : 1) /
1832	    doi.doi_max_offset);
1833
1834	aux[0] = '\0';
1835
1836	if (doi.doi_checksum != ZIO_CHECKSUM_INHERIT || verbosity >= 6) {
1837		(void) snprintf(aux + strlen(aux), sizeof (aux), " (K=%s)",
1838		    ZDB_CHECKSUM_NAME(doi.doi_checksum));
1839	}
1840
1841	if (doi.doi_compress != ZIO_COMPRESS_INHERIT || verbosity >= 6) {
1842		(void) snprintf(aux + strlen(aux), sizeof (aux), " (Z=%s)",
1843		    ZDB_COMPRESS_NAME(doi.doi_compress));
1844	}
1845
1846	(void) printf("%10lld  %3u  %5s  %5s  %5s  %5s  %6s  %s%s\n",
1847	    (u_longlong_t)object, doi.doi_indirection, iblk, dblk,
1848	    asize, lsize, fill, ZDB_OT_NAME(doi.doi_type), aux);
1849
1850	if (doi.doi_bonus_type != DMU_OT_NONE && verbosity > 3) {
1851		(void) printf("%10s  %3s  %5s  %5s  %5s  %5s  %6s  %s\n",
1852		    "", "", "", "", "", bonus_size, "bonus",
1853		    ZDB_OT_NAME(doi.doi_bonus_type));
1854	}
1855
1856	if (verbosity >= 4) {
1857		(void) printf("\tdnode flags: %s%s%s\n",
1858		    (dn->dn_phys->dn_flags & DNODE_FLAG_USED_BYTES) ?
1859		    "USED_BYTES " : "",
1860		    (dn->dn_phys->dn_flags & DNODE_FLAG_USERUSED_ACCOUNTED) ?
1861		    "USERUSED_ACCOUNTED " : "",
1862		    (dn->dn_phys->dn_flags & DNODE_FLAG_SPILL_BLKPTR) ?
1863		    "SPILL_BLKPTR" : "");
1864		(void) printf("\tdnode maxblkid: %llu\n",
1865		    (longlong_t)dn->dn_phys->dn_maxblkid);
1866
1867		object_viewer[ZDB_OT_TYPE(doi.doi_bonus_type)](os, object,
1868		    bonus, bsize);
1869		object_viewer[ZDB_OT_TYPE(doi.doi_type)](os, object, NULL, 0);
1870		*print_header = 1;
1871	}
1872
1873	if (verbosity >= 5)
1874		dump_indirect(dn);
1875
1876	if (verbosity >= 5) {
1877		/*
1878		 * Report the list of segments that comprise the object.
1879		 */
1880		uint64_t start = 0;
1881		uint64_t end;
1882		uint64_t blkfill = 1;
1883		int minlvl = 1;
1884
1885		if (dn->dn_type == DMU_OT_DNODE) {
1886			minlvl = 0;
1887			blkfill = DNODES_PER_BLOCK;
1888		}
1889
1890		for (;;) {
1891			char segsize[32];
1892			error = dnode_next_offset(dn,
1893			    0, &start, minlvl, blkfill, 0);
1894			if (error)
1895				break;
1896			end = start;
1897			error = dnode_next_offset(dn,
1898			    DNODE_FIND_HOLE, &end, minlvl, blkfill, 0);
1899			zdb_nicenum(end - start, segsize);
1900			(void) printf("\t\tsegment [%016llx, %016llx)"
1901			    " size %5s\n", (u_longlong_t)start,
1902			    (u_longlong_t)end, segsize);
1903			if (error)
1904				break;
1905			start = end;
1906		}
1907	}
1908
1909	if (db != NULL)
1910		dmu_buf_rele(db, FTAG);
1911}
1912
1913static char *objset_types[DMU_OST_NUMTYPES] = {
1914	"NONE", "META", "ZPL", "ZVOL", "OTHER", "ANY" };
1915
1916static void
1917dump_dir(objset_t *os)
1918{
1919	dmu_objset_stats_t dds;
1920	uint64_t object, object_count;
1921	uint64_t refdbytes, usedobjs, scratch;
1922	char numbuf[32];
1923	char blkbuf[BP_SPRINTF_LEN + 20];
1924	char osname[MAXNAMELEN];
1925	char *type = "UNKNOWN";
1926	int verbosity = dump_opt['d'];
1927	int print_header = 1;
1928	int i, error;
1929
1930	dsl_pool_config_enter(dmu_objset_pool(os), FTAG);
1931	dmu_objset_fast_stat(os, &dds);
1932	dsl_pool_config_exit(dmu_objset_pool(os), FTAG);
1933
1934	if (dds.dds_type < DMU_OST_NUMTYPES)
1935		type = objset_types[dds.dds_type];
1936
1937	if (dds.dds_type == DMU_OST_META) {
1938		dds.dds_creation_txg = TXG_INITIAL;
1939		usedobjs = BP_GET_FILL(os->os_rootbp);
1940		refdbytes = dsl_dir_phys(os->os_spa->spa_dsl_pool->dp_mos_dir)->
1941		    dd_used_bytes;
1942	} else {
1943		dmu_objset_space(os, &refdbytes, &scratch, &usedobjs, &scratch);
1944	}
1945
1946	ASSERT3U(usedobjs, ==, BP_GET_FILL(os->os_rootbp));
1947
1948	zdb_nicenum(refdbytes, numbuf);
1949
1950	if (verbosity >= 4) {
1951		(void) snprintf(blkbuf, sizeof (blkbuf), ", rootbp ");
1952		(void) snprintf_blkptr(blkbuf + strlen(blkbuf),
1953		    sizeof (blkbuf) - strlen(blkbuf), os->os_rootbp);
1954	} else {
1955		blkbuf[0] = '\0';
1956	}
1957
1958	dmu_objset_name(os, osname);
1959
1960	(void) printf("Dataset %s [%s], ID %llu, cr_txg %llu, "
1961	    "%s, %llu objects%s\n",
1962	    osname, type, (u_longlong_t)dmu_objset_id(os),
1963	    (u_longlong_t)dds.dds_creation_txg,
1964	    numbuf, (u_longlong_t)usedobjs, blkbuf);
1965
1966	if (zopt_objects != 0) {
1967		for (i = 0; i < zopt_objects; i++)
1968			dump_object(os, zopt_object[i], verbosity,
1969			    &print_header);
1970		(void) printf("\n");
1971		return;
1972	}
1973
1974	if (dump_opt['i'] != 0 || verbosity >= 2)
1975		dump_intent_log(dmu_objset_zil(os));
1976
1977	if (dmu_objset_ds(os) != NULL)
1978		dump_deadlist(&dmu_objset_ds(os)->ds_deadlist);
1979
1980	if (verbosity < 2)
1981		return;
1982
1983	if (BP_IS_HOLE(os->os_rootbp))
1984		return;
1985
1986	dump_object(os, 0, verbosity, &print_header);
1987	object_count = 0;
1988	if (DMU_USERUSED_DNODE(os) != NULL &&
1989	    DMU_USERUSED_DNODE(os)->dn_type != 0) {
1990		dump_object(os, DMU_USERUSED_OBJECT, verbosity, &print_header);
1991		dump_object(os, DMU_GROUPUSED_OBJECT, verbosity, &print_header);
1992	}
1993
1994	object = 0;
1995	while ((error = dmu_object_next(os, &object, B_FALSE, 0)) == 0) {
1996		dump_object(os, object, verbosity, &print_header);
1997		object_count++;
1998	}
1999
2000	ASSERT3U(object_count, ==, usedobjs);
2001
2002	(void) printf("\n");
2003
2004	if (error != ESRCH) {
2005		(void) fprintf(stderr, "dmu_object_next() = %d\n", error);
2006		abort();
2007	}
2008}
2009
2010static void
2011dump_uberblock(uberblock_t *ub, const char *header, const char *footer)
2012{
2013	time_t timestamp = ub->ub_timestamp;
2014
2015	(void) printf(header ? header : "");
2016	(void) printf("\tmagic = %016llx\n", (u_longlong_t)ub->ub_magic);
2017	(void) printf("\tversion = %llu\n", (u_longlong_t)ub->ub_version);
2018	(void) printf("\ttxg = %llu\n", (u_longlong_t)ub->ub_txg);
2019	(void) printf("\tguid_sum = %llu\n", (u_longlong_t)ub->ub_guid_sum);
2020	(void) printf("\ttimestamp = %llu UTC = %s",
2021	    (u_longlong_t)ub->ub_timestamp, asctime(localtime(&timestamp)));
2022	if (dump_opt['u'] >= 3) {
2023		char blkbuf[BP_SPRINTF_LEN];
2024		snprintf_blkptr(blkbuf, sizeof (blkbuf), &ub->ub_rootbp);
2025		(void) printf("\trootbp = %s\n", blkbuf);
2026	}
2027	(void) printf(footer ? footer : "");
2028}
2029
2030static void
2031dump_config(spa_t *spa)
2032{
2033	dmu_buf_t *db;
2034	size_t nvsize = 0;
2035	int error = 0;
2036
2037
2038	error = dmu_bonus_hold(spa->spa_meta_objset,
2039	    spa->spa_config_object, FTAG, &db);
2040
2041	if (error == 0) {
2042		nvsize = *(uint64_t *)db->db_data;
2043		dmu_buf_rele(db, FTAG);
2044
2045		(void) printf("\nMOS Configuration:\n");
2046		dump_packed_nvlist(spa->spa_meta_objset,
2047		    spa->spa_config_object, (void *)&nvsize, 1);
2048	} else {
2049		(void) fprintf(stderr, "dmu_bonus_hold(%llu) failed, errno %d",
2050		    (u_longlong_t)spa->spa_config_object, error);
2051	}
2052}
2053
2054static void
2055dump_cachefile(const char *cachefile)
2056{
2057	int fd;
2058	struct stat64 statbuf;
2059	char *buf;
2060	nvlist_t *config;
2061
2062	if ((fd = open64(cachefile, O_RDONLY)) < 0) {
2063		(void) printf("cannot open '%s': %s\n", cachefile,
2064		    strerror(errno));
2065		exit(1);
2066	}
2067
2068	if (fstat64(fd, &statbuf) != 0) {
2069		(void) printf("failed to stat '%s': %s\n", cachefile,
2070		    strerror(errno));
2071		exit(1);
2072	}
2073
2074	if ((buf = malloc(statbuf.st_size)) == NULL) {
2075		(void) fprintf(stderr, "failed to allocate %llu bytes\n",
2076		    (u_longlong_t)statbuf.st_size);
2077		exit(1);
2078	}
2079
2080	if (read(fd, buf, statbuf.st_size) != statbuf.st_size) {
2081		(void) fprintf(stderr, "failed to read %llu bytes\n",
2082		    (u_longlong_t)statbuf.st_size);
2083		exit(1);
2084	}
2085
2086	(void) close(fd);
2087
2088	if (nvlist_unpack(buf, statbuf.st_size, &config, 0) != 0) {
2089		(void) fprintf(stderr, "failed to unpack nvlist\n");
2090		exit(1);
2091	}
2092
2093	free(buf);
2094
2095	dump_nvlist(config, 0);
2096
2097	nvlist_free(config);
2098}
2099
2100#define	ZDB_MAX_UB_HEADER_SIZE 32
2101
2102static void
2103dump_label_uberblocks(vdev_label_t *lbl, uint64_t ashift)
2104{
2105	vdev_t vd;
2106	vdev_t *vdp = &vd;
2107	char header[ZDB_MAX_UB_HEADER_SIZE];
2108
2109	vd.vdev_ashift = ashift;
2110	vdp->vdev_top = vdp;
2111
2112	for (int i = 0; i < VDEV_UBERBLOCK_COUNT(vdp); i++) {
2113		uint64_t uoff = VDEV_UBERBLOCK_OFFSET(vdp, i);
2114		uberblock_t *ub = (void *)((char *)lbl + uoff);
2115
2116		if (uberblock_verify(ub))
2117			continue;
2118		(void) snprintf(header, ZDB_MAX_UB_HEADER_SIZE,
2119		    "Uberblock[%d]\n", i);
2120		dump_uberblock(ub, header, "");
2121	}
2122}
2123
2124static void
2125dump_label(const char *dev)
2126{
2127	int fd;
2128	vdev_label_t label;
2129	char *path, *buf = label.vl_vdev_phys.vp_nvlist;
2130	size_t buflen = sizeof (label.vl_vdev_phys.vp_nvlist);
2131	struct stat64 statbuf;
2132	uint64_t psize, ashift;
2133	int len = strlen(dev) + 1;
2134
2135	if (strncmp(dev, "/dev/dsk/", 9) == 0) {
2136		len++;
2137		path = malloc(len);
2138		(void) snprintf(path, len, "%s%s", "/dev/rdsk/", dev + 9);
2139	} else {
2140		path = strdup(dev);
2141	}
2142
2143	if ((fd = open64(path, O_RDONLY)) < 0) {
2144		(void) printf("cannot open '%s': %s\n", path, strerror(errno));
2145		free(path);
2146		exit(1);
2147	}
2148
2149	if (fstat64(fd, &statbuf) != 0) {
2150		(void) printf("failed to stat '%s': %s\n", path,
2151		    strerror(errno));
2152		free(path);
2153		(void) close(fd);
2154		exit(1);
2155	}
2156
2157	if (S_ISBLK(statbuf.st_mode)) {
2158		(void) printf("cannot use '%s': character device required\n",
2159		    path);
2160		free(path);
2161		(void) close(fd);
2162		exit(1);
2163	}
2164
2165	psize = statbuf.st_size;
2166	psize = P2ALIGN(psize, (uint64_t)sizeof (vdev_label_t));
2167
2168	for (int l = 0; l < VDEV_LABELS; l++) {
2169		nvlist_t *config = NULL;
2170
2171		(void) printf("--------------------------------------------\n");
2172		(void) printf("LABEL %d\n", l);
2173		(void) printf("--------------------------------------------\n");
2174
2175		if (pread64(fd, &label, sizeof (label),
2176		    vdev_label_offset(psize, l, 0)) != sizeof (label)) {
2177			(void) printf("failed to read label %d\n", l);
2178			continue;
2179		}
2180
2181		if (nvlist_unpack(buf, buflen, &config, 0) != 0) {
2182			(void) printf("failed to unpack label %d\n", l);
2183			ashift = SPA_MINBLOCKSHIFT;
2184		} else {
2185			nvlist_t *vdev_tree = NULL;
2186
2187			dump_nvlist(config, 4);
2188			if ((nvlist_lookup_nvlist(config,
2189			    ZPOOL_CONFIG_VDEV_TREE, &vdev_tree) != 0) ||
2190			    (nvlist_lookup_uint64(vdev_tree,
2191			    ZPOOL_CONFIG_ASHIFT, &ashift) != 0))
2192				ashift = SPA_MINBLOCKSHIFT;
2193			nvlist_free(config);
2194		}
2195		if (dump_opt['u'])
2196			dump_label_uberblocks(&label, ashift);
2197	}
2198
2199	free(path);
2200	(void) close(fd);
2201}
2202
2203static uint64_t dataset_feature_count[SPA_FEATURES];
2204
2205/*ARGSUSED*/
2206static int
2207dump_one_dir(const char *dsname, void *arg)
2208{
2209	int error;
2210	objset_t *os;
2211
2212	error = dmu_objset_own(dsname, DMU_OST_ANY, B_TRUE, FTAG, &os);
2213	if (error) {
2214		(void) printf("Could not open %s, error %d\n", dsname, error);
2215		return (0);
2216	}
2217
2218	for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
2219		if (!dmu_objset_ds(os)->ds_feature_inuse[f])
2220			continue;
2221		ASSERT(spa_feature_table[f].fi_flags &
2222		    ZFEATURE_FLAG_PER_DATASET);
2223		dataset_feature_count[f]++;
2224	}
2225
2226	dump_dir(os);
2227	dmu_objset_disown(os, FTAG);
2228	fuid_table_destroy();
2229	sa_loaded = B_FALSE;
2230	return (0);
2231}
2232
2233/*
2234 * Block statistics.
2235 */
2236#define	PSIZE_HISTO_SIZE (SPA_OLD_MAXBLOCKSIZE / SPA_MINBLOCKSIZE + 2)
2237typedef struct zdb_blkstats {
2238	uint64_t zb_asize;
2239	uint64_t zb_lsize;
2240	uint64_t zb_psize;
2241	uint64_t zb_count;
2242	uint64_t zb_gangs;
2243	uint64_t zb_ditto_samevdev;
2244	uint64_t zb_psize_histogram[PSIZE_HISTO_SIZE];
2245} zdb_blkstats_t;
2246
2247/*
2248 * Extended object types to report deferred frees and dedup auto-ditto blocks.
2249 */
2250#define	ZDB_OT_DEFERRED	(DMU_OT_NUMTYPES + 0)
2251#define	ZDB_OT_DITTO	(DMU_OT_NUMTYPES + 1)
2252#define	ZDB_OT_OTHER	(DMU_OT_NUMTYPES + 2)
2253#define	ZDB_OT_TOTAL	(DMU_OT_NUMTYPES + 3)
2254
2255static char *zdb_ot_extname[] = {
2256	"deferred free",
2257	"dedup ditto",
2258	"other",
2259	"Total",
2260};
2261
2262#define	ZB_TOTAL	DN_MAX_LEVELS
2263
2264typedef struct zdb_cb {
2265	zdb_blkstats_t	zcb_type[ZB_TOTAL + 1][ZDB_OT_TOTAL + 1];
2266	uint64_t	zcb_dedup_asize;
2267	uint64_t	zcb_dedup_blocks;
2268	uint64_t	zcb_embedded_blocks[NUM_BP_EMBEDDED_TYPES];
2269	uint64_t	zcb_embedded_histogram[NUM_BP_EMBEDDED_TYPES]
2270	    [BPE_PAYLOAD_SIZE];
2271	uint64_t	zcb_start;
2272	uint64_t	zcb_lastprint;
2273	uint64_t	zcb_totalasize;
2274	uint64_t	zcb_errors[256];
2275	int		zcb_readfails;
2276	int		zcb_haderrors;
2277	spa_t		*zcb_spa;
2278} zdb_cb_t;
2279
2280static void
2281zdb_count_block(zdb_cb_t *zcb, zilog_t *zilog, const blkptr_t *bp,
2282    dmu_object_type_t type)
2283{
2284	uint64_t refcnt = 0;
2285
2286	ASSERT(type < ZDB_OT_TOTAL);
2287
2288	if (zilog && zil_bp_tree_add(zilog, bp) != 0)
2289		return;
2290
2291	for (int i = 0; i < 4; i++) {
2292		int l = (i < 2) ? BP_GET_LEVEL(bp) : ZB_TOTAL;
2293		int t = (i & 1) ? type : ZDB_OT_TOTAL;
2294		int equal;
2295		zdb_blkstats_t *zb = &zcb->zcb_type[l][t];
2296
2297		zb->zb_asize += BP_GET_ASIZE(bp);
2298		zb->zb_lsize += BP_GET_LSIZE(bp);
2299		zb->zb_psize += BP_GET_PSIZE(bp);
2300		zb->zb_count++;
2301
2302		/*
2303		 * The histogram is only big enough to record blocks up to
2304		 * SPA_OLD_MAXBLOCKSIZE; larger blocks go into the last,
2305		 * "other", bucket.
2306		 */
2307		int idx = BP_GET_PSIZE(bp) >> SPA_MINBLOCKSHIFT;
2308		idx = MIN(idx, SPA_OLD_MAXBLOCKSIZE / SPA_MINBLOCKSIZE + 1);
2309		zb->zb_psize_histogram[idx]++;
2310
2311		zb->zb_gangs += BP_COUNT_GANG(bp);
2312
2313		switch (BP_GET_NDVAS(bp)) {
2314		case 2:
2315			if (DVA_GET_VDEV(&bp->blk_dva[0]) ==
2316			    DVA_GET_VDEV(&bp->blk_dva[1]))
2317				zb->zb_ditto_samevdev++;
2318			break;
2319		case 3:
2320			equal = (DVA_GET_VDEV(&bp->blk_dva[0]) ==
2321			    DVA_GET_VDEV(&bp->blk_dva[1])) +
2322			    (DVA_GET_VDEV(&bp->blk_dva[0]) ==
2323			    DVA_GET_VDEV(&bp->blk_dva[2])) +
2324			    (DVA_GET_VDEV(&bp->blk_dva[1]) ==
2325			    DVA_GET_VDEV(&bp->blk_dva[2]));
2326			if (equal != 0)
2327				zb->zb_ditto_samevdev++;
2328			break;
2329		}
2330
2331	}
2332
2333	if (BP_IS_EMBEDDED(bp)) {
2334		zcb->zcb_embedded_blocks[BPE_GET_ETYPE(bp)]++;
2335		zcb->zcb_embedded_histogram[BPE_GET_ETYPE(bp)]
2336		    [BPE_GET_PSIZE(bp)]++;
2337		return;
2338	}
2339
2340	if (dump_opt['L'])
2341		return;
2342
2343	if (BP_GET_DEDUP(bp)) {
2344		ddt_t *ddt;
2345		ddt_entry_t *dde;
2346
2347		ddt = ddt_select(zcb->zcb_spa, bp);
2348		ddt_enter(ddt);
2349		dde = ddt_lookup(ddt, bp, B_FALSE);
2350
2351		if (dde == NULL) {
2352			refcnt = 0;
2353		} else {
2354			ddt_phys_t *ddp = ddt_phys_select(dde, bp);
2355			ddt_phys_decref(ddp);
2356			refcnt = ddp->ddp_refcnt;
2357			if (ddt_phys_total_refcnt(dde) == 0)
2358				ddt_remove(ddt, dde);
2359		}
2360		ddt_exit(ddt);
2361	}
2362
2363	VERIFY3U(zio_wait(zio_claim(NULL, zcb->zcb_spa,
2364	    refcnt ? 0 : spa_first_txg(zcb->zcb_spa),
2365	    bp, NULL, NULL, ZIO_FLAG_CANFAIL)), ==, 0);
2366}
2367
2368static void
2369zdb_blkptr_done(zio_t *zio)
2370{
2371	spa_t *spa = zio->io_spa;
2372	blkptr_t *bp = zio->io_bp;
2373	int ioerr = zio->io_error;
2374	zdb_cb_t *zcb = zio->io_private;
2375	zbookmark_phys_t *zb = &zio->io_bookmark;
2376
2377	zio_data_buf_free(zio->io_data, zio->io_size);
2378
2379	mutex_enter(&spa->spa_scrub_lock);
2380	spa->spa_scrub_inflight--;
2381	cv_broadcast(&spa->spa_scrub_io_cv);
2382
2383	if (ioerr && !(zio->io_flags & ZIO_FLAG_SPECULATIVE)) {
2384		char blkbuf[BP_SPRINTF_LEN];
2385
2386		zcb->zcb_haderrors = 1;
2387		zcb->zcb_errors[ioerr]++;
2388
2389		if (dump_opt['b'] >= 2)
2390			snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
2391		else
2392			blkbuf[0] = '\0';
2393
2394		(void) printf("zdb_blkptr_cb: "
2395		    "Got error %d reading "
2396		    "<%llu, %llu, %lld, %llx> %s -- skipping\n",
2397		    ioerr,
2398		    (u_longlong_t)zb->zb_objset,
2399		    (u_longlong_t)zb->zb_object,
2400		    (u_longlong_t)zb->zb_level,
2401		    (u_longlong_t)zb->zb_blkid,
2402		    blkbuf);
2403	}
2404	mutex_exit(&spa->spa_scrub_lock);
2405}
2406
2407static int
2408zdb_blkptr_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
2409    const zbookmark_phys_t *zb, const dnode_phys_t *dnp, void *arg)
2410{
2411	zdb_cb_t *zcb = arg;
2412	dmu_object_type_t type;
2413	boolean_t is_metadata;
2414
2415	if (bp == NULL)
2416		return (0);
2417
2418	if (dump_opt['b'] >= 5 && bp->blk_birth > 0) {
2419		char blkbuf[BP_SPRINTF_LEN];
2420		snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
2421		(void) printf("objset %llu object %llu "
2422		    "level %lld offset 0x%llx %s\n",
2423		    (u_longlong_t)zb->zb_objset,
2424		    (u_longlong_t)zb->zb_object,
2425		    (longlong_t)zb->zb_level,
2426		    (u_longlong_t)blkid2offset(dnp, bp, zb),
2427		    blkbuf);
2428	}
2429
2430	if (BP_IS_HOLE(bp))
2431		return (0);
2432
2433	type = BP_GET_TYPE(bp);
2434
2435	zdb_count_block(zcb, zilog, bp,
2436	    (type & DMU_OT_NEWTYPE) ? ZDB_OT_OTHER : type);
2437
2438	is_metadata = (BP_GET_LEVEL(bp) != 0 || DMU_OT_IS_METADATA(type));
2439
2440	if (!BP_IS_EMBEDDED(bp) &&
2441	    (dump_opt['c'] > 1 || (dump_opt['c'] && is_metadata))) {
2442		size_t size = BP_GET_PSIZE(bp);
2443		void *data = zio_data_buf_alloc(size);
2444		int flags = ZIO_FLAG_CANFAIL | ZIO_FLAG_SCRUB | ZIO_FLAG_RAW;
2445
2446		/* If it's an intent log block, failure is expected. */
2447		if (zb->zb_level == ZB_ZIL_LEVEL)
2448			flags |= ZIO_FLAG_SPECULATIVE;
2449
2450		mutex_enter(&spa->spa_scrub_lock);
2451		while (spa->spa_scrub_inflight > max_inflight)
2452			cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock);
2453		spa->spa_scrub_inflight++;
2454		mutex_exit(&spa->spa_scrub_lock);
2455
2456		zio_nowait(zio_read(NULL, spa, bp, data, size,
2457		    zdb_blkptr_done, zcb, ZIO_PRIORITY_ASYNC_READ, flags, zb));
2458	}
2459
2460	zcb->zcb_readfails = 0;
2461
2462	/* only call gethrtime() every 100 blocks */
2463	static int iters;
2464	if (++iters > 100)
2465		iters = 0;
2466	else
2467		return (0);
2468
2469	if (dump_opt['b'] < 5 && gethrtime() > zcb->zcb_lastprint + NANOSEC) {
2470		uint64_t now = gethrtime();
2471		char buf[10];
2472		uint64_t bytes = zcb->zcb_type[ZB_TOTAL][ZDB_OT_TOTAL].zb_asize;
2473		int kb_per_sec =
2474		    1 + bytes / (1 + ((now - zcb->zcb_start) / 1000 / 1000));
2475		int sec_remaining =
2476		    (zcb->zcb_totalasize - bytes) / 1024 / kb_per_sec;
2477
2478		zfs_nicenum(bytes, buf, sizeof (buf));
2479		(void) fprintf(stderr,
2480		    "\r%5s completed (%4dMB/s) "
2481		    "estimated time remaining: %uhr %02umin %02usec        ",
2482		    buf, kb_per_sec / 1024,
2483		    sec_remaining / 60 / 60,
2484		    sec_remaining / 60 % 60,
2485		    sec_remaining % 60);
2486
2487		zcb->zcb_lastprint = now;
2488	}
2489
2490	return (0);
2491}
2492
2493static void
2494zdb_leak(void *arg, uint64_t start, uint64_t size)
2495{
2496	vdev_t *vd = arg;
2497
2498	(void) printf("leaked space: vdev %llu, offset 0x%llx, size %llu\n",
2499	    (u_longlong_t)vd->vdev_id, (u_longlong_t)start, (u_longlong_t)size);
2500}
2501
2502static metaslab_ops_t zdb_metaslab_ops = {
2503	NULL	/* alloc */
2504};
2505
2506static void
2507zdb_ddt_leak_init(spa_t *spa, zdb_cb_t *zcb)
2508{
2509	ddt_bookmark_t ddb = { 0 };
2510	ddt_entry_t dde;
2511	int error;
2512
2513	while ((error = ddt_walk(spa, &ddb, &dde)) == 0) {
2514		blkptr_t blk;
2515		ddt_phys_t *ddp = dde.dde_phys;
2516
2517		if (ddb.ddb_class == DDT_CLASS_UNIQUE)
2518			return;
2519
2520		ASSERT(ddt_phys_total_refcnt(&dde) > 1);
2521
2522		for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
2523			if (ddp->ddp_phys_birth == 0)
2524				continue;
2525			ddt_bp_create(ddb.ddb_checksum,
2526			    &dde.dde_key, ddp, &blk);
2527			if (p == DDT_PHYS_DITTO) {
2528				zdb_count_block(zcb, NULL, &blk, ZDB_OT_DITTO);
2529			} else {
2530				zcb->zcb_dedup_asize +=
2531				    BP_GET_ASIZE(&blk) * (ddp->ddp_refcnt - 1);
2532				zcb->zcb_dedup_blocks++;
2533			}
2534		}
2535		if (!dump_opt['L']) {
2536			ddt_t *ddt = spa->spa_ddt[ddb.ddb_checksum];
2537			ddt_enter(ddt);
2538			VERIFY(ddt_lookup(ddt, &blk, B_TRUE) != NULL);
2539			ddt_exit(ddt);
2540		}
2541	}
2542
2543	ASSERT(error == ENOENT);
2544}
2545
2546static void
2547zdb_leak_init(spa_t *spa, zdb_cb_t *zcb)
2548{
2549	zcb->zcb_spa = spa;
2550
2551	if (!dump_opt['L']) {
2552		vdev_t *rvd = spa->spa_root_vdev;
2553		for (uint64_t c = 0; c < rvd->vdev_children; c++) {
2554			vdev_t *vd = rvd->vdev_child[c];
2555			for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
2556				metaslab_t *msp = vd->vdev_ms[m];
2557				mutex_enter(&msp->ms_lock);
2558				metaslab_unload(msp);
2559
2560				/*
2561				 * For leak detection, we overload the metaslab
2562				 * ms_tree to contain allocated segments
2563				 * instead of free segments. As a result,
2564				 * we can't use the normal metaslab_load/unload
2565				 * interfaces.
2566				 */
2567				if (msp->ms_sm != NULL) {
2568					(void) fprintf(stderr,
2569					    "\rloading space map for "
2570					    "vdev %llu of %llu, "
2571					    "metaslab %llu of %llu ...",
2572					    (longlong_t)c,
2573					    (longlong_t)rvd->vdev_children,
2574					    (longlong_t)m,
2575					    (longlong_t)vd->vdev_ms_count);
2576
2577					msp->ms_ops = &zdb_metaslab_ops;
2578
2579					/*
2580					 * We don't want to spend the CPU
2581					 * manipulating the size-ordered
2582					 * tree, so clear the range_tree
2583					 * ops.
2584					 */
2585					msp->ms_tree->rt_ops = NULL;
2586					VERIFY0(space_map_load(msp->ms_sm,
2587					    msp->ms_tree, SM_ALLOC));
2588					msp->ms_loaded = B_TRUE;
2589				}
2590				mutex_exit(&msp->ms_lock);
2591			}
2592		}
2593		(void) fprintf(stderr, "\n");
2594	}
2595
2596	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
2597
2598	zdb_ddt_leak_init(spa, zcb);
2599
2600	spa_config_exit(spa, SCL_CONFIG, FTAG);
2601}
2602
2603static void
2604zdb_leak_fini(spa_t *spa)
2605{
2606	if (!dump_opt['L']) {
2607		vdev_t *rvd = spa->spa_root_vdev;
2608		for (int c = 0; c < rvd->vdev_children; c++) {
2609			vdev_t *vd = rvd->vdev_child[c];
2610			for (int m = 0; m < vd->vdev_ms_count; m++) {
2611				metaslab_t *msp = vd->vdev_ms[m];
2612				mutex_enter(&msp->ms_lock);
2613
2614				/*
2615				 * The ms_tree has been overloaded to
2616				 * contain allocated segments. Now that we
2617				 * finished traversing all blocks, any
2618				 * block that remains in the ms_tree
2619				 * represents an allocated block that we
2620				 * did not claim during the traversal.
2621				 * Claimed blocks would have been removed
2622				 * from the ms_tree.
2623				 */
2624				range_tree_vacate(msp->ms_tree, zdb_leak, vd);
2625				msp->ms_loaded = B_FALSE;
2626
2627				mutex_exit(&msp->ms_lock);
2628			}
2629		}
2630	}
2631}
2632
2633/* ARGSUSED */
2634static int
2635count_block_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
2636{
2637	zdb_cb_t *zcb = arg;
2638
2639	if (dump_opt['b'] >= 5) {
2640		char blkbuf[BP_SPRINTF_LEN];
2641		snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
2642		(void) printf("[%s] %s\n",
2643		    "deferred free", blkbuf);
2644	}
2645	zdb_count_block(zcb, NULL, bp, ZDB_OT_DEFERRED);
2646	return (0);
2647}
2648
2649static int
2650dump_block_stats(spa_t *spa)
2651{
2652	zdb_cb_t zcb = { 0 };
2653	zdb_blkstats_t *zb, *tzb;
2654	uint64_t norm_alloc, norm_space, total_alloc, total_found;
2655	int flags = TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA | TRAVERSE_HARD;
2656	boolean_t leaks = B_FALSE;
2657
2658	(void) printf("\nTraversing all blocks %s%s%s%s%s...\n\n",
2659	    (dump_opt['c'] || !dump_opt['L']) ? "to verify " : "",
2660	    (dump_opt['c'] == 1) ? "metadata " : "",
2661	    dump_opt['c'] ? "checksums " : "",
2662	    (dump_opt['c'] && !dump_opt['L']) ? "and verify " : "",
2663	    !dump_opt['L'] ? "nothing leaked " : "");
2664
2665	/*
2666	 * Load all space maps as SM_ALLOC maps, then traverse the pool
2667	 * claiming each block we discover.  If the pool is perfectly
2668	 * consistent, the space maps will be empty when we're done.
2669	 * Anything left over is a leak; any block we can't claim (because
2670	 * it's not part of any space map) is a double allocation,
2671	 * reference to a freed block, or an unclaimed log block.
2672	 */
2673	zdb_leak_init(spa, &zcb);
2674
2675	/*
2676	 * If there's a deferred-free bplist, process that first.
2677	 */
2678	(void) bpobj_iterate_nofree(&spa->spa_deferred_bpobj,
2679	    count_block_cb, &zcb, NULL);
2680	if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
2681		(void) bpobj_iterate_nofree(&spa->spa_dsl_pool->dp_free_bpobj,
2682		    count_block_cb, &zcb, NULL);
2683	}
2684	if (spa_feature_is_active(spa, SPA_FEATURE_ASYNC_DESTROY)) {
2685		VERIFY3U(0, ==, bptree_iterate(spa->spa_meta_objset,
2686		    spa->spa_dsl_pool->dp_bptree_obj, B_FALSE, count_block_cb,
2687		    &zcb, NULL));
2688	}
2689
2690	if (dump_opt['c'] > 1)
2691		flags |= TRAVERSE_PREFETCH_DATA;
2692
2693	zcb.zcb_totalasize = metaslab_class_get_alloc(spa_normal_class(spa));
2694	zcb.zcb_start = zcb.zcb_lastprint = gethrtime();
2695	zcb.zcb_haderrors |= traverse_pool(spa, 0, flags, zdb_blkptr_cb, &zcb);
2696
2697	/*
2698	 * If we've traversed the data blocks then we need to wait for those
2699	 * I/Os to complete. We leverage "The Godfather" zio to wait on
2700	 * all async I/Os to complete.
2701	 */
2702	if (dump_opt['c']) {
2703		for (int i = 0; i < max_ncpus; i++) {
2704			(void) zio_wait(spa->spa_async_zio_root[i]);
2705			spa->spa_async_zio_root[i] = zio_root(spa, NULL, NULL,
2706			    ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE |
2707			    ZIO_FLAG_GODFATHER);
2708		}
2709	}
2710
2711	if (zcb.zcb_haderrors) {
2712		(void) printf("\nError counts:\n\n");
2713		(void) printf("\t%5s  %s\n", "errno", "count");
2714		for (int e = 0; e < 256; e++) {
2715			if (zcb.zcb_errors[e] != 0) {
2716				(void) printf("\t%5d  %llu\n",
2717				    e, (u_longlong_t)zcb.zcb_errors[e]);
2718			}
2719		}
2720	}
2721
2722	/*
2723	 * Report any leaked segments.
2724	 */
2725	zdb_leak_fini(spa);
2726
2727	tzb = &zcb.zcb_type[ZB_TOTAL][ZDB_OT_TOTAL];
2728
2729	norm_alloc = metaslab_class_get_alloc(spa_normal_class(spa));
2730	norm_space = metaslab_class_get_space(spa_normal_class(spa));
2731
2732	total_alloc = norm_alloc + metaslab_class_get_alloc(spa_log_class(spa));
2733	total_found = tzb->zb_asize - zcb.zcb_dedup_asize;
2734
2735	if (total_found == total_alloc) {
2736		if (!dump_opt['L'])
2737			(void) printf("\n\tNo leaks (block sum matches space"
2738			    " maps exactly)\n");
2739	} else {
2740		(void) printf("block traversal size %llu != alloc %llu "
2741		    "(%s %lld)\n",
2742		    (u_longlong_t)total_found,
2743		    (u_longlong_t)total_alloc,
2744		    (dump_opt['L']) ? "unreachable" : "leaked",
2745		    (longlong_t)(total_alloc - total_found));
2746		leaks = B_TRUE;
2747	}
2748
2749	if (tzb->zb_count == 0)
2750		return (2);
2751
2752	(void) printf("\n");
2753	(void) printf("\tbp count:      %10llu\n",
2754	    (u_longlong_t)tzb->zb_count);
2755	(void) printf("\tganged count:  %10llu\n",
2756	    (longlong_t)tzb->zb_gangs);
2757	(void) printf("\tbp logical:    %10llu      avg: %6llu\n",
2758	    (u_longlong_t)tzb->zb_lsize,
2759	    (u_longlong_t)(tzb->zb_lsize / tzb->zb_count));
2760	(void) printf("\tbp physical:   %10llu      avg:"
2761	    " %6llu     compression: %6.2f\n",
2762	    (u_longlong_t)tzb->zb_psize,
2763	    (u_longlong_t)(tzb->zb_psize / tzb->zb_count),
2764	    (double)tzb->zb_lsize / tzb->zb_psize);
2765	(void) printf("\tbp allocated:  %10llu      avg:"
2766	    " %6llu     compression: %6.2f\n",
2767	    (u_longlong_t)tzb->zb_asize,
2768	    (u_longlong_t)(tzb->zb_asize / tzb->zb_count),
2769	    (double)tzb->zb_lsize / tzb->zb_asize);
2770	(void) printf("\tbp deduped:    %10llu    ref>1:"
2771	    " %6llu   deduplication: %6.2f\n",
2772	    (u_longlong_t)zcb.zcb_dedup_asize,
2773	    (u_longlong_t)zcb.zcb_dedup_blocks,
2774	    (double)zcb.zcb_dedup_asize / tzb->zb_asize + 1.0);
2775	(void) printf("\tSPA allocated: %10llu     used: %5.2f%%\n",
2776	    (u_longlong_t)norm_alloc, 100.0 * norm_alloc / norm_space);
2777
2778	for (bp_embedded_type_t i = 0; i < NUM_BP_EMBEDDED_TYPES; i++) {
2779		if (zcb.zcb_embedded_blocks[i] == 0)
2780			continue;
2781		(void) printf("\n");
2782		(void) printf("\tadditional, non-pointer bps of type %u: "
2783		    "%10llu\n",
2784		    i, (u_longlong_t)zcb.zcb_embedded_blocks[i]);
2785
2786		if (dump_opt['b'] >= 3) {
2787			(void) printf("\t number of (compressed) bytes:  "
2788			    "number of bps\n");
2789			dump_histogram(zcb.zcb_embedded_histogram[i],
2790			    sizeof (zcb.zcb_embedded_histogram[i]) /
2791			    sizeof (zcb.zcb_embedded_histogram[i][0]), 0);
2792		}
2793	}
2794
2795	if (tzb->zb_ditto_samevdev != 0) {
2796		(void) printf("\tDittoed blocks on same vdev: %llu\n",
2797		    (longlong_t)tzb->zb_ditto_samevdev);
2798	}
2799
2800	if (dump_opt['b'] >= 2) {
2801		int l, t, level;
2802		(void) printf("\nBlocks\tLSIZE\tPSIZE\tASIZE"
2803		    "\t  avg\t comp\t%%Total\tType\n");
2804
2805		for (t = 0; t <= ZDB_OT_TOTAL; t++) {
2806			char csize[32], lsize[32], psize[32], asize[32];
2807			char avg[32], gang[32];
2808			char *typename;
2809
2810			if (t < DMU_OT_NUMTYPES)
2811				typename = dmu_ot[t].ot_name;
2812			else
2813				typename = zdb_ot_extname[t - DMU_OT_NUMTYPES];
2814
2815			if (zcb.zcb_type[ZB_TOTAL][t].zb_asize == 0) {
2816				(void) printf("%6s\t%5s\t%5s\t%5s"
2817				    "\t%5s\t%5s\t%6s\t%s\n",
2818				    "-",
2819				    "-",
2820				    "-",
2821				    "-",
2822				    "-",
2823				    "-",
2824				    "-",
2825				    typename);
2826				continue;
2827			}
2828
2829			for (l = ZB_TOTAL - 1; l >= -1; l--) {
2830				level = (l == -1 ? ZB_TOTAL : l);
2831				zb = &zcb.zcb_type[level][t];
2832
2833				if (zb->zb_asize == 0)
2834					continue;
2835
2836				if (dump_opt['b'] < 3 && level != ZB_TOTAL)
2837					continue;
2838
2839				if (level == 0 && zb->zb_asize ==
2840				    zcb.zcb_type[ZB_TOTAL][t].zb_asize)
2841					continue;
2842
2843				zdb_nicenum(zb->zb_count, csize);
2844				zdb_nicenum(zb->zb_lsize, lsize);
2845				zdb_nicenum(zb->zb_psize, psize);
2846				zdb_nicenum(zb->zb_asize, asize);
2847				zdb_nicenum(zb->zb_asize / zb->zb_count, avg);
2848				zdb_nicenum(zb->zb_gangs, gang);
2849
2850				(void) printf("%6s\t%5s\t%5s\t%5s\t%5s"
2851				    "\t%5.2f\t%6.2f\t",
2852				    csize, lsize, psize, asize, avg,
2853				    (double)zb->zb_lsize / zb->zb_psize,
2854				    100.0 * zb->zb_asize / tzb->zb_asize);
2855
2856				if (level == ZB_TOTAL)
2857					(void) printf("%s\n", typename);
2858				else
2859					(void) printf("    L%d %s\n",
2860					    level, typename);
2861
2862				if (dump_opt['b'] >= 3 && zb->zb_gangs > 0) {
2863					(void) printf("\t number of ganged "
2864					    "blocks: %s\n", gang);
2865				}
2866
2867				if (dump_opt['b'] >= 4) {
2868					(void) printf("psize "
2869					    "(in 512-byte sectors): "
2870					    "number of blocks\n");
2871					dump_histogram(zb->zb_psize_histogram,
2872					    PSIZE_HISTO_SIZE, 0);
2873				}
2874			}
2875		}
2876	}
2877
2878	(void) printf("\n");
2879
2880	if (leaks)
2881		return (2);
2882
2883	if (zcb.zcb_haderrors)
2884		return (3);
2885
2886	return (0);
2887}
2888
2889typedef struct zdb_ddt_entry {
2890	ddt_key_t	zdde_key;
2891	uint64_t	zdde_ref_blocks;
2892	uint64_t	zdde_ref_lsize;
2893	uint64_t	zdde_ref_psize;
2894	uint64_t	zdde_ref_dsize;
2895	avl_node_t	zdde_node;
2896} zdb_ddt_entry_t;
2897
2898/* ARGSUSED */
2899static int
2900zdb_ddt_add_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
2901    const zbookmark_phys_t *zb, const dnode_phys_t *dnp, void *arg)
2902{
2903	avl_tree_t *t = arg;
2904	avl_index_t where;
2905	zdb_ddt_entry_t *zdde, zdde_search;
2906
2907	if (bp == NULL || BP_IS_HOLE(bp) || BP_IS_EMBEDDED(bp))
2908		return (0);
2909
2910	if (dump_opt['S'] > 1 && zb->zb_level == ZB_ROOT_LEVEL) {
2911		(void) printf("traversing objset %llu, %llu objects, "
2912		    "%lu blocks so far\n",
2913		    (u_longlong_t)zb->zb_objset,
2914		    (u_longlong_t)BP_GET_FILL(bp),
2915		    avl_numnodes(t));
2916	}
2917
2918	if (BP_IS_HOLE(bp) || BP_GET_CHECKSUM(bp) == ZIO_CHECKSUM_OFF ||
2919	    BP_GET_LEVEL(bp) > 0 || DMU_OT_IS_METADATA(BP_GET_TYPE(bp)))
2920		return (0);
2921
2922	ddt_key_fill(&zdde_search.zdde_key, bp);
2923
2924	zdde = avl_find(t, &zdde_search, &where);
2925
2926	if (zdde == NULL) {
2927		zdde = umem_zalloc(sizeof (*zdde), UMEM_NOFAIL);
2928		zdde->zdde_key = zdde_search.zdde_key;
2929		avl_insert(t, zdde, where);
2930	}
2931
2932	zdde->zdde_ref_blocks += 1;
2933	zdde->zdde_ref_lsize += BP_GET_LSIZE(bp);
2934	zdde->zdde_ref_psize += BP_GET_PSIZE(bp);
2935	zdde->zdde_ref_dsize += bp_get_dsize_sync(spa, bp);
2936
2937	return (0);
2938}
2939
2940static void
2941dump_simulated_ddt(spa_t *spa)
2942{
2943	avl_tree_t t;
2944	void *cookie = NULL;
2945	zdb_ddt_entry_t *zdde;
2946	ddt_histogram_t ddh_total = { 0 };
2947	ddt_stat_t dds_total = { 0 };
2948
2949	avl_create(&t, ddt_entry_compare,
2950	    sizeof (zdb_ddt_entry_t), offsetof(zdb_ddt_entry_t, zdde_node));
2951
2952	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
2953
2954	(void) traverse_pool(spa, 0, TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA,
2955	    zdb_ddt_add_cb, &t);
2956
2957	spa_config_exit(spa, SCL_CONFIG, FTAG);
2958
2959	while ((zdde = avl_destroy_nodes(&t, &cookie)) != NULL) {
2960		ddt_stat_t dds;
2961		uint64_t refcnt = zdde->zdde_ref_blocks;
2962		ASSERT(refcnt != 0);
2963
2964		dds.dds_blocks = zdde->zdde_ref_blocks / refcnt;
2965		dds.dds_lsize = zdde->zdde_ref_lsize / refcnt;
2966		dds.dds_psize = zdde->zdde_ref_psize / refcnt;
2967		dds.dds_dsize = zdde->zdde_ref_dsize / refcnt;
2968
2969		dds.dds_ref_blocks = zdde->zdde_ref_blocks;
2970		dds.dds_ref_lsize = zdde->zdde_ref_lsize;
2971		dds.dds_ref_psize = zdde->zdde_ref_psize;
2972		dds.dds_ref_dsize = zdde->zdde_ref_dsize;
2973
2974		ddt_stat_add(&ddh_total.ddh_stat[highbit64(refcnt) - 1],
2975		    &dds, 0);
2976
2977		umem_free(zdde, sizeof (*zdde));
2978	}
2979
2980	avl_destroy(&t);
2981
2982	ddt_histogram_stat(&dds_total, &ddh_total);
2983
2984	(void) printf("Simulated DDT histogram:\n");
2985
2986	zpool_dump_ddt(&dds_total, &ddh_total);
2987
2988	dump_dedup_ratio(&dds_total);
2989}
2990
2991static void
2992dump_zpool(spa_t *spa)
2993{
2994	dsl_pool_t *dp = spa_get_dsl(spa);
2995	int rc = 0;
2996
2997	if (dump_opt['S']) {
2998		dump_simulated_ddt(spa);
2999		return;
3000	}
3001
3002	if (!dump_opt['e'] && dump_opt['C'] > 1) {
3003		(void) printf("\nCached configuration:\n");
3004		dump_nvlist(spa->spa_config, 8);
3005	}
3006
3007	if (dump_opt['C'])
3008		dump_config(spa);
3009
3010	if (dump_opt['u'])
3011		dump_uberblock(&spa->spa_uberblock, "\nUberblock:\n", "\n");
3012
3013	if (dump_opt['D'])
3014		dump_all_ddts(spa);
3015
3016	if (dump_opt['d'] > 2 || dump_opt['m'])
3017		dump_metaslabs(spa);
3018	if (dump_opt['M'])
3019		dump_metaslab_groups(spa);
3020
3021	if (dump_opt['d'] || dump_opt['i']) {
3022		dump_dir(dp->dp_meta_objset);
3023		if (dump_opt['d'] >= 3) {
3024			dump_full_bpobj(&spa->spa_deferred_bpobj,
3025			    "Deferred frees", 0);
3026			if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
3027				dump_full_bpobj(
3028				    &spa->spa_dsl_pool->dp_free_bpobj,
3029				    "Pool snapshot frees", 0);
3030			}
3031
3032			if (spa_feature_is_active(spa,
3033			    SPA_FEATURE_ASYNC_DESTROY)) {
3034				dump_bptree(spa->spa_meta_objset,
3035				    spa->spa_dsl_pool->dp_bptree_obj,
3036				    "Pool dataset frees");
3037			}
3038			dump_dtl(spa->spa_root_vdev, 0);
3039		}
3040		(void) dmu_objset_find(spa_name(spa), dump_one_dir,
3041		    NULL, DS_FIND_SNAPSHOTS | DS_FIND_CHILDREN);
3042
3043		for (spa_feature_t f = 0; f < SPA_FEATURES; f++) {
3044			uint64_t refcount;
3045
3046			if (!(spa_feature_table[f].fi_flags &
3047			    ZFEATURE_FLAG_PER_DATASET)) {
3048				ASSERT0(dataset_feature_count[f]);
3049				continue;
3050			}
3051			(void) feature_get_refcount(spa,
3052			    &spa_feature_table[f], &refcount);
3053			if (dataset_feature_count[f] != refcount) {
3054				(void) printf("%s feature refcount mismatch: "
3055				    "%lld datasets != %lld refcount\n",
3056				    spa_feature_table[f].fi_uname,
3057				    (longlong_t)dataset_feature_count[f],
3058				    (longlong_t)refcount);
3059				rc = 2;
3060			} else {
3061				(void) printf("Verified %s feature refcount "
3062				    "of %llu is correct\n",
3063				    spa_feature_table[f].fi_uname,
3064				    (longlong_t)refcount);
3065			}
3066		}
3067	}
3068	if (rc == 0 && (dump_opt['b'] || dump_opt['c']))
3069		rc = dump_block_stats(spa);
3070
3071	if (rc == 0)
3072		rc = verify_spacemap_refcounts(spa);
3073
3074	if (dump_opt['s'])
3075		show_pool_stats(spa);
3076
3077	if (dump_opt['h'])
3078		dump_history(spa);
3079
3080	if (rc != 0)
3081		exit(rc);
3082}
3083
3084#define	ZDB_FLAG_CHECKSUM	0x0001
3085#define	ZDB_FLAG_DECOMPRESS	0x0002
3086#define	ZDB_FLAG_BSWAP		0x0004
3087#define	ZDB_FLAG_GBH		0x0008
3088#define	ZDB_FLAG_INDIRECT	0x0010
3089#define	ZDB_FLAG_PHYS		0x0020
3090#define	ZDB_FLAG_RAW		0x0040
3091#define	ZDB_FLAG_PRINT_BLKPTR	0x0080
3092
3093int flagbits[256];
3094
3095static void
3096zdb_print_blkptr(blkptr_t *bp, int flags)
3097{
3098	char blkbuf[BP_SPRINTF_LEN];
3099
3100	if (flags & ZDB_FLAG_BSWAP)
3101		byteswap_uint64_array((void *)bp, sizeof (blkptr_t));
3102
3103	snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
3104	(void) printf("%s\n", blkbuf);
3105}
3106
3107static void
3108zdb_dump_indirect(blkptr_t *bp, int nbps, int flags)
3109{
3110	int i;
3111
3112	for (i = 0; i < nbps; i++)
3113		zdb_print_blkptr(&bp[i], flags);
3114}
3115
3116static void
3117zdb_dump_gbh(void *buf, int flags)
3118{
3119	zdb_dump_indirect((blkptr_t *)buf, SPA_GBH_NBLKPTRS, flags);
3120}
3121
3122static void
3123zdb_dump_block_raw(void *buf, uint64_t size, int flags)
3124{
3125	if (flags & ZDB_FLAG_BSWAP)
3126		byteswap_uint64_array(buf, size);
3127	(void) write(1, buf, size);
3128}
3129
3130static void
3131zdb_dump_block(char *label, void *buf, uint64_t size, int flags)
3132{
3133	uint64_t *d = (uint64_t *)buf;
3134	int nwords = size / sizeof (uint64_t);
3135	int do_bswap = !!(flags & ZDB_FLAG_BSWAP);
3136	int i, j;
3137	char *hdr, *c;
3138
3139
3140	if (do_bswap)
3141		hdr = " 7 6 5 4 3 2 1 0   f e d c b a 9 8";
3142	else
3143		hdr = " 0 1 2 3 4 5 6 7   8 9 a b c d e f";
3144
3145	(void) printf("\n%s\n%6s   %s  0123456789abcdef\n", label, "", hdr);
3146
3147	for (i = 0; i < nwords; i += 2) {
3148		(void) printf("%06llx:  %016llx  %016llx  ",
3149		    (u_longlong_t)(i * sizeof (uint64_t)),
3150		    (u_longlong_t)(do_bswap ? BSWAP_64(d[i]) : d[i]),
3151		    (u_longlong_t)(do_bswap ? BSWAP_64(d[i + 1]) : d[i + 1]));
3152
3153		c = (char *)&d[i];
3154		for (j = 0; j < 2 * sizeof (uint64_t); j++)
3155			(void) printf("%c", isprint(c[j]) ? c[j] : '.');
3156		(void) printf("\n");
3157	}
3158}
3159
3160/*
3161 * There are two acceptable formats:
3162 *	leaf_name	  - For example: c1t0d0 or /tmp/ztest.0a
3163 *	child[.child]*    - For example: 0.1.1
3164 *
3165 * The second form can be used to specify arbitrary vdevs anywhere
3166 * in the heirarchy.  For example, in a pool with a mirror of
3167 * RAID-Zs, you can specify either RAID-Z vdev with 0.0 or 0.1 .
3168 */
3169static vdev_t *
3170zdb_vdev_lookup(vdev_t *vdev, char *path)
3171{
3172	char *s, *p, *q;
3173	int i;
3174
3175	if (vdev == NULL)
3176		return (NULL);
3177
3178	/* First, assume the x.x.x.x format */
3179	i = (int)strtoul(path, &s, 10);
3180	if (s == path || (s && *s != '.' && *s != '\0'))
3181		goto name;
3182	if (i < 0 || i >= vdev->vdev_children)
3183		return (NULL);
3184
3185	vdev = vdev->vdev_child[i];
3186	if (*s == '\0')
3187		return (vdev);
3188	return (zdb_vdev_lookup(vdev, s+1));
3189
3190name:
3191	for (i = 0; i < vdev->vdev_children; i++) {
3192		vdev_t *vc = vdev->vdev_child[i];
3193
3194		if (vc->vdev_path == NULL) {
3195			vc = zdb_vdev_lookup(vc, path);
3196			if (vc == NULL)
3197				continue;
3198			else
3199				return (vc);
3200		}
3201
3202		p = strrchr(vc->vdev_path, '/');
3203		p = p ? p + 1 : vc->vdev_path;
3204		q = &vc->vdev_path[strlen(vc->vdev_path) - 2];
3205
3206		if (strcmp(vc->vdev_path, path) == 0)
3207			return (vc);
3208		if (strcmp(p, path) == 0)
3209			return (vc);
3210		if (strcmp(q, "s0") == 0 && strncmp(p, path, q - p) == 0)
3211			return (vc);
3212	}
3213
3214	return (NULL);
3215}
3216
3217/*
3218 * Read a block from a pool and print it out.  The syntax of the
3219 * block descriptor is:
3220 *
3221 *	pool:vdev_specifier:offset:size[:flags]
3222 *
3223 *	pool           - The name of the pool you wish to read from
3224 *	vdev_specifier - Which vdev (see comment for zdb_vdev_lookup)
3225 *	offset         - offset, in hex, in bytes
3226 *	size           - Amount of data to read, in hex, in bytes
3227 *	flags          - A string of characters specifying options
3228 *		 b: Decode a blkptr at given offset within block
3229 *		*c: Calculate and display checksums
3230 *		 d: Decompress data before dumping
3231 *		 e: Byteswap data before dumping
3232 *		 g: Display data as a gang block header
3233 *		 i: Display as an indirect block
3234 *		 p: Do I/O to physical offset
3235 *		 r: Dump raw data to stdout
3236 *
3237 *              * = not yet implemented
3238 */
3239static void
3240zdb_read_block(char *thing, spa_t *spa)
3241{
3242	blkptr_t blk, *bp = &blk;
3243	dva_t *dva = bp->blk_dva;
3244	int flags = 0;
3245	uint64_t offset = 0, size = 0, psize = 0, lsize = 0, blkptr_offset = 0;
3246	zio_t *zio;
3247	vdev_t *vd;
3248	void *pbuf, *lbuf, *buf;
3249	char *s, *p, *dup, *vdev, *flagstr;
3250	int i, error;
3251
3252	dup = strdup(thing);
3253	s = strtok(dup, ":");
3254	vdev = s ? s : "";
3255	s = strtok(NULL, ":");
3256	offset = strtoull(s ? s : "", NULL, 16);
3257	s = strtok(NULL, ":");
3258	size = strtoull(s ? s : "", NULL, 16);
3259	s = strtok(NULL, ":");
3260	flagstr = s ? s : "";
3261
3262	s = NULL;
3263	if (size == 0)
3264		s = "size must not be zero";
3265	if (!IS_P2ALIGNED(size, DEV_BSIZE))
3266		s = "size must be a multiple of sector size";
3267	if (!IS_P2ALIGNED(offset, DEV_BSIZE))
3268		s = "offset must be a multiple of sector size";
3269	if (s) {
3270		(void) printf("Invalid block specifier: %s  - %s\n", thing, s);
3271		free(dup);
3272		return;
3273	}
3274
3275	for (s = strtok(flagstr, ":"); s; s = strtok(NULL, ":")) {
3276		for (i = 0; flagstr[i]; i++) {
3277			int bit = flagbits[(uchar_t)flagstr[i]];
3278
3279			if (bit == 0) {
3280				(void) printf("***Invalid flag: %c\n",
3281				    flagstr[i]);
3282				continue;
3283			}
3284			flags |= bit;
3285
3286			/* If it's not something with an argument, keep going */
3287			if ((bit & (ZDB_FLAG_CHECKSUM |
3288			    ZDB_FLAG_PRINT_BLKPTR)) == 0)
3289				continue;
3290
3291			p = &flagstr[i + 1];
3292			if (bit == ZDB_FLAG_PRINT_BLKPTR)
3293				blkptr_offset = strtoull(p, &p, 16);
3294			if (*p != ':' && *p != '\0') {
3295				(void) printf("***Invalid flag arg: '%s'\n", s);
3296				free(dup);
3297				return;
3298			}
3299		}
3300	}
3301
3302	vd = zdb_vdev_lookup(spa->spa_root_vdev, vdev);
3303	if (vd == NULL) {
3304		(void) printf("***Invalid vdev: %s\n", vdev);
3305		free(dup);
3306		return;
3307	} else {
3308		if (vd->vdev_path)
3309			(void) fprintf(stderr, "Found vdev: %s\n",
3310			    vd->vdev_path);
3311		else
3312			(void) fprintf(stderr, "Found vdev type: %s\n",
3313			    vd->vdev_ops->vdev_op_type);
3314	}
3315
3316	psize = size;
3317	lsize = size;
3318
3319	pbuf = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
3320	lbuf = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
3321
3322	BP_ZERO(bp);
3323
3324	DVA_SET_VDEV(&dva[0], vd->vdev_id);
3325	DVA_SET_OFFSET(&dva[0], offset);
3326	DVA_SET_GANG(&dva[0], !!(flags & ZDB_FLAG_GBH));
3327	DVA_SET_ASIZE(&dva[0], vdev_psize_to_asize(vd, psize));
3328
3329	BP_SET_BIRTH(bp, TXG_INITIAL, TXG_INITIAL);
3330
3331	BP_SET_LSIZE(bp, lsize);
3332	BP_SET_PSIZE(bp, psize);
3333	BP_SET_COMPRESS(bp, ZIO_COMPRESS_OFF);
3334	BP_SET_CHECKSUM(bp, ZIO_CHECKSUM_OFF);
3335	BP_SET_TYPE(bp, DMU_OT_NONE);
3336	BP_SET_LEVEL(bp, 0);
3337	BP_SET_DEDUP(bp, 0);
3338	BP_SET_BYTEORDER(bp, ZFS_HOST_BYTEORDER);
3339
3340	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
3341	zio = zio_root(spa, NULL, NULL, 0);
3342
3343	if (vd == vd->vdev_top) {
3344		/*
3345		 * Treat this as a normal block read.
3346		 */
3347		zio_nowait(zio_read(zio, spa, bp, pbuf, psize, NULL, NULL,
3348		    ZIO_PRIORITY_SYNC_READ,
3349		    ZIO_FLAG_CANFAIL | ZIO_FLAG_RAW, NULL));
3350	} else {
3351		/*
3352		 * Treat this as a vdev child I/O.
3353		 */
3354		zio_nowait(zio_vdev_child_io(zio, bp, vd, offset, pbuf, psize,
3355		    ZIO_TYPE_READ, ZIO_PRIORITY_SYNC_READ,
3356		    ZIO_FLAG_DONT_CACHE | ZIO_FLAG_DONT_QUEUE |
3357		    ZIO_FLAG_DONT_PROPAGATE | ZIO_FLAG_DONT_RETRY |
3358		    ZIO_FLAG_CANFAIL | ZIO_FLAG_RAW, NULL, NULL));
3359	}
3360
3361	error = zio_wait(zio);
3362	spa_config_exit(spa, SCL_STATE, FTAG);
3363
3364	if (error) {
3365		(void) printf("Read of %s failed, error: %d\n", thing, error);
3366		goto out;
3367	}
3368
3369	if (flags & ZDB_FLAG_DECOMPRESS) {
3370		/*
3371		 * We don't know how the data was compressed, so just try
3372		 * every decompress function at every inflated blocksize.
3373		 */
3374		enum zio_compress c;
3375		void *pbuf2 = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
3376		void *lbuf2 = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
3377
3378		bcopy(pbuf, pbuf2, psize);
3379
3380		VERIFY(random_get_pseudo_bytes((uint8_t *)pbuf + psize,
3381		    SPA_MAXBLOCKSIZE - psize) == 0);
3382
3383		VERIFY(random_get_pseudo_bytes((uint8_t *)pbuf2 + psize,
3384		    SPA_MAXBLOCKSIZE - psize) == 0);
3385
3386		for (lsize = SPA_MAXBLOCKSIZE; lsize > psize;
3387		    lsize -= SPA_MINBLOCKSIZE) {
3388			for (c = 0; c < ZIO_COMPRESS_FUNCTIONS; c++) {
3389				if (zio_decompress_data(c, pbuf, lbuf,
3390				    psize, lsize) == 0 &&
3391				    zio_decompress_data(c, pbuf2, lbuf2,
3392				    psize, lsize) == 0 &&
3393				    bcmp(lbuf, lbuf2, lsize) == 0)
3394					break;
3395			}
3396			if (c != ZIO_COMPRESS_FUNCTIONS)
3397				break;
3398			lsize -= SPA_MINBLOCKSIZE;
3399		}
3400
3401		umem_free(pbuf2, SPA_MAXBLOCKSIZE);
3402		umem_free(lbuf2, SPA_MAXBLOCKSIZE);
3403
3404		if (lsize <= psize) {
3405			(void) printf("Decompress of %s failed\n", thing);
3406			goto out;
3407		}
3408		buf = lbuf;
3409		size = lsize;
3410	} else {
3411		buf = pbuf;
3412		size = psize;
3413	}
3414
3415	if (flags & ZDB_FLAG_PRINT_BLKPTR)
3416		zdb_print_blkptr((blkptr_t *)(void *)
3417		    ((uintptr_t)buf + (uintptr_t)blkptr_offset), flags);
3418	else if (flags & ZDB_FLAG_RAW)
3419		zdb_dump_block_raw(buf, size, flags);
3420	else if (flags & ZDB_FLAG_INDIRECT)
3421		zdb_dump_indirect((blkptr_t *)buf, size / sizeof (blkptr_t),
3422		    flags);
3423	else if (flags & ZDB_FLAG_GBH)
3424		zdb_dump_gbh(buf, flags);
3425	else
3426		zdb_dump_block(thing, buf, size, flags);
3427
3428out:
3429	umem_free(pbuf, SPA_MAXBLOCKSIZE);
3430	umem_free(lbuf, SPA_MAXBLOCKSIZE);
3431	free(dup);
3432}
3433
3434static boolean_t
3435pool_match(nvlist_t *cfg, char *tgt)
3436{
3437	uint64_t v, guid = strtoull(tgt, NULL, 0);
3438	char *s;
3439
3440	if (guid != 0) {
3441		if (nvlist_lookup_uint64(cfg, ZPOOL_CONFIG_POOL_GUID, &v) == 0)
3442			return (v == guid);
3443	} else {
3444		if (nvlist_lookup_string(cfg, ZPOOL_CONFIG_POOL_NAME, &s) == 0)
3445			return (strcmp(s, tgt) == 0);
3446	}
3447	return (B_FALSE);
3448}
3449
3450static char *
3451find_zpool(char **target, nvlist_t **configp, int dirc, char **dirv)
3452{
3453	nvlist_t *pools;
3454	nvlist_t *match = NULL;
3455	char *name = NULL;
3456	char *sepp = NULL;
3457	char sep;
3458	int count = 0;
3459	importargs_t args = { 0 };
3460
3461	args.paths = dirc;
3462	args.path = dirv;
3463	args.can_be_active = B_TRUE;
3464
3465	if ((sepp = strpbrk(*target, "/@")) != NULL) {
3466		sep = *sepp;
3467		*sepp = '\0';
3468	}
3469
3470	pools = zpool_search_import(g_zfs, &args);
3471
3472	if (pools != NULL) {
3473		nvpair_t *elem = NULL;
3474		while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) {
3475			verify(nvpair_value_nvlist(elem, configp) == 0);
3476			if (pool_match(*configp, *target)) {
3477				count++;
3478				if (match != NULL) {
3479					/* print previously found config */
3480					if (name != NULL) {
3481						(void) printf("%s\n", name);
3482						dump_nvlist(match, 8);
3483						name = NULL;
3484					}
3485					(void) printf("%s\n",
3486					    nvpair_name(elem));
3487					dump_nvlist(*configp, 8);
3488				} else {
3489					match = *configp;
3490					name = nvpair_name(elem);
3491				}
3492			}
3493		}
3494	}
3495	if (count > 1)
3496		(void) fatal("\tMatched %d pools - use pool GUID "
3497		    "instead of pool name or \n"
3498		    "\tpool name part of a dataset name to select pool", count);
3499
3500	if (sepp)
3501		*sepp = sep;
3502	/*
3503	 * If pool GUID was specified for pool id, replace it with pool name
3504	 */
3505	if (name && (strstr(*target, name) != *target)) {
3506		int sz = 1 + strlen(name) + ((sepp) ? strlen(sepp) : 0);
3507
3508		*target = umem_alloc(sz, UMEM_NOFAIL);
3509		(void) snprintf(*target, sz, "%s%s", name, sepp ? sepp : "");
3510	}
3511
3512	*configp = name ? match : NULL;
3513
3514	return (name);
3515}
3516
3517int
3518main(int argc, char **argv)
3519{
3520	int i, c;
3521	struct rlimit rl = { 1024, 1024 };
3522	spa_t *spa = NULL;
3523	objset_t *os = NULL;
3524	int dump_all = 1;
3525	int verbose = 0;
3526	int error = 0;
3527	char **searchdirs = NULL;
3528	int nsearch = 0;
3529	char *target;
3530	nvlist_t *policy = NULL;
3531	uint64_t max_txg = UINT64_MAX;
3532	int rewind = ZPOOL_NEVER_REWIND;
3533	char *spa_config_path_env;
3534
3535	(void) setrlimit(RLIMIT_NOFILE, &rl);
3536	(void) enable_extended_FILE_stdio(-1, -1);
3537
3538	dprintf_setup(&argc, argv);
3539
3540	/*
3541	 * If there is an environment variable SPA_CONFIG_PATH it overrides
3542	 * default spa_config_path setting. If -U flag is specified it will
3543	 * override this environment variable settings once again.
3544	 */
3545	spa_config_path_env = getenv("SPA_CONFIG_PATH");
3546	if (spa_config_path_env != NULL)
3547		spa_config_path = spa_config_path_env;
3548
3549	while ((c = getopt(argc, argv,
3550	    "bcdhilmMI:suCDRSAFLXx:evp:t:U:P")) != -1) {
3551		switch (c) {
3552		case 'b':
3553		case 'c':
3554		case 'd':
3555		case 'h':
3556		case 'i':
3557		case 'l':
3558		case 'm':
3559		case 's':
3560		case 'u':
3561		case 'C':
3562		case 'D':
3563		case 'M':
3564		case 'R':
3565		case 'S':
3566			dump_opt[c]++;
3567			dump_all = 0;
3568			break;
3569		case 'A':
3570		case 'F':
3571		case 'L':
3572		case 'X':
3573		case 'e':
3574		case 'P':
3575			dump_opt[c]++;
3576			break;
3577		case 'I':
3578			max_inflight = strtoull(optarg, NULL, 0);
3579			if (max_inflight == 0) {
3580				(void) fprintf(stderr, "maximum number "
3581				    "of inflight I/Os must be greater "
3582				    "than 0\n");
3583				usage();
3584			}
3585			break;
3586		case 'p':
3587			if (searchdirs == NULL) {
3588				searchdirs = umem_alloc(sizeof (char *),
3589				    UMEM_NOFAIL);
3590			} else {
3591				char **tmp = umem_alloc((nsearch + 1) *
3592				    sizeof (char *), UMEM_NOFAIL);
3593				bcopy(searchdirs, tmp, nsearch *
3594				    sizeof (char *));
3595				umem_free(searchdirs,
3596				    nsearch * sizeof (char *));
3597				searchdirs = tmp;
3598			}
3599			searchdirs[nsearch++] = optarg;
3600			break;
3601		case 't':
3602			max_txg = strtoull(optarg, NULL, 0);
3603			if (max_txg < TXG_INITIAL) {
3604				(void) fprintf(stderr, "incorrect txg "
3605				    "specified: %s\n", optarg);
3606				usage();
3607			}
3608			break;
3609		case 'U':
3610			spa_config_path = optarg;
3611			break;
3612		case 'v':
3613			verbose++;
3614			break;
3615		case 'x':
3616			vn_dumpdir = optarg;
3617			break;
3618		default:
3619			usage();
3620			break;
3621		}
3622	}
3623
3624	if (!dump_opt['e'] && searchdirs != NULL) {
3625		(void) fprintf(stderr, "-p option requires use of -e\n");
3626		usage();
3627	}
3628
3629	/*
3630	 * ZDB does not typically re-read blocks; therefore limit the ARC
3631	 * to 256 MB, which can be used entirely for metadata.
3632	 */
3633	zfs_arc_max = zfs_arc_meta_limit = 256 * 1024 * 1024;
3634
3635	/*
3636	 * "zdb -c" uses checksum-verifying scrub i/os which are async reads.
3637	 * "zdb -b" uses traversal prefetch which uses async reads.
3638	 * For good performance, let several of them be active at once.
3639	 */
3640	zfs_vdev_async_read_max_active = 10;
3641
3642	kernel_init(FREAD);
3643	g_zfs = libzfs_init();
3644	ASSERT(g_zfs != NULL);
3645
3646	if (dump_all)
3647		verbose = MAX(verbose, 1);
3648
3649	for (c = 0; c < 256; c++) {
3650		if (dump_all && !strchr("elAFLRSXP", c))
3651			dump_opt[c] = 1;
3652		if (dump_opt[c])
3653			dump_opt[c] += verbose;
3654	}
3655
3656	aok = (dump_opt['A'] == 1) || (dump_opt['A'] > 2);
3657	zfs_recover = (dump_opt['A'] > 1);
3658
3659	argc -= optind;
3660	argv += optind;
3661
3662	if (argc < 2 && dump_opt['R'])
3663		usage();
3664	if (argc < 1) {
3665		if (!dump_opt['e'] && dump_opt['C']) {
3666			dump_cachefile(spa_config_path);
3667			return (0);
3668		}
3669		usage();
3670	}
3671
3672	if (dump_opt['l']) {
3673		dump_label(argv[0]);
3674		return (0);
3675	}
3676
3677	if (dump_opt['X'] || dump_opt['F'])
3678		rewind = ZPOOL_DO_REWIND |
3679		    (dump_opt['X'] ? ZPOOL_EXTREME_REWIND : 0);
3680
3681	if (nvlist_alloc(&policy, NV_UNIQUE_NAME_TYPE, 0) != 0 ||
3682	    nvlist_add_uint64(policy, ZPOOL_REWIND_REQUEST_TXG, max_txg) != 0 ||
3683	    nvlist_add_uint32(policy, ZPOOL_REWIND_REQUEST, rewind) != 0)
3684		fatal("internal error: %s", strerror(ENOMEM));
3685
3686	error = 0;
3687	target = argv[0];
3688
3689	if (dump_opt['e']) {
3690		nvlist_t *cfg = NULL;
3691		char *name = find_zpool(&target, &cfg, nsearch, searchdirs);
3692
3693		error = ENOENT;
3694		if (name) {
3695			if (dump_opt['C'] > 1) {
3696				(void) printf("\nConfiguration for import:\n");
3697				dump_nvlist(cfg, 8);
3698			}
3699			if (nvlist_add_nvlist(cfg,
3700			    ZPOOL_REWIND_POLICY, policy) != 0) {
3701				fatal("can't open '%s': %s",
3702				    target, strerror(ENOMEM));
3703			}
3704			if ((error = spa_import(name, cfg, NULL,
3705			    ZFS_IMPORT_MISSING_LOG)) != 0) {
3706				error = spa_import(name, cfg, NULL,
3707				    ZFS_IMPORT_VERBATIM);
3708			}
3709		}
3710	}
3711
3712	if (error == 0) {
3713		if (strpbrk(target, "/@") == NULL || dump_opt['R']) {
3714			error = spa_open_rewind(target, &spa, FTAG, policy,
3715			    NULL);
3716			if (error) {
3717				/*
3718				 * If we're missing the log device then
3719				 * try opening the pool after clearing the
3720				 * log state.
3721				 */
3722				mutex_enter(&spa_namespace_lock);
3723				if ((spa = spa_lookup(target)) != NULL &&
3724				    spa->spa_log_state == SPA_LOG_MISSING) {
3725					spa->spa_log_state = SPA_LOG_CLEAR;
3726					error = 0;
3727				}
3728				mutex_exit(&spa_namespace_lock);
3729
3730				if (!error) {
3731					error = spa_open_rewind(target, &spa,
3732					    FTAG, policy, NULL);
3733				}
3734			}
3735		} else {
3736			error = dmu_objset_own(target, DMU_OST_ANY,
3737			    B_TRUE, FTAG, &os);
3738		}
3739	}
3740	nvlist_free(policy);
3741
3742	if (error)
3743		fatal("can't open '%s': %s", target, strerror(error));
3744
3745	argv++;
3746	argc--;
3747	if (!dump_opt['R']) {
3748		if (argc > 0) {
3749			zopt_objects = argc;
3750			zopt_object = calloc(zopt_objects, sizeof (uint64_t));
3751			for (i = 0; i < zopt_objects; i++) {
3752				errno = 0;
3753				zopt_object[i] = strtoull(argv[i], NULL, 0);
3754				if (zopt_object[i] == 0 && errno != 0)
3755					fatal("bad number %s: %s",
3756					    argv[i], strerror(errno));
3757			}
3758		}
3759		if (os != NULL) {
3760			dump_dir(os);
3761		} else if (zopt_objects > 0 && !dump_opt['m']) {
3762			dump_dir(spa->spa_meta_objset);
3763		} else {
3764			dump_zpool(spa);
3765		}
3766	} else {
3767		flagbits['b'] = ZDB_FLAG_PRINT_BLKPTR;
3768		flagbits['c'] = ZDB_FLAG_CHECKSUM;
3769		flagbits['d'] = ZDB_FLAG_DECOMPRESS;
3770		flagbits['e'] = ZDB_FLAG_BSWAP;
3771		flagbits['g'] = ZDB_FLAG_GBH;
3772		flagbits['i'] = ZDB_FLAG_INDIRECT;
3773		flagbits['p'] = ZDB_FLAG_PHYS;
3774		flagbits['r'] = ZDB_FLAG_RAW;
3775
3776		for (i = 0; i < argc; i++)
3777			zdb_read_block(argv[i], spa);
3778	}
3779
3780	(os != NULL) ? dmu_objset_disown(os, FTAG) : spa_close(spa, FTAG);
3781
3782	fuid_table_destroy();
3783	sa_loaded = B_FALSE;
3784
3785	libzfs_fini(g_zfs);
3786	kernel_fini();
3787
3788	return (0);
3789}
3790