xref: /freebsd/sys/contrib/openzfs/cmd/zdb/zdb.c (revision 3e8eb5c7f4909209c042403ddee340b2ee7003a5)
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, 2019 by Delphix. All rights reserved.
25  * Copyright (c) 2014 Integros [integros.com]
26  * Copyright 2016 Nexenta Systems, Inc.
27  * Copyright (c) 2017, 2018 Lawrence Livermore National Security, LLC.
28  * Copyright (c) 2015, 2017, Intel Corporation.
29  * Copyright (c) 2020 Datto Inc.
30  * Copyright (c) 2020, The FreeBSD Foundation [1]
31  *
32  * [1] Portions of this software were developed by Allan Jude
33  *     under sponsorship from the FreeBSD Foundation.
34  * Copyright (c) 2021 Allan Jude
35  * Copyright (c) 2021 Toomas Soome <tsoome@me.com>
36  */
37 
38 #include <stdio.h>
39 #include <unistd.h>
40 #include <stdlib.h>
41 #include <ctype.h>
42 #include <getopt.h>
43 #include <sys/zfs_context.h>
44 #include <sys/spa.h>
45 #include <sys/spa_impl.h>
46 #include <sys/dmu.h>
47 #include <sys/zap.h>
48 #include <sys/fs/zfs.h>
49 #include <sys/zfs_znode.h>
50 #include <sys/zfs_sa.h>
51 #include <sys/sa.h>
52 #include <sys/sa_impl.h>
53 #include <sys/vdev.h>
54 #include <sys/vdev_impl.h>
55 #include <sys/metaslab_impl.h>
56 #include <sys/dmu_objset.h>
57 #include <sys/dsl_dir.h>
58 #include <sys/dsl_dataset.h>
59 #include <sys/dsl_pool.h>
60 #include <sys/dsl_bookmark.h>
61 #include <sys/dbuf.h>
62 #include <sys/zil.h>
63 #include <sys/zil_impl.h>
64 #include <sys/stat.h>
65 #include <sys/resource.h>
66 #include <sys/dmu_send.h>
67 #include <sys/dmu_traverse.h>
68 #include <sys/zio_checksum.h>
69 #include <sys/zio_compress.h>
70 #include <sys/zfs_fuid.h>
71 #include <sys/arc.h>
72 #include <sys/arc_impl.h>
73 #include <sys/ddt.h>
74 #include <sys/zfeature.h>
75 #include <sys/abd.h>
76 #include <sys/blkptr.h>
77 #include <sys/dsl_crypt.h>
78 #include <sys/dsl_scan.h>
79 #include <sys/btree.h>
80 #include <zfs_comutil.h>
81 #include <sys/zstd/zstd.h>
82 
83 #include <libnvpair.h>
84 #include <libzutil.h>
85 
86 #include "zdb.h"
87 
88 #define	ZDB_COMPRESS_NAME(idx) ((idx) < ZIO_COMPRESS_FUNCTIONS ?	\
89 	zio_compress_table[(idx)].ci_name : "UNKNOWN")
90 #define	ZDB_CHECKSUM_NAME(idx) ((idx) < ZIO_CHECKSUM_FUNCTIONS ?	\
91 	zio_checksum_table[(idx)].ci_name : "UNKNOWN")
92 #define	ZDB_OT_TYPE(idx) ((idx) < DMU_OT_NUMTYPES ? (idx) :		\
93 	(idx) == DMU_OTN_ZAP_DATA || (idx) == DMU_OTN_ZAP_METADATA ?	\
94 	DMU_OT_ZAP_OTHER : \
95 	(idx) == DMU_OTN_UINT64_DATA || (idx) == DMU_OTN_UINT64_METADATA ? \
96 	DMU_OT_UINT64_OTHER : DMU_OT_NUMTYPES)
97 
98 /* Some platforms require part of inode IDs to be remapped */
99 #ifdef __APPLE__
100 #define	ZDB_MAP_OBJECT_ID(obj) INO_XNUTOZFS(obj, 2)
101 #else
102 #define	ZDB_MAP_OBJECT_ID(obj) (obj)
103 #endif
104 
105 static char *
106 zdb_ot_name(dmu_object_type_t type)
107 {
108 	if (type < DMU_OT_NUMTYPES)
109 		return (dmu_ot[type].ot_name);
110 	else if ((type & DMU_OT_NEWTYPE) &&
111 	    ((type & DMU_OT_BYTESWAP_MASK) < DMU_BSWAP_NUMFUNCS))
112 		return (dmu_ot_byteswap[type & DMU_OT_BYTESWAP_MASK].ob_name);
113 	else
114 		return ("UNKNOWN");
115 }
116 
117 extern int reference_tracking_enable;
118 extern int zfs_recover;
119 extern unsigned long zfs_arc_meta_min, zfs_arc_meta_limit;
120 extern int zfs_vdev_async_read_max_active;
121 extern boolean_t spa_load_verify_dryrun;
122 extern boolean_t spa_mode_readable_spacemaps;
123 extern int zfs_reconstruct_indirect_combinations_max;
124 extern int zfs_btree_verify_intensity;
125 
126 static const char cmdname[] = "zdb";
127 uint8_t dump_opt[256];
128 
129 typedef void object_viewer_t(objset_t *, uint64_t, void *data, size_t size);
130 
131 uint64_t *zopt_metaslab = NULL;
132 static unsigned zopt_metaslab_args = 0;
133 
134 typedef struct zopt_object_range {
135 	uint64_t zor_obj_start;
136 	uint64_t zor_obj_end;
137 	uint64_t zor_flags;
138 } zopt_object_range_t;
139 zopt_object_range_t *zopt_object_ranges = NULL;
140 static unsigned zopt_object_args = 0;
141 
142 static int flagbits[256];
143 
144 #define	ZOR_FLAG_PLAIN_FILE	0x0001
145 #define	ZOR_FLAG_DIRECTORY	0x0002
146 #define	ZOR_FLAG_SPACE_MAP	0x0004
147 #define	ZOR_FLAG_ZAP		0x0008
148 #define	ZOR_FLAG_ALL_TYPES	-1
149 #define	ZOR_SUPPORTED_FLAGS	(ZOR_FLAG_PLAIN_FILE	| \
150 				ZOR_FLAG_DIRECTORY	| \
151 				ZOR_FLAG_SPACE_MAP	| \
152 				ZOR_FLAG_ZAP)
153 
154 #define	ZDB_FLAG_CHECKSUM	0x0001
155 #define	ZDB_FLAG_DECOMPRESS	0x0002
156 #define	ZDB_FLAG_BSWAP		0x0004
157 #define	ZDB_FLAG_GBH		0x0008
158 #define	ZDB_FLAG_INDIRECT	0x0010
159 #define	ZDB_FLAG_RAW		0x0020
160 #define	ZDB_FLAG_PRINT_BLKPTR	0x0040
161 #define	ZDB_FLAG_VERBOSE	0x0080
162 
163 uint64_t max_inflight_bytes = 256 * 1024 * 1024; /* 256MB */
164 static int leaked_objects = 0;
165 static range_tree_t *mos_refd_objs;
166 
167 static void snprintf_blkptr_compact(char *, size_t, const blkptr_t *,
168     boolean_t);
169 static void mos_obj_refd(uint64_t);
170 static void mos_obj_refd_multiple(uint64_t);
171 static int dump_bpobj_cb(void *arg, const blkptr_t *bp, boolean_t free,
172     dmu_tx_t *tx);
173 
174 typedef struct sublivelist_verify {
175 	/* FREE's that haven't yet matched to an ALLOC, in one sub-livelist */
176 	zfs_btree_t sv_pair;
177 
178 	/* ALLOC's without a matching FREE, accumulates across sub-livelists */
179 	zfs_btree_t sv_leftover;
180 } sublivelist_verify_t;
181 
182 static int
183 livelist_compare(const void *larg, const void *rarg)
184 {
185 	const blkptr_t *l = larg;
186 	const blkptr_t *r = rarg;
187 
188 	/* Sort them according to dva[0] */
189 	uint64_t l_dva0_vdev, r_dva0_vdev;
190 	l_dva0_vdev = DVA_GET_VDEV(&l->blk_dva[0]);
191 	r_dva0_vdev = DVA_GET_VDEV(&r->blk_dva[0]);
192 	if (l_dva0_vdev < r_dva0_vdev)
193 		return (-1);
194 	else if (l_dva0_vdev > r_dva0_vdev)
195 		return (+1);
196 
197 	/* if vdevs are equal, sort by offsets. */
198 	uint64_t l_dva0_offset;
199 	uint64_t r_dva0_offset;
200 	l_dva0_offset = DVA_GET_OFFSET(&l->blk_dva[0]);
201 	r_dva0_offset = DVA_GET_OFFSET(&r->blk_dva[0]);
202 	if (l_dva0_offset < r_dva0_offset) {
203 		return (-1);
204 	} else if (l_dva0_offset > r_dva0_offset) {
205 		return (+1);
206 	}
207 
208 	/*
209 	 * Since we're storing blkptrs without cancelling FREE/ALLOC pairs,
210 	 * it's possible the offsets are equal. In that case, sort by txg
211 	 */
212 	if (l->blk_birth < r->blk_birth) {
213 		return (-1);
214 	} else if (l->blk_birth > r->blk_birth) {
215 		return (+1);
216 	}
217 	return (0);
218 }
219 
220 typedef struct sublivelist_verify_block {
221 	dva_t svb_dva;
222 
223 	/*
224 	 * We need this to check if the block marked as allocated
225 	 * in the livelist was freed (and potentially reallocated)
226 	 * in the metaslab spacemaps at a later TXG.
227 	 */
228 	uint64_t svb_allocated_txg;
229 } sublivelist_verify_block_t;
230 
231 static void zdb_print_blkptr(const blkptr_t *bp, int flags);
232 
233 typedef struct sublivelist_verify_block_refcnt {
234 	/* block pointer entry in livelist being verified */
235 	blkptr_t svbr_blk;
236 
237 	/*
238 	 * Refcount gets incremented to 1 when we encounter the first
239 	 * FREE entry for the svfbr block pointer and a node for it
240 	 * is created in our ZDB verification/tracking metadata.
241 	 *
242 	 * As we encounter more FREE entries we increment this counter
243 	 * and similarly decrement it whenever we find the respective
244 	 * ALLOC entries for this block.
245 	 *
246 	 * When the refcount gets to 0 it means that all the FREE and
247 	 * ALLOC entries of this block have paired up and we no longer
248 	 * need to track it in our verification logic (e.g. the node
249 	 * containing this struct in our verification data structure
250 	 * should be freed).
251 	 *
252 	 * [refer to sublivelist_verify_blkptr() for the actual code]
253 	 */
254 	uint32_t svbr_refcnt;
255 } sublivelist_verify_block_refcnt_t;
256 
257 static int
258 sublivelist_block_refcnt_compare(const void *larg, const void *rarg)
259 {
260 	const sublivelist_verify_block_refcnt_t *l = larg;
261 	const sublivelist_verify_block_refcnt_t *r = rarg;
262 	return (livelist_compare(&l->svbr_blk, &r->svbr_blk));
263 }
264 
265 static int
266 sublivelist_verify_blkptr(void *arg, const blkptr_t *bp, boolean_t free,
267     dmu_tx_t *tx)
268 {
269 	ASSERT3P(tx, ==, NULL);
270 	struct sublivelist_verify *sv = arg;
271 	sublivelist_verify_block_refcnt_t current = {
272 			.svbr_blk = *bp,
273 
274 			/*
275 			 * Start with 1 in case this is the first free entry.
276 			 * This field is not used for our B-Tree comparisons
277 			 * anyway.
278 			 */
279 			.svbr_refcnt = 1,
280 	};
281 
282 	zfs_btree_index_t where;
283 	sublivelist_verify_block_refcnt_t *pair =
284 	    zfs_btree_find(&sv->sv_pair, &current, &where);
285 	if (free) {
286 		if (pair == NULL) {
287 			/* first free entry for this block pointer */
288 			zfs_btree_add(&sv->sv_pair, &current);
289 		} else {
290 			pair->svbr_refcnt++;
291 		}
292 	} else {
293 		if (pair == NULL) {
294 			/* block that is currently marked as allocated */
295 			for (int i = 0; i < SPA_DVAS_PER_BP; i++) {
296 				if (DVA_IS_EMPTY(&bp->blk_dva[i]))
297 					break;
298 				sublivelist_verify_block_t svb = {
299 				    .svb_dva = bp->blk_dva[i],
300 				    .svb_allocated_txg = bp->blk_birth
301 				};
302 
303 				if (zfs_btree_find(&sv->sv_leftover, &svb,
304 				    &where) == NULL) {
305 					zfs_btree_add_idx(&sv->sv_leftover,
306 					    &svb, &where);
307 				}
308 			}
309 		} else {
310 			/* alloc matches a free entry */
311 			pair->svbr_refcnt--;
312 			if (pair->svbr_refcnt == 0) {
313 				/* all allocs and frees have been matched */
314 				zfs_btree_remove_idx(&sv->sv_pair, &where);
315 			}
316 		}
317 	}
318 
319 	return (0);
320 }
321 
322 static int
323 sublivelist_verify_func(void *args, dsl_deadlist_entry_t *dle)
324 {
325 	int err;
326 	struct sublivelist_verify *sv = args;
327 
328 	zfs_btree_create(&sv->sv_pair, sublivelist_block_refcnt_compare,
329 	    sizeof (sublivelist_verify_block_refcnt_t));
330 
331 	err = bpobj_iterate_nofree(&dle->dle_bpobj, sublivelist_verify_blkptr,
332 	    sv, NULL);
333 
334 	sublivelist_verify_block_refcnt_t *e;
335 	zfs_btree_index_t *cookie = NULL;
336 	while ((e = zfs_btree_destroy_nodes(&sv->sv_pair, &cookie)) != NULL) {
337 		char blkbuf[BP_SPRINTF_LEN];
338 		snprintf_blkptr_compact(blkbuf, sizeof (blkbuf),
339 		    &e->svbr_blk, B_TRUE);
340 		(void) printf("\tERROR: %d unmatched FREE(s): %s\n",
341 		    e->svbr_refcnt, blkbuf);
342 	}
343 	zfs_btree_destroy(&sv->sv_pair);
344 
345 	return (err);
346 }
347 
348 static int
349 livelist_block_compare(const void *larg, const void *rarg)
350 {
351 	const sublivelist_verify_block_t *l = larg;
352 	const sublivelist_verify_block_t *r = rarg;
353 
354 	if (DVA_GET_VDEV(&l->svb_dva) < DVA_GET_VDEV(&r->svb_dva))
355 		return (-1);
356 	else if (DVA_GET_VDEV(&l->svb_dva) > DVA_GET_VDEV(&r->svb_dva))
357 		return (+1);
358 
359 	if (DVA_GET_OFFSET(&l->svb_dva) < DVA_GET_OFFSET(&r->svb_dva))
360 		return (-1);
361 	else if (DVA_GET_OFFSET(&l->svb_dva) > DVA_GET_OFFSET(&r->svb_dva))
362 		return (+1);
363 
364 	if (DVA_GET_ASIZE(&l->svb_dva) < DVA_GET_ASIZE(&r->svb_dva))
365 		return (-1);
366 	else if (DVA_GET_ASIZE(&l->svb_dva) > DVA_GET_ASIZE(&r->svb_dva))
367 		return (+1);
368 
369 	return (0);
370 }
371 
372 /*
373  * Check for errors in a livelist while tracking all unfreed ALLOCs in the
374  * sublivelist_verify_t: sv->sv_leftover
375  */
376 static void
377 livelist_verify(dsl_deadlist_t *dl, void *arg)
378 {
379 	sublivelist_verify_t *sv = arg;
380 	dsl_deadlist_iterate(dl, sublivelist_verify_func, sv);
381 }
382 
383 /*
384  * Check for errors in the livelist entry and discard the intermediary
385  * data structures
386  */
387 static int
388 sublivelist_verify_lightweight(void *args, dsl_deadlist_entry_t *dle)
389 {
390 	(void) args;
391 	sublivelist_verify_t sv;
392 	zfs_btree_create(&sv.sv_leftover, livelist_block_compare,
393 	    sizeof (sublivelist_verify_block_t));
394 	int err = sublivelist_verify_func(&sv, dle);
395 	zfs_btree_clear(&sv.sv_leftover);
396 	zfs_btree_destroy(&sv.sv_leftover);
397 	return (err);
398 }
399 
400 typedef struct metaslab_verify {
401 	/*
402 	 * Tree containing all the leftover ALLOCs from the livelists
403 	 * that are part of this metaslab.
404 	 */
405 	zfs_btree_t mv_livelist_allocs;
406 
407 	/*
408 	 * Metaslab information.
409 	 */
410 	uint64_t mv_vdid;
411 	uint64_t mv_msid;
412 	uint64_t mv_start;
413 	uint64_t mv_end;
414 
415 	/*
416 	 * What's currently allocated for this metaslab.
417 	 */
418 	range_tree_t *mv_allocated;
419 } metaslab_verify_t;
420 
421 typedef void ll_iter_t(dsl_deadlist_t *ll, void *arg);
422 
423 typedef int (*zdb_log_sm_cb_t)(spa_t *spa, space_map_entry_t *sme, uint64_t txg,
424     void *arg);
425 
426 typedef struct unflushed_iter_cb_arg {
427 	spa_t *uic_spa;
428 	uint64_t uic_txg;
429 	void *uic_arg;
430 	zdb_log_sm_cb_t uic_cb;
431 } unflushed_iter_cb_arg_t;
432 
433 static int
434 iterate_through_spacemap_logs_cb(space_map_entry_t *sme, void *arg)
435 {
436 	unflushed_iter_cb_arg_t *uic = arg;
437 	return (uic->uic_cb(uic->uic_spa, sme, uic->uic_txg, uic->uic_arg));
438 }
439 
440 static void
441 iterate_through_spacemap_logs(spa_t *spa, zdb_log_sm_cb_t cb, void *arg)
442 {
443 	if (!spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP))
444 		return;
445 
446 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
447 	for (spa_log_sm_t *sls = avl_first(&spa->spa_sm_logs_by_txg);
448 	    sls; sls = AVL_NEXT(&spa->spa_sm_logs_by_txg, sls)) {
449 		space_map_t *sm = NULL;
450 		VERIFY0(space_map_open(&sm, spa_meta_objset(spa),
451 		    sls->sls_sm_obj, 0, UINT64_MAX, SPA_MINBLOCKSHIFT));
452 
453 		unflushed_iter_cb_arg_t uic = {
454 			.uic_spa = spa,
455 			.uic_txg = sls->sls_txg,
456 			.uic_arg = arg,
457 			.uic_cb = cb
458 		};
459 		VERIFY0(space_map_iterate(sm, space_map_length(sm),
460 		    iterate_through_spacemap_logs_cb, &uic));
461 		space_map_close(sm);
462 	}
463 	spa_config_exit(spa, SCL_CONFIG, FTAG);
464 }
465 
466 static void
467 verify_livelist_allocs(metaslab_verify_t *mv, uint64_t txg,
468     uint64_t offset, uint64_t size)
469 {
470 	sublivelist_verify_block_t svb;
471 	DVA_SET_VDEV(&svb.svb_dva, mv->mv_vdid);
472 	DVA_SET_OFFSET(&svb.svb_dva, offset);
473 	DVA_SET_ASIZE(&svb.svb_dva, size);
474 	zfs_btree_index_t where;
475 	uint64_t end_offset = offset + size;
476 
477 	/*
478 	 *  Look for an exact match for spacemap entry in the livelist entries.
479 	 *  Then, look for other livelist entries that fall within the range
480 	 *  of the spacemap entry as it may have been condensed
481 	 */
482 	sublivelist_verify_block_t *found =
483 	    zfs_btree_find(&mv->mv_livelist_allocs, &svb, &where);
484 	if (found == NULL) {
485 		found = zfs_btree_next(&mv->mv_livelist_allocs, &where, &where);
486 	}
487 	for (; found != NULL && DVA_GET_VDEV(&found->svb_dva) == mv->mv_vdid &&
488 	    DVA_GET_OFFSET(&found->svb_dva) < end_offset;
489 	    found = zfs_btree_next(&mv->mv_livelist_allocs, &where, &where)) {
490 		if (found->svb_allocated_txg <= txg) {
491 			(void) printf("ERROR: Livelist ALLOC [%llx:%llx] "
492 			    "from TXG %llx FREED at TXG %llx\n",
493 			    (u_longlong_t)DVA_GET_OFFSET(&found->svb_dva),
494 			    (u_longlong_t)DVA_GET_ASIZE(&found->svb_dva),
495 			    (u_longlong_t)found->svb_allocated_txg,
496 			    (u_longlong_t)txg);
497 		}
498 	}
499 }
500 
501 static int
502 metaslab_spacemap_validation_cb(space_map_entry_t *sme, void *arg)
503 {
504 	metaslab_verify_t *mv = arg;
505 	uint64_t offset = sme->sme_offset;
506 	uint64_t size = sme->sme_run;
507 	uint64_t txg = sme->sme_txg;
508 
509 	if (sme->sme_type == SM_ALLOC) {
510 		if (range_tree_contains(mv->mv_allocated,
511 		    offset, size)) {
512 			(void) printf("ERROR: DOUBLE ALLOC: "
513 			    "%llu [%llx:%llx] "
514 			    "%llu:%llu LOG_SM\n",
515 			    (u_longlong_t)txg, (u_longlong_t)offset,
516 			    (u_longlong_t)size, (u_longlong_t)mv->mv_vdid,
517 			    (u_longlong_t)mv->mv_msid);
518 		} else {
519 			range_tree_add(mv->mv_allocated,
520 			    offset, size);
521 		}
522 	} else {
523 		if (!range_tree_contains(mv->mv_allocated,
524 		    offset, size)) {
525 			(void) printf("ERROR: DOUBLE FREE: "
526 			    "%llu [%llx:%llx] "
527 			    "%llu:%llu LOG_SM\n",
528 			    (u_longlong_t)txg, (u_longlong_t)offset,
529 			    (u_longlong_t)size, (u_longlong_t)mv->mv_vdid,
530 			    (u_longlong_t)mv->mv_msid);
531 		} else {
532 			range_tree_remove(mv->mv_allocated,
533 			    offset, size);
534 		}
535 	}
536 
537 	if (sme->sme_type != SM_ALLOC) {
538 		/*
539 		 * If something is freed in the spacemap, verify that
540 		 * it is not listed as allocated in the livelist.
541 		 */
542 		verify_livelist_allocs(mv, txg, offset, size);
543 	}
544 	return (0);
545 }
546 
547 static int
548 spacemap_check_sm_log_cb(spa_t *spa, space_map_entry_t *sme,
549     uint64_t txg, void *arg)
550 {
551 	metaslab_verify_t *mv = arg;
552 	uint64_t offset = sme->sme_offset;
553 	uint64_t vdev_id = sme->sme_vdev;
554 
555 	vdev_t *vd = vdev_lookup_top(spa, vdev_id);
556 
557 	/* skip indirect vdevs */
558 	if (!vdev_is_concrete(vd))
559 		return (0);
560 
561 	if (vdev_id != mv->mv_vdid)
562 		return (0);
563 
564 	metaslab_t *ms = vd->vdev_ms[offset >> vd->vdev_ms_shift];
565 	if (ms->ms_id != mv->mv_msid)
566 		return (0);
567 
568 	if (txg < metaslab_unflushed_txg(ms))
569 		return (0);
570 
571 
572 	ASSERT3U(txg, ==, sme->sme_txg);
573 	return (metaslab_spacemap_validation_cb(sme, mv));
574 }
575 
576 static void
577 spacemap_check_sm_log(spa_t *spa, metaslab_verify_t *mv)
578 {
579 	iterate_through_spacemap_logs(spa, spacemap_check_sm_log_cb, mv);
580 }
581 
582 static void
583 spacemap_check_ms_sm(space_map_t  *sm, metaslab_verify_t *mv)
584 {
585 	if (sm == NULL)
586 		return;
587 
588 	VERIFY0(space_map_iterate(sm, space_map_length(sm),
589 	    metaslab_spacemap_validation_cb, mv));
590 }
591 
592 static void iterate_deleted_livelists(spa_t *spa, ll_iter_t func, void *arg);
593 
594 /*
595  * Transfer blocks from sv_leftover tree to the mv_livelist_allocs if
596  * they are part of that metaslab (mv_msid).
597  */
598 static void
599 mv_populate_livelist_allocs(metaslab_verify_t *mv, sublivelist_verify_t *sv)
600 {
601 	zfs_btree_index_t where;
602 	sublivelist_verify_block_t *svb;
603 	ASSERT3U(zfs_btree_numnodes(&mv->mv_livelist_allocs), ==, 0);
604 	for (svb = zfs_btree_first(&sv->sv_leftover, &where);
605 	    svb != NULL;
606 	    svb = zfs_btree_next(&sv->sv_leftover, &where, &where)) {
607 		if (DVA_GET_VDEV(&svb->svb_dva) != mv->mv_vdid)
608 			continue;
609 
610 		if (DVA_GET_OFFSET(&svb->svb_dva) < mv->mv_start &&
611 		    (DVA_GET_OFFSET(&svb->svb_dva) +
612 		    DVA_GET_ASIZE(&svb->svb_dva)) > mv->mv_start) {
613 			(void) printf("ERROR: Found block that crosses "
614 			    "metaslab boundary: <%llu:%llx:%llx>\n",
615 			    (u_longlong_t)DVA_GET_VDEV(&svb->svb_dva),
616 			    (u_longlong_t)DVA_GET_OFFSET(&svb->svb_dva),
617 			    (u_longlong_t)DVA_GET_ASIZE(&svb->svb_dva));
618 			continue;
619 		}
620 
621 		if (DVA_GET_OFFSET(&svb->svb_dva) < mv->mv_start)
622 			continue;
623 
624 		if (DVA_GET_OFFSET(&svb->svb_dva) >= mv->mv_end)
625 			continue;
626 
627 		if ((DVA_GET_OFFSET(&svb->svb_dva) +
628 		    DVA_GET_ASIZE(&svb->svb_dva)) > mv->mv_end) {
629 			(void) printf("ERROR: Found block that crosses "
630 			    "metaslab boundary: <%llu:%llx:%llx>\n",
631 			    (u_longlong_t)DVA_GET_VDEV(&svb->svb_dva),
632 			    (u_longlong_t)DVA_GET_OFFSET(&svb->svb_dva),
633 			    (u_longlong_t)DVA_GET_ASIZE(&svb->svb_dva));
634 			continue;
635 		}
636 
637 		zfs_btree_add(&mv->mv_livelist_allocs, svb);
638 	}
639 
640 	for (svb = zfs_btree_first(&mv->mv_livelist_allocs, &where);
641 	    svb != NULL;
642 	    svb = zfs_btree_next(&mv->mv_livelist_allocs, &where, &where)) {
643 		zfs_btree_remove(&sv->sv_leftover, svb);
644 	}
645 }
646 
647 /*
648  * [Livelist Check]
649  * Iterate through all the sublivelists and:
650  * - report leftover frees (**)
651  * - record leftover ALLOCs together with their TXG [see Cross Check]
652  *
653  * (**) Note: Double ALLOCs are valid in datasets that have dedup
654  *      enabled. Similarly double FREEs are allowed as well but
655  *      only if they pair up with a corresponding ALLOC entry once
656  *      we our done with our sublivelist iteration.
657  *
658  * [Spacemap Check]
659  * for each metaslab:
660  * - iterate over spacemap and then the metaslab's entries in the
661  *   spacemap log, then report any double FREEs and ALLOCs (do not
662  *   blow up).
663  *
664  * [Cross Check]
665  * After finishing the Livelist Check phase and while being in the
666  * Spacemap Check phase, we find all the recorded leftover ALLOCs
667  * of the livelist check that are part of the metaslab that we are
668  * currently looking at in the Spacemap Check. We report any entries
669  * that are marked as ALLOCs in the livelists but have been actually
670  * freed (and potentially allocated again) after their TXG stamp in
671  * the spacemaps. Also report any ALLOCs from the livelists that
672  * belong to indirect vdevs (e.g. their vdev completed removal).
673  *
674  * Note that this will miss Log Spacemap entries that cancelled each other
675  * out before being flushed to the metaslab, so we are not guaranteed
676  * to match all erroneous ALLOCs.
677  */
678 static void
679 livelist_metaslab_validate(spa_t *spa)
680 {
681 	(void) printf("Verifying deleted livelist entries\n");
682 
683 	sublivelist_verify_t sv;
684 	zfs_btree_create(&sv.sv_leftover, livelist_block_compare,
685 	    sizeof (sublivelist_verify_block_t));
686 	iterate_deleted_livelists(spa, livelist_verify, &sv);
687 
688 	(void) printf("Verifying metaslab entries\n");
689 	vdev_t *rvd = spa->spa_root_vdev;
690 	for (uint64_t c = 0; c < rvd->vdev_children; c++) {
691 		vdev_t *vd = rvd->vdev_child[c];
692 
693 		if (!vdev_is_concrete(vd))
694 			continue;
695 
696 		for (uint64_t mid = 0; mid < vd->vdev_ms_count; mid++) {
697 			metaslab_t *m = vd->vdev_ms[mid];
698 
699 			(void) fprintf(stderr,
700 			    "\rverifying concrete vdev %llu, "
701 			    "metaslab %llu of %llu ...",
702 			    (longlong_t)vd->vdev_id,
703 			    (longlong_t)mid,
704 			    (longlong_t)vd->vdev_ms_count);
705 
706 			uint64_t shift, start;
707 			range_seg_type_t type =
708 			    metaslab_calculate_range_tree_type(vd, m,
709 			    &start, &shift);
710 			metaslab_verify_t mv;
711 			mv.mv_allocated = range_tree_create(NULL,
712 			    type, NULL, start, shift);
713 			mv.mv_vdid = vd->vdev_id;
714 			mv.mv_msid = m->ms_id;
715 			mv.mv_start = m->ms_start;
716 			mv.mv_end = m->ms_start + m->ms_size;
717 			zfs_btree_create(&mv.mv_livelist_allocs,
718 			    livelist_block_compare,
719 			    sizeof (sublivelist_verify_block_t));
720 
721 			mv_populate_livelist_allocs(&mv, &sv);
722 
723 			spacemap_check_ms_sm(m->ms_sm, &mv);
724 			spacemap_check_sm_log(spa, &mv);
725 
726 			range_tree_vacate(mv.mv_allocated, NULL, NULL);
727 			range_tree_destroy(mv.mv_allocated);
728 			zfs_btree_clear(&mv.mv_livelist_allocs);
729 			zfs_btree_destroy(&mv.mv_livelist_allocs);
730 		}
731 	}
732 	(void) fprintf(stderr, "\n");
733 
734 	/*
735 	 * If there are any segments in the leftover tree after we walked
736 	 * through all the metaslabs in the concrete vdevs then this means
737 	 * that we have segments in the livelists that belong to indirect
738 	 * vdevs and are marked as allocated.
739 	 */
740 	if (zfs_btree_numnodes(&sv.sv_leftover) == 0) {
741 		zfs_btree_destroy(&sv.sv_leftover);
742 		return;
743 	}
744 	(void) printf("ERROR: Found livelist blocks marked as allocated "
745 	    "for indirect vdevs:\n");
746 
747 	zfs_btree_index_t *where = NULL;
748 	sublivelist_verify_block_t *svb;
749 	while ((svb = zfs_btree_destroy_nodes(&sv.sv_leftover, &where)) !=
750 	    NULL) {
751 		int vdev_id = DVA_GET_VDEV(&svb->svb_dva);
752 		ASSERT3U(vdev_id, <, rvd->vdev_children);
753 		vdev_t *vd = rvd->vdev_child[vdev_id];
754 		ASSERT(!vdev_is_concrete(vd));
755 		(void) printf("<%d:%llx:%llx> TXG %llx\n",
756 		    vdev_id, (u_longlong_t)DVA_GET_OFFSET(&svb->svb_dva),
757 		    (u_longlong_t)DVA_GET_ASIZE(&svb->svb_dva),
758 		    (u_longlong_t)svb->svb_allocated_txg);
759 	}
760 	(void) printf("\n");
761 	zfs_btree_destroy(&sv.sv_leftover);
762 }
763 
764 /*
765  * These libumem hooks provide a reasonable set of defaults for the allocator's
766  * debugging facilities.
767  */
768 const char *
769 _umem_debug_init(void)
770 {
771 	return ("default,verbose"); /* $UMEM_DEBUG setting */
772 }
773 
774 const char *
775 _umem_logging_init(void)
776 {
777 	return ("fail,contents"); /* $UMEM_LOGGING setting */
778 }
779 
780 static void
781 usage(void)
782 {
783 	(void) fprintf(stderr,
784 	    "Usage:\t%s [-AbcdDFGhikLMPsvXy] [-e [-V] [-p <path> ...]] "
785 	    "[-I <inflight I/Os>]\n"
786 	    "\t\t[-o <var>=<value>]... [-t <txg>] [-U <cache>] [-x <dumpdir>]\n"
787 	    "\t\t[<poolname>[/<dataset | objset id>] [<object | range> ...]]\n"
788 	    "\t%s [-AdiPv] [-e [-V] [-p <path> ...]] [-U <cache>]\n"
789 	    "\t\t[<poolname>[/<dataset | objset id>] [<object | range> ...]\n"
790 	    "\t%s [-v] <bookmark>\n"
791 	    "\t%s -C [-A] [-U <cache>]\n"
792 	    "\t%s -l [-Aqu] <device>\n"
793 	    "\t%s -m [-AFLPX] [-e [-V] [-p <path> ...]] [-t <txg>] "
794 	    "[-U <cache>]\n\t\t<poolname> [<vdev> [<metaslab> ...]]\n"
795 	    "\t%s -O <dataset> <path>\n"
796 	    "\t%s -r <dataset> <path> <destination>\n"
797 	    "\t%s -R [-A] [-e [-V] [-p <path> ...]] [-U <cache>]\n"
798 	    "\t\t<poolname> <vdev>:<offset>:<size>[:<flags>]\n"
799 	    "\t%s -E [-A] word0:word1:...:word15\n"
800 	    "\t%s -S [-AP] [-e [-V] [-p <path> ...]] [-U <cache>] "
801 	    "<poolname>\n\n",
802 	    cmdname, cmdname, cmdname, cmdname, cmdname, cmdname, cmdname,
803 	    cmdname, cmdname, cmdname, cmdname);
804 
805 	(void) fprintf(stderr, "    Dataset name must include at least one "
806 	    "separator character '/' or '@'\n");
807 	(void) fprintf(stderr, "    If dataset name is specified, only that "
808 	    "dataset is dumped\n");
809 	(void) fprintf(stderr,  "    If object numbers or object number "
810 	    "ranges are specified, only those\n"
811 	    "    objects or ranges are dumped.\n\n");
812 	(void) fprintf(stderr,
813 	    "    Object ranges take the form <start>:<end>[:<flags>]\n"
814 	    "        start    Starting object number\n"
815 	    "        end      Ending object number, or -1 for no upper bound\n"
816 	    "        flags    Optional flags to select object types:\n"
817 	    "            A     All objects (this is the default)\n"
818 	    "            d     ZFS directories\n"
819 	    "            f     ZFS files \n"
820 	    "            m     SPA space maps\n"
821 	    "            z     ZAPs\n"
822 	    "            -     Negate effect of next flag\n\n");
823 	(void) fprintf(stderr, "    Options to control amount of output:\n");
824 	(void) fprintf(stderr, "        -b --block-stats             "
825 	    "block statistics\n");
826 	(void) fprintf(stderr, "        -c --checksum                "
827 	    "checksum all metadata (twice for all data) blocks\n");
828 	(void) fprintf(stderr, "        -C --config                  "
829 	    "config (or cachefile if alone)\n");
830 	(void) fprintf(stderr, "        -d --datasets                "
831 	    "dataset(s)\n");
832 	(void) fprintf(stderr, "        -D --dedup-stats             "
833 	    "dedup statistics\n");
834 	(void) fprintf(stderr, "        -E --embedded-block-pointer=INTEGER\n"
835 	    "                                     decode and display block "
836 	    "from an embedded block pointer\n");
837 	(void) fprintf(stderr, "        -h --history                 "
838 	    "pool history\n");
839 	(void) fprintf(stderr, "        -i --intent-logs             "
840 	    "intent logs\n");
841 	(void) fprintf(stderr, "        -l --label                   "
842 	    "read label contents\n");
843 	(void) fprintf(stderr, "        -k --checkpointed-state      "
844 	    "examine the checkpointed state of the pool\n");
845 	(void) fprintf(stderr, "        -L --disable-leak-tracking   "
846 	    "disable leak tracking (do not load spacemaps)\n");
847 	(void) fprintf(stderr, "        -m --metaslabs               "
848 	    "metaslabs\n");
849 	(void) fprintf(stderr, "        -M --metaslab-groups         "
850 	    "metaslab groups\n");
851 	(void) fprintf(stderr, "        -O --object-lookups          "
852 	    "perform object lookups by path\n");
853 	(void) fprintf(stderr, "        -r --copy-object             "
854 	    "copy an object by path to file\n");
855 	(void) fprintf(stderr, "        -R --read-block              "
856 	    "read and display block from a device\n");
857 	(void) fprintf(stderr, "        -s --io-stats                "
858 	    "report stats on zdb's I/O\n");
859 	(void) fprintf(stderr, "        -S --simulate-dedup          "
860 	    "simulate dedup to measure effect\n");
861 	(void) fprintf(stderr, "        -v --verbose                 "
862 	    "verbose (applies to all others)\n");
863 	(void) fprintf(stderr, "        -y --livelist                "
864 	    "perform livelist and metaslab validation on any livelists being "
865 	    "deleted\n\n");
866 	(void) fprintf(stderr, "    Below options are intended for use "
867 	    "with other options:\n");
868 	(void) fprintf(stderr, "        -A --ignore-assertions       "
869 	    "ignore assertions (-A), enable panic recovery (-AA) or both "
870 	    "(-AAA)\n");
871 	(void) fprintf(stderr, "        -e --exported                "
872 	    "pool is exported/destroyed/has altroot/not in a cachefile\n");
873 	(void) fprintf(stderr, "        -F --automatic-rewind        "
874 	    "attempt automatic rewind within safe range of transaction "
875 	    "groups\n");
876 	(void) fprintf(stderr, "        -G --dump-debug-msg          "
877 	    "dump zfs_dbgmsg buffer before exiting\n");
878 	(void) fprintf(stderr, "        -I --inflight=INTEGER        "
879 	    "specify the maximum number of checksumming I/Os "
880 	    "[default is 200]\n");
881 	(void) fprintf(stderr, "        -o --option=\"OPTION=INTEGER\" "
882 	    "set global variable to an unsigned 32-bit integer\n");
883 	(void) fprintf(stderr, "        -p --path==PATH              "
884 	    "use one or more with -e to specify path to vdev dir\n");
885 	(void) fprintf(stderr, "        -P --parseable               "
886 	    "print numbers in parseable form\n");
887 	(void) fprintf(stderr, "        -q --skip-label              "
888 	    "don't print label contents\n");
889 	(void) fprintf(stderr, "        -t --txg=INTEGER             "
890 	    "highest txg to use when searching for uberblocks\n");
891 	(void) fprintf(stderr, "        -u --uberblock               "
892 	    "uberblock\n");
893 	(void) fprintf(stderr, "        -U --cachefile=PATH          "
894 	    "use alternate cachefile\n");
895 	(void) fprintf(stderr, "        -V --verbatim                "
896 	    "do verbatim import\n");
897 	(void) fprintf(stderr, "        -x --dump-blocks=PATH        "
898 	    "dump all read blocks into specified directory\n");
899 	(void) fprintf(stderr, "        -X --extreme-rewind          "
900 	    "attempt extreme rewind (does not work with dataset)\n");
901 	(void) fprintf(stderr, "        -Y --all-reconstruction      "
902 	    "attempt all reconstruction combinations for split blocks\n");
903 	(void) fprintf(stderr, "        -Z --zstd-headers            "
904 	    "show ZSTD headers \n");
905 	(void) fprintf(stderr, "Specify an option more than once (e.g. -bb) "
906 	    "to make only that option verbose\n");
907 	(void) fprintf(stderr, "Default is to dump everything non-verbosely\n");
908 	exit(1);
909 }
910 
911 static void
912 dump_debug_buffer(void)
913 {
914 	if (dump_opt['G']) {
915 		(void) printf("\n");
916 		(void) fflush(stdout);
917 		zfs_dbgmsg_print("zdb");
918 	}
919 }
920 
921 /*
922  * Called for usage errors that are discovered after a call to spa_open(),
923  * dmu_bonus_hold(), or pool_match().  abort() is called for other errors.
924  */
925 
926 static void
927 fatal(const char *fmt, ...)
928 {
929 	va_list ap;
930 
931 	va_start(ap, fmt);
932 	(void) fprintf(stderr, "%s: ", cmdname);
933 	(void) vfprintf(stderr, fmt, ap);
934 	va_end(ap);
935 	(void) fprintf(stderr, "\n");
936 
937 	dump_debug_buffer();
938 
939 	exit(1);
940 }
941 
942 static void
943 dump_packed_nvlist(objset_t *os, uint64_t object, void *data, size_t size)
944 {
945 	(void) size;
946 	nvlist_t *nv;
947 	size_t nvsize = *(uint64_t *)data;
948 	char *packed = umem_alloc(nvsize, UMEM_NOFAIL);
949 
950 	VERIFY(0 == dmu_read(os, object, 0, nvsize, packed, DMU_READ_PREFETCH));
951 
952 	VERIFY(nvlist_unpack(packed, nvsize, &nv, 0) == 0);
953 
954 	umem_free(packed, nvsize);
955 
956 	dump_nvlist(nv, 8);
957 
958 	nvlist_free(nv);
959 }
960 
961 static void
962 dump_history_offsets(objset_t *os, uint64_t object, void *data, size_t size)
963 {
964 	(void) os, (void) object, (void) size;
965 	spa_history_phys_t *shp = data;
966 
967 	if (shp == NULL)
968 		return;
969 
970 	(void) printf("\t\tpool_create_len = %llu\n",
971 	    (u_longlong_t)shp->sh_pool_create_len);
972 	(void) printf("\t\tphys_max_off = %llu\n",
973 	    (u_longlong_t)shp->sh_phys_max_off);
974 	(void) printf("\t\tbof = %llu\n",
975 	    (u_longlong_t)shp->sh_bof);
976 	(void) printf("\t\teof = %llu\n",
977 	    (u_longlong_t)shp->sh_eof);
978 	(void) printf("\t\trecords_lost = %llu\n",
979 	    (u_longlong_t)shp->sh_records_lost);
980 }
981 
982 static void
983 zdb_nicenum(uint64_t num, char *buf, size_t buflen)
984 {
985 	if (dump_opt['P'])
986 		(void) snprintf(buf, buflen, "%llu", (longlong_t)num);
987 	else
988 		nicenum(num, buf, sizeof (buf));
989 }
990 
991 static const char histo_stars[] = "****************************************";
992 static const uint64_t histo_width = sizeof (histo_stars) - 1;
993 
994 static void
995 dump_histogram(const uint64_t *histo, int size, int offset)
996 {
997 	int i;
998 	int minidx = size - 1;
999 	int maxidx = 0;
1000 	uint64_t max = 0;
1001 
1002 	for (i = 0; i < size; i++) {
1003 		if (histo[i] > max)
1004 			max = histo[i];
1005 		if (histo[i] > 0 && i > maxidx)
1006 			maxidx = i;
1007 		if (histo[i] > 0 && i < minidx)
1008 			minidx = i;
1009 	}
1010 
1011 	if (max < histo_width)
1012 		max = histo_width;
1013 
1014 	for (i = minidx; i <= maxidx; i++) {
1015 		(void) printf("\t\t\t%3u: %6llu %s\n",
1016 		    i + offset, (u_longlong_t)histo[i],
1017 		    &histo_stars[(max - histo[i]) * histo_width / max]);
1018 	}
1019 }
1020 
1021 static void
1022 dump_zap_stats(objset_t *os, uint64_t object)
1023 {
1024 	int error;
1025 	zap_stats_t zs;
1026 
1027 	error = zap_get_stats(os, object, &zs);
1028 	if (error)
1029 		return;
1030 
1031 	if (zs.zs_ptrtbl_len == 0) {
1032 		ASSERT(zs.zs_num_blocks == 1);
1033 		(void) printf("\tmicrozap: %llu bytes, %llu entries\n",
1034 		    (u_longlong_t)zs.zs_blocksize,
1035 		    (u_longlong_t)zs.zs_num_entries);
1036 		return;
1037 	}
1038 
1039 	(void) printf("\tFat ZAP stats:\n");
1040 
1041 	(void) printf("\t\tPointer table:\n");
1042 	(void) printf("\t\t\t%llu elements\n",
1043 	    (u_longlong_t)zs.zs_ptrtbl_len);
1044 	(void) printf("\t\t\tzt_blk: %llu\n",
1045 	    (u_longlong_t)zs.zs_ptrtbl_zt_blk);
1046 	(void) printf("\t\t\tzt_numblks: %llu\n",
1047 	    (u_longlong_t)zs.zs_ptrtbl_zt_numblks);
1048 	(void) printf("\t\t\tzt_shift: %llu\n",
1049 	    (u_longlong_t)zs.zs_ptrtbl_zt_shift);
1050 	(void) printf("\t\t\tzt_blks_copied: %llu\n",
1051 	    (u_longlong_t)zs.zs_ptrtbl_blks_copied);
1052 	(void) printf("\t\t\tzt_nextblk: %llu\n",
1053 	    (u_longlong_t)zs.zs_ptrtbl_nextblk);
1054 
1055 	(void) printf("\t\tZAP entries: %llu\n",
1056 	    (u_longlong_t)zs.zs_num_entries);
1057 	(void) printf("\t\tLeaf blocks: %llu\n",
1058 	    (u_longlong_t)zs.zs_num_leafs);
1059 	(void) printf("\t\tTotal blocks: %llu\n",
1060 	    (u_longlong_t)zs.zs_num_blocks);
1061 	(void) printf("\t\tzap_block_type: 0x%llx\n",
1062 	    (u_longlong_t)zs.zs_block_type);
1063 	(void) printf("\t\tzap_magic: 0x%llx\n",
1064 	    (u_longlong_t)zs.zs_magic);
1065 	(void) printf("\t\tzap_salt: 0x%llx\n",
1066 	    (u_longlong_t)zs.zs_salt);
1067 
1068 	(void) printf("\t\tLeafs with 2^n pointers:\n");
1069 	dump_histogram(zs.zs_leafs_with_2n_pointers, ZAP_HISTOGRAM_SIZE, 0);
1070 
1071 	(void) printf("\t\tBlocks with n*5 entries:\n");
1072 	dump_histogram(zs.zs_blocks_with_n5_entries, ZAP_HISTOGRAM_SIZE, 0);
1073 
1074 	(void) printf("\t\tBlocks n/10 full:\n");
1075 	dump_histogram(zs.zs_blocks_n_tenths_full, ZAP_HISTOGRAM_SIZE, 0);
1076 
1077 	(void) printf("\t\tEntries with n chunks:\n");
1078 	dump_histogram(zs.zs_entries_using_n_chunks, ZAP_HISTOGRAM_SIZE, 0);
1079 
1080 	(void) printf("\t\tBuckets with n entries:\n");
1081 	dump_histogram(zs.zs_buckets_with_n_entries, ZAP_HISTOGRAM_SIZE, 0);
1082 }
1083 
1084 static void
1085 dump_none(objset_t *os, uint64_t object, void *data, size_t size)
1086 {
1087 	(void) os, (void) object, (void) data, (void) size;
1088 }
1089 
1090 static void
1091 dump_unknown(objset_t *os, uint64_t object, void *data, size_t size)
1092 {
1093 	(void) os, (void) object, (void) data, (void) size;
1094 	(void) printf("\tUNKNOWN OBJECT TYPE\n");
1095 }
1096 
1097 static void
1098 dump_uint8(objset_t *os, uint64_t object, void *data, size_t size)
1099 {
1100 	(void) os, (void) object, (void) data, (void) size;
1101 }
1102 
1103 static void
1104 dump_uint64(objset_t *os, uint64_t object, void *data, size_t size)
1105 {
1106 	uint64_t *arr;
1107 	uint64_t oursize;
1108 	if (dump_opt['d'] < 6)
1109 		return;
1110 
1111 	if (data == NULL) {
1112 		dmu_object_info_t doi;
1113 
1114 		VERIFY0(dmu_object_info(os, object, &doi));
1115 		size = doi.doi_max_offset;
1116 		/*
1117 		 * We cap the size at 1 mebibyte here to prevent
1118 		 * allocation failures and nigh-infinite printing if the
1119 		 * object is extremely large.
1120 		 */
1121 		oursize = MIN(size, 1 << 20);
1122 		arr = kmem_alloc(oursize, KM_SLEEP);
1123 
1124 		int err = dmu_read(os, object, 0, oursize, arr, 0);
1125 		if (err != 0) {
1126 			(void) printf("got error %u from dmu_read\n", err);
1127 			kmem_free(arr, oursize);
1128 			return;
1129 		}
1130 	} else {
1131 		/*
1132 		 * Even though the allocation is already done in this code path,
1133 		 * we still cap the size to prevent excessive printing.
1134 		 */
1135 		oursize = MIN(size, 1 << 20);
1136 		arr = data;
1137 	}
1138 
1139 	if (size == 0) {
1140 		(void) printf("\t\t[]\n");
1141 		return;
1142 	}
1143 
1144 	(void) printf("\t\t[%0llx", (u_longlong_t)arr[0]);
1145 	for (size_t i = 1; i * sizeof (uint64_t) < oursize; i++) {
1146 		if (i % 4 != 0)
1147 			(void) printf(", %0llx", (u_longlong_t)arr[i]);
1148 		else
1149 			(void) printf(",\n\t\t%0llx", (u_longlong_t)arr[i]);
1150 	}
1151 	if (oursize != size)
1152 		(void) printf(", ... ");
1153 	(void) printf("]\n");
1154 
1155 	if (data == NULL)
1156 		kmem_free(arr, oursize);
1157 }
1158 
1159 static void
1160 dump_zap(objset_t *os, uint64_t object, void *data, size_t size)
1161 {
1162 	(void) data, (void) size;
1163 	zap_cursor_t zc;
1164 	zap_attribute_t attr;
1165 	void *prop;
1166 	unsigned i;
1167 
1168 	dump_zap_stats(os, object);
1169 	(void) printf("\n");
1170 
1171 	for (zap_cursor_init(&zc, os, object);
1172 	    zap_cursor_retrieve(&zc, &attr) == 0;
1173 	    zap_cursor_advance(&zc)) {
1174 		(void) printf("\t\t%s = ", attr.za_name);
1175 		if (attr.za_num_integers == 0) {
1176 			(void) printf("\n");
1177 			continue;
1178 		}
1179 		prop = umem_zalloc(attr.za_num_integers *
1180 		    attr.za_integer_length, UMEM_NOFAIL);
1181 		(void) zap_lookup(os, object, attr.za_name,
1182 		    attr.za_integer_length, attr.za_num_integers, prop);
1183 		if (attr.za_integer_length == 1) {
1184 			if (strcmp(attr.za_name,
1185 			    DSL_CRYPTO_KEY_MASTER_KEY) == 0 ||
1186 			    strcmp(attr.za_name,
1187 			    DSL_CRYPTO_KEY_HMAC_KEY) == 0 ||
1188 			    strcmp(attr.za_name, DSL_CRYPTO_KEY_IV) == 0 ||
1189 			    strcmp(attr.za_name, DSL_CRYPTO_KEY_MAC) == 0 ||
1190 			    strcmp(attr.za_name, DMU_POOL_CHECKSUM_SALT) == 0) {
1191 				uint8_t *u8 = prop;
1192 
1193 				for (i = 0; i < attr.za_num_integers; i++) {
1194 					(void) printf("%02x", u8[i]);
1195 				}
1196 			} else {
1197 				(void) printf("%s", (char *)prop);
1198 			}
1199 		} else {
1200 			for (i = 0; i < attr.za_num_integers; i++) {
1201 				switch (attr.za_integer_length) {
1202 				case 2:
1203 					(void) printf("%u ",
1204 					    ((uint16_t *)prop)[i]);
1205 					break;
1206 				case 4:
1207 					(void) printf("%u ",
1208 					    ((uint32_t *)prop)[i]);
1209 					break;
1210 				case 8:
1211 					(void) printf("%lld ",
1212 					    (u_longlong_t)((int64_t *)prop)[i]);
1213 					break;
1214 				}
1215 			}
1216 		}
1217 		(void) printf("\n");
1218 		umem_free(prop, attr.za_num_integers * attr.za_integer_length);
1219 	}
1220 	zap_cursor_fini(&zc);
1221 }
1222 
1223 static void
1224 dump_bpobj(objset_t *os, uint64_t object, void *data, size_t size)
1225 {
1226 	bpobj_phys_t *bpop = data;
1227 	uint64_t i;
1228 	char bytes[32], comp[32], uncomp[32];
1229 
1230 	/* make sure the output won't get truncated */
1231 	_Static_assert(sizeof (bytes) >= NN_NUMBUF_SZ, "bytes truncated");
1232 	_Static_assert(sizeof (comp) >= NN_NUMBUF_SZ, "comp truncated");
1233 	_Static_assert(sizeof (uncomp) >= NN_NUMBUF_SZ, "uncomp truncated");
1234 
1235 	if (bpop == NULL)
1236 		return;
1237 
1238 	zdb_nicenum(bpop->bpo_bytes, bytes, sizeof (bytes));
1239 	zdb_nicenum(bpop->bpo_comp, comp, sizeof (comp));
1240 	zdb_nicenum(bpop->bpo_uncomp, uncomp, sizeof (uncomp));
1241 
1242 	(void) printf("\t\tnum_blkptrs = %llu\n",
1243 	    (u_longlong_t)bpop->bpo_num_blkptrs);
1244 	(void) printf("\t\tbytes = %s\n", bytes);
1245 	if (size >= BPOBJ_SIZE_V1) {
1246 		(void) printf("\t\tcomp = %s\n", comp);
1247 		(void) printf("\t\tuncomp = %s\n", uncomp);
1248 	}
1249 	if (size >= BPOBJ_SIZE_V2) {
1250 		(void) printf("\t\tsubobjs = %llu\n",
1251 		    (u_longlong_t)bpop->bpo_subobjs);
1252 		(void) printf("\t\tnum_subobjs = %llu\n",
1253 		    (u_longlong_t)bpop->bpo_num_subobjs);
1254 	}
1255 	if (size >= sizeof (*bpop)) {
1256 		(void) printf("\t\tnum_freed = %llu\n",
1257 		    (u_longlong_t)bpop->bpo_num_freed);
1258 	}
1259 
1260 	if (dump_opt['d'] < 5)
1261 		return;
1262 
1263 	for (i = 0; i < bpop->bpo_num_blkptrs; i++) {
1264 		char blkbuf[BP_SPRINTF_LEN];
1265 		blkptr_t bp;
1266 
1267 		int err = dmu_read(os, object,
1268 		    i * sizeof (bp), sizeof (bp), &bp, 0);
1269 		if (err != 0) {
1270 			(void) printf("got error %u from dmu_read\n", err);
1271 			break;
1272 		}
1273 		snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), &bp,
1274 		    BP_GET_FREE(&bp));
1275 		(void) printf("\t%s\n", blkbuf);
1276 	}
1277 }
1278 
1279 static void
1280 dump_bpobj_subobjs(objset_t *os, uint64_t object, void *data, size_t size)
1281 {
1282 	(void) data, (void) size;
1283 	dmu_object_info_t doi;
1284 	int64_t i;
1285 
1286 	VERIFY0(dmu_object_info(os, object, &doi));
1287 	uint64_t *subobjs = kmem_alloc(doi.doi_max_offset, KM_SLEEP);
1288 
1289 	int err = dmu_read(os, object, 0, doi.doi_max_offset, subobjs, 0);
1290 	if (err != 0) {
1291 		(void) printf("got error %u from dmu_read\n", err);
1292 		kmem_free(subobjs, doi.doi_max_offset);
1293 		return;
1294 	}
1295 
1296 	int64_t last_nonzero = -1;
1297 	for (i = 0; i < doi.doi_max_offset / 8; i++) {
1298 		if (subobjs[i] != 0)
1299 			last_nonzero = i;
1300 	}
1301 
1302 	for (i = 0; i <= last_nonzero; i++) {
1303 		(void) printf("\t%llu\n", (u_longlong_t)subobjs[i]);
1304 	}
1305 	kmem_free(subobjs, doi.doi_max_offset);
1306 }
1307 
1308 static void
1309 dump_ddt_zap(objset_t *os, uint64_t object, void *data, size_t size)
1310 {
1311 	(void) data, (void) size;
1312 	dump_zap_stats(os, object);
1313 	/* contents are printed elsewhere, properly decoded */
1314 }
1315 
1316 static void
1317 dump_sa_attrs(objset_t *os, uint64_t object, void *data, size_t size)
1318 {
1319 	(void) data, (void) size;
1320 	zap_cursor_t zc;
1321 	zap_attribute_t attr;
1322 
1323 	dump_zap_stats(os, object);
1324 	(void) printf("\n");
1325 
1326 	for (zap_cursor_init(&zc, os, object);
1327 	    zap_cursor_retrieve(&zc, &attr) == 0;
1328 	    zap_cursor_advance(&zc)) {
1329 		(void) printf("\t\t%s = ", attr.za_name);
1330 		if (attr.za_num_integers == 0) {
1331 			(void) printf("\n");
1332 			continue;
1333 		}
1334 		(void) printf(" %llx : [%d:%d:%d]\n",
1335 		    (u_longlong_t)attr.za_first_integer,
1336 		    (int)ATTR_LENGTH(attr.za_first_integer),
1337 		    (int)ATTR_BSWAP(attr.za_first_integer),
1338 		    (int)ATTR_NUM(attr.za_first_integer));
1339 	}
1340 	zap_cursor_fini(&zc);
1341 }
1342 
1343 static void
1344 dump_sa_layouts(objset_t *os, uint64_t object, void *data, size_t size)
1345 {
1346 	(void) data, (void) size;
1347 	zap_cursor_t zc;
1348 	zap_attribute_t attr;
1349 	uint16_t *layout_attrs;
1350 	unsigned i;
1351 
1352 	dump_zap_stats(os, object);
1353 	(void) printf("\n");
1354 
1355 	for (zap_cursor_init(&zc, os, object);
1356 	    zap_cursor_retrieve(&zc, &attr) == 0;
1357 	    zap_cursor_advance(&zc)) {
1358 		(void) printf("\t\t%s = [", attr.za_name);
1359 		if (attr.za_num_integers == 0) {
1360 			(void) printf("\n");
1361 			continue;
1362 		}
1363 
1364 		VERIFY(attr.za_integer_length == 2);
1365 		layout_attrs = umem_zalloc(attr.za_num_integers *
1366 		    attr.za_integer_length, UMEM_NOFAIL);
1367 
1368 		VERIFY(zap_lookup(os, object, attr.za_name,
1369 		    attr.za_integer_length,
1370 		    attr.za_num_integers, layout_attrs) == 0);
1371 
1372 		for (i = 0; i != attr.za_num_integers; i++)
1373 			(void) printf(" %d ", (int)layout_attrs[i]);
1374 		(void) printf("]\n");
1375 		umem_free(layout_attrs,
1376 		    attr.za_num_integers * attr.za_integer_length);
1377 	}
1378 	zap_cursor_fini(&zc);
1379 }
1380 
1381 static void
1382 dump_zpldir(objset_t *os, uint64_t object, void *data, size_t size)
1383 {
1384 	(void) data, (void) size;
1385 	zap_cursor_t zc;
1386 	zap_attribute_t attr;
1387 	const char *typenames[] = {
1388 		/* 0 */ "not specified",
1389 		/* 1 */ "FIFO",
1390 		/* 2 */ "Character Device",
1391 		/* 3 */ "3 (invalid)",
1392 		/* 4 */ "Directory",
1393 		/* 5 */ "5 (invalid)",
1394 		/* 6 */ "Block Device",
1395 		/* 7 */ "7 (invalid)",
1396 		/* 8 */ "Regular File",
1397 		/* 9 */ "9 (invalid)",
1398 		/* 10 */ "Symbolic Link",
1399 		/* 11 */ "11 (invalid)",
1400 		/* 12 */ "Socket",
1401 		/* 13 */ "Door",
1402 		/* 14 */ "Event Port",
1403 		/* 15 */ "15 (invalid)",
1404 	};
1405 
1406 	dump_zap_stats(os, object);
1407 	(void) printf("\n");
1408 
1409 	for (zap_cursor_init(&zc, os, object);
1410 	    zap_cursor_retrieve(&zc, &attr) == 0;
1411 	    zap_cursor_advance(&zc)) {
1412 		(void) printf("\t\t%s = %lld (type: %s)\n",
1413 		    attr.za_name, ZFS_DIRENT_OBJ(attr.za_first_integer),
1414 		    typenames[ZFS_DIRENT_TYPE(attr.za_first_integer)]);
1415 	}
1416 	zap_cursor_fini(&zc);
1417 }
1418 
1419 static int
1420 get_dtl_refcount(vdev_t *vd)
1421 {
1422 	int refcount = 0;
1423 
1424 	if (vd->vdev_ops->vdev_op_leaf) {
1425 		space_map_t *sm = vd->vdev_dtl_sm;
1426 
1427 		if (sm != NULL &&
1428 		    sm->sm_dbuf->db_size == sizeof (space_map_phys_t))
1429 			return (1);
1430 		return (0);
1431 	}
1432 
1433 	for (unsigned c = 0; c < vd->vdev_children; c++)
1434 		refcount += get_dtl_refcount(vd->vdev_child[c]);
1435 	return (refcount);
1436 }
1437 
1438 static int
1439 get_metaslab_refcount(vdev_t *vd)
1440 {
1441 	int refcount = 0;
1442 
1443 	if (vd->vdev_top == vd) {
1444 		for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
1445 			space_map_t *sm = vd->vdev_ms[m]->ms_sm;
1446 
1447 			if (sm != NULL &&
1448 			    sm->sm_dbuf->db_size == sizeof (space_map_phys_t))
1449 				refcount++;
1450 		}
1451 	}
1452 	for (unsigned c = 0; c < vd->vdev_children; c++)
1453 		refcount += get_metaslab_refcount(vd->vdev_child[c]);
1454 
1455 	return (refcount);
1456 }
1457 
1458 static int
1459 get_obsolete_refcount(vdev_t *vd)
1460 {
1461 	uint64_t obsolete_sm_object;
1462 	int refcount = 0;
1463 
1464 	VERIFY0(vdev_obsolete_sm_object(vd, &obsolete_sm_object));
1465 	if (vd->vdev_top == vd && obsolete_sm_object != 0) {
1466 		dmu_object_info_t doi;
1467 		VERIFY0(dmu_object_info(vd->vdev_spa->spa_meta_objset,
1468 		    obsolete_sm_object, &doi));
1469 		if (doi.doi_bonus_size == sizeof (space_map_phys_t)) {
1470 			refcount++;
1471 		}
1472 	} else {
1473 		ASSERT3P(vd->vdev_obsolete_sm, ==, NULL);
1474 		ASSERT3U(obsolete_sm_object, ==, 0);
1475 	}
1476 	for (unsigned c = 0; c < vd->vdev_children; c++) {
1477 		refcount += get_obsolete_refcount(vd->vdev_child[c]);
1478 	}
1479 
1480 	return (refcount);
1481 }
1482 
1483 static int
1484 get_prev_obsolete_spacemap_refcount(spa_t *spa)
1485 {
1486 	uint64_t prev_obj =
1487 	    spa->spa_condensing_indirect_phys.scip_prev_obsolete_sm_object;
1488 	if (prev_obj != 0) {
1489 		dmu_object_info_t doi;
1490 		VERIFY0(dmu_object_info(spa->spa_meta_objset, prev_obj, &doi));
1491 		if (doi.doi_bonus_size == sizeof (space_map_phys_t)) {
1492 			return (1);
1493 		}
1494 	}
1495 	return (0);
1496 }
1497 
1498 static int
1499 get_checkpoint_refcount(vdev_t *vd)
1500 {
1501 	int refcount = 0;
1502 
1503 	if (vd->vdev_top == vd && vd->vdev_top_zap != 0 &&
1504 	    zap_contains(spa_meta_objset(vd->vdev_spa),
1505 	    vd->vdev_top_zap, VDEV_TOP_ZAP_POOL_CHECKPOINT_SM) == 0)
1506 		refcount++;
1507 
1508 	for (uint64_t c = 0; c < vd->vdev_children; c++)
1509 		refcount += get_checkpoint_refcount(vd->vdev_child[c]);
1510 
1511 	return (refcount);
1512 }
1513 
1514 static int
1515 get_log_spacemap_refcount(spa_t *spa)
1516 {
1517 	return (avl_numnodes(&spa->spa_sm_logs_by_txg));
1518 }
1519 
1520 static int
1521 verify_spacemap_refcounts(spa_t *spa)
1522 {
1523 	uint64_t expected_refcount = 0;
1524 	uint64_t actual_refcount;
1525 
1526 	(void) feature_get_refcount(spa,
1527 	    &spa_feature_table[SPA_FEATURE_SPACEMAP_HISTOGRAM],
1528 	    &expected_refcount);
1529 	actual_refcount = get_dtl_refcount(spa->spa_root_vdev);
1530 	actual_refcount += get_metaslab_refcount(spa->spa_root_vdev);
1531 	actual_refcount += get_obsolete_refcount(spa->spa_root_vdev);
1532 	actual_refcount += get_prev_obsolete_spacemap_refcount(spa);
1533 	actual_refcount += get_checkpoint_refcount(spa->spa_root_vdev);
1534 	actual_refcount += get_log_spacemap_refcount(spa);
1535 
1536 	if (expected_refcount != actual_refcount) {
1537 		(void) printf("space map refcount mismatch: expected %lld != "
1538 		    "actual %lld\n",
1539 		    (longlong_t)expected_refcount,
1540 		    (longlong_t)actual_refcount);
1541 		return (2);
1542 	}
1543 	return (0);
1544 }
1545 
1546 static void
1547 dump_spacemap(objset_t *os, space_map_t *sm)
1548 {
1549 	const char *ddata[] = { "ALLOC", "FREE", "CONDENSE", "INVALID",
1550 	    "INVALID", "INVALID", "INVALID", "INVALID" };
1551 
1552 	if (sm == NULL)
1553 		return;
1554 
1555 	(void) printf("space map object %llu:\n",
1556 	    (longlong_t)sm->sm_object);
1557 	(void) printf("  smp_length = 0x%llx\n",
1558 	    (longlong_t)sm->sm_phys->smp_length);
1559 	(void) printf("  smp_alloc = 0x%llx\n",
1560 	    (longlong_t)sm->sm_phys->smp_alloc);
1561 
1562 	if (dump_opt['d'] < 6 && dump_opt['m'] < 4)
1563 		return;
1564 
1565 	/*
1566 	 * Print out the freelist entries in both encoded and decoded form.
1567 	 */
1568 	uint8_t mapshift = sm->sm_shift;
1569 	int64_t alloc = 0;
1570 	uint64_t word, entry_id = 0;
1571 	for (uint64_t offset = 0; offset < space_map_length(sm);
1572 	    offset += sizeof (word)) {
1573 
1574 		VERIFY0(dmu_read(os, space_map_object(sm), offset,
1575 		    sizeof (word), &word, DMU_READ_PREFETCH));
1576 
1577 		if (sm_entry_is_debug(word)) {
1578 			uint64_t de_txg = SM_DEBUG_TXG_DECODE(word);
1579 			uint64_t de_sync_pass = SM_DEBUG_SYNCPASS_DECODE(word);
1580 			if (de_txg == 0) {
1581 				(void) printf(
1582 				    "\t    [%6llu] PADDING\n",
1583 				    (u_longlong_t)entry_id);
1584 			} else {
1585 				(void) printf(
1586 				    "\t    [%6llu] %s: txg %llu pass %llu\n",
1587 				    (u_longlong_t)entry_id,
1588 				    ddata[SM_DEBUG_ACTION_DECODE(word)],
1589 				    (u_longlong_t)de_txg,
1590 				    (u_longlong_t)de_sync_pass);
1591 			}
1592 			entry_id++;
1593 			continue;
1594 		}
1595 
1596 		uint8_t words;
1597 		char entry_type;
1598 		uint64_t entry_off, entry_run, entry_vdev = SM_NO_VDEVID;
1599 
1600 		if (sm_entry_is_single_word(word)) {
1601 			entry_type = (SM_TYPE_DECODE(word) == SM_ALLOC) ?
1602 			    'A' : 'F';
1603 			entry_off = (SM_OFFSET_DECODE(word) << mapshift) +
1604 			    sm->sm_start;
1605 			entry_run = SM_RUN_DECODE(word) << mapshift;
1606 			words = 1;
1607 		} else {
1608 			/* it is a two-word entry so we read another word */
1609 			ASSERT(sm_entry_is_double_word(word));
1610 
1611 			uint64_t extra_word;
1612 			offset += sizeof (extra_word);
1613 			VERIFY0(dmu_read(os, space_map_object(sm), offset,
1614 			    sizeof (extra_word), &extra_word,
1615 			    DMU_READ_PREFETCH));
1616 
1617 			ASSERT3U(offset, <=, space_map_length(sm));
1618 
1619 			entry_run = SM2_RUN_DECODE(word) << mapshift;
1620 			entry_vdev = SM2_VDEV_DECODE(word);
1621 			entry_type = (SM2_TYPE_DECODE(extra_word) == SM_ALLOC) ?
1622 			    'A' : 'F';
1623 			entry_off = (SM2_OFFSET_DECODE(extra_word) <<
1624 			    mapshift) + sm->sm_start;
1625 			words = 2;
1626 		}
1627 
1628 		(void) printf("\t    [%6llu]    %c  range:"
1629 		    " %010llx-%010llx  size: %06llx vdev: %06llu words: %u\n",
1630 		    (u_longlong_t)entry_id,
1631 		    entry_type, (u_longlong_t)entry_off,
1632 		    (u_longlong_t)(entry_off + entry_run),
1633 		    (u_longlong_t)entry_run,
1634 		    (u_longlong_t)entry_vdev, words);
1635 
1636 		if (entry_type == 'A')
1637 			alloc += entry_run;
1638 		else
1639 			alloc -= entry_run;
1640 		entry_id++;
1641 	}
1642 	if (alloc != space_map_allocated(sm)) {
1643 		(void) printf("space_map_object alloc (%lld) INCONSISTENT "
1644 		    "with space map summary (%lld)\n",
1645 		    (longlong_t)space_map_allocated(sm), (longlong_t)alloc);
1646 	}
1647 }
1648 
1649 static void
1650 dump_metaslab_stats(metaslab_t *msp)
1651 {
1652 	char maxbuf[32];
1653 	range_tree_t *rt = msp->ms_allocatable;
1654 	zfs_btree_t *t = &msp->ms_allocatable_by_size;
1655 	int free_pct = range_tree_space(rt) * 100 / msp->ms_size;
1656 
1657 	/* max sure nicenum has enough space */
1658 	_Static_assert(sizeof (maxbuf) >= NN_NUMBUF_SZ, "maxbuf truncated");
1659 
1660 	zdb_nicenum(metaslab_largest_allocatable(msp), maxbuf, sizeof (maxbuf));
1661 
1662 	(void) printf("\t %25s %10lu   %7s  %6s   %4s %4d%%\n",
1663 	    "segments", zfs_btree_numnodes(t), "maxsize", maxbuf,
1664 	    "freepct", free_pct);
1665 	(void) printf("\tIn-memory histogram:\n");
1666 	dump_histogram(rt->rt_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
1667 }
1668 
1669 static void
1670 dump_metaslab(metaslab_t *msp)
1671 {
1672 	vdev_t *vd = msp->ms_group->mg_vd;
1673 	spa_t *spa = vd->vdev_spa;
1674 	space_map_t *sm = msp->ms_sm;
1675 	char freebuf[32];
1676 
1677 	zdb_nicenum(msp->ms_size - space_map_allocated(sm), freebuf,
1678 	    sizeof (freebuf));
1679 
1680 	(void) printf(
1681 	    "\tmetaslab %6llu   offset %12llx   spacemap %6llu   free    %5s\n",
1682 	    (u_longlong_t)msp->ms_id, (u_longlong_t)msp->ms_start,
1683 	    (u_longlong_t)space_map_object(sm), freebuf);
1684 
1685 	if (dump_opt['m'] > 2 && !dump_opt['L']) {
1686 		mutex_enter(&msp->ms_lock);
1687 		VERIFY0(metaslab_load(msp));
1688 		range_tree_stat_verify(msp->ms_allocatable);
1689 		dump_metaslab_stats(msp);
1690 		metaslab_unload(msp);
1691 		mutex_exit(&msp->ms_lock);
1692 	}
1693 
1694 	if (dump_opt['m'] > 1 && sm != NULL &&
1695 	    spa_feature_is_active(spa, SPA_FEATURE_SPACEMAP_HISTOGRAM)) {
1696 		/*
1697 		 * The space map histogram represents free space in chunks
1698 		 * of sm_shift (i.e. bucket 0 refers to 2^sm_shift).
1699 		 */
1700 		(void) printf("\tOn-disk histogram:\t\tfragmentation %llu\n",
1701 		    (u_longlong_t)msp->ms_fragmentation);
1702 		dump_histogram(sm->sm_phys->smp_histogram,
1703 		    SPACE_MAP_HISTOGRAM_SIZE, sm->sm_shift);
1704 	}
1705 
1706 	if (vd->vdev_ops == &vdev_draid_ops)
1707 		ASSERT3U(msp->ms_size, <=, 1ULL << vd->vdev_ms_shift);
1708 	else
1709 		ASSERT3U(msp->ms_size, ==, 1ULL << vd->vdev_ms_shift);
1710 
1711 	dump_spacemap(spa->spa_meta_objset, msp->ms_sm);
1712 
1713 	if (spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP)) {
1714 		(void) printf("\tFlush data:\n\tunflushed txg=%llu\n\n",
1715 		    (u_longlong_t)metaslab_unflushed_txg(msp));
1716 	}
1717 }
1718 
1719 static void
1720 print_vdev_metaslab_header(vdev_t *vd)
1721 {
1722 	vdev_alloc_bias_t alloc_bias = vd->vdev_alloc_bias;
1723 	const char *bias_str = "";
1724 	if (alloc_bias == VDEV_BIAS_LOG || vd->vdev_islog) {
1725 		bias_str = VDEV_ALLOC_BIAS_LOG;
1726 	} else if (alloc_bias == VDEV_BIAS_SPECIAL) {
1727 		bias_str = VDEV_ALLOC_BIAS_SPECIAL;
1728 	} else if (alloc_bias == VDEV_BIAS_DEDUP) {
1729 		bias_str = VDEV_ALLOC_BIAS_DEDUP;
1730 	}
1731 
1732 	uint64_t ms_flush_data_obj = 0;
1733 	if (vd->vdev_top_zap != 0) {
1734 		int error = zap_lookup(spa_meta_objset(vd->vdev_spa),
1735 		    vd->vdev_top_zap, VDEV_TOP_ZAP_MS_UNFLUSHED_PHYS_TXGS,
1736 		    sizeof (uint64_t), 1, &ms_flush_data_obj);
1737 		if (error != ENOENT) {
1738 			ASSERT0(error);
1739 		}
1740 	}
1741 
1742 	(void) printf("\tvdev %10llu   %s",
1743 	    (u_longlong_t)vd->vdev_id, bias_str);
1744 
1745 	if (ms_flush_data_obj != 0) {
1746 		(void) printf("   ms_unflushed_phys object %llu",
1747 		    (u_longlong_t)ms_flush_data_obj);
1748 	}
1749 
1750 	(void) printf("\n\t%-10s%5llu   %-19s   %-15s   %-12s\n",
1751 	    "metaslabs", (u_longlong_t)vd->vdev_ms_count,
1752 	    "offset", "spacemap", "free");
1753 	(void) printf("\t%15s   %19s   %15s   %12s\n",
1754 	    "---------------", "-------------------",
1755 	    "---------------", "------------");
1756 }
1757 
1758 static void
1759 dump_metaslab_groups(spa_t *spa, boolean_t show_special)
1760 {
1761 	vdev_t *rvd = spa->spa_root_vdev;
1762 	metaslab_class_t *mc = spa_normal_class(spa);
1763 	metaslab_class_t *smc = spa_special_class(spa);
1764 	uint64_t fragmentation;
1765 
1766 	metaslab_class_histogram_verify(mc);
1767 
1768 	for (unsigned c = 0; c < rvd->vdev_children; c++) {
1769 		vdev_t *tvd = rvd->vdev_child[c];
1770 		metaslab_group_t *mg = tvd->vdev_mg;
1771 
1772 		if (mg == NULL || (mg->mg_class != mc &&
1773 		    (!show_special || mg->mg_class != smc)))
1774 			continue;
1775 
1776 		metaslab_group_histogram_verify(mg);
1777 		mg->mg_fragmentation = metaslab_group_fragmentation(mg);
1778 
1779 		(void) printf("\tvdev %10llu\t\tmetaslabs%5llu\t\t"
1780 		    "fragmentation",
1781 		    (u_longlong_t)tvd->vdev_id,
1782 		    (u_longlong_t)tvd->vdev_ms_count);
1783 		if (mg->mg_fragmentation == ZFS_FRAG_INVALID) {
1784 			(void) printf("%3s\n", "-");
1785 		} else {
1786 			(void) printf("%3llu%%\n",
1787 			    (u_longlong_t)mg->mg_fragmentation);
1788 		}
1789 		dump_histogram(mg->mg_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
1790 	}
1791 
1792 	(void) printf("\tpool %s\tfragmentation", spa_name(spa));
1793 	fragmentation = metaslab_class_fragmentation(mc);
1794 	if (fragmentation == ZFS_FRAG_INVALID)
1795 		(void) printf("\t%3s\n", "-");
1796 	else
1797 		(void) printf("\t%3llu%%\n", (u_longlong_t)fragmentation);
1798 	dump_histogram(mc->mc_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
1799 }
1800 
1801 static void
1802 print_vdev_indirect(vdev_t *vd)
1803 {
1804 	vdev_indirect_config_t *vic = &vd->vdev_indirect_config;
1805 	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
1806 	vdev_indirect_births_t *vib = vd->vdev_indirect_births;
1807 
1808 	if (vim == NULL) {
1809 		ASSERT3P(vib, ==, NULL);
1810 		return;
1811 	}
1812 
1813 	ASSERT3U(vdev_indirect_mapping_object(vim), ==,
1814 	    vic->vic_mapping_object);
1815 	ASSERT3U(vdev_indirect_births_object(vib), ==,
1816 	    vic->vic_births_object);
1817 
1818 	(void) printf("indirect births obj %llu:\n",
1819 	    (longlong_t)vic->vic_births_object);
1820 	(void) printf("    vib_count = %llu\n",
1821 	    (longlong_t)vdev_indirect_births_count(vib));
1822 	for (uint64_t i = 0; i < vdev_indirect_births_count(vib); i++) {
1823 		vdev_indirect_birth_entry_phys_t *cur_vibe =
1824 		    &vib->vib_entries[i];
1825 		(void) printf("\toffset %llx -> txg %llu\n",
1826 		    (longlong_t)cur_vibe->vibe_offset,
1827 		    (longlong_t)cur_vibe->vibe_phys_birth_txg);
1828 	}
1829 	(void) printf("\n");
1830 
1831 	(void) printf("indirect mapping obj %llu:\n",
1832 	    (longlong_t)vic->vic_mapping_object);
1833 	(void) printf("    vim_max_offset = 0x%llx\n",
1834 	    (longlong_t)vdev_indirect_mapping_max_offset(vim));
1835 	(void) printf("    vim_bytes_mapped = 0x%llx\n",
1836 	    (longlong_t)vdev_indirect_mapping_bytes_mapped(vim));
1837 	(void) printf("    vim_count = %llu\n",
1838 	    (longlong_t)vdev_indirect_mapping_num_entries(vim));
1839 
1840 	if (dump_opt['d'] <= 5 && dump_opt['m'] <= 3)
1841 		return;
1842 
1843 	uint32_t *counts = vdev_indirect_mapping_load_obsolete_counts(vim);
1844 
1845 	for (uint64_t i = 0; i < vdev_indirect_mapping_num_entries(vim); i++) {
1846 		vdev_indirect_mapping_entry_phys_t *vimep =
1847 		    &vim->vim_entries[i];
1848 		(void) printf("\t<%llx:%llx:%llx> -> "
1849 		    "<%llx:%llx:%llx> (%x obsolete)\n",
1850 		    (longlong_t)vd->vdev_id,
1851 		    (longlong_t)DVA_MAPPING_GET_SRC_OFFSET(vimep),
1852 		    (longlong_t)DVA_GET_ASIZE(&vimep->vimep_dst),
1853 		    (longlong_t)DVA_GET_VDEV(&vimep->vimep_dst),
1854 		    (longlong_t)DVA_GET_OFFSET(&vimep->vimep_dst),
1855 		    (longlong_t)DVA_GET_ASIZE(&vimep->vimep_dst),
1856 		    counts[i]);
1857 	}
1858 	(void) printf("\n");
1859 
1860 	uint64_t obsolete_sm_object;
1861 	VERIFY0(vdev_obsolete_sm_object(vd, &obsolete_sm_object));
1862 	if (obsolete_sm_object != 0) {
1863 		objset_t *mos = vd->vdev_spa->spa_meta_objset;
1864 		(void) printf("obsolete space map object %llu:\n",
1865 		    (u_longlong_t)obsolete_sm_object);
1866 		ASSERT(vd->vdev_obsolete_sm != NULL);
1867 		ASSERT3U(space_map_object(vd->vdev_obsolete_sm), ==,
1868 		    obsolete_sm_object);
1869 		dump_spacemap(mos, vd->vdev_obsolete_sm);
1870 		(void) printf("\n");
1871 	}
1872 }
1873 
1874 static void
1875 dump_metaslabs(spa_t *spa)
1876 {
1877 	vdev_t *vd, *rvd = spa->spa_root_vdev;
1878 	uint64_t m, c = 0, children = rvd->vdev_children;
1879 
1880 	(void) printf("\nMetaslabs:\n");
1881 
1882 	if (!dump_opt['d'] && zopt_metaslab_args > 0) {
1883 		c = zopt_metaslab[0];
1884 
1885 		if (c >= children)
1886 			(void) fatal("bad vdev id: %llu", (u_longlong_t)c);
1887 
1888 		if (zopt_metaslab_args > 1) {
1889 			vd = rvd->vdev_child[c];
1890 			print_vdev_metaslab_header(vd);
1891 
1892 			for (m = 1; m < zopt_metaslab_args; m++) {
1893 				if (zopt_metaslab[m] < vd->vdev_ms_count)
1894 					dump_metaslab(
1895 					    vd->vdev_ms[zopt_metaslab[m]]);
1896 				else
1897 					(void) fprintf(stderr, "bad metaslab "
1898 					    "number %llu\n",
1899 					    (u_longlong_t)zopt_metaslab[m]);
1900 			}
1901 			(void) printf("\n");
1902 			return;
1903 		}
1904 		children = c + 1;
1905 	}
1906 	for (; c < children; c++) {
1907 		vd = rvd->vdev_child[c];
1908 		print_vdev_metaslab_header(vd);
1909 
1910 		print_vdev_indirect(vd);
1911 
1912 		for (m = 0; m < vd->vdev_ms_count; m++)
1913 			dump_metaslab(vd->vdev_ms[m]);
1914 		(void) printf("\n");
1915 	}
1916 }
1917 
1918 static void
1919 dump_log_spacemaps(spa_t *spa)
1920 {
1921 	if (!spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP))
1922 		return;
1923 
1924 	(void) printf("\nLog Space Maps in Pool:\n");
1925 	for (spa_log_sm_t *sls = avl_first(&spa->spa_sm_logs_by_txg);
1926 	    sls; sls = AVL_NEXT(&spa->spa_sm_logs_by_txg, sls)) {
1927 		space_map_t *sm = NULL;
1928 		VERIFY0(space_map_open(&sm, spa_meta_objset(spa),
1929 		    sls->sls_sm_obj, 0, UINT64_MAX, SPA_MINBLOCKSHIFT));
1930 
1931 		(void) printf("Log Spacemap object %llu txg %llu\n",
1932 		    (u_longlong_t)sls->sls_sm_obj, (u_longlong_t)sls->sls_txg);
1933 		dump_spacemap(spa->spa_meta_objset, sm);
1934 		space_map_close(sm);
1935 	}
1936 	(void) printf("\n");
1937 }
1938 
1939 static void
1940 dump_dde(const ddt_t *ddt, const ddt_entry_t *dde, uint64_t index)
1941 {
1942 	const ddt_phys_t *ddp = dde->dde_phys;
1943 	const ddt_key_t *ddk = &dde->dde_key;
1944 	const char *types[4] = { "ditto", "single", "double", "triple" };
1945 	char blkbuf[BP_SPRINTF_LEN];
1946 	blkptr_t blk;
1947 	int p;
1948 
1949 	for (p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
1950 		if (ddp->ddp_phys_birth == 0)
1951 			continue;
1952 		ddt_bp_create(ddt->ddt_checksum, ddk, ddp, &blk);
1953 		snprintf_blkptr(blkbuf, sizeof (blkbuf), &blk);
1954 		(void) printf("index %llx refcnt %llu %s %s\n",
1955 		    (u_longlong_t)index, (u_longlong_t)ddp->ddp_refcnt,
1956 		    types[p], blkbuf);
1957 	}
1958 }
1959 
1960 static void
1961 dump_dedup_ratio(const ddt_stat_t *dds)
1962 {
1963 	double rL, rP, rD, D, dedup, compress, copies;
1964 
1965 	if (dds->dds_blocks == 0)
1966 		return;
1967 
1968 	rL = (double)dds->dds_ref_lsize;
1969 	rP = (double)dds->dds_ref_psize;
1970 	rD = (double)dds->dds_ref_dsize;
1971 	D = (double)dds->dds_dsize;
1972 
1973 	dedup = rD / D;
1974 	compress = rL / rP;
1975 	copies = rD / rP;
1976 
1977 	(void) printf("dedup = %.2f, compress = %.2f, copies = %.2f, "
1978 	    "dedup * compress / copies = %.2f\n\n",
1979 	    dedup, compress, copies, dedup * compress / copies);
1980 }
1981 
1982 static void
1983 dump_ddt(ddt_t *ddt, enum ddt_type type, enum ddt_class class)
1984 {
1985 	char name[DDT_NAMELEN];
1986 	ddt_entry_t dde;
1987 	uint64_t walk = 0;
1988 	dmu_object_info_t doi;
1989 	uint64_t count, dspace, mspace;
1990 	int error;
1991 
1992 	error = ddt_object_info(ddt, type, class, &doi);
1993 
1994 	if (error == ENOENT)
1995 		return;
1996 	ASSERT(error == 0);
1997 
1998 	error = ddt_object_count(ddt, type, class, &count);
1999 	ASSERT(error == 0);
2000 	if (count == 0)
2001 		return;
2002 
2003 	dspace = doi.doi_physical_blocks_512 << 9;
2004 	mspace = doi.doi_fill_count * doi.doi_data_block_size;
2005 
2006 	ddt_object_name(ddt, type, class, name);
2007 
2008 	(void) printf("%s: %llu entries, size %llu on disk, %llu in core\n",
2009 	    name,
2010 	    (u_longlong_t)count,
2011 	    (u_longlong_t)(dspace / count),
2012 	    (u_longlong_t)(mspace / count));
2013 
2014 	if (dump_opt['D'] < 3)
2015 		return;
2016 
2017 	zpool_dump_ddt(NULL, &ddt->ddt_histogram[type][class]);
2018 
2019 	if (dump_opt['D'] < 4)
2020 		return;
2021 
2022 	if (dump_opt['D'] < 5 && class == DDT_CLASS_UNIQUE)
2023 		return;
2024 
2025 	(void) printf("%s contents:\n\n", name);
2026 
2027 	while ((error = ddt_object_walk(ddt, type, class, &walk, &dde)) == 0)
2028 		dump_dde(ddt, &dde, walk);
2029 
2030 	ASSERT3U(error, ==, ENOENT);
2031 
2032 	(void) printf("\n");
2033 }
2034 
2035 static void
2036 dump_all_ddts(spa_t *spa)
2037 {
2038 	ddt_histogram_t ddh_total = {{{0}}};
2039 	ddt_stat_t dds_total = {0};
2040 
2041 	for (enum zio_checksum c = 0; c < ZIO_CHECKSUM_FUNCTIONS; c++) {
2042 		ddt_t *ddt = spa->spa_ddt[c];
2043 		for (enum ddt_type type = 0; type < DDT_TYPES; type++) {
2044 			for (enum ddt_class class = 0; class < DDT_CLASSES;
2045 			    class++) {
2046 				dump_ddt(ddt, type, class);
2047 			}
2048 		}
2049 	}
2050 
2051 	ddt_get_dedup_stats(spa, &dds_total);
2052 
2053 	if (dds_total.dds_blocks == 0) {
2054 		(void) printf("All DDTs are empty\n");
2055 		return;
2056 	}
2057 
2058 	(void) printf("\n");
2059 
2060 	if (dump_opt['D'] > 1) {
2061 		(void) printf("DDT histogram (aggregated over all DDTs):\n");
2062 		ddt_get_dedup_histogram(spa, &ddh_total);
2063 		zpool_dump_ddt(&dds_total, &ddh_total);
2064 	}
2065 
2066 	dump_dedup_ratio(&dds_total);
2067 }
2068 
2069 static void
2070 dump_dtl_seg(void *arg, uint64_t start, uint64_t size)
2071 {
2072 	char *prefix = arg;
2073 
2074 	(void) printf("%s [%llu,%llu) length %llu\n",
2075 	    prefix,
2076 	    (u_longlong_t)start,
2077 	    (u_longlong_t)(start + size),
2078 	    (u_longlong_t)(size));
2079 }
2080 
2081 static void
2082 dump_dtl(vdev_t *vd, int indent)
2083 {
2084 	spa_t *spa = vd->vdev_spa;
2085 	boolean_t required;
2086 	const char *name[DTL_TYPES] = { "missing", "partial", "scrub",
2087 		"outage" };
2088 	char prefix[256];
2089 
2090 	spa_vdev_state_enter(spa, SCL_NONE);
2091 	required = vdev_dtl_required(vd);
2092 	(void) spa_vdev_state_exit(spa, NULL, 0);
2093 
2094 	if (indent == 0)
2095 		(void) printf("\nDirty time logs:\n\n");
2096 
2097 	(void) printf("\t%*s%s [%s]\n", indent, "",
2098 	    vd->vdev_path ? vd->vdev_path :
2099 	    vd->vdev_parent ? vd->vdev_ops->vdev_op_type : spa_name(spa),
2100 	    required ? "DTL-required" : "DTL-expendable");
2101 
2102 	for (int t = 0; t < DTL_TYPES; t++) {
2103 		range_tree_t *rt = vd->vdev_dtl[t];
2104 		if (range_tree_space(rt) == 0)
2105 			continue;
2106 		(void) snprintf(prefix, sizeof (prefix), "\t%*s%s",
2107 		    indent + 2, "", name[t]);
2108 		range_tree_walk(rt, dump_dtl_seg, prefix);
2109 		if (dump_opt['d'] > 5 && vd->vdev_children == 0)
2110 			dump_spacemap(spa->spa_meta_objset,
2111 			    vd->vdev_dtl_sm);
2112 	}
2113 
2114 	for (unsigned c = 0; c < vd->vdev_children; c++)
2115 		dump_dtl(vd->vdev_child[c], indent + 4);
2116 }
2117 
2118 static void
2119 dump_history(spa_t *spa)
2120 {
2121 	nvlist_t **events = NULL;
2122 	char *buf;
2123 	uint64_t resid, len, off = 0;
2124 	uint_t num = 0;
2125 	int error;
2126 	char tbuf[30];
2127 
2128 	if ((buf = malloc(SPA_OLD_MAXBLOCKSIZE)) == NULL) {
2129 		(void) fprintf(stderr, "%s: unable to allocate I/O buffer\n",
2130 		    __func__);
2131 		return;
2132 	}
2133 
2134 	do {
2135 		len = SPA_OLD_MAXBLOCKSIZE;
2136 
2137 		if ((error = spa_history_get(spa, &off, &len, buf)) != 0) {
2138 			(void) fprintf(stderr, "Unable to read history: "
2139 			    "error %d\n", error);
2140 			free(buf);
2141 			return;
2142 		}
2143 
2144 		if (zpool_history_unpack(buf, len, &resid, &events, &num) != 0)
2145 			break;
2146 
2147 		off -= resid;
2148 	} while (len != 0);
2149 
2150 	(void) printf("\nHistory:\n");
2151 	for (unsigned i = 0; i < num; i++) {
2152 		boolean_t printed = B_FALSE;
2153 
2154 		if (nvlist_exists(events[i], ZPOOL_HIST_TIME)) {
2155 			time_t tsec;
2156 			struct tm t;
2157 
2158 			tsec = fnvlist_lookup_uint64(events[i],
2159 			    ZPOOL_HIST_TIME);
2160 			(void) localtime_r(&tsec, &t);
2161 			(void) strftime(tbuf, sizeof (tbuf), "%F.%T", &t);
2162 		} else {
2163 			tbuf[0] = '\0';
2164 		}
2165 
2166 		if (nvlist_exists(events[i], ZPOOL_HIST_CMD)) {
2167 			(void) printf("%s %s\n", tbuf,
2168 			    fnvlist_lookup_string(events[i], ZPOOL_HIST_CMD));
2169 		} else if (nvlist_exists(events[i], ZPOOL_HIST_INT_EVENT)) {
2170 			uint64_t ievent;
2171 
2172 			ievent = fnvlist_lookup_uint64(events[i],
2173 			    ZPOOL_HIST_INT_EVENT);
2174 			if (ievent >= ZFS_NUM_LEGACY_HISTORY_EVENTS)
2175 				goto next;
2176 
2177 			(void) printf(" %s [internal %s txg:%ju] %s\n",
2178 			    tbuf,
2179 			    zfs_history_event_names[ievent],
2180 			    fnvlist_lookup_uint64(events[i],
2181 			    ZPOOL_HIST_TXG),
2182 			    fnvlist_lookup_string(events[i],
2183 			    ZPOOL_HIST_INT_STR));
2184 		} else if (nvlist_exists(events[i], ZPOOL_HIST_INT_NAME)) {
2185 			(void) printf("%s [txg:%ju] %s", tbuf,
2186 			    fnvlist_lookup_uint64(events[i],
2187 			    ZPOOL_HIST_TXG),
2188 			    fnvlist_lookup_string(events[i],
2189 			    ZPOOL_HIST_INT_NAME));
2190 
2191 			if (nvlist_exists(events[i], ZPOOL_HIST_DSNAME)) {
2192 				(void) printf(" %s (%llu)",
2193 				    fnvlist_lookup_string(events[i],
2194 				    ZPOOL_HIST_DSNAME),
2195 				    (u_longlong_t)fnvlist_lookup_uint64(
2196 				    events[i],
2197 				    ZPOOL_HIST_DSID));
2198 			}
2199 
2200 			(void) printf(" %s\n", fnvlist_lookup_string(events[i],
2201 			    ZPOOL_HIST_INT_STR));
2202 		} else if (nvlist_exists(events[i], ZPOOL_HIST_IOCTL)) {
2203 			(void) printf("%s ioctl %s\n", tbuf,
2204 			    fnvlist_lookup_string(events[i],
2205 			    ZPOOL_HIST_IOCTL));
2206 
2207 			if (nvlist_exists(events[i], ZPOOL_HIST_INPUT_NVL)) {
2208 				(void) printf("    input:\n");
2209 				dump_nvlist(fnvlist_lookup_nvlist(events[i],
2210 				    ZPOOL_HIST_INPUT_NVL), 8);
2211 			}
2212 			if (nvlist_exists(events[i], ZPOOL_HIST_OUTPUT_NVL)) {
2213 				(void) printf("    output:\n");
2214 				dump_nvlist(fnvlist_lookup_nvlist(events[i],
2215 				    ZPOOL_HIST_OUTPUT_NVL), 8);
2216 			}
2217 			if (nvlist_exists(events[i], ZPOOL_HIST_ERRNO)) {
2218 				(void) printf("    errno: %lld\n",
2219 				    (longlong_t)fnvlist_lookup_int64(events[i],
2220 				    ZPOOL_HIST_ERRNO));
2221 			}
2222 		} else {
2223 			goto next;
2224 		}
2225 
2226 		printed = B_TRUE;
2227 next:
2228 		if (dump_opt['h'] > 1) {
2229 			if (!printed)
2230 				(void) printf("unrecognized record:\n");
2231 			dump_nvlist(events[i], 2);
2232 		}
2233 	}
2234 	free(buf);
2235 }
2236 
2237 static void
2238 dump_dnode(objset_t *os, uint64_t object, void *data, size_t size)
2239 {
2240 	(void) os, (void) object, (void) data, (void) size;
2241 }
2242 
2243 static uint64_t
2244 blkid2offset(const dnode_phys_t *dnp, const blkptr_t *bp,
2245     const zbookmark_phys_t *zb)
2246 {
2247 	if (dnp == NULL) {
2248 		ASSERT(zb->zb_level < 0);
2249 		if (zb->zb_object == 0)
2250 			return (zb->zb_blkid);
2251 		return (zb->zb_blkid * BP_GET_LSIZE(bp));
2252 	}
2253 
2254 	ASSERT(zb->zb_level >= 0);
2255 
2256 	return ((zb->zb_blkid <<
2257 	    (zb->zb_level * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT))) *
2258 	    dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT);
2259 }
2260 
2261 static void
2262 snprintf_zstd_header(spa_t *spa, char *blkbuf, size_t buflen,
2263     const blkptr_t *bp)
2264 {
2265 	abd_t *pabd;
2266 	void *buf;
2267 	zio_t *zio;
2268 	zfs_zstdhdr_t zstd_hdr;
2269 	int error;
2270 
2271 	if (BP_GET_COMPRESS(bp) != ZIO_COMPRESS_ZSTD)
2272 		return;
2273 
2274 	if (BP_IS_HOLE(bp))
2275 		return;
2276 
2277 	if (BP_IS_EMBEDDED(bp)) {
2278 		buf = malloc(SPA_MAXBLOCKSIZE);
2279 		if (buf == NULL) {
2280 			(void) fprintf(stderr, "out of memory\n");
2281 			exit(1);
2282 		}
2283 		decode_embedded_bp_compressed(bp, buf);
2284 		memcpy(&zstd_hdr, buf, sizeof (zstd_hdr));
2285 		free(buf);
2286 		zstd_hdr.c_len = BE_32(zstd_hdr.c_len);
2287 		zstd_hdr.raw_version_level = BE_32(zstd_hdr.raw_version_level);
2288 		(void) snprintf(blkbuf + strlen(blkbuf),
2289 		    buflen - strlen(blkbuf),
2290 		    " ZSTD:size=%u:version=%u:level=%u:EMBEDDED",
2291 		    zstd_hdr.c_len, zfs_get_hdrversion(&zstd_hdr),
2292 		    zfs_get_hdrlevel(&zstd_hdr));
2293 		return;
2294 	}
2295 
2296 	pabd = abd_alloc_for_io(SPA_MAXBLOCKSIZE, B_FALSE);
2297 	zio = zio_root(spa, NULL, NULL, 0);
2298 
2299 	/* Decrypt but don't decompress so we can read the compression header */
2300 	zio_nowait(zio_read(zio, spa, bp, pabd, BP_GET_PSIZE(bp), NULL, NULL,
2301 	    ZIO_PRIORITY_SYNC_READ, ZIO_FLAG_CANFAIL | ZIO_FLAG_RAW_COMPRESS,
2302 	    NULL));
2303 	error = zio_wait(zio);
2304 	if (error) {
2305 		(void) fprintf(stderr, "read failed: %d\n", error);
2306 		return;
2307 	}
2308 	buf = abd_borrow_buf_copy(pabd, BP_GET_LSIZE(bp));
2309 	memcpy(&zstd_hdr, buf, sizeof (zstd_hdr));
2310 	zstd_hdr.c_len = BE_32(zstd_hdr.c_len);
2311 	zstd_hdr.raw_version_level = BE_32(zstd_hdr.raw_version_level);
2312 
2313 	(void) snprintf(blkbuf + strlen(blkbuf),
2314 	    buflen - strlen(blkbuf),
2315 	    " ZSTD:size=%u:version=%u:level=%u:NORMAL",
2316 	    zstd_hdr.c_len, zfs_get_hdrversion(&zstd_hdr),
2317 	    zfs_get_hdrlevel(&zstd_hdr));
2318 
2319 	abd_return_buf_copy(pabd, buf, BP_GET_LSIZE(bp));
2320 }
2321 
2322 static void
2323 snprintf_blkptr_compact(char *blkbuf, size_t buflen, const blkptr_t *bp,
2324     boolean_t bp_freed)
2325 {
2326 	const dva_t *dva = bp->blk_dva;
2327 	int ndvas = dump_opt['d'] > 5 ? BP_GET_NDVAS(bp) : 1;
2328 	int i;
2329 
2330 	if (dump_opt['b'] >= 6) {
2331 		snprintf_blkptr(blkbuf, buflen, bp);
2332 		if (bp_freed) {
2333 			(void) snprintf(blkbuf + strlen(blkbuf),
2334 			    buflen - strlen(blkbuf), " %s", "FREE");
2335 		}
2336 		return;
2337 	}
2338 
2339 	if (BP_IS_EMBEDDED(bp)) {
2340 		(void) sprintf(blkbuf,
2341 		    "EMBEDDED et=%u %llxL/%llxP B=%llu",
2342 		    (int)BPE_GET_ETYPE(bp),
2343 		    (u_longlong_t)BPE_GET_LSIZE(bp),
2344 		    (u_longlong_t)BPE_GET_PSIZE(bp),
2345 		    (u_longlong_t)bp->blk_birth);
2346 		return;
2347 	}
2348 
2349 	blkbuf[0] = '\0';
2350 
2351 	for (i = 0; i < ndvas; i++)
2352 		(void) snprintf(blkbuf + strlen(blkbuf),
2353 		    buflen - strlen(blkbuf), "%llu:%llx:%llx ",
2354 		    (u_longlong_t)DVA_GET_VDEV(&dva[i]),
2355 		    (u_longlong_t)DVA_GET_OFFSET(&dva[i]),
2356 		    (u_longlong_t)DVA_GET_ASIZE(&dva[i]));
2357 
2358 	if (BP_IS_HOLE(bp)) {
2359 		(void) snprintf(blkbuf + strlen(blkbuf),
2360 		    buflen - strlen(blkbuf),
2361 		    "%llxL B=%llu",
2362 		    (u_longlong_t)BP_GET_LSIZE(bp),
2363 		    (u_longlong_t)bp->blk_birth);
2364 	} else {
2365 		(void) snprintf(blkbuf + strlen(blkbuf),
2366 		    buflen - strlen(blkbuf),
2367 		    "%llxL/%llxP F=%llu B=%llu/%llu",
2368 		    (u_longlong_t)BP_GET_LSIZE(bp),
2369 		    (u_longlong_t)BP_GET_PSIZE(bp),
2370 		    (u_longlong_t)BP_GET_FILL(bp),
2371 		    (u_longlong_t)bp->blk_birth,
2372 		    (u_longlong_t)BP_PHYSICAL_BIRTH(bp));
2373 		if (bp_freed)
2374 			(void) snprintf(blkbuf + strlen(blkbuf),
2375 			    buflen - strlen(blkbuf), " %s", "FREE");
2376 		(void) snprintf(blkbuf + strlen(blkbuf),
2377 		    buflen - strlen(blkbuf), " cksum=%llx:%llx:%llx:%llx",
2378 		    (u_longlong_t)bp->blk_cksum.zc_word[0],
2379 		    (u_longlong_t)bp->blk_cksum.zc_word[1],
2380 		    (u_longlong_t)bp->blk_cksum.zc_word[2],
2381 		    (u_longlong_t)bp->blk_cksum.zc_word[3]);
2382 	}
2383 }
2384 
2385 static void
2386 print_indirect(spa_t *spa, blkptr_t *bp, const zbookmark_phys_t *zb,
2387     const dnode_phys_t *dnp)
2388 {
2389 	char blkbuf[BP_SPRINTF_LEN];
2390 	int l;
2391 
2392 	if (!BP_IS_EMBEDDED(bp)) {
2393 		ASSERT3U(BP_GET_TYPE(bp), ==, dnp->dn_type);
2394 		ASSERT3U(BP_GET_LEVEL(bp), ==, zb->zb_level);
2395 	}
2396 
2397 	(void) printf("%16llx ", (u_longlong_t)blkid2offset(dnp, bp, zb));
2398 
2399 	ASSERT(zb->zb_level >= 0);
2400 
2401 	for (l = dnp->dn_nlevels - 1; l >= -1; l--) {
2402 		if (l == zb->zb_level) {
2403 			(void) printf("L%llx", (u_longlong_t)zb->zb_level);
2404 		} else {
2405 			(void) printf(" ");
2406 		}
2407 	}
2408 
2409 	snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), bp, B_FALSE);
2410 	if (dump_opt['Z'] && BP_GET_COMPRESS(bp) == ZIO_COMPRESS_ZSTD)
2411 		snprintf_zstd_header(spa, blkbuf, sizeof (blkbuf), bp);
2412 	(void) printf("%s\n", blkbuf);
2413 }
2414 
2415 static int
2416 visit_indirect(spa_t *spa, const dnode_phys_t *dnp,
2417     blkptr_t *bp, const zbookmark_phys_t *zb)
2418 {
2419 	int err = 0;
2420 
2421 	if (bp->blk_birth == 0)
2422 		return (0);
2423 
2424 	print_indirect(spa, bp, zb, dnp);
2425 
2426 	if (BP_GET_LEVEL(bp) > 0 && !BP_IS_HOLE(bp)) {
2427 		arc_flags_t flags = ARC_FLAG_WAIT;
2428 		int i;
2429 		blkptr_t *cbp;
2430 		int epb = BP_GET_LSIZE(bp) >> SPA_BLKPTRSHIFT;
2431 		arc_buf_t *buf;
2432 		uint64_t fill = 0;
2433 		ASSERT(!BP_IS_REDACTED(bp));
2434 
2435 		err = arc_read(NULL, spa, bp, arc_getbuf_func, &buf,
2436 		    ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, zb);
2437 		if (err)
2438 			return (err);
2439 		ASSERT(buf->b_data);
2440 
2441 		/* recursively visit blocks below this */
2442 		cbp = buf->b_data;
2443 		for (i = 0; i < epb; i++, cbp++) {
2444 			zbookmark_phys_t czb;
2445 
2446 			SET_BOOKMARK(&czb, zb->zb_objset, zb->zb_object,
2447 			    zb->zb_level - 1,
2448 			    zb->zb_blkid * epb + i);
2449 			err = visit_indirect(spa, dnp, cbp, &czb);
2450 			if (err)
2451 				break;
2452 			fill += BP_GET_FILL(cbp);
2453 		}
2454 		if (!err)
2455 			ASSERT3U(fill, ==, BP_GET_FILL(bp));
2456 		arc_buf_destroy(buf, &buf);
2457 	}
2458 
2459 	return (err);
2460 }
2461 
2462 static void
2463 dump_indirect(dnode_t *dn)
2464 {
2465 	dnode_phys_t *dnp = dn->dn_phys;
2466 	zbookmark_phys_t czb;
2467 
2468 	(void) printf("Indirect blocks:\n");
2469 
2470 	SET_BOOKMARK(&czb, dmu_objset_id(dn->dn_objset),
2471 	    dn->dn_object, dnp->dn_nlevels - 1, 0);
2472 	for (int j = 0; j < dnp->dn_nblkptr; j++) {
2473 		czb.zb_blkid = j;
2474 		(void) visit_indirect(dmu_objset_spa(dn->dn_objset), dnp,
2475 		    &dnp->dn_blkptr[j], &czb);
2476 	}
2477 
2478 	(void) printf("\n");
2479 }
2480 
2481 static void
2482 dump_dsl_dir(objset_t *os, uint64_t object, void *data, size_t size)
2483 {
2484 	(void) os, (void) object;
2485 	dsl_dir_phys_t *dd = data;
2486 	time_t crtime;
2487 	char nice[32];
2488 
2489 	/* make sure nicenum has enough space */
2490 	_Static_assert(sizeof (nice) >= NN_NUMBUF_SZ, "nice truncated");
2491 
2492 	if (dd == NULL)
2493 		return;
2494 
2495 	ASSERT3U(size, >=, sizeof (dsl_dir_phys_t));
2496 
2497 	crtime = dd->dd_creation_time;
2498 	(void) printf("\t\tcreation_time = %s", ctime(&crtime));
2499 	(void) printf("\t\thead_dataset_obj = %llu\n",
2500 	    (u_longlong_t)dd->dd_head_dataset_obj);
2501 	(void) printf("\t\tparent_dir_obj = %llu\n",
2502 	    (u_longlong_t)dd->dd_parent_obj);
2503 	(void) printf("\t\torigin_obj = %llu\n",
2504 	    (u_longlong_t)dd->dd_origin_obj);
2505 	(void) printf("\t\tchild_dir_zapobj = %llu\n",
2506 	    (u_longlong_t)dd->dd_child_dir_zapobj);
2507 	zdb_nicenum(dd->dd_used_bytes, nice, sizeof (nice));
2508 	(void) printf("\t\tused_bytes = %s\n", nice);
2509 	zdb_nicenum(dd->dd_compressed_bytes, nice, sizeof (nice));
2510 	(void) printf("\t\tcompressed_bytes = %s\n", nice);
2511 	zdb_nicenum(dd->dd_uncompressed_bytes, nice, sizeof (nice));
2512 	(void) printf("\t\tuncompressed_bytes = %s\n", nice);
2513 	zdb_nicenum(dd->dd_quota, nice, sizeof (nice));
2514 	(void) printf("\t\tquota = %s\n", nice);
2515 	zdb_nicenum(dd->dd_reserved, nice, sizeof (nice));
2516 	(void) printf("\t\treserved = %s\n", nice);
2517 	(void) printf("\t\tprops_zapobj = %llu\n",
2518 	    (u_longlong_t)dd->dd_props_zapobj);
2519 	(void) printf("\t\tdeleg_zapobj = %llu\n",
2520 	    (u_longlong_t)dd->dd_deleg_zapobj);
2521 	(void) printf("\t\tflags = %llx\n",
2522 	    (u_longlong_t)dd->dd_flags);
2523 
2524 #define	DO(which) \
2525 	zdb_nicenum(dd->dd_used_breakdown[DD_USED_ ## which], nice, \
2526 	    sizeof (nice)); \
2527 	(void) printf("\t\tused_breakdown[" #which "] = %s\n", nice)
2528 	DO(HEAD);
2529 	DO(SNAP);
2530 	DO(CHILD);
2531 	DO(CHILD_RSRV);
2532 	DO(REFRSRV);
2533 #undef DO
2534 	(void) printf("\t\tclones = %llu\n",
2535 	    (u_longlong_t)dd->dd_clones);
2536 }
2537 
2538 static void
2539 dump_dsl_dataset(objset_t *os, uint64_t object, void *data, size_t size)
2540 {
2541 	(void) os, (void) object;
2542 	dsl_dataset_phys_t *ds = data;
2543 	time_t crtime;
2544 	char used[32], compressed[32], uncompressed[32], unique[32];
2545 	char blkbuf[BP_SPRINTF_LEN];
2546 
2547 	/* make sure nicenum has enough space */
2548 	_Static_assert(sizeof (used) >= NN_NUMBUF_SZ, "used truncated");
2549 	_Static_assert(sizeof (compressed) >= NN_NUMBUF_SZ,
2550 	    "compressed truncated");
2551 	_Static_assert(sizeof (uncompressed) >= NN_NUMBUF_SZ,
2552 	    "uncompressed truncated");
2553 	_Static_assert(sizeof (unique) >= NN_NUMBUF_SZ, "unique truncated");
2554 
2555 	if (ds == NULL)
2556 		return;
2557 
2558 	ASSERT(size == sizeof (*ds));
2559 	crtime = ds->ds_creation_time;
2560 	zdb_nicenum(ds->ds_referenced_bytes, used, sizeof (used));
2561 	zdb_nicenum(ds->ds_compressed_bytes, compressed, sizeof (compressed));
2562 	zdb_nicenum(ds->ds_uncompressed_bytes, uncompressed,
2563 	    sizeof (uncompressed));
2564 	zdb_nicenum(ds->ds_unique_bytes, unique, sizeof (unique));
2565 	snprintf_blkptr(blkbuf, sizeof (blkbuf), &ds->ds_bp);
2566 
2567 	(void) printf("\t\tdir_obj = %llu\n",
2568 	    (u_longlong_t)ds->ds_dir_obj);
2569 	(void) printf("\t\tprev_snap_obj = %llu\n",
2570 	    (u_longlong_t)ds->ds_prev_snap_obj);
2571 	(void) printf("\t\tprev_snap_txg = %llu\n",
2572 	    (u_longlong_t)ds->ds_prev_snap_txg);
2573 	(void) printf("\t\tnext_snap_obj = %llu\n",
2574 	    (u_longlong_t)ds->ds_next_snap_obj);
2575 	(void) printf("\t\tsnapnames_zapobj = %llu\n",
2576 	    (u_longlong_t)ds->ds_snapnames_zapobj);
2577 	(void) printf("\t\tnum_children = %llu\n",
2578 	    (u_longlong_t)ds->ds_num_children);
2579 	(void) printf("\t\tuserrefs_obj = %llu\n",
2580 	    (u_longlong_t)ds->ds_userrefs_obj);
2581 	(void) printf("\t\tcreation_time = %s", ctime(&crtime));
2582 	(void) printf("\t\tcreation_txg = %llu\n",
2583 	    (u_longlong_t)ds->ds_creation_txg);
2584 	(void) printf("\t\tdeadlist_obj = %llu\n",
2585 	    (u_longlong_t)ds->ds_deadlist_obj);
2586 	(void) printf("\t\tused_bytes = %s\n", used);
2587 	(void) printf("\t\tcompressed_bytes = %s\n", compressed);
2588 	(void) printf("\t\tuncompressed_bytes = %s\n", uncompressed);
2589 	(void) printf("\t\tunique = %s\n", unique);
2590 	(void) printf("\t\tfsid_guid = %llu\n",
2591 	    (u_longlong_t)ds->ds_fsid_guid);
2592 	(void) printf("\t\tguid = %llu\n",
2593 	    (u_longlong_t)ds->ds_guid);
2594 	(void) printf("\t\tflags = %llx\n",
2595 	    (u_longlong_t)ds->ds_flags);
2596 	(void) printf("\t\tnext_clones_obj = %llu\n",
2597 	    (u_longlong_t)ds->ds_next_clones_obj);
2598 	(void) printf("\t\tprops_obj = %llu\n",
2599 	    (u_longlong_t)ds->ds_props_obj);
2600 	(void) printf("\t\tbp = %s\n", blkbuf);
2601 }
2602 
2603 static int
2604 dump_bptree_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
2605 {
2606 	(void) arg, (void) tx;
2607 	char blkbuf[BP_SPRINTF_LEN];
2608 
2609 	if (bp->blk_birth != 0) {
2610 		snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
2611 		(void) printf("\t%s\n", blkbuf);
2612 	}
2613 	return (0);
2614 }
2615 
2616 static void
2617 dump_bptree(objset_t *os, uint64_t obj, const char *name)
2618 {
2619 	char bytes[32];
2620 	bptree_phys_t *bt;
2621 	dmu_buf_t *db;
2622 
2623 	/* make sure nicenum has enough space */
2624 	_Static_assert(sizeof (bytes) >= NN_NUMBUF_SZ, "bytes truncated");
2625 
2626 	if (dump_opt['d'] < 3)
2627 		return;
2628 
2629 	VERIFY3U(0, ==, dmu_bonus_hold(os, obj, FTAG, &db));
2630 	bt = db->db_data;
2631 	zdb_nicenum(bt->bt_bytes, bytes, sizeof (bytes));
2632 	(void) printf("\n    %s: %llu datasets, %s\n",
2633 	    name, (unsigned long long)(bt->bt_end - bt->bt_begin), bytes);
2634 	dmu_buf_rele(db, FTAG);
2635 
2636 	if (dump_opt['d'] < 5)
2637 		return;
2638 
2639 	(void) printf("\n");
2640 
2641 	(void) bptree_iterate(os, obj, B_FALSE, dump_bptree_cb, NULL, NULL);
2642 }
2643 
2644 static int
2645 dump_bpobj_cb(void *arg, const blkptr_t *bp, boolean_t bp_freed, dmu_tx_t *tx)
2646 {
2647 	(void) arg, (void) tx;
2648 	char blkbuf[BP_SPRINTF_LEN];
2649 
2650 	ASSERT(bp->blk_birth != 0);
2651 	snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), bp, bp_freed);
2652 	(void) printf("\t%s\n", blkbuf);
2653 	return (0);
2654 }
2655 
2656 static void
2657 dump_full_bpobj(bpobj_t *bpo, const char *name, int indent)
2658 {
2659 	char bytes[32];
2660 	char comp[32];
2661 	char uncomp[32];
2662 	uint64_t i;
2663 
2664 	/* make sure nicenum has enough space */
2665 	_Static_assert(sizeof (bytes) >= NN_NUMBUF_SZ, "bytes truncated");
2666 	_Static_assert(sizeof (comp) >= NN_NUMBUF_SZ, "comp truncated");
2667 	_Static_assert(sizeof (uncomp) >= NN_NUMBUF_SZ, "uncomp truncated");
2668 
2669 	if (dump_opt['d'] < 3)
2670 		return;
2671 
2672 	zdb_nicenum(bpo->bpo_phys->bpo_bytes, bytes, sizeof (bytes));
2673 	if (bpo->bpo_havesubobj && bpo->bpo_phys->bpo_subobjs != 0) {
2674 		zdb_nicenum(bpo->bpo_phys->bpo_comp, comp, sizeof (comp));
2675 		zdb_nicenum(bpo->bpo_phys->bpo_uncomp, uncomp, sizeof (uncomp));
2676 		if (bpo->bpo_havefreed) {
2677 			(void) printf("    %*s: object %llu, %llu local "
2678 			    "blkptrs, %llu freed, %llu subobjs in object %llu, "
2679 			    "%s (%s/%s comp)\n",
2680 			    indent * 8, name,
2681 			    (u_longlong_t)bpo->bpo_object,
2682 			    (u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
2683 			    (u_longlong_t)bpo->bpo_phys->bpo_num_freed,
2684 			    (u_longlong_t)bpo->bpo_phys->bpo_num_subobjs,
2685 			    (u_longlong_t)bpo->bpo_phys->bpo_subobjs,
2686 			    bytes, comp, uncomp);
2687 		} else {
2688 			(void) printf("    %*s: object %llu, %llu local "
2689 			    "blkptrs, %llu subobjs in object %llu, "
2690 			    "%s (%s/%s comp)\n",
2691 			    indent * 8, name,
2692 			    (u_longlong_t)bpo->bpo_object,
2693 			    (u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
2694 			    (u_longlong_t)bpo->bpo_phys->bpo_num_subobjs,
2695 			    (u_longlong_t)bpo->bpo_phys->bpo_subobjs,
2696 			    bytes, comp, uncomp);
2697 		}
2698 
2699 		for (i = 0; i < bpo->bpo_phys->bpo_num_subobjs; i++) {
2700 			uint64_t subobj;
2701 			bpobj_t subbpo;
2702 			int error;
2703 			VERIFY0(dmu_read(bpo->bpo_os,
2704 			    bpo->bpo_phys->bpo_subobjs,
2705 			    i * sizeof (subobj), sizeof (subobj), &subobj, 0));
2706 			error = bpobj_open(&subbpo, bpo->bpo_os, subobj);
2707 			if (error != 0) {
2708 				(void) printf("ERROR %u while trying to open "
2709 				    "subobj id %llu\n",
2710 				    error, (u_longlong_t)subobj);
2711 				continue;
2712 			}
2713 			dump_full_bpobj(&subbpo, "subobj", indent + 1);
2714 			bpobj_close(&subbpo);
2715 		}
2716 	} else {
2717 		if (bpo->bpo_havefreed) {
2718 			(void) printf("    %*s: object %llu, %llu blkptrs, "
2719 			    "%llu freed, %s\n",
2720 			    indent * 8, name,
2721 			    (u_longlong_t)bpo->bpo_object,
2722 			    (u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
2723 			    (u_longlong_t)bpo->bpo_phys->bpo_num_freed,
2724 			    bytes);
2725 		} else {
2726 			(void) printf("    %*s: object %llu, %llu blkptrs, "
2727 			    "%s\n",
2728 			    indent * 8, name,
2729 			    (u_longlong_t)bpo->bpo_object,
2730 			    (u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
2731 			    bytes);
2732 		}
2733 	}
2734 
2735 	if (dump_opt['d'] < 5)
2736 		return;
2737 
2738 
2739 	if (indent == 0) {
2740 		(void) bpobj_iterate_nofree(bpo, dump_bpobj_cb, NULL, NULL);
2741 		(void) printf("\n");
2742 	}
2743 }
2744 
2745 static int
2746 dump_bookmark(dsl_pool_t *dp, char *name, boolean_t print_redact,
2747     boolean_t print_list)
2748 {
2749 	int err = 0;
2750 	zfs_bookmark_phys_t prop;
2751 	objset_t *mos = dp->dp_spa->spa_meta_objset;
2752 	err = dsl_bookmark_lookup(dp, name, NULL, &prop);
2753 
2754 	if (err != 0) {
2755 		return (err);
2756 	}
2757 
2758 	(void) printf("\t#%s: ", strchr(name, '#') + 1);
2759 	(void) printf("{guid: %llx creation_txg: %llu creation_time: "
2760 	    "%llu redaction_obj: %llu}\n", (u_longlong_t)prop.zbm_guid,
2761 	    (u_longlong_t)prop.zbm_creation_txg,
2762 	    (u_longlong_t)prop.zbm_creation_time,
2763 	    (u_longlong_t)prop.zbm_redaction_obj);
2764 
2765 	IMPLY(print_list, print_redact);
2766 	if (!print_redact || prop.zbm_redaction_obj == 0)
2767 		return (0);
2768 
2769 	redaction_list_t *rl;
2770 	VERIFY0(dsl_redaction_list_hold_obj(dp,
2771 	    prop.zbm_redaction_obj, FTAG, &rl));
2772 
2773 	redaction_list_phys_t *rlp = rl->rl_phys;
2774 	(void) printf("\tRedacted:\n\t\tProgress: ");
2775 	if (rlp->rlp_last_object != UINT64_MAX ||
2776 	    rlp->rlp_last_blkid != UINT64_MAX) {
2777 		(void) printf("%llu %llu (incomplete)\n",
2778 		    (u_longlong_t)rlp->rlp_last_object,
2779 		    (u_longlong_t)rlp->rlp_last_blkid);
2780 	} else {
2781 		(void) printf("complete\n");
2782 	}
2783 	(void) printf("\t\tSnapshots: [");
2784 	for (unsigned int i = 0; i < rlp->rlp_num_snaps; i++) {
2785 		if (i > 0)
2786 			(void) printf(", ");
2787 		(void) printf("%0llu",
2788 		    (u_longlong_t)rlp->rlp_snaps[i]);
2789 	}
2790 	(void) printf("]\n\t\tLength: %llu\n",
2791 	    (u_longlong_t)rlp->rlp_num_entries);
2792 
2793 	if (!print_list) {
2794 		dsl_redaction_list_rele(rl, FTAG);
2795 		return (0);
2796 	}
2797 
2798 	if (rlp->rlp_num_entries == 0) {
2799 		dsl_redaction_list_rele(rl, FTAG);
2800 		(void) printf("\t\tRedaction List: []\n\n");
2801 		return (0);
2802 	}
2803 
2804 	redact_block_phys_t *rbp_buf;
2805 	uint64_t size;
2806 	dmu_object_info_t doi;
2807 
2808 	VERIFY0(dmu_object_info(mos, prop.zbm_redaction_obj, &doi));
2809 	size = doi.doi_max_offset;
2810 	rbp_buf = kmem_alloc(size, KM_SLEEP);
2811 
2812 	err = dmu_read(mos, prop.zbm_redaction_obj, 0, size,
2813 	    rbp_buf, 0);
2814 	if (err != 0) {
2815 		dsl_redaction_list_rele(rl, FTAG);
2816 		kmem_free(rbp_buf, size);
2817 		return (err);
2818 	}
2819 
2820 	(void) printf("\t\tRedaction List: [{object: %llx, offset: "
2821 	    "%llx, blksz: %x, count: %llx}",
2822 	    (u_longlong_t)rbp_buf[0].rbp_object,
2823 	    (u_longlong_t)rbp_buf[0].rbp_blkid,
2824 	    (uint_t)(redact_block_get_size(&rbp_buf[0])),
2825 	    (u_longlong_t)redact_block_get_count(&rbp_buf[0]));
2826 
2827 	for (size_t i = 1; i < rlp->rlp_num_entries; i++) {
2828 		(void) printf(",\n\t\t{object: %llx, offset: %llx, "
2829 		    "blksz: %x, count: %llx}",
2830 		    (u_longlong_t)rbp_buf[i].rbp_object,
2831 		    (u_longlong_t)rbp_buf[i].rbp_blkid,
2832 		    (uint_t)(redact_block_get_size(&rbp_buf[i])),
2833 		    (u_longlong_t)redact_block_get_count(&rbp_buf[i]));
2834 	}
2835 	dsl_redaction_list_rele(rl, FTAG);
2836 	kmem_free(rbp_buf, size);
2837 	(void) printf("]\n\n");
2838 	return (0);
2839 }
2840 
2841 static void
2842 dump_bookmarks(objset_t *os, int verbosity)
2843 {
2844 	zap_cursor_t zc;
2845 	zap_attribute_t attr;
2846 	dsl_dataset_t *ds = dmu_objset_ds(os);
2847 	dsl_pool_t *dp = spa_get_dsl(os->os_spa);
2848 	objset_t *mos = os->os_spa->spa_meta_objset;
2849 	if (verbosity < 4)
2850 		return;
2851 	dsl_pool_config_enter(dp, FTAG);
2852 
2853 	for (zap_cursor_init(&zc, mos, ds->ds_bookmarks_obj);
2854 	    zap_cursor_retrieve(&zc, &attr) == 0;
2855 	    zap_cursor_advance(&zc)) {
2856 		char osname[ZFS_MAX_DATASET_NAME_LEN];
2857 		char buf[ZFS_MAX_DATASET_NAME_LEN];
2858 		dmu_objset_name(os, osname);
2859 		VERIFY3S(0, <=, snprintf(buf, sizeof (buf), "%s#%s", osname,
2860 		    attr.za_name));
2861 		(void) dump_bookmark(dp, buf, verbosity >= 5, verbosity >= 6);
2862 	}
2863 	zap_cursor_fini(&zc);
2864 	dsl_pool_config_exit(dp, FTAG);
2865 }
2866 
2867 static void
2868 bpobj_count_refd(bpobj_t *bpo)
2869 {
2870 	mos_obj_refd(bpo->bpo_object);
2871 
2872 	if (bpo->bpo_havesubobj && bpo->bpo_phys->bpo_subobjs != 0) {
2873 		mos_obj_refd(bpo->bpo_phys->bpo_subobjs);
2874 		for (uint64_t i = 0; i < bpo->bpo_phys->bpo_num_subobjs; i++) {
2875 			uint64_t subobj;
2876 			bpobj_t subbpo;
2877 			int error;
2878 			VERIFY0(dmu_read(bpo->bpo_os,
2879 			    bpo->bpo_phys->bpo_subobjs,
2880 			    i * sizeof (subobj), sizeof (subobj), &subobj, 0));
2881 			error = bpobj_open(&subbpo, bpo->bpo_os, subobj);
2882 			if (error != 0) {
2883 				(void) printf("ERROR %u while trying to open "
2884 				    "subobj id %llu\n",
2885 				    error, (u_longlong_t)subobj);
2886 				continue;
2887 			}
2888 			bpobj_count_refd(&subbpo);
2889 			bpobj_close(&subbpo);
2890 		}
2891 	}
2892 }
2893 
2894 static int
2895 dsl_deadlist_entry_count_refd(void *arg, dsl_deadlist_entry_t *dle)
2896 {
2897 	spa_t *spa = arg;
2898 	uint64_t empty_bpobj = spa->spa_dsl_pool->dp_empty_bpobj;
2899 	if (dle->dle_bpobj.bpo_object != empty_bpobj)
2900 		bpobj_count_refd(&dle->dle_bpobj);
2901 	return (0);
2902 }
2903 
2904 static int
2905 dsl_deadlist_entry_dump(void *arg, dsl_deadlist_entry_t *dle)
2906 {
2907 	ASSERT(arg == NULL);
2908 	if (dump_opt['d'] >= 5) {
2909 		char buf[128];
2910 		(void) snprintf(buf, sizeof (buf),
2911 		    "mintxg %llu -> obj %llu",
2912 		    (longlong_t)dle->dle_mintxg,
2913 		    (longlong_t)dle->dle_bpobj.bpo_object);
2914 
2915 		dump_full_bpobj(&dle->dle_bpobj, buf, 0);
2916 	} else {
2917 		(void) printf("mintxg %llu -> obj %llu\n",
2918 		    (longlong_t)dle->dle_mintxg,
2919 		    (longlong_t)dle->dle_bpobj.bpo_object);
2920 	}
2921 	return (0);
2922 }
2923 
2924 static void
2925 dump_blkptr_list(dsl_deadlist_t *dl, char *name)
2926 {
2927 	char bytes[32];
2928 	char comp[32];
2929 	char uncomp[32];
2930 	char entries[32];
2931 	spa_t *spa = dmu_objset_spa(dl->dl_os);
2932 	uint64_t empty_bpobj = spa->spa_dsl_pool->dp_empty_bpobj;
2933 
2934 	if (dl->dl_oldfmt) {
2935 		if (dl->dl_bpobj.bpo_object != empty_bpobj)
2936 			bpobj_count_refd(&dl->dl_bpobj);
2937 	} else {
2938 		mos_obj_refd(dl->dl_object);
2939 		dsl_deadlist_iterate(dl, dsl_deadlist_entry_count_refd, spa);
2940 	}
2941 
2942 	/* make sure nicenum has enough space */
2943 	_Static_assert(sizeof (bytes) >= NN_NUMBUF_SZ, "bytes truncated");
2944 	_Static_assert(sizeof (comp) >= NN_NUMBUF_SZ, "comp truncated");
2945 	_Static_assert(sizeof (uncomp) >= NN_NUMBUF_SZ, "uncomp truncated");
2946 	_Static_assert(sizeof (entries) >= NN_NUMBUF_SZ, "entries truncated");
2947 
2948 	if (dump_opt['d'] < 3)
2949 		return;
2950 
2951 	if (dl->dl_oldfmt) {
2952 		dump_full_bpobj(&dl->dl_bpobj, "old-format deadlist", 0);
2953 		return;
2954 	}
2955 
2956 	zdb_nicenum(dl->dl_phys->dl_used, bytes, sizeof (bytes));
2957 	zdb_nicenum(dl->dl_phys->dl_comp, comp, sizeof (comp));
2958 	zdb_nicenum(dl->dl_phys->dl_uncomp, uncomp, sizeof (uncomp));
2959 	zdb_nicenum(avl_numnodes(&dl->dl_tree), entries, sizeof (entries));
2960 	(void) printf("\n    %s: %s (%s/%s comp), %s entries\n",
2961 	    name, bytes, comp, uncomp, entries);
2962 
2963 	if (dump_opt['d'] < 4)
2964 		return;
2965 
2966 	(void) printf("\n");
2967 
2968 	dsl_deadlist_iterate(dl, dsl_deadlist_entry_dump, NULL);
2969 }
2970 
2971 static int
2972 verify_dd_livelist(objset_t *os)
2973 {
2974 	uint64_t ll_used, used, ll_comp, comp, ll_uncomp, uncomp;
2975 	dsl_pool_t *dp = spa_get_dsl(os->os_spa);
2976 	dsl_dir_t  *dd = os->os_dsl_dataset->ds_dir;
2977 
2978 	ASSERT(!dmu_objset_is_snapshot(os));
2979 	if (!dsl_deadlist_is_open(&dd->dd_livelist))
2980 		return (0);
2981 
2982 	/* Iterate through the livelist to check for duplicates */
2983 	dsl_deadlist_iterate(&dd->dd_livelist, sublivelist_verify_lightweight,
2984 	    NULL);
2985 
2986 	dsl_pool_config_enter(dp, FTAG);
2987 	dsl_deadlist_space(&dd->dd_livelist, &ll_used,
2988 	    &ll_comp, &ll_uncomp);
2989 
2990 	dsl_dataset_t *origin_ds;
2991 	ASSERT(dsl_pool_config_held(dp));
2992 	VERIFY0(dsl_dataset_hold_obj(dp,
2993 	    dsl_dir_phys(dd)->dd_origin_obj, FTAG, &origin_ds));
2994 	VERIFY0(dsl_dataset_space_written(origin_ds, os->os_dsl_dataset,
2995 	    &used, &comp, &uncomp));
2996 	dsl_dataset_rele(origin_ds, FTAG);
2997 	dsl_pool_config_exit(dp, FTAG);
2998 	/*
2999 	 *  It's possible that the dataset's uncomp space is larger than the
3000 	 *  livelist's because livelists do not track embedded block pointers
3001 	 */
3002 	if (used != ll_used || comp != ll_comp || uncomp < ll_uncomp) {
3003 		char nice_used[32], nice_comp[32], nice_uncomp[32];
3004 		(void) printf("Discrepancy in space accounting:\n");
3005 		zdb_nicenum(used, nice_used, sizeof (nice_used));
3006 		zdb_nicenum(comp, nice_comp, sizeof (nice_comp));
3007 		zdb_nicenum(uncomp, nice_uncomp, sizeof (nice_uncomp));
3008 		(void) printf("dir: used %s, comp %s, uncomp %s\n",
3009 		    nice_used, nice_comp, nice_uncomp);
3010 		zdb_nicenum(ll_used, nice_used, sizeof (nice_used));
3011 		zdb_nicenum(ll_comp, nice_comp, sizeof (nice_comp));
3012 		zdb_nicenum(ll_uncomp, nice_uncomp, sizeof (nice_uncomp));
3013 		(void) printf("livelist: used %s, comp %s, uncomp %s\n",
3014 		    nice_used, nice_comp, nice_uncomp);
3015 		return (1);
3016 	}
3017 	return (0);
3018 }
3019 
3020 static avl_tree_t idx_tree;
3021 static avl_tree_t domain_tree;
3022 static boolean_t fuid_table_loaded;
3023 static objset_t *sa_os = NULL;
3024 static sa_attr_type_t *sa_attr_table = NULL;
3025 
3026 static int
3027 open_objset(const char *path, void *tag, objset_t **osp)
3028 {
3029 	int err;
3030 	uint64_t sa_attrs = 0;
3031 	uint64_t version = 0;
3032 
3033 	VERIFY3P(sa_os, ==, NULL);
3034 	/*
3035 	 * We can't own an objset if it's redacted.  Therefore, we do this
3036 	 * dance: hold the objset, then acquire a long hold on its dataset, then
3037 	 * release the pool (which is held as part of holding the objset).
3038 	 */
3039 	err = dmu_objset_hold(path, tag, osp);
3040 	if (err != 0) {
3041 		(void) fprintf(stderr, "failed to hold dataset '%s': %s\n",
3042 		    path, strerror(err));
3043 		return (err);
3044 	}
3045 	dsl_dataset_long_hold(dmu_objset_ds(*osp), tag);
3046 	dsl_pool_rele(dmu_objset_pool(*osp), tag);
3047 
3048 	if (dmu_objset_type(*osp) == DMU_OST_ZFS && !(*osp)->os_encrypted) {
3049 		(void) zap_lookup(*osp, MASTER_NODE_OBJ, ZPL_VERSION_STR,
3050 		    8, 1, &version);
3051 		if (version >= ZPL_VERSION_SA) {
3052 			(void) zap_lookup(*osp, MASTER_NODE_OBJ, ZFS_SA_ATTRS,
3053 			    8, 1, &sa_attrs);
3054 		}
3055 		err = sa_setup(*osp, sa_attrs, zfs_attr_table, ZPL_END,
3056 		    &sa_attr_table);
3057 		if (err != 0) {
3058 			(void) fprintf(stderr, "sa_setup failed: %s\n",
3059 			    strerror(err));
3060 			dsl_dataset_long_rele(dmu_objset_ds(*osp), tag);
3061 			dsl_dataset_rele(dmu_objset_ds(*osp), tag);
3062 			*osp = NULL;
3063 		}
3064 	}
3065 	sa_os = *osp;
3066 
3067 	return (0);
3068 }
3069 
3070 static void
3071 close_objset(objset_t *os, void *tag)
3072 {
3073 	VERIFY3P(os, ==, sa_os);
3074 	if (os->os_sa != NULL)
3075 		sa_tear_down(os);
3076 	dsl_dataset_long_rele(dmu_objset_ds(os), tag);
3077 	dsl_dataset_rele(dmu_objset_ds(os), tag);
3078 	sa_attr_table = NULL;
3079 	sa_os = NULL;
3080 }
3081 
3082 static void
3083 fuid_table_destroy(void)
3084 {
3085 	if (fuid_table_loaded) {
3086 		zfs_fuid_table_destroy(&idx_tree, &domain_tree);
3087 		fuid_table_loaded = B_FALSE;
3088 	}
3089 }
3090 
3091 /*
3092  * print uid or gid information.
3093  * For normal POSIX id just the id is printed in decimal format.
3094  * For CIFS files with FUID the fuid is printed in hex followed by
3095  * the domain-rid string.
3096  */
3097 static void
3098 print_idstr(uint64_t id, const char *id_type)
3099 {
3100 	if (FUID_INDEX(id)) {
3101 		char *domain;
3102 
3103 		domain = zfs_fuid_idx_domain(&idx_tree, FUID_INDEX(id));
3104 		(void) printf("\t%s     %llx [%s-%d]\n", id_type,
3105 		    (u_longlong_t)id, domain, (int)FUID_RID(id));
3106 	} else {
3107 		(void) printf("\t%s     %llu\n", id_type, (u_longlong_t)id);
3108 	}
3109 
3110 }
3111 
3112 static void
3113 dump_uidgid(objset_t *os, uint64_t uid, uint64_t gid)
3114 {
3115 	uint32_t uid_idx, gid_idx;
3116 
3117 	uid_idx = FUID_INDEX(uid);
3118 	gid_idx = FUID_INDEX(gid);
3119 
3120 	/* Load domain table, if not already loaded */
3121 	if (!fuid_table_loaded && (uid_idx || gid_idx)) {
3122 		uint64_t fuid_obj;
3123 
3124 		/* first find the fuid object.  It lives in the master node */
3125 		VERIFY(zap_lookup(os, MASTER_NODE_OBJ, ZFS_FUID_TABLES,
3126 		    8, 1, &fuid_obj) == 0);
3127 		zfs_fuid_avl_tree_create(&idx_tree, &domain_tree);
3128 		(void) zfs_fuid_table_load(os, fuid_obj,
3129 		    &idx_tree, &domain_tree);
3130 		fuid_table_loaded = B_TRUE;
3131 	}
3132 
3133 	print_idstr(uid, "uid");
3134 	print_idstr(gid, "gid");
3135 }
3136 
3137 static void
3138 dump_znode_sa_xattr(sa_handle_t *hdl)
3139 {
3140 	nvlist_t *sa_xattr;
3141 	nvpair_t *elem = NULL;
3142 	int sa_xattr_size = 0;
3143 	int sa_xattr_entries = 0;
3144 	int error;
3145 	char *sa_xattr_packed;
3146 
3147 	error = sa_size(hdl, sa_attr_table[ZPL_DXATTR], &sa_xattr_size);
3148 	if (error || sa_xattr_size == 0)
3149 		return;
3150 
3151 	sa_xattr_packed = malloc(sa_xattr_size);
3152 	if (sa_xattr_packed == NULL)
3153 		return;
3154 
3155 	error = sa_lookup(hdl, sa_attr_table[ZPL_DXATTR],
3156 	    sa_xattr_packed, sa_xattr_size);
3157 	if (error) {
3158 		free(sa_xattr_packed);
3159 		return;
3160 	}
3161 
3162 	error = nvlist_unpack(sa_xattr_packed, sa_xattr_size, &sa_xattr, 0);
3163 	if (error) {
3164 		free(sa_xattr_packed);
3165 		return;
3166 	}
3167 
3168 	while ((elem = nvlist_next_nvpair(sa_xattr, elem)) != NULL)
3169 		sa_xattr_entries++;
3170 
3171 	(void) printf("\tSA xattrs: %d bytes, %d entries\n\n",
3172 	    sa_xattr_size, sa_xattr_entries);
3173 	while ((elem = nvlist_next_nvpair(sa_xattr, elem)) != NULL) {
3174 		uchar_t *value;
3175 		uint_t cnt, idx;
3176 
3177 		(void) printf("\t\t%s = ", nvpair_name(elem));
3178 		nvpair_value_byte_array(elem, &value, &cnt);
3179 		for (idx = 0; idx < cnt; ++idx) {
3180 			if (isprint(value[idx]))
3181 				(void) putchar(value[idx]);
3182 			else
3183 				(void) printf("\\%3.3o", value[idx]);
3184 		}
3185 		(void) putchar('\n');
3186 	}
3187 
3188 	nvlist_free(sa_xattr);
3189 	free(sa_xattr_packed);
3190 }
3191 
3192 static void
3193 dump_znode_symlink(sa_handle_t *hdl)
3194 {
3195 	int sa_symlink_size = 0;
3196 	char linktarget[MAXPATHLEN];
3197 	int error;
3198 
3199 	error = sa_size(hdl, sa_attr_table[ZPL_SYMLINK], &sa_symlink_size);
3200 	if (error || sa_symlink_size == 0) {
3201 		return;
3202 	}
3203 	if (sa_symlink_size >= sizeof (linktarget)) {
3204 		(void) printf("symlink size %d is too large\n",
3205 		    sa_symlink_size);
3206 		return;
3207 	}
3208 	linktarget[sa_symlink_size] = '\0';
3209 	if (sa_lookup(hdl, sa_attr_table[ZPL_SYMLINK],
3210 	    &linktarget, sa_symlink_size) == 0)
3211 		(void) printf("\ttarget	%s\n", linktarget);
3212 }
3213 
3214 static void
3215 dump_znode(objset_t *os, uint64_t object, void *data, size_t size)
3216 {
3217 	(void) data, (void) size;
3218 	char path[MAXPATHLEN * 2];	/* allow for xattr and failure prefix */
3219 	sa_handle_t *hdl;
3220 	uint64_t xattr, rdev, gen;
3221 	uint64_t uid, gid, mode, fsize, parent, links;
3222 	uint64_t pflags;
3223 	uint64_t acctm[2], modtm[2], chgtm[2], crtm[2];
3224 	time_t z_crtime, z_atime, z_mtime, z_ctime;
3225 	sa_bulk_attr_t bulk[12];
3226 	int idx = 0;
3227 	int error;
3228 
3229 	VERIFY3P(os, ==, sa_os);
3230 	if (sa_handle_get(os, object, NULL, SA_HDL_PRIVATE, &hdl)) {
3231 		(void) printf("Failed to get handle for SA znode\n");
3232 		return;
3233 	}
3234 
3235 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_UID], NULL, &uid, 8);
3236 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_GID], NULL, &gid, 8);
3237 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_LINKS], NULL,
3238 	    &links, 8);
3239 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_GEN], NULL, &gen, 8);
3240 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_MODE], NULL,
3241 	    &mode, 8);
3242 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_PARENT],
3243 	    NULL, &parent, 8);
3244 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_SIZE], NULL,
3245 	    &fsize, 8);
3246 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_ATIME], NULL,
3247 	    acctm, 16);
3248 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_MTIME], NULL,
3249 	    modtm, 16);
3250 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_CRTIME], NULL,
3251 	    crtm, 16);
3252 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_CTIME], NULL,
3253 	    chgtm, 16);
3254 	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_FLAGS], NULL,
3255 	    &pflags, 8);
3256 
3257 	if (sa_bulk_lookup(hdl, bulk, idx)) {
3258 		(void) sa_handle_destroy(hdl);
3259 		return;
3260 	}
3261 
3262 	z_crtime = (time_t)crtm[0];
3263 	z_atime = (time_t)acctm[0];
3264 	z_mtime = (time_t)modtm[0];
3265 	z_ctime = (time_t)chgtm[0];
3266 
3267 	if (dump_opt['d'] > 4) {
3268 		error = zfs_obj_to_path(os, object, path, sizeof (path));
3269 		if (error == ESTALE) {
3270 			(void) snprintf(path, sizeof (path), "on delete queue");
3271 		} else if (error != 0) {
3272 			leaked_objects++;
3273 			(void) snprintf(path, sizeof (path),
3274 			    "path not found, possibly leaked");
3275 		}
3276 		(void) printf("\tpath	%s\n", path);
3277 	}
3278 
3279 	if (S_ISLNK(mode))
3280 		dump_znode_symlink(hdl);
3281 	dump_uidgid(os, uid, gid);
3282 	(void) printf("\tatime	%s", ctime(&z_atime));
3283 	(void) printf("\tmtime	%s", ctime(&z_mtime));
3284 	(void) printf("\tctime	%s", ctime(&z_ctime));
3285 	(void) printf("\tcrtime	%s", ctime(&z_crtime));
3286 	(void) printf("\tgen	%llu\n", (u_longlong_t)gen);
3287 	(void) printf("\tmode	%llo\n", (u_longlong_t)mode);
3288 	(void) printf("\tsize	%llu\n", (u_longlong_t)fsize);
3289 	(void) printf("\tparent	%llu\n", (u_longlong_t)parent);
3290 	(void) printf("\tlinks	%llu\n", (u_longlong_t)links);
3291 	(void) printf("\tpflags	%llx\n", (u_longlong_t)pflags);
3292 	if (dmu_objset_projectquota_enabled(os) && (pflags & ZFS_PROJID)) {
3293 		uint64_t projid;
3294 
3295 		if (sa_lookup(hdl, sa_attr_table[ZPL_PROJID], &projid,
3296 		    sizeof (uint64_t)) == 0)
3297 			(void) printf("\tprojid	%llu\n", (u_longlong_t)projid);
3298 	}
3299 	if (sa_lookup(hdl, sa_attr_table[ZPL_XATTR], &xattr,
3300 	    sizeof (uint64_t)) == 0)
3301 		(void) printf("\txattr	%llu\n", (u_longlong_t)xattr);
3302 	if (sa_lookup(hdl, sa_attr_table[ZPL_RDEV], &rdev,
3303 	    sizeof (uint64_t)) == 0)
3304 		(void) printf("\trdev	0x%016llx\n", (u_longlong_t)rdev);
3305 	dump_znode_sa_xattr(hdl);
3306 	sa_handle_destroy(hdl);
3307 }
3308 
3309 static void
3310 dump_acl(objset_t *os, uint64_t object, void *data, size_t size)
3311 {
3312 	(void) os, (void) object, (void) data, (void) size;
3313 }
3314 
3315 static void
3316 dump_dmu_objset(objset_t *os, uint64_t object, void *data, size_t size)
3317 {
3318 	(void) os, (void) object, (void) data, (void) size;
3319 }
3320 
3321 static object_viewer_t *object_viewer[DMU_OT_NUMTYPES + 1] = {
3322 	dump_none,		/* unallocated			*/
3323 	dump_zap,		/* object directory		*/
3324 	dump_uint64,		/* object array			*/
3325 	dump_none,		/* packed nvlist		*/
3326 	dump_packed_nvlist,	/* packed nvlist size		*/
3327 	dump_none,		/* bpobj			*/
3328 	dump_bpobj,		/* bpobj header			*/
3329 	dump_none,		/* SPA space map header		*/
3330 	dump_none,		/* SPA space map		*/
3331 	dump_none,		/* ZIL intent log		*/
3332 	dump_dnode,		/* DMU dnode			*/
3333 	dump_dmu_objset,	/* DMU objset			*/
3334 	dump_dsl_dir,		/* DSL directory		*/
3335 	dump_zap,		/* DSL directory child map	*/
3336 	dump_zap,		/* DSL dataset snap map		*/
3337 	dump_zap,		/* DSL props			*/
3338 	dump_dsl_dataset,	/* DSL dataset			*/
3339 	dump_znode,		/* ZFS znode			*/
3340 	dump_acl,		/* ZFS V0 ACL			*/
3341 	dump_uint8,		/* ZFS plain file		*/
3342 	dump_zpldir,		/* ZFS directory		*/
3343 	dump_zap,		/* ZFS master node		*/
3344 	dump_zap,		/* ZFS delete queue		*/
3345 	dump_uint8,		/* zvol object			*/
3346 	dump_zap,		/* zvol prop			*/
3347 	dump_uint8,		/* other uint8[]		*/
3348 	dump_uint64,		/* other uint64[]		*/
3349 	dump_zap,		/* other ZAP			*/
3350 	dump_zap,		/* persistent error log		*/
3351 	dump_uint8,		/* SPA history			*/
3352 	dump_history_offsets,	/* SPA history offsets		*/
3353 	dump_zap,		/* Pool properties		*/
3354 	dump_zap,		/* DSL permissions		*/
3355 	dump_acl,		/* ZFS ACL			*/
3356 	dump_uint8,		/* ZFS SYSACL			*/
3357 	dump_none,		/* FUID nvlist			*/
3358 	dump_packed_nvlist,	/* FUID nvlist size		*/
3359 	dump_zap,		/* DSL dataset next clones	*/
3360 	dump_zap,		/* DSL scrub queue		*/
3361 	dump_zap,		/* ZFS user/group/project used	*/
3362 	dump_zap,		/* ZFS user/group/project quota	*/
3363 	dump_zap,		/* snapshot refcount tags	*/
3364 	dump_ddt_zap,		/* DDT ZAP object		*/
3365 	dump_zap,		/* DDT statistics		*/
3366 	dump_znode,		/* SA object			*/
3367 	dump_zap,		/* SA Master Node		*/
3368 	dump_sa_attrs,		/* SA attribute registration	*/
3369 	dump_sa_layouts,	/* SA attribute layouts		*/
3370 	dump_zap,		/* DSL scrub translations	*/
3371 	dump_none,		/* fake dedup BP		*/
3372 	dump_zap,		/* deadlist			*/
3373 	dump_none,		/* deadlist hdr			*/
3374 	dump_zap,		/* dsl clones			*/
3375 	dump_bpobj_subobjs,	/* bpobj subobjs		*/
3376 	dump_unknown,		/* Unknown type, must be last	*/
3377 };
3378 
3379 static boolean_t
3380 match_object_type(dmu_object_type_t obj_type, uint64_t flags)
3381 {
3382 	boolean_t match = B_TRUE;
3383 
3384 	switch (obj_type) {
3385 	case DMU_OT_DIRECTORY_CONTENTS:
3386 		if (!(flags & ZOR_FLAG_DIRECTORY))
3387 			match = B_FALSE;
3388 		break;
3389 	case DMU_OT_PLAIN_FILE_CONTENTS:
3390 		if (!(flags & ZOR_FLAG_PLAIN_FILE))
3391 			match = B_FALSE;
3392 		break;
3393 	case DMU_OT_SPACE_MAP:
3394 		if (!(flags & ZOR_FLAG_SPACE_MAP))
3395 			match = B_FALSE;
3396 		break;
3397 	default:
3398 		if (strcmp(zdb_ot_name(obj_type), "zap") == 0) {
3399 			if (!(flags & ZOR_FLAG_ZAP))
3400 				match = B_FALSE;
3401 			break;
3402 		}
3403 
3404 		/*
3405 		 * If all bits except some of the supported flags are
3406 		 * set, the user combined the all-types flag (A) with
3407 		 * a negated flag to exclude some types (e.g. A-f to
3408 		 * show all object types except plain files).
3409 		 */
3410 		if ((flags | ZOR_SUPPORTED_FLAGS) != ZOR_FLAG_ALL_TYPES)
3411 			match = B_FALSE;
3412 
3413 		break;
3414 	}
3415 
3416 	return (match);
3417 }
3418 
3419 static void
3420 dump_object(objset_t *os, uint64_t object, int verbosity,
3421     boolean_t *print_header, uint64_t *dnode_slots_used, uint64_t flags)
3422 {
3423 	dmu_buf_t *db = NULL;
3424 	dmu_object_info_t doi;
3425 	dnode_t *dn;
3426 	boolean_t dnode_held = B_FALSE;
3427 	void *bonus = NULL;
3428 	size_t bsize = 0;
3429 	char iblk[32], dblk[32], lsize[32], asize[32], fill[32], dnsize[32];
3430 	char bonus_size[32];
3431 	char aux[50];
3432 	int error;
3433 
3434 	/* make sure nicenum has enough space */
3435 	_Static_assert(sizeof (iblk) >= NN_NUMBUF_SZ, "iblk truncated");
3436 	_Static_assert(sizeof (dblk) >= NN_NUMBUF_SZ, "dblk truncated");
3437 	_Static_assert(sizeof (lsize) >= NN_NUMBUF_SZ, "lsize truncated");
3438 	_Static_assert(sizeof (asize) >= NN_NUMBUF_SZ, "asize truncated");
3439 	_Static_assert(sizeof (bonus_size) >= NN_NUMBUF_SZ,
3440 	    "bonus_size truncated");
3441 
3442 	if (*print_header) {
3443 		(void) printf("\n%10s  %3s  %5s  %5s  %5s  %6s  %5s  %6s  %s\n",
3444 		    "Object", "lvl", "iblk", "dblk", "dsize", "dnsize",
3445 		    "lsize", "%full", "type");
3446 		*print_header = 0;
3447 	}
3448 
3449 	if (object == 0) {
3450 		dn = DMU_META_DNODE(os);
3451 		dmu_object_info_from_dnode(dn, &doi);
3452 	} else {
3453 		/*
3454 		 * Encrypted datasets will have sensitive bonus buffers
3455 		 * encrypted. Therefore we cannot hold the bonus buffer and
3456 		 * must hold the dnode itself instead.
3457 		 */
3458 		error = dmu_object_info(os, object, &doi);
3459 		if (error)
3460 			fatal("dmu_object_info() failed, errno %u", error);
3461 
3462 		if (os->os_encrypted &&
3463 		    DMU_OT_IS_ENCRYPTED(doi.doi_bonus_type)) {
3464 			error = dnode_hold(os, object, FTAG, &dn);
3465 			if (error)
3466 				fatal("dnode_hold() failed, errno %u", error);
3467 			dnode_held = B_TRUE;
3468 		} else {
3469 			error = dmu_bonus_hold(os, object, FTAG, &db);
3470 			if (error)
3471 				fatal("dmu_bonus_hold(%llu) failed, errno %u",
3472 				    object, error);
3473 			bonus = db->db_data;
3474 			bsize = db->db_size;
3475 			dn = DB_DNODE((dmu_buf_impl_t *)db);
3476 		}
3477 	}
3478 
3479 	/*
3480 	 * Default to showing all object types if no flags were specified.
3481 	 */
3482 	if (flags != 0 && flags != ZOR_FLAG_ALL_TYPES &&
3483 	    !match_object_type(doi.doi_type, flags))
3484 		goto out;
3485 
3486 	if (dnode_slots_used)
3487 		*dnode_slots_used = doi.doi_dnodesize / DNODE_MIN_SIZE;
3488 
3489 	zdb_nicenum(doi.doi_metadata_block_size, iblk, sizeof (iblk));
3490 	zdb_nicenum(doi.doi_data_block_size, dblk, sizeof (dblk));
3491 	zdb_nicenum(doi.doi_max_offset, lsize, sizeof (lsize));
3492 	zdb_nicenum(doi.doi_physical_blocks_512 << 9, asize, sizeof (asize));
3493 	zdb_nicenum(doi.doi_bonus_size, bonus_size, sizeof (bonus_size));
3494 	zdb_nicenum(doi.doi_dnodesize, dnsize, sizeof (dnsize));
3495 	(void) sprintf(fill, "%6.2f", 100.0 * doi.doi_fill_count *
3496 	    doi.doi_data_block_size / (object == 0 ? DNODES_PER_BLOCK : 1) /
3497 	    doi.doi_max_offset);
3498 
3499 	aux[0] = '\0';
3500 
3501 	if (doi.doi_checksum != ZIO_CHECKSUM_INHERIT || verbosity >= 6) {
3502 		(void) snprintf(aux + strlen(aux), sizeof (aux) - strlen(aux),
3503 		    " (K=%s)", ZDB_CHECKSUM_NAME(doi.doi_checksum));
3504 	}
3505 
3506 	if (doi.doi_compress == ZIO_COMPRESS_INHERIT &&
3507 	    ZIO_COMPRESS_HASLEVEL(os->os_compress) && verbosity >= 6) {
3508 		const char *compname = NULL;
3509 		if (zfs_prop_index_to_string(ZFS_PROP_COMPRESSION,
3510 		    ZIO_COMPRESS_RAW(os->os_compress, os->os_complevel),
3511 		    &compname) == 0) {
3512 			(void) snprintf(aux + strlen(aux),
3513 			    sizeof (aux) - strlen(aux), " (Z=inherit=%s)",
3514 			    compname);
3515 		} else {
3516 			(void) snprintf(aux + strlen(aux),
3517 			    sizeof (aux) - strlen(aux),
3518 			    " (Z=inherit=%s-unknown)",
3519 			    ZDB_COMPRESS_NAME(os->os_compress));
3520 		}
3521 	} else if (doi.doi_compress == ZIO_COMPRESS_INHERIT && verbosity >= 6) {
3522 		(void) snprintf(aux + strlen(aux), sizeof (aux) - strlen(aux),
3523 		    " (Z=inherit=%s)", ZDB_COMPRESS_NAME(os->os_compress));
3524 	} else if (doi.doi_compress != ZIO_COMPRESS_INHERIT || verbosity >= 6) {
3525 		(void) snprintf(aux + strlen(aux), sizeof (aux) - strlen(aux),
3526 		    " (Z=%s)", ZDB_COMPRESS_NAME(doi.doi_compress));
3527 	}
3528 
3529 	(void) printf("%10lld  %3u  %5s  %5s  %5s  %6s  %5s  %6s  %s%s\n",
3530 	    (u_longlong_t)object, doi.doi_indirection, iblk, dblk,
3531 	    asize, dnsize, lsize, fill, zdb_ot_name(doi.doi_type), aux);
3532 
3533 	if (doi.doi_bonus_type != DMU_OT_NONE && verbosity > 3) {
3534 		(void) printf("%10s  %3s  %5s  %5s  %5s  %5s  %5s  %6s  %s\n",
3535 		    "", "", "", "", "", "", bonus_size, "bonus",
3536 		    zdb_ot_name(doi.doi_bonus_type));
3537 	}
3538 
3539 	if (verbosity >= 4) {
3540 		(void) printf("\tdnode flags: %s%s%s%s\n",
3541 		    (dn->dn_phys->dn_flags & DNODE_FLAG_USED_BYTES) ?
3542 		    "USED_BYTES " : "",
3543 		    (dn->dn_phys->dn_flags & DNODE_FLAG_USERUSED_ACCOUNTED) ?
3544 		    "USERUSED_ACCOUNTED " : "",
3545 		    (dn->dn_phys->dn_flags & DNODE_FLAG_USEROBJUSED_ACCOUNTED) ?
3546 		    "USEROBJUSED_ACCOUNTED " : "",
3547 		    (dn->dn_phys->dn_flags & DNODE_FLAG_SPILL_BLKPTR) ?
3548 		    "SPILL_BLKPTR" : "");
3549 		(void) printf("\tdnode maxblkid: %llu\n",
3550 		    (longlong_t)dn->dn_phys->dn_maxblkid);
3551 
3552 		if (!dnode_held) {
3553 			object_viewer[ZDB_OT_TYPE(doi.doi_bonus_type)](os,
3554 			    object, bonus, bsize);
3555 		} else {
3556 			(void) printf("\t\t(bonus encrypted)\n");
3557 		}
3558 
3559 		if (!os->os_encrypted || !DMU_OT_IS_ENCRYPTED(doi.doi_type)) {
3560 			object_viewer[ZDB_OT_TYPE(doi.doi_type)](os, object,
3561 			    NULL, 0);
3562 		} else {
3563 			(void) printf("\t\t(object encrypted)\n");
3564 		}
3565 
3566 		*print_header = B_TRUE;
3567 	}
3568 
3569 	if (verbosity >= 5)
3570 		dump_indirect(dn);
3571 
3572 	if (verbosity >= 5) {
3573 		/*
3574 		 * Report the list of segments that comprise the object.
3575 		 */
3576 		uint64_t start = 0;
3577 		uint64_t end;
3578 		uint64_t blkfill = 1;
3579 		int minlvl = 1;
3580 
3581 		if (dn->dn_type == DMU_OT_DNODE) {
3582 			minlvl = 0;
3583 			blkfill = DNODES_PER_BLOCK;
3584 		}
3585 
3586 		for (;;) {
3587 			char segsize[32];
3588 			/* make sure nicenum has enough space */
3589 			_Static_assert(sizeof (segsize) >= NN_NUMBUF_SZ,
3590 			    "segsize truncated");
3591 			error = dnode_next_offset(dn,
3592 			    0, &start, minlvl, blkfill, 0);
3593 			if (error)
3594 				break;
3595 			end = start;
3596 			error = dnode_next_offset(dn,
3597 			    DNODE_FIND_HOLE, &end, minlvl, blkfill, 0);
3598 			zdb_nicenum(end - start, segsize, sizeof (segsize));
3599 			(void) printf("\t\tsegment [%016llx, %016llx)"
3600 			    " size %5s\n", (u_longlong_t)start,
3601 			    (u_longlong_t)end, segsize);
3602 			if (error)
3603 				break;
3604 			start = end;
3605 		}
3606 	}
3607 
3608 out:
3609 	if (db != NULL)
3610 		dmu_buf_rele(db, FTAG);
3611 	if (dnode_held)
3612 		dnode_rele(dn, FTAG);
3613 }
3614 
3615 static void
3616 count_dir_mos_objects(dsl_dir_t *dd)
3617 {
3618 	mos_obj_refd(dd->dd_object);
3619 	mos_obj_refd(dsl_dir_phys(dd)->dd_child_dir_zapobj);
3620 	mos_obj_refd(dsl_dir_phys(dd)->dd_deleg_zapobj);
3621 	mos_obj_refd(dsl_dir_phys(dd)->dd_props_zapobj);
3622 	mos_obj_refd(dsl_dir_phys(dd)->dd_clones);
3623 
3624 	/*
3625 	 * The dd_crypto_obj can be referenced by multiple dsl_dir's.
3626 	 * Ignore the references after the first one.
3627 	 */
3628 	mos_obj_refd_multiple(dd->dd_crypto_obj);
3629 }
3630 
3631 static void
3632 count_ds_mos_objects(dsl_dataset_t *ds)
3633 {
3634 	mos_obj_refd(ds->ds_object);
3635 	mos_obj_refd(dsl_dataset_phys(ds)->ds_next_clones_obj);
3636 	mos_obj_refd(dsl_dataset_phys(ds)->ds_props_obj);
3637 	mos_obj_refd(dsl_dataset_phys(ds)->ds_userrefs_obj);
3638 	mos_obj_refd(dsl_dataset_phys(ds)->ds_snapnames_zapobj);
3639 	mos_obj_refd(ds->ds_bookmarks_obj);
3640 
3641 	if (!dsl_dataset_is_snapshot(ds)) {
3642 		count_dir_mos_objects(ds->ds_dir);
3643 	}
3644 }
3645 
3646 static const char *objset_types[DMU_OST_NUMTYPES] = {
3647 	"NONE", "META", "ZPL", "ZVOL", "OTHER", "ANY" };
3648 
3649 /*
3650  * Parse a string denoting a range of object IDs of the form
3651  * <start>[:<end>[:flags]], and store the results in zor.
3652  * Return 0 on success. On error, return 1 and update the msg
3653  * pointer to point to a descriptive error message.
3654  */
3655 static int
3656 parse_object_range(char *range, zopt_object_range_t *zor, char **msg)
3657 {
3658 	uint64_t flags = 0;
3659 	char *p, *s, *dup, *flagstr, *tmp = NULL;
3660 	size_t len;
3661 	int i;
3662 	int rc = 0;
3663 
3664 	if (strchr(range, ':') == NULL) {
3665 		zor->zor_obj_start = strtoull(range, &p, 0);
3666 		if (*p != '\0') {
3667 			*msg = "Invalid characters in object ID";
3668 			rc = 1;
3669 		}
3670 		zor->zor_obj_start = ZDB_MAP_OBJECT_ID(zor->zor_obj_start);
3671 		zor->zor_obj_end = zor->zor_obj_start;
3672 		return (rc);
3673 	}
3674 
3675 	if (strchr(range, ':') == range) {
3676 		*msg = "Invalid leading colon";
3677 		rc = 1;
3678 		return (rc);
3679 	}
3680 
3681 	len = strlen(range);
3682 	if (range[len - 1] == ':') {
3683 		*msg = "Invalid trailing colon";
3684 		rc = 1;
3685 		return (rc);
3686 	}
3687 
3688 	dup = strdup(range);
3689 	s = strtok_r(dup, ":", &tmp);
3690 	zor->zor_obj_start = strtoull(s, &p, 0);
3691 
3692 	if (*p != '\0') {
3693 		*msg = "Invalid characters in start object ID";
3694 		rc = 1;
3695 		goto out;
3696 	}
3697 
3698 	s = strtok_r(NULL, ":", &tmp);
3699 	zor->zor_obj_end = strtoull(s, &p, 0);
3700 
3701 	if (*p != '\0') {
3702 		*msg = "Invalid characters in end object ID";
3703 		rc = 1;
3704 		goto out;
3705 	}
3706 
3707 	if (zor->zor_obj_start > zor->zor_obj_end) {
3708 		*msg = "Start object ID may not exceed end object ID";
3709 		rc = 1;
3710 		goto out;
3711 	}
3712 
3713 	s = strtok_r(NULL, ":", &tmp);
3714 	if (s == NULL) {
3715 		zor->zor_flags = ZOR_FLAG_ALL_TYPES;
3716 		goto out;
3717 	} else if (strtok_r(NULL, ":", &tmp) != NULL) {
3718 		*msg = "Invalid colon-delimited field after flags";
3719 		rc = 1;
3720 		goto out;
3721 	}
3722 
3723 	flagstr = s;
3724 	for (i = 0; flagstr[i]; i++) {
3725 		int bit;
3726 		boolean_t negation = (flagstr[i] == '-');
3727 
3728 		if (negation) {
3729 			i++;
3730 			if (flagstr[i] == '\0') {
3731 				*msg = "Invalid trailing negation operator";
3732 				rc = 1;
3733 				goto out;
3734 			}
3735 		}
3736 		bit = flagbits[(uchar_t)flagstr[i]];
3737 		if (bit == 0) {
3738 			*msg = "Invalid flag";
3739 			rc = 1;
3740 			goto out;
3741 		}
3742 		if (negation)
3743 			flags &= ~bit;
3744 		else
3745 			flags |= bit;
3746 	}
3747 	zor->zor_flags = flags;
3748 
3749 	zor->zor_obj_start = ZDB_MAP_OBJECT_ID(zor->zor_obj_start);
3750 	zor->zor_obj_end = ZDB_MAP_OBJECT_ID(zor->zor_obj_end);
3751 
3752 out:
3753 	free(dup);
3754 	return (rc);
3755 }
3756 
3757 static void
3758 dump_objset(objset_t *os)
3759 {
3760 	dmu_objset_stats_t dds = { 0 };
3761 	uint64_t object, object_count;
3762 	uint64_t refdbytes, usedobjs, scratch;
3763 	char numbuf[32];
3764 	char blkbuf[BP_SPRINTF_LEN + 20];
3765 	char osname[ZFS_MAX_DATASET_NAME_LEN];
3766 	const char *type = "UNKNOWN";
3767 	int verbosity = dump_opt['d'];
3768 	boolean_t print_header;
3769 	unsigned i;
3770 	int error;
3771 	uint64_t total_slots_used = 0;
3772 	uint64_t max_slot_used = 0;
3773 	uint64_t dnode_slots;
3774 	uint64_t obj_start;
3775 	uint64_t obj_end;
3776 	uint64_t flags;
3777 
3778 	/* make sure nicenum has enough space */
3779 	_Static_assert(sizeof (numbuf) >= NN_NUMBUF_SZ, "numbuf truncated");
3780 
3781 	dsl_pool_config_enter(dmu_objset_pool(os), FTAG);
3782 	dmu_objset_fast_stat(os, &dds);
3783 	dsl_pool_config_exit(dmu_objset_pool(os), FTAG);
3784 
3785 	print_header = B_TRUE;
3786 
3787 	if (dds.dds_type < DMU_OST_NUMTYPES)
3788 		type = objset_types[dds.dds_type];
3789 
3790 	if (dds.dds_type == DMU_OST_META) {
3791 		dds.dds_creation_txg = TXG_INITIAL;
3792 		usedobjs = BP_GET_FILL(os->os_rootbp);
3793 		refdbytes = dsl_dir_phys(os->os_spa->spa_dsl_pool->dp_mos_dir)->
3794 		    dd_used_bytes;
3795 	} else {
3796 		dmu_objset_space(os, &refdbytes, &scratch, &usedobjs, &scratch);
3797 	}
3798 
3799 	ASSERT3U(usedobjs, ==, BP_GET_FILL(os->os_rootbp));
3800 
3801 	zdb_nicenum(refdbytes, numbuf, sizeof (numbuf));
3802 
3803 	if (verbosity >= 4) {
3804 		(void) snprintf(blkbuf, sizeof (blkbuf), ", rootbp ");
3805 		(void) snprintf_blkptr(blkbuf + strlen(blkbuf),
3806 		    sizeof (blkbuf) - strlen(blkbuf), os->os_rootbp);
3807 	} else {
3808 		blkbuf[0] = '\0';
3809 	}
3810 
3811 	dmu_objset_name(os, osname);
3812 
3813 	(void) printf("Dataset %s [%s], ID %llu, cr_txg %llu, "
3814 	    "%s, %llu objects%s%s\n",
3815 	    osname, type, (u_longlong_t)dmu_objset_id(os),
3816 	    (u_longlong_t)dds.dds_creation_txg,
3817 	    numbuf, (u_longlong_t)usedobjs, blkbuf,
3818 	    (dds.dds_inconsistent) ? " (inconsistent)" : "");
3819 
3820 	for (i = 0; i < zopt_object_args; i++) {
3821 		obj_start = zopt_object_ranges[i].zor_obj_start;
3822 		obj_end = zopt_object_ranges[i].zor_obj_end;
3823 		flags = zopt_object_ranges[i].zor_flags;
3824 
3825 		object = obj_start;
3826 		if (object == 0 || obj_start == obj_end)
3827 			dump_object(os, object, verbosity, &print_header, NULL,
3828 			    flags);
3829 		else
3830 			object--;
3831 
3832 		while ((dmu_object_next(os, &object, B_FALSE, 0) == 0) &&
3833 		    object <= obj_end) {
3834 			dump_object(os, object, verbosity, &print_header, NULL,
3835 			    flags);
3836 		}
3837 	}
3838 
3839 	if (zopt_object_args > 0) {
3840 		(void) printf("\n");
3841 		return;
3842 	}
3843 
3844 	if (dump_opt['i'] != 0 || verbosity >= 2)
3845 		dump_intent_log(dmu_objset_zil(os));
3846 
3847 	if (dmu_objset_ds(os) != NULL) {
3848 		dsl_dataset_t *ds = dmu_objset_ds(os);
3849 		dump_blkptr_list(&ds->ds_deadlist, "Deadlist");
3850 		if (dsl_deadlist_is_open(&ds->ds_dir->dd_livelist) &&
3851 		    !dmu_objset_is_snapshot(os)) {
3852 			dump_blkptr_list(&ds->ds_dir->dd_livelist, "Livelist");
3853 			if (verify_dd_livelist(os) != 0)
3854 				fatal("livelist is incorrect");
3855 		}
3856 
3857 		if (dsl_dataset_remap_deadlist_exists(ds)) {
3858 			(void) printf("ds_remap_deadlist:\n");
3859 			dump_blkptr_list(&ds->ds_remap_deadlist, "Deadlist");
3860 		}
3861 		count_ds_mos_objects(ds);
3862 	}
3863 
3864 	if (dmu_objset_ds(os) != NULL)
3865 		dump_bookmarks(os, verbosity);
3866 
3867 	if (verbosity < 2)
3868 		return;
3869 
3870 	if (BP_IS_HOLE(os->os_rootbp))
3871 		return;
3872 
3873 	dump_object(os, 0, verbosity, &print_header, NULL, 0);
3874 	object_count = 0;
3875 	if (DMU_USERUSED_DNODE(os) != NULL &&
3876 	    DMU_USERUSED_DNODE(os)->dn_type != 0) {
3877 		dump_object(os, DMU_USERUSED_OBJECT, verbosity, &print_header,
3878 		    NULL, 0);
3879 		dump_object(os, DMU_GROUPUSED_OBJECT, verbosity, &print_header,
3880 		    NULL, 0);
3881 	}
3882 
3883 	if (DMU_PROJECTUSED_DNODE(os) != NULL &&
3884 	    DMU_PROJECTUSED_DNODE(os)->dn_type != 0)
3885 		dump_object(os, DMU_PROJECTUSED_OBJECT, verbosity,
3886 		    &print_header, NULL, 0);
3887 
3888 	object = 0;
3889 	while ((error = dmu_object_next(os, &object, B_FALSE, 0)) == 0) {
3890 		dump_object(os, object, verbosity, &print_header, &dnode_slots,
3891 		    0);
3892 		object_count++;
3893 		total_slots_used += dnode_slots;
3894 		max_slot_used = object + dnode_slots - 1;
3895 	}
3896 
3897 	(void) printf("\n");
3898 
3899 	(void) printf("    Dnode slots:\n");
3900 	(void) printf("\tTotal used:    %10llu\n",
3901 	    (u_longlong_t)total_slots_used);
3902 	(void) printf("\tMax used:      %10llu\n",
3903 	    (u_longlong_t)max_slot_used);
3904 	(void) printf("\tPercent empty: %10lf\n",
3905 	    (double)(max_slot_used - total_slots_used)*100 /
3906 	    (double)max_slot_used);
3907 	(void) printf("\n");
3908 
3909 	if (error != ESRCH) {
3910 		(void) fprintf(stderr, "dmu_object_next() = %d\n", error);
3911 		abort();
3912 	}
3913 
3914 	ASSERT3U(object_count, ==, usedobjs);
3915 
3916 	if (leaked_objects != 0) {
3917 		(void) printf("%d potentially leaked objects detected\n",
3918 		    leaked_objects);
3919 		leaked_objects = 0;
3920 	}
3921 }
3922 
3923 static void
3924 dump_uberblock(uberblock_t *ub, const char *header, const char *footer)
3925 {
3926 	time_t timestamp = ub->ub_timestamp;
3927 
3928 	(void) printf("%s", header ? header : "");
3929 	(void) printf("\tmagic = %016llx\n", (u_longlong_t)ub->ub_magic);
3930 	(void) printf("\tversion = %llu\n", (u_longlong_t)ub->ub_version);
3931 	(void) printf("\ttxg = %llu\n", (u_longlong_t)ub->ub_txg);
3932 	(void) printf("\tguid_sum = %llu\n", (u_longlong_t)ub->ub_guid_sum);
3933 	(void) printf("\ttimestamp = %llu UTC = %s",
3934 	    (u_longlong_t)ub->ub_timestamp, ctime(&timestamp));
3935 
3936 	(void) printf("\tmmp_magic = %016llx\n",
3937 	    (u_longlong_t)ub->ub_mmp_magic);
3938 	if (MMP_VALID(ub)) {
3939 		(void) printf("\tmmp_delay = %0llu\n",
3940 		    (u_longlong_t)ub->ub_mmp_delay);
3941 		if (MMP_SEQ_VALID(ub))
3942 			(void) printf("\tmmp_seq = %u\n",
3943 			    (unsigned int) MMP_SEQ(ub));
3944 		if (MMP_FAIL_INT_VALID(ub))
3945 			(void) printf("\tmmp_fail = %u\n",
3946 			    (unsigned int) MMP_FAIL_INT(ub));
3947 		if (MMP_INTERVAL_VALID(ub))
3948 			(void) printf("\tmmp_write = %u\n",
3949 			    (unsigned int) MMP_INTERVAL(ub));
3950 		/* After MMP_* to make summarize_uberblock_mmp cleaner */
3951 		(void) printf("\tmmp_valid = %x\n",
3952 		    (unsigned int) ub->ub_mmp_config & 0xFF);
3953 	}
3954 
3955 	if (dump_opt['u'] >= 4) {
3956 		char blkbuf[BP_SPRINTF_LEN];
3957 		snprintf_blkptr(blkbuf, sizeof (blkbuf), &ub->ub_rootbp);
3958 		(void) printf("\trootbp = %s\n", blkbuf);
3959 	}
3960 	(void) printf("\tcheckpoint_txg = %llu\n",
3961 	    (u_longlong_t)ub->ub_checkpoint_txg);
3962 	(void) printf("%s", footer ? footer : "");
3963 }
3964 
3965 static void
3966 dump_config(spa_t *spa)
3967 {
3968 	dmu_buf_t *db;
3969 	size_t nvsize = 0;
3970 	int error = 0;
3971 
3972 
3973 	error = dmu_bonus_hold(spa->spa_meta_objset,
3974 	    spa->spa_config_object, FTAG, &db);
3975 
3976 	if (error == 0) {
3977 		nvsize = *(uint64_t *)db->db_data;
3978 		dmu_buf_rele(db, FTAG);
3979 
3980 		(void) printf("\nMOS Configuration:\n");
3981 		dump_packed_nvlist(spa->spa_meta_objset,
3982 		    spa->spa_config_object, (void *)&nvsize, 1);
3983 	} else {
3984 		(void) fprintf(stderr, "dmu_bonus_hold(%llu) failed, errno %d",
3985 		    (u_longlong_t)spa->spa_config_object, error);
3986 	}
3987 }
3988 
3989 static void
3990 dump_cachefile(const char *cachefile)
3991 {
3992 	int fd;
3993 	struct stat64 statbuf;
3994 	char *buf;
3995 	nvlist_t *config;
3996 
3997 	if ((fd = open64(cachefile, O_RDONLY)) < 0) {
3998 		(void) printf("cannot open '%s': %s\n", cachefile,
3999 		    strerror(errno));
4000 		exit(1);
4001 	}
4002 
4003 	if (fstat64(fd, &statbuf) != 0) {
4004 		(void) printf("failed to stat '%s': %s\n", cachefile,
4005 		    strerror(errno));
4006 		exit(1);
4007 	}
4008 
4009 	if ((buf = malloc(statbuf.st_size)) == NULL) {
4010 		(void) fprintf(stderr, "failed to allocate %llu bytes\n",
4011 		    (u_longlong_t)statbuf.st_size);
4012 		exit(1);
4013 	}
4014 
4015 	if (read(fd, buf, statbuf.st_size) != statbuf.st_size) {
4016 		(void) fprintf(stderr, "failed to read %llu bytes\n",
4017 		    (u_longlong_t)statbuf.st_size);
4018 		exit(1);
4019 	}
4020 
4021 	(void) close(fd);
4022 
4023 	if (nvlist_unpack(buf, statbuf.st_size, &config, 0) != 0) {
4024 		(void) fprintf(stderr, "failed to unpack nvlist\n");
4025 		exit(1);
4026 	}
4027 
4028 	free(buf);
4029 
4030 	dump_nvlist(config, 0);
4031 
4032 	nvlist_free(config);
4033 }
4034 
4035 /*
4036  * ZFS label nvlist stats
4037  */
4038 typedef struct zdb_nvl_stats {
4039 	int		zns_list_count;
4040 	int		zns_leaf_count;
4041 	size_t		zns_leaf_largest;
4042 	size_t		zns_leaf_total;
4043 	nvlist_t	*zns_string;
4044 	nvlist_t	*zns_uint64;
4045 	nvlist_t	*zns_boolean;
4046 } zdb_nvl_stats_t;
4047 
4048 static void
4049 collect_nvlist_stats(nvlist_t *nvl, zdb_nvl_stats_t *stats)
4050 {
4051 	nvlist_t *list, **array;
4052 	nvpair_t *nvp = NULL;
4053 	char *name;
4054 	uint_t i, items;
4055 
4056 	stats->zns_list_count++;
4057 
4058 	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
4059 		name = nvpair_name(nvp);
4060 
4061 		switch (nvpair_type(nvp)) {
4062 		case DATA_TYPE_STRING:
4063 			fnvlist_add_string(stats->zns_string, name,
4064 			    fnvpair_value_string(nvp));
4065 			break;
4066 		case DATA_TYPE_UINT64:
4067 			fnvlist_add_uint64(stats->zns_uint64, name,
4068 			    fnvpair_value_uint64(nvp));
4069 			break;
4070 		case DATA_TYPE_BOOLEAN:
4071 			fnvlist_add_boolean(stats->zns_boolean, name);
4072 			break;
4073 		case DATA_TYPE_NVLIST:
4074 			if (nvpair_value_nvlist(nvp, &list) == 0)
4075 				collect_nvlist_stats(list, stats);
4076 			break;
4077 		case DATA_TYPE_NVLIST_ARRAY:
4078 			if (nvpair_value_nvlist_array(nvp, &array, &items) != 0)
4079 				break;
4080 
4081 			for (i = 0; i < items; i++) {
4082 				collect_nvlist_stats(array[i], stats);
4083 
4084 				/* collect stats on leaf vdev */
4085 				if (strcmp(name, "children") == 0) {
4086 					size_t size;
4087 
4088 					(void) nvlist_size(array[i], &size,
4089 					    NV_ENCODE_XDR);
4090 					stats->zns_leaf_total += size;
4091 					if (size > stats->zns_leaf_largest)
4092 						stats->zns_leaf_largest = size;
4093 					stats->zns_leaf_count++;
4094 				}
4095 			}
4096 			break;
4097 		default:
4098 			(void) printf("skip type %d!\n", (int)nvpair_type(nvp));
4099 		}
4100 	}
4101 }
4102 
4103 static void
4104 dump_nvlist_stats(nvlist_t *nvl, size_t cap)
4105 {
4106 	zdb_nvl_stats_t stats = { 0 };
4107 	size_t size, sum = 0, total;
4108 	size_t noise;
4109 
4110 	/* requires nvlist with non-unique names for stat collection */
4111 	VERIFY0(nvlist_alloc(&stats.zns_string, 0, 0));
4112 	VERIFY0(nvlist_alloc(&stats.zns_uint64, 0, 0));
4113 	VERIFY0(nvlist_alloc(&stats.zns_boolean, 0, 0));
4114 	VERIFY0(nvlist_size(stats.zns_boolean, &noise, NV_ENCODE_XDR));
4115 
4116 	(void) printf("\n\nZFS Label NVList Config Stats:\n");
4117 
4118 	VERIFY0(nvlist_size(nvl, &total, NV_ENCODE_XDR));
4119 	(void) printf("  %d bytes used, %d bytes free (using %4.1f%%)\n\n",
4120 	    (int)total, (int)(cap - total), 100.0 * total / cap);
4121 
4122 	collect_nvlist_stats(nvl, &stats);
4123 
4124 	VERIFY0(nvlist_size(stats.zns_uint64, &size, NV_ENCODE_XDR));
4125 	size -= noise;
4126 	sum += size;
4127 	(void) printf("%12s %4d %6d bytes (%5.2f%%)\n", "integers:",
4128 	    (int)fnvlist_num_pairs(stats.zns_uint64),
4129 	    (int)size, 100.0 * size / total);
4130 
4131 	VERIFY0(nvlist_size(stats.zns_string, &size, NV_ENCODE_XDR));
4132 	size -= noise;
4133 	sum += size;
4134 	(void) printf("%12s %4d %6d bytes (%5.2f%%)\n", "strings:",
4135 	    (int)fnvlist_num_pairs(stats.zns_string),
4136 	    (int)size, 100.0 * size / total);
4137 
4138 	VERIFY0(nvlist_size(stats.zns_boolean, &size, NV_ENCODE_XDR));
4139 	size -= noise;
4140 	sum += size;
4141 	(void) printf("%12s %4d %6d bytes (%5.2f%%)\n", "booleans:",
4142 	    (int)fnvlist_num_pairs(stats.zns_boolean),
4143 	    (int)size, 100.0 * size / total);
4144 
4145 	size = total - sum;	/* treat remainder as nvlist overhead */
4146 	(void) printf("%12s %4d %6d bytes (%5.2f%%)\n\n", "nvlists:",
4147 	    stats.zns_list_count, (int)size, 100.0 * size / total);
4148 
4149 	if (stats.zns_leaf_count > 0) {
4150 		size_t average = stats.zns_leaf_total / stats.zns_leaf_count;
4151 
4152 		(void) printf("%12s %4d %6d bytes average\n", "leaf vdevs:",
4153 		    stats.zns_leaf_count, (int)average);
4154 		(void) printf("%24d bytes largest\n",
4155 		    (int)stats.zns_leaf_largest);
4156 
4157 		if (dump_opt['l'] >= 3 && average > 0)
4158 			(void) printf("  space for %d additional leaf vdevs\n",
4159 			    (int)((cap - total) / average));
4160 	}
4161 	(void) printf("\n");
4162 
4163 	nvlist_free(stats.zns_string);
4164 	nvlist_free(stats.zns_uint64);
4165 	nvlist_free(stats.zns_boolean);
4166 }
4167 
4168 typedef struct cksum_record {
4169 	zio_cksum_t cksum;
4170 	boolean_t labels[VDEV_LABELS];
4171 	avl_node_t link;
4172 } cksum_record_t;
4173 
4174 static int
4175 cksum_record_compare(const void *x1, const void *x2)
4176 {
4177 	const cksum_record_t *l = (cksum_record_t *)x1;
4178 	const cksum_record_t *r = (cksum_record_t *)x2;
4179 	int arraysize = ARRAY_SIZE(l->cksum.zc_word);
4180 	int difference = 0;
4181 
4182 	for (int i = 0; i < arraysize; i++) {
4183 		difference = TREE_CMP(l->cksum.zc_word[i], r->cksum.zc_word[i]);
4184 		if (difference)
4185 			break;
4186 	}
4187 
4188 	return (difference);
4189 }
4190 
4191 static cksum_record_t *
4192 cksum_record_alloc(zio_cksum_t *cksum, int l)
4193 {
4194 	cksum_record_t *rec;
4195 
4196 	rec = umem_zalloc(sizeof (*rec), UMEM_NOFAIL);
4197 	rec->cksum = *cksum;
4198 	rec->labels[l] = B_TRUE;
4199 
4200 	return (rec);
4201 }
4202 
4203 static cksum_record_t *
4204 cksum_record_lookup(avl_tree_t *tree, zio_cksum_t *cksum)
4205 {
4206 	cksum_record_t lookup = { .cksum = *cksum };
4207 	avl_index_t where;
4208 
4209 	return (avl_find(tree, &lookup, &where));
4210 }
4211 
4212 static cksum_record_t *
4213 cksum_record_insert(avl_tree_t *tree, zio_cksum_t *cksum, int l)
4214 {
4215 	cksum_record_t *rec;
4216 
4217 	rec = cksum_record_lookup(tree, cksum);
4218 	if (rec) {
4219 		rec->labels[l] = B_TRUE;
4220 	} else {
4221 		rec = cksum_record_alloc(cksum, l);
4222 		avl_add(tree, rec);
4223 	}
4224 
4225 	return (rec);
4226 }
4227 
4228 static int
4229 first_label(cksum_record_t *rec)
4230 {
4231 	for (int i = 0; i < VDEV_LABELS; i++)
4232 		if (rec->labels[i])
4233 			return (i);
4234 
4235 	return (-1);
4236 }
4237 
4238 static void
4239 print_label_numbers(char *prefix, cksum_record_t *rec)
4240 {
4241 	printf("%s", prefix);
4242 	for (int i = 0; i < VDEV_LABELS; i++)
4243 		if (rec->labels[i] == B_TRUE)
4244 			printf("%d ", i);
4245 	printf("\n");
4246 }
4247 
4248 #define	MAX_UBERBLOCK_COUNT (VDEV_UBERBLOCK_RING >> UBERBLOCK_SHIFT)
4249 
4250 typedef struct zdb_label {
4251 	vdev_label_t label;
4252 	uint64_t label_offset;
4253 	nvlist_t *config_nv;
4254 	cksum_record_t *config;
4255 	cksum_record_t *uberblocks[MAX_UBERBLOCK_COUNT];
4256 	boolean_t header_printed;
4257 	boolean_t read_failed;
4258 	boolean_t cksum_valid;
4259 } zdb_label_t;
4260 
4261 static void
4262 print_label_header(zdb_label_t *label, int l)
4263 {
4264 
4265 	if (dump_opt['q'])
4266 		return;
4267 
4268 	if (label->header_printed == B_TRUE)
4269 		return;
4270 
4271 	(void) printf("------------------------------------\n");
4272 	(void) printf("LABEL %d %s\n", l,
4273 	    label->cksum_valid ? "" : "(Bad label cksum)");
4274 	(void) printf("------------------------------------\n");
4275 
4276 	label->header_printed = B_TRUE;
4277 }
4278 
4279 static void
4280 print_l2arc_header(void)
4281 {
4282 	(void) printf("------------------------------------\n");
4283 	(void) printf("L2ARC device header\n");
4284 	(void) printf("------------------------------------\n");
4285 }
4286 
4287 static void
4288 print_l2arc_log_blocks(void)
4289 {
4290 	(void) printf("------------------------------------\n");
4291 	(void) printf("L2ARC device log blocks\n");
4292 	(void) printf("------------------------------------\n");
4293 }
4294 
4295 static void
4296 dump_l2arc_log_entries(uint64_t log_entries,
4297     l2arc_log_ent_phys_t *le, uint64_t i)
4298 {
4299 	for (int j = 0; j < log_entries; j++) {
4300 		dva_t dva = le[j].le_dva;
4301 		(void) printf("lb[%4llu]\tle[%4d]\tDVA asize: %llu, "
4302 		    "vdev: %llu, offset: %llu\n",
4303 		    (u_longlong_t)i, j + 1,
4304 		    (u_longlong_t)DVA_GET_ASIZE(&dva),
4305 		    (u_longlong_t)DVA_GET_VDEV(&dva),
4306 		    (u_longlong_t)DVA_GET_OFFSET(&dva));
4307 		(void) printf("|\t\t\t\tbirth: %llu\n",
4308 		    (u_longlong_t)le[j].le_birth);
4309 		(void) printf("|\t\t\t\tlsize: %llu\n",
4310 		    (u_longlong_t)L2BLK_GET_LSIZE((&le[j])->le_prop));
4311 		(void) printf("|\t\t\t\tpsize: %llu\n",
4312 		    (u_longlong_t)L2BLK_GET_PSIZE((&le[j])->le_prop));
4313 		(void) printf("|\t\t\t\tcompr: %llu\n",
4314 		    (u_longlong_t)L2BLK_GET_COMPRESS((&le[j])->le_prop));
4315 		(void) printf("|\t\t\t\tcomplevel: %llu\n",
4316 		    (u_longlong_t)(&le[j])->le_complevel);
4317 		(void) printf("|\t\t\t\ttype: %llu\n",
4318 		    (u_longlong_t)L2BLK_GET_TYPE((&le[j])->le_prop));
4319 		(void) printf("|\t\t\t\tprotected: %llu\n",
4320 		    (u_longlong_t)L2BLK_GET_PROTECTED((&le[j])->le_prop));
4321 		(void) printf("|\t\t\t\tprefetch: %llu\n",
4322 		    (u_longlong_t)L2BLK_GET_PREFETCH((&le[j])->le_prop));
4323 		(void) printf("|\t\t\t\taddress: %llu\n",
4324 		    (u_longlong_t)le[j].le_daddr);
4325 		(void) printf("|\t\t\t\tARC state: %llu\n",
4326 		    (u_longlong_t)L2BLK_GET_STATE((&le[j])->le_prop));
4327 		(void) printf("|\n");
4328 	}
4329 	(void) printf("\n");
4330 }
4331 
4332 static void
4333 dump_l2arc_log_blkptr(l2arc_log_blkptr_t lbps)
4334 {
4335 	(void) printf("|\t\tdaddr: %llu\n", (u_longlong_t)lbps.lbp_daddr);
4336 	(void) printf("|\t\tpayload_asize: %llu\n",
4337 	    (u_longlong_t)lbps.lbp_payload_asize);
4338 	(void) printf("|\t\tpayload_start: %llu\n",
4339 	    (u_longlong_t)lbps.lbp_payload_start);
4340 	(void) printf("|\t\tlsize: %llu\n",
4341 	    (u_longlong_t)L2BLK_GET_LSIZE((&lbps)->lbp_prop));
4342 	(void) printf("|\t\tasize: %llu\n",
4343 	    (u_longlong_t)L2BLK_GET_PSIZE((&lbps)->lbp_prop));
4344 	(void) printf("|\t\tcompralgo: %llu\n",
4345 	    (u_longlong_t)L2BLK_GET_COMPRESS((&lbps)->lbp_prop));
4346 	(void) printf("|\t\tcksumalgo: %llu\n",
4347 	    (u_longlong_t)L2BLK_GET_CHECKSUM((&lbps)->lbp_prop));
4348 	(void) printf("|\n\n");
4349 }
4350 
4351 static void
4352 dump_l2arc_log_blocks(int fd, l2arc_dev_hdr_phys_t l2dhdr,
4353     l2arc_dev_hdr_phys_t *rebuild)
4354 {
4355 	l2arc_log_blk_phys_t this_lb;
4356 	uint64_t asize;
4357 	l2arc_log_blkptr_t lbps[2];
4358 	abd_t *abd;
4359 	zio_cksum_t cksum;
4360 	int failed = 0;
4361 	l2arc_dev_t dev;
4362 
4363 	if (!dump_opt['q'])
4364 		print_l2arc_log_blocks();
4365 	memcpy(lbps, l2dhdr.dh_start_lbps, sizeof (lbps));
4366 
4367 	dev.l2ad_evict = l2dhdr.dh_evict;
4368 	dev.l2ad_start = l2dhdr.dh_start;
4369 	dev.l2ad_end = l2dhdr.dh_end;
4370 
4371 	if (l2dhdr.dh_start_lbps[0].lbp_daddr == 0) {
4372 		/* no log blocks to read */
4373 		if (!dump_opt['q']) {
4374 			(void) printf("No log blocks to read\n");
4375 			(void) printf("\n");
4376 		}
4377 		return;
4378 	} else {
4379 		dev.l2ad_hand = lbps[0].lbp_daddr +
4380 		    L2BLK_GET_PSIZE((&lbps[0])->lbp_prop);
4381 	}
4382 
4383 	dev.l2ad_first = !!(l2dhdr.dh_flags & L2ARC_DEV_HDR_EVICT_FIRST);
4384 
4385 	for (;;) {
4386 		if (!l2arc_log_blkptr_valid(&dev, &lbps[0]))
4387 			break;
4388 
4389 		/* L2BLK_GET_PSIZE returns aligned size for log blocks */
4390 		asize = L2BLK_GET_PSIZE((&lbps[0])->lbp_prop);
4391 		if (pread64(fd, &this_lb, asize, lbps[0].lbp_daddr) != asize) {
4392 			if (!dump_opt['q']) {
4393 				(void) printf("Error while reading next log "
4394 				    "block\n\n");
4395 			}
4396 			break;
4397 		}
4398 
4399 		fletcher_4_native_varsize(&this_lb, asize, &cksum);
4400 		if (!ZIO_CHECKSUM_EQUAL(cksum, lbps[0].lbp_cksum)) {
4401 			failed++;
4402 			if (!dump_opt['q']) {
4403 				(void) printf("Invalid cksum\n");
4404 				dump_l2arc_log_blkptr(lbps[0]);
4405 			}
4406 			break;
4407 		}
4408 
4409 		switch (L2BLK_GET_COMPRESS((&lbps[0])->lbp_prop)) {
4410 		case ZIO_COMPRESS_OFF:
4411 			break;
4412 		default:
4413 			abd = abd_alloc_for_io(asize, B_TRUE);
4414 			abd_copy_from_buf_off(abd, &this_lb, 0, asize);
4415 			zio_decompress_data(L2BLK_GET_COMPRESS(
4416 			    (&lbps[0])->lbp_prop), abd, &this_lb,
4417 			    asize, sizeof (this_lb), NULL);
4418 			abd_free(abd);
4419 			break;
4420 		}
4421 
4422 		if (this_lb.lb_magic == BSWAP_64(L2ARC_LOG_BLK_MAGIC))
4423 			byteswap_uint64_array(&this_lb, sizeof (this_lb));
4424 		if (this_lb.lb_magic != L2ARC_LOG_BLK_MAGIC) {
4425 			if (!dump_opt['q'])
4426 				(void) printf("Invalid log block magic\n\n");
4427 			break;
4428 		}
4429 
4430 		rebuild->dh_lb_count++;
4431 		rebuild->dh_lb_asize += asize;
4432 		if (dump_opt['l'] > 1 && !dump_opt['q']) {
4433 			(void) printf("lb[%4llu]\tmagic: %llu\n",
4434 			    (u_longlong_t)rebuild->dh_lb_count,
4435 			    (u_longlong_t)this_lb.lb_magic);
4436 			dump_l2arc_log_blkptr(lbps[0]);
4437 		}
4438 
4439 		if (dump_opt['l'] > 2 && !dump_opt['q'])
4440 			dump_l2arc_log_entries(l2dhdr.dh_log_entries,
4441 			    this_lb.lb_entries,
4442 			    rebuild->dh_lb_count);
4443 
4444 		if (l2arc_range_check_overlap(lbps[1].lbp_payload_start,
4445 		    lbps[0].lbp_payload_start, dev.l2ad_evict) &&
4446 		    !dev.l2ad_first)
4447 			break;
4448 
4449 		lbps[0] = lbps[1];
4450 		lbps[1] = this_lb.lb_prev_lbp;
4451 	}
4452 
4453 	if (!dump_opt['q']) {
4454 		(void) printf("log_blk_count:\t %llu with valid cksum\n",
4455 		    (u_longlong_t)rebuild->dh_lb_count);
4456 		(void) printf("\t\t %d with invalid cksum\n", failed);
4457 		(void) printf("log_blk_asize:\t %llu\n\n",
4458 		    (u_longlong_t)rebuild->dh_lb_asize);
4459 	}
4460 }
4461 
4462 static int
4463 dump_l2arc_header(int fd)
4464 {
4465 	l2arc_dev_hdr_phys_t l2dhdr = {0}, rebuild = {0};
4466 	int error = B_FALSE;
4467 
4468 	if (pread64(fd, &l2dhdr, sizeof (l2dhdr),
4469 	    VDEV_LABEL_START_SIZE) != sizeof (l2dhdr)) {
4470 		error = B_TRUE;
4471 	} else {
4472 		if (l2dhdr.dh_magic == BSWAP_64(L2ARC_DEV_HDR_MAGIC))
4473 			byteswap_uint64_array(&l2dhdr, sizeof (l2dhdr));
4474 
4475 		if (l2dhdr.dh_magic != L2ARC_DEV_HDR_MAGIC)
4476 			error = B_TRUE;
4477 	}
4478 
4479 	if (error) {
4480 		(void) printf("L2ARC device header not found\n\n");
4481 		/* Do not return an error here for backward compatibility */
4482 		return (0);
4483 	} else if (!dump_opt['q']) {
4484 		print_l2arc_header();
4485 
4486 		(void) printf("    magic: %llu\n",
4487 		    (u_longlong_t)l2dhdr.dh_magic);
4488 		(void) printf("    version: %llu\n",
4489 		    (u_longlong_t)l2dhdr.dh_version);
4490 		(void) printf("    pool_guid: %llu\n",
4491 		    (u_longlong_t)l2dhdr.dh_spa_guid);
4492 		(void) printf("    flags: %llu\n",
4493 		    (u_longlong_t)l2dhdr.dh_flags);
4494 		(void) printf("    start_lbps[0]: %llu\n",
4495 		    (u_longlong_t)
4496 		    l2dhdr.dh_start_lbps[0].lbp_daddr);
4497 		(void) printf("    start_lbps[1]: %llu\n",
4498 		    (u_longlong_t)
4499 		    l2dhdr.dh_start_lbps[1].lbp_daddr);
4500 		(void) printf("    log_blk_ent: %llu\n",
4501 		    (u_longlong_t)l2dhdr.dh_log_entries);
4502 		(void) printf("    start: %llu\n",
4503 		    (u_longlong_t)l2dhdr.dh_start);
4504 		(void) printf("    end: %llu\n",
4505 		    (u_longlong_t)l2dhdr.dh_end);
4506 		(void) printf("    evict: %llu\n",
4507 		    (u_longlong_t)l2dhdr.dh_evict);
4508 		(void) printf("    lb_asize_refcount: %llu\n",
4509 		    (u_longlong_t)l2dhdr.dh_lb_asize);
4510 		(void) printf("    lb_count_refcount: %llu\n",
4511 		    (u_longlong_t)l2dhdr.dh_lb_count);
4512 		(void) printf("    trim_action_time: %llu\n",
4513 		    (u_longlong_t)l2dhdr.dh_trim_action_time);
4514 		(void) printf("    trim_state: %llu\n\n",
4515 		    (u_longlong_t)l2dhdr.dh_trim_state);
4516 	}
4517 
4518 	dump_l2arc_log_blocks(fd, l2dhdr, &rebuild);
4519 	/*
4520 	 * The total aligned size of log blocks and the number of log blocks
4521 	 * reported in the header of the device may be less than what zdb
4522 	 * reports by dump_l2arc_log_blocks() which emulates l2arc_rebuild().
4523 	 * This happens because dump_l2arc_log_blocks() lacks the memory
4524 	 * pressure valve that l2arc_rebuild() has. Thus, if we are on a system
4525 	 * with low memory, l2arc_rebuild will exit prematurely and dh_lb_asize
4526 	 * and dh_lb_count will be lower to begin with than what exists on the
4527 	 * device. This is normal and zdb should not exit with an error. The
4528 	 * opposite case should never happen though, the values reported in the
4529 	 * header should never be higher than what dump_l2arc_log_blocks() and
4530 	 * l2arc_rebuild() report. If this happens there is a leak in the
4531 	 * accounting of log blocks.
4532 	 */
4533 	if (l2dhdr.dh_lb_asize > rebuild.dh_lb_asize ||
4534 	    l2dhdr.dh_lb_count > rebuild.dh_lb_count)
4535 		return (1);
4536 
4537 	return (0);
4538 }
4539 
4540 static void
4541 dump_config_from_label(zdb_label_t *label, size_t buflen, int l)
4542 {
4543 	if (dump_opt['q'])
4544 		return;
4545 
4546 	if ((dump_opt['l'] < 3) && (first_label(label->config) != l))
4547 		return;
4548 
4549 	print_label_header(label, l);
4550 	dump_nvlist(label->config_nv, 4);
4551 	print_label_numbers("    labels = ", label->config);
4552 
4553 	if (dump_opt['l'] >= 2)
4554 		dump_nvlist_stats(label->config_nv, buflen);
4555 }
4556 
4557 #define	ZDB_MAX_UB_HEADER_SIZE 32
4558 
4559 static void
4560 dump_label_uberblocks(zdb_label_t *label, uint64_t ashift, int label_num)
4561 {
4562 
4563 	vdev_t vd;
4564 	char header[ZDB_MAX_UB_HEADER_SIZE];
4565 
4566 	vd.vdev_ashift = ashift;
4567 	vd.vdev_top = &vd;
4568 
4569 	for (int i = 0; i < VDEV_UBERBLOCK_COUNT(&vd); i++) {
4570 		uint64_t uoff = VDEV_UBERBLOCK_OFFSET(&vd, i);
4571 		uberblock_t *ub = (void *)((char *)&label->label + uoff);
4572 		cksum_record_t *rec = label->uberblocks[i];
4573 
4574 		if (rec == NULL) {
4575 			if (dump_opt['u'] >= 2) {
4576 				print_label_header(label, label_num);
4577 				(void) printf("    Uberblock[%d] invalid\n", i);
4578 			}
4579 			continue;
4580 		}
4581 
4582 		if ((dump_opt['u'] < 3) && (first_label(rec) != label_num))
4583 			continue;
4584 
4585 		if ((dump_opt['u'] < 4) &&
4586 		    (ub->ub_mmp_magic == MMP_MAGIC) && ub->ub_mmp_delay &&
4587 		    (i >= VDEV_UBERBLOCK_COUNT(&vd) - MMP_BLOCKS_PER_LABEL))
4588 			continue;
4589 
4590 		print_label_header(label, label_num);
4591 		(void) snprintf(header, ZDB_MAX_UB_HEADER_SIZE,
4592 		    "    Uberblock[%d]\n", i);
4593 		dump_uberblock(ub, header, "");
4594 		print_label_numbers("        labels = ", rec);
4595 	}
4596 }
4597 
4598 static char curpath[PATH_MAX];
4599 
4600 /*
4601  * Iterate through the path components, recursively passing
4602  * current one's obj and remaining path until we find the obj
4603  * for the last one.
4604  */
4605 static int
4606 dump_path_impl(objset_t *os, uint64_t obj, char *name, uint64_t *retobj)
4607 {
4608 	int err;
4609 	boolean_t header = B_TRUE;
4610 	uint64_t child_obj;
4611 	char *s;
4612 	dmu_buf_t *db;
4613 	dmu_object_info_t doi;
4614 
4615 	if ((s = strchr(name, '/')) != NULL)
4616 		*s = '\0';
4617 	err = zap_lookup(os, obj, name, 8, 1, &child_obj);
4618 
4619 	(void) strlcat(curpath, name, sizeof (curpath));
4620 
4621 	if (err != 0) {
4622 		(void) fprintf(stderr, "failed to lookup %s: %s\n",
4623 		    curpath, strerror(err));
4624 		return (err);
4625 	}
4626 
4627 	child_obj = ZFS_DIRENT_OBJ(child_obj);
4628 	err = sa_buf_hold(os, child_obj, FTAG, &db);
4629 	if (err != 0) {
4630 		(void) fprintf(stderr,
4631 		    "failed to get SA dbuf for obj %llu: %s\n",
4632 		    (u_longlong_t)child_obj, strerror(err));
4633 		return (EINVAL);
4634 	}
4635 	dmu_object_info_from_db(db, &doi);
4636 	sa_buf_rele(db, FTAG);
4637 
4638 	if (doi.doi_bonus_type != DMU_OT_SA &&
4639 	    doi.doi_bonus_type != DMU_OT_ZNODE) {
4640 		(void) fprintf(stderr, "invalid bonus type %d for obj %llu\n",
4641 		    doi.doi_bonus_type, (u_longlong_t)child_obj);
4642 		return (EINVAL);
4643 	}
4644 
4645 	if (dump_opt['v'] > 6) {
4646 		(void) printf("obj=%llu %s type=%d bonustype=%d\n",
4647 		    (u_longlong_t)child_obj, curpath, doi.doi_type,
4648 		    doi.doi_bonus_type);
4649 	}
4650 
4651 	(void) strlcat(curpath, "/", sizeof (curpath));
4652 
4653 	switch (doi.doi_type) {
4654 	case DMU_OT_DIRECTORY_CONTENTS:
4655 		if (s != NULL && *(s + 1) != '\0')
4656 			return (dump_path_impl(os, child_obj, s + 1, retobj));
4657 		zfs_fallthrough;
4658 	case DMU_OT_PLAIN_FILE_CONTENTS:
4659 		if (retobj != NULL) {
4660 			*retobj = child_obj;
4661 		} else {
4662 			dump_object(os, child_obj, dump_opt['v'], &header,
4663 			    NULL, 0);
4664 		}
4665 		return (0);
4666 	default:
4667 		(void) fprintf(stderr, "object %llu has non-file/directory "
4668 		    "type %d\n", (u_longlong_t)obj, doi.doi_type);
4669 		break;
4670 	}
4671 
4672 	return (EINVAL);
4673 }
4674 
4675 /*
4676  * Dump the blocks for the object specified by path inside the dataset.
4677  */
4678 static int
4679 dump_path(char *ds, char *path, uint64_t *retobj)
4680 {
4681 	int err;
4682 	objset_t *os;
4683 	uint64_t root_obj;
4684 
4685 	err = open_objset(ds, FTAG, &os);
4686 	if (err != 0)
4687 		return (err);
4688 
4689 	err = zap_lookup(os, MASTER_NODE_OBJ, ZFS_ROOT_OBJ, 8, 1, &root_obj);
4690 	if (err != 0) {
4691 		(void) fprintf(stderr, "can't lookup root znode: %s\n",
4692 		    strerror(err));
4693 		close_objset(os, FTAG);
4694 		return (EINVAL);
4695 	}
4696 
4697 	(void) snprintf(curpath, sizeof (curpath), "dataset=%s path=/", ds);
4698 
4699 	err = dump_path_impl(os, root_obj, path, retobj);
4700 
4701 	close_objset(os, FTAG);
4702 	return (err);
4703 }
4704 
4705 static int
4706 zdb_copy_object(objset_t *os, uint64_t srcobj, char *destfile)
4707 {
4708 	int err = 0;
4709 	uint64_t size, readsize, oursize, offset;
4710 	ssize_t writesize;
4711 	sa_handle_t *hdl;
4712 
4713 	(void) printf("Copying object %" PRIu64 " to file %s\n", srcobj,
4714 	    destfile);
4715 
4716 	VERIFY3P(os, ==, sa_os);
4717 	if ((err = sa_handle_get(os, srcobj, NULL, SA_HDL_PRIVATE, &hdl))) {
4718 		(void) printf("Failed to get handle for SA znode\n");
4719 		return (err);
4720 	}
4721 	if ((err = sa_lookup(hdl, sa_attr_table[ZPL_SIZE], &size, 8))) {
4722 		(void) sa_handle_destroy(hdl);
4723 		return (err);
4724 	}
4725 	(void) sa_handle_destroy(hdl);
4726 
4727 	(void) printf("Object %" PRIu64 " is %" PRIu64 " bytes\n", srcobj,
4728 	    size);
4729 	if (size == 0) {
4730 		return (EINVAL);
4731 	}
4732 
4733 	int fd = open(destfile, O_WRONLY | O_CREAT | O_TRUNC, 0644);
4734 	/*
4735 	 * We cap the size at 1 mebibyte here to prevent
4736 	 * allocation failures and nigh-infinite printing if the
4737 	 * object is extremely large.
4738 	 */
4739 	oursize = MIN(size, 1 << 20);
4740 	offset = 0;
4741 	char *buf = kmem_alloc(oursize, KM_NOSLEEP);
4742 	if (buf == NULL) {
4743 		return (ENOMEM);
4744 	}
4745 
4746 	while (offset < size) {
4747 		readsize = MIN(size - offset, 1 << 20);
4748 		err = dmu_read(os, srcobj, offset, readsize, buf, 0);
4749 		if (err != 0) {
4750 			(void) printf("got error %u from dmu_read\n", err);
4751 			kmem_free(buf, oursize);
4752 			return (err);
4753 		}
4754 		if (dump_opt['v'] > 3) {
4755 			(void) printf("Read offset=%" PRIu64 " size=%" PRIu64
4756 			    " error=%d\n", offset, readsize, err);
4757 		}
4758 
4759 		writesize = write(fd, buf, readsize);
4760 		if (writesize < 0) {
4761 			err = errno;
4762 			break;
4763 		} else if (writesize != readsize) {
4764 			/* Incomplete write */
4765 			(void) fprintf(stderr, "Short write, only wrote %llu of"
4766 			    " %" PRIu64 " bytes, exiting...\n",
4767 			    (u_longlong_t)writesize, readsize);
4768 			break;
4769 		}
4770 
4771 		offset += readsize;
4772 	}
4773 
4774 	(void) close(fd);
4775 
4776 	if (buf != NULL)
4777 		kmem_free(buf, oursize);
4778 
4779 	return (err);
4780 }
4781 
4782 static boolean_t
4783 label_cksum_valid(vdev_label_t *label, uint64_t offset)
4784 {
4785 	zio_checksum_info_t *ci = &zio_checksum_table[ZIO_CHECKSUM_LABEL];
4786 	zio_cksum_t expected_cksum;
4787 	zio_cksum_t actual_cksum;
4788 	zio_cksum_t verifier;
4789 	zio_eck_t *eck;
4790 	int byteswap;
4791 
4792 	void *data = (char *)label + offsetof(vdev_label_t, vl_vdev_phys);
4793 	eck = (zio_eck_t *)((char *)(data) + VDEV_PHYS_SIZE) - 1;
4794 
4795 	offset += offsetof(vdev_label_t, vl_vdev_phys);
4796 	ZIO_SET_CHECKSUM(&verifier, offset, 0, 0, 0);
4797 
4798 	byteswap = (eck->zec_magic == BSWAP_64(ZEC_MAGIC));
4799 	if (byteswap)
4800 		byteswap_uint64_array(&verifier, sizeof (zio_cksum_t));
4801 
4802 	expected_cksum = eck->zec_cksum;
4803 	eck->zec_cksum = verifier;
4804 
4805 	abd_t *abd = abd_get_from_buf(data, VDEV_PHYS_SIZE);
4806 	ci->ci_func[byteswap](abd, VDEV_PHYS_SIZE, NULL, &actual_cksum);
4807 	abd_free(abd);
4808 
4809 	if (byteswap)
4810 		byteswap_uint64_array(&expected_cksum, sizeof (zio_cksum_t));
4811 
4812 	if (ZIO_CHECKSUM_EQUAL(actual_cksum, expected_cksum))
4813 		return (B_TRUE);
4814 
4815 	return (B_FALSE);
4816 }
4817 
4818 static int
4819 dump_label(const char *dev)
4820 {
4821 	char path[MAXPATHLEN];
4822 	zdb_label_t labels[VDEV_LABELS] = {{{{0}}}};
4823 	uint64_t psize, ashift, l2cache;
4824 	struct stat64 statbuf;
4825 	boolean_t config_found = B_FALSE;
4826 	boolean_t error = B_FALSE;
4827 	boolean_t read_l2arc_header = B_FALSE;
4828 	avl_tree_t config_tree;
4829 	avl_tree_t uberblock_tree;
4830 	void *node, *cookie;
4831 	int fd;
4832 
4833 	/*
4834 	 * Check if we were given absolute path and use it as is.
4835 	 * Otherwise if the provided vdev name doesn't point to a file,
4836 	 * try prepending expected disk paths and partition numbers.
4837 	 */
4838 	(void) strlcpy(path, dev, sizeof (path));
4839 	if (dev[0] != '/' && stat64(path, &statbuf) != 0) {
4840 		int error;
4841 
4842 		error = zfs_resolve_shortname(dev, path, MAXPATHLEN);
4843 		if (error == 0 && zfs_dev_is_whole_disk(path)) {
4844 			if (zfs_append_partition(path, MAXPATHLEN) == -1)
4845 				error = ENOENT;
4846 		}
4847 
4848 		if (error || (stat64(path, &statbuf) != 0)) {
4849 			(void) printf("failed to find device %s, try "
4850 			    "specifying absolute path instead\n", dev);
4851 			return (1);
4852 		}
4853 	}
4854 
4855 	if ((fd = open64(path, O_RDONLY)) < 0) {
4856 		(void) printf("cannot open '%s': %s\n", path, strerror(errno));
4857 		exit(1);
4858 	}
4859 
4860 	if (fstat64_blk(fd, &statbuf) != 0) {
4861 		(void) printf("failed to stat '%s': %s\n", path,
4862 		    strerror(errno));
4863 		(void) close(fd);
4864 		exit(1);
4865 	}
4866 
4867 	if (S_ISBLK(statbuf.st_mode) && zfs_dev_flush(fd) != 0)
4868 		(void) printf("failed to invalidate cache '%s' : %s\n", path,
4869 		    strerror(errno));
4870 
4871 	avl_create(&config_tree, cksum_record_compare,
4872 	    sizeof (cksum_record_t), offsetof(cksum_record_t, link));
4873 	avl_create(&uberblock_tree, cksum_record_compare,
4874 	    sizeof (cksum_record_t), offsetof(cksum_record_t, link));
4875 
4876 	psize = statbuf.st_size;
4877 	psize = P2ALIGN(psize, (uint64_t)sizeof (vdev_label_t));
4878 	ashift = SPA_MINBLOCKSHIFT;
4879 
4880 	/*
4881 	 * 1. Read the label from disk
4882 	 * 2. Verify label cksum
4883 	 * 3. Unpack the configuration and insert in config tree.
4884 	 * 4. Traverse all uberblocks and insert in uberblock tree.
4885 	 */
4886 	for (int l = 0; l < VDEV_LABELS; l++) {
4887 		zdb_label_t *label = &labels[l];
4888 		char *buf = label->label.vl_vdev_phys.vp_nvlist;
4889 		size_t buflen = sizeof (label->label.vl_vdev_phys.vp_nvlist);
4890 		nvlist_t *config;
4891 		cksum_record_t *rec;
4892 		zio_cksum_t cksum;
4893 		vdev_t vd;
4894 
4895 		label->label_offset = vdev_label_offset(psize, l, 0);
4896 
4897 		if (pread64(fd, &label->label, sizeof (label->label),
4898 		    label->label_offset) != sizeof (label->label)) {
4899 			if (!dump_opt['q'])
4900 				(void) printf("failed to read label %d\n", l);
4901 			label->read_failed = B_TRUE;
4902 			error = B_TRUE;
4903 			continue;
4904 		}
4905 
4906 		label->read_failed = B_FALSE;
4907 		label->cksum_valid = label_cksum_valid(&label->label,
4908 		    label->label_offset);
4909 
4910 		if (nvlist_unpack(buf, buflen, &config, 0) == 0) {
4911 			nvlist_t *vdev_tree = NULL;
4912 			size_t size;
4913 
4914 			if ((nvlist_lookup_nvlist(config,
4915 			    ZPOOL_CONFIG_VDEV_TREE, &vdev_tree) != 0) ||
4916 			    (nvlist_lookup_uint64(vdev_tree,
4917 			    ZPOOL_CONFIG_ASHIFT, &ashift) != 0))
4918 				ashift = SPA_MINBLOCKSHIFT;
4919 
4920 			if (nvlist_size(config, &size, NV_ENCODE_XDR) != 0)
4921 				size = buflen;
4922 
4923 			/* If the device is a cache device clear the header. */
4924 			if (!read_l2arc_header) {
4925 				if (nvlist_lookup_uint64(config,
4926 				    ZPOOL_CONFIG_POOL_STATE, &l2cache) == 0 &&
4927 				    l2cache == POOL_STATE_L2CACHE) {
4928 					read_l2arc_header = B_TRUE;
4929 				}
4930 			}
4931 
4932 			fletcher_4_native_varsize(buf, size, &cksum);
4933 			rec = cksum_record_insert(&config_tree, &cksum, l);
4934 
4935 			label->config = rec;
4936 			label->config_nv = config;
4937 			config_found = B_TRUE;
4938 		} else {
4939 			error = B_TRUE;
4940 		}
4941 
4942 		vd.vdev_ashift = ashift;
4943 		vd.vdev_top = &vd;
4944 
4945 		for (int i = 0; i < VDEV_UBERBLOCK_COUNT(&vd); i++) {
4946 			uint64_t uoff = VDEV_UBERBLOCK_OFFSET(&vd, i);
4947 			uberblock_t *ub = (void *)((char *)label + uoff);
4948 
4949 			if (uberblock_verify(ub))
4950 				continue;
4951 
4952 			fletcher_4_native_varsize(ub, sizeof (*ub), &cksum);
4953 			rec = cksum_record_insert(&uberblock_tree, &cksum, l);
4954 
4955 			label->uberblocks[i] = rec;
4956 		}
4957 	}
4958 
4959 	/*
4960 	 * Dump the label and uberblocks.
4961 	 */
4962 	for (int l = 0; l < VDEV_LABELS; l++) {
4963 		zdb_label_t *label = &labels[l];
4964 		size_t buflen = sizeof (label->label.vl_vdev_phys.vp_nvlist);
4965 
4966 		if (label->read_failed == B_TRUE)
4967 			continue;
4968 
4969 		if (label->config_nv) {
4970 			dump_config_from_label(label, buflen, l);
4971 		} else {
4972 			if (!dump_opt['q'])
4973 				(void) printf("failed to unpack label %d\n", l);
4974 		}
4975 
4976 		if (dump_opt['u'])
4977 			dump_label_uberblocks(label, ashift, l);
4978 
4979 		nvlist_free(label->config_nv);
4980 	}
4981 
4982 	/*
4983 	 * Dump the L2ARC header, if existent.
4984 	 */
4985 	if (read_l2arc_header)
4986 		error |= dump_l2arc_header(fd);
4987 
4988 	cookie = NULL;
4989 	while ((node = avl_destroy_nodes(&config_tree, &cookie)) != NULL)
4990 		umem_free(node, sizeof (cksum_record_t));
4991 
4992 	cookie = NULL;
4993 	while ((node = avl_destroy_nodes(&uberblock_tree, &cookie)) != NULL)
4994 		umem_free(node, sizeof (cksum_record_t));
4995 
4996 	avl_destroy(&config_tree);
4997 	avl_destroy(&uberblock_tree);
4998 
4999 	(void) close(fd);
5000 
5001 	return (config_found == B_FALSE ? 2 :
5002 	    (error == B_TRUE ? 1 : 0));
5003 }
5004 
5005 static uint64_t dataset_feature_count[SPA_FEATURES];
5006 static uint64_t global_feature_count[SPA_FEATURES];
5007 static uint64_t remap_deadlist_count = 0;
5008 
5009 static int
5010 dump_one_objset(const char *dsname, void *arg)
5011 {
5012 	(void) arg;
5013 	int error;
5014 	objset_t *os;
5015 	spa_feature_t f;
5016 
5017 	error = open_objset(dsname, FTAG, &os);
5018 	if (error != 0)
5019 		return (0);
5020 
5021 	for (f = 0; f < SPA_FEATURES; f++) {
5022 		if (!dsl_dataset_feature_is_active(dmu_objset_ds(os), f))
5023 			continue;
5024 		ASSERT(spa_feature_table[f].fi_flags &
5025 		    ZFEATURE_FLAG_PER_DATASET);
5026 		dataset_feature_count[f]++;
5027 	}
5028 
5029 	if (dsl_dataset_remap_deadlist_exists(dmu_objset_ds(os))) {
5030 		remap_deadlist_count++;
5031 	}
5032 
5033 	for (dsl_bookmark_node_t *dbn =
5034 	    avl_first(&dmu_objset_ds(os)->ds_bookmarks); dbn != NULL;
5035 	    dbn = AVL_NEXT(&dmu_objset_ds(os)->ds_bookmarks, dbn)) {
5036 		mos_obj_refd(dbn->dbn_phys.zbm_redaction_obj);
5037 		if (dbn->dbn_phys.zbm_redaction_obj != 0)
5038 			global_feature_count[SPA_FEATURE_REDACTION_BOOKMARKS]++;
5039 		if (dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN)
5040 			global_feature_count[SPA_FEATURE_BOOKMARK_WRITTEN]++;
5041 	}
5042 
5043 	if (dsl_deadlist_is_open(&dmu_objset_ds(os)->ds_dir->dd_livelist) &&
5044 	    !dmu_objset_is_snapshot(os)) {
5045 		global_feature_count[SPA_FEATURE_LIVELIST]++;
5046 	}
5047 
5048 	dump_objset(os);
5049 	close_objset(os, FTAG);
5050 	fuid_table_destroy();
5051 	return (0);
5052 }
5053 
5054 /*
5055  * Block statistics.
5056  */
5057 #define	PSIZE_HISTO_SIZE (SPA_OLD_MAXBLOCKSIZE / SPA_MINBLOCKSIZE + 2)
5058 typedef struct zdb_blkstats {
5059 	uint64_t zb_asize;
5060 	uint64_t zb_lsize;
5061 	uint64_t zb_psize;
5062 	uint64_t zb_count;
5063 	uint64_t zb_gangs;
5064 	uint64_t zb_ditto_samevdev;
5065 	uint64_t zb_ditto_same_ms;
5066 	uint64_t zb_psize_histogram[PSIZE_HISTO_SIZE];
5067 } zdb_blkstats_t;
5068 
5069 /*
5070  * Extended object types to report deferred frees and dedup auto-ditto blocks.
5071  */
5072 #define	ZDB_OT_DEFERRED	(DMU_OT_NUMTYPES + 0)
5073 #define	ZDB_OT_DITTO	(DMU_OT_NUMTYPES + 1)
5074 #define	ZDB_OT_OTHER	(DMU_OT_NUMTYPES + 2)
5075 #define	ZDB_OT_TOTAL	(DMU_OT_NUMTYPES + 3)
5076 
5077 static const char *zdb_ot_extname[] = {
5078 	"deferred free",
5079 	"dedup ditto",
5080 	"other",
5081 	"Total",
5082 };
5083 
5084 #define	ZB_TOTAL	DN_MAX_LEVELS
5085 #define	SPA_MAX_FOR_16M	(SPA_MAXBLOCKSHIFT+1)
5086 
5087 typedef struct zdb_cb {
5088 	zdb_blkstats_t	zcb_type[ZB_TOTAL + 1][ZDB_OT_TOTAL + 1];
5089 	uint64_t	zcb_removing_size;
5090 	uint64_t	zcb_checkpoint_size;
5091 	uint64_t	zcb_dedup_asize;
5092 	uint64_t	zcb_dedup_blocks;
5093 	uint64_t	zcb_psize_count[SPA_MAX_FOR_16M];
5094 	uint64_t	zcb_lsize_count[SPA_MAX_FOR_16M];
5095 	uint64_t	zcb_asize_count[SPA_MAX_FOR_16M];
5096 	uint64_t	zcb_psize_len[SPA_MAX_FOR_16M];
5097 	uint64_t	zcb_lsize_len[SPA_MAX_FOR_16M];
5098 	uint64_t	zcb_asize_len[SPA_MAX_FOR_16M];
5099 	uint64_t	zcb_psize_total;
5100 	uint64_t	zcb_lsize_total;
5101 	uint64_t	zcb_asize_total;
5102 	uint64_t	zcb_embedded_blocks[NUM_BP_EMBEDDED_TYPES];
5103 	uint64_t	zcb_embedded_histogram[NUM_BP_EMBEDDED_TYPES]
5104 	    [BPE_PAYLOAD_SIZE + 1];
5105 	uint64_t	zcb_start;
5106 	hrtime_t	zcb_lastprint;
5107 	uint64_t	zcb_totalasize;
5108 	uint64_t	zcb_errors[256];
5109 	int		zcb_readfails;
5110 	int		zcb_haderrors;
5111 	spa_t		*zcb_spa;
5112 	uint32_t	**zcb_vd_obsolete_counts;
5113 } zdb_cb_t;
5114 
5115 /* test if two DVA offsets from same vdev are within the same metaslab */
5116 static boolean_t
5117 same_metaslab(spa_t *spa, uint64_t vdev, uint64_t off1, uint64_t off2)
5118 {
5119 	vdev_t *vd = vdev_lookup_top(spa, vdev);
5120 	uint64_t ms_shift = vd->vdev_ms_shift;
5121 
5122 	return ((off1 >> ms_shift) == (off2 >> ms_shift));
5123 }
5124 
5125 /*
5126  * Used to simplify reporting of the histogram data.
5127  */
5128 typedef struct one_histo {
5129 	char *name;
5130 	uint64_t *count;
5131 	uint64_t *len;
5132 	uint64_t cumulative;
5133 } one_histo_t;
5134 
5135 /*
5136  * The number of separate histograms processed for psize, lsize and asize.
5137  */
5138 #define	NUM_HISTO 3
5139 
5140 /*
5141  * This routine will create a fixed column size output of three different
5142  * histograms showing by blocksize of 512 - 2^ SPA_MAX_FOR_16M
5143  * the count, length and cumulative length of the psize, lsize and
5144  * asize blocks.
5145  *
5146  * All three types of blocks are listed on a single line
5147  *
5148  * By default the table is printed in nicenumber format (e.g. 123K) but
5149  * if the '-P' parameter is specified then the full raw number (parseable)
5150  * is printed out.
5151  */
5152 static void
5153 dump_size_histograms(zdb_cb_t *zcb)
5154 {
5155 	/*
5156 	 * A temporary buffer that allows us to convert a number into
5157 	 * a string using zdb_nicenumber to allow either raw or human
5158 	 * readable numbers to be output.
5159 	 */
5160 	char numbuf[32];
5161 
5162 	/*
5163 	 * Define titles which are used in the headers of the tables
5164 	 * printed by this routine.
5165 	 */
5166 	const char blocksize_title1[] = "block";
5167 	const char blocksize_title2[] = "size";
5168 	const char count_title[] = "Count";
5169 	const char length_title[] = "Size";
5170 	const char cumulative_title[] = "Cum.";
5171 
5172 	/*
5173 	 * Setup the histogram arrays (psize, lsize, and asize).
5174 	 */
5175 	one_histo_t parm_histo[NUM_HISTO];
5176 
5177 	parm_histo[0].name = "psize";
5178 	parm_histo[0].count = zcb->zcb_psize_count;
5179 	parm_histo[0].len = zcb->zcb_psize_len;
5180 	parm_histo[0].cumulative = 0;
5181 
5182 	parm_histo[1].name = "lsize";
5183 	parm_histo[1].count = zcb->zcb_lsize_count;
5184 	parm_histo[1].len = zcb->zcb_lsize_len;
5185 	parm_histo[1].cumulative = 0;
5186 
5187 	parm_histo[2].name = "asize";
5188 	parm_histo[2].count = zcb->zcb_asize_count;
5189 	parm_histo[2].len = zcb->zcb_asize_len;
5190 	parm_histo[2].cumulative = 0;
5191 
5192 
5193 	(void) printf("\nBlock Size Histogram\n");
5194 	/*
5195 	 * Print the first line titles
5196 	 */
5197 	if (dump_opt['P'])
5198 		(void) printf("\n%s\t", blocksize_title1);
5199 	else
5200 		(void) printf("\n%7s   ", blocksize_title1);
5201 
5202 	for (int j = 0; j < NUM_HISTO; j++) {
5203 		if (dump_opt['P']) {
5204 			if (j < NUM_HISTO - 1) {
5205 				(void) printf("%s\t\t\t", parm_histo[j].name);
5206 			} else {
5207 				/* Don't print trailing spaces */
5208 				(void) printf("  %s", parm_histo[j].name);
5209 			}
5210 		} else {
5211 			if (j < NUM_HISTO - 1) {
5212 				/* Left aligned strings in the output */
5213 				(void) printf("%-7s              ",
5214 				    parm_histo[j].name);
5215 			} else {
5216 				/* Don't print trailing spaces */
5217 				(void) printf("%s", parm_histo[j].name);
5218 			}
5219 		}
5220 	}
5221 	(void) printf("\n");
5222 
5223 	/*
5224 	 * Print the second line titles
5225 	 */
5226 	if (dump_opt['P']) {
5227 		(void) printf("%s\t", blocksize_title2);
5228 	} else {
5229 		(void) printf("%7s ", blocksize_title2);
5230 	}
5231 
5232 	for (int i = 0; i < NUM_HISTO; i++) {
5233 		if (dump_opt['P']) {
5234 			(void) printf("%s\t%s\t%s\t",
5235 			    count_title, length_title, cumulative_title);
5236 		} else {
5237 			(void) printf("%7s%7s%7s",
5238 			    count_title, length_title, cumulative_title);
5239 		}
5240 	}
5241 	(void) printf("\n");
5242 
5243 	/*
5244 	 * Print the rows
5245 	 */
5246 	for (int i = SPA_MINBLOCKSHIFT; i < SPA_MAX_FOR_16M; i++) {
5247 
5248 		/*
5249 		 * Print the first column showing the blocksize
5250 		 */
5251 		zdb_nicenum((1ULL << i), numbuf, sizeof (numbuf));
5252 
5253 		if (dump_opt['P']) {
5254 			printf("%s", numbuf);
5255 		} else {
5256 			printf("%7s:", numbuf);
5257 		}
5258 
5259 		/*
5260 		 * Print the remaining set of 3 columns per size:
5261 		 * for psize, lsize and asize
5262 		 */
5263 		for (int j = 0; j < NUM_HISTO; j++) {
5264 			parm_histo[j].cumulative += parm_histo[j].len[i];
5265 
5266 			zdb_nicenum(parm_histo[j].count[i],
5267 			    numbuf, sizeof (numbuf));
5268 			if (dump_opt['P'])
5269 				(void) printf("\t%s", numbuf);
5270 			else
5271 				(void) printf("%7s", numbuf);
5272 
5273 			zdb_nicenum(parm_histo[j].len[i],
5274 			    numbuf, sizeof (numbuf));
5275 			if (dump_opt['P'])
5276 				(void) printf("\t%s", numbuf);
5277 			else
5278 				(void) printf("%7s", numbuf);
5279 
5280 			zdb_nicenum(parm_histo[j].cumulative,
5281 			    numbuf, sizeof (numbuf));
5282 			if (dump_opt['P'])
5283 				(void) printf("\t%s", numbuf);
5284 			else
5285 				(void) printf("%7s", numbuf);
5286 		}
5287 		(void) printf("\n");
5288 	}
5289 }
5290 
5291 static void
5292 zdb_count_block(zdb_cb_t *zcb, zilog_t *zilog, const blkptr_t *bp,
5293     dmu_object_type_t type)
5294 {
5295 	uint64_t refcnt = 0;
5296 	int i;
5297 
5298 	ASSERT(type < ZDB_OT_TOTAL);
5299 
5300 	if (zilog && zil_bp_tree_add(zilog, bp) != 0)
5301 		return;
5302 
5303 	spa_config_enter(zcb->zcb_spa, SCL_CONFIG, FTAG, RW_READER);
5304 
5305 	for (i = 0; i < 4; i++) {
5306 		int l = (i < 2) ? BP_GET_LEVEL(bp) : ZB_TOTAL;
5307 		int t = (i & 1) ? type : ZDB_OT_TOTAL;
5308 		int equal;
5309 		zdb_blkstats_t *zb = &zcb->zcb_type[l][t];
5310 
5311 		zb->zb_asize += BP_GET_ASIZE(bp);
5312 		zb->zb_lsize += BP_GET_LSIZE(bp);
5313 		zb->zb_psize += BP_GET_PSIZE(bp);
5314 		zb->zb_count++;
5315 
5316 		/*
5317 		 * The histogram is only big enough to record blocks up to
5318 		 * SPA_OLD_MAXBLOCKSIZE; larger blocks go into the last,
5319 		 * "other", bucket.
5320 		 */
5321 		unsigned idx = BP_GET_PSIZE(bp) >> SPA_MINBLOCKSHIFT;
5322 		idx = MIN(idx, SPA_OLD_MAXBLOCKSIZE / SPA_MINBLOCKSIZE + 1);
5323 		zb->zb_psize_histogram[idx]++;
5324 
5325 		zb->zb_gangs += BP_COUNT_GANG(bp);
5326 
5327 		switch (BP_GET_NDVAS(bp)) {
5328 		case 2:
5329 			if (DVA_GET_VDEV(&bp->blk_dva[0]) ==
5330 			    DVA_GET_VDEV(&bp->blk_dva[1])) {
5331 				zb->zb_ditto_samevdev++;
5332 
5333 				if (same_metaslab(zcb->zcb_spa,
5334 				    DVA_GET_VDEV(&bp->blk_dva[0]),
5335 				    DVA_GET_OFFSET(&bp->blk_dva[0]),
5336 				    DVA_GET_OFFSET(&bp->blk_dva[1])))
5337 					zb->zb_ditto_same_ms++;
5338 			}
5339 			break;
5340 		case 3:
5341 			equal = (DVA_GET_VDEV(&bp->blk_dva[0]) ==
5342 			    DVA_GET_VDEV(&bp->blk_dva[1])) +
5343 			    (DVA_GET_VDEV(&bp->blk_dva[0]) ==
5344 			    DVA_GET_VDEV(&bp->blk_dva[2])) +
5345 			    (DVA_GET_VDEV(&bp->blk_dva[1]) ==
5346 			    DVA_GET_VDEV(&bp->blk_dva[2]));
5347 			if (equal != 0) {
5348 				zb->zb_ditto_samevdev++;
5349 
5350 				if (DVA_GET_VDEV(&bp->blk_dva[0]) ==
5351 				    DVA_GET_VDEV(&bp->blk_dva[1]) &&
5352 				    same_metaslab(zcb->zcb_spa,
5353 				    DVA_GET_VDEV(&bp->blk_dva[0]),
5354 				    DVA_GET_OFFSET(&bp->blk_dva[0]),
5355 				    DVA_GET_OFFSET(&bp->blk_dva[1])))
5356 					zb->zb_ditto_same_ms++;
5357 				else if (DVA_GET_VDEV(&bp->blk_dva[0]) ==
5358 				    DVA_GET_VDEV(&bp->blk_dva[2]) &&
5359 				    same_metaslab(zcb->zcb_spa,
5360 				    DVA_GET_VDEV(&bp->blk_dva[0]),
5361 				    DVA_GET_OFFSET(&bp->blk_dva[0]),
5362 				    DVA_GET_OFFSET(&bp->blk_dva[2])))
5363 					zb->zb_ditto_same_ms++;
5364 				else if (DVA_GET_VDEV(&bp->blk_dva[1]) ==
5365 				    DVA_GET_VDEV(&bp->blk_dva[2]) &&
5366 				    same_metaslab(zcb->zcb_spa,
5367 				    DVA_GET_VDEV(&bp->blk_dva[1]),
5368 				    DVA_GET_OFFSET(&bp->blk_dva[1]),
5369 				    DVA_GET_OFFSET(&bp->blk_dva[2])))
5370 					zb->zb_ditto_same_ms++;
5371 			}
5372 			break;
5373 		}
5374 	}
5375 
5376 	spa_config_exit(zcb->zcb_spa, SCL_CONFIG, FTAG);
5377 
5378 	if (BP_IS_EMBEDDED(bp)) {
5379 		zcb->zcb_embedded_blocks[BPE_GET_ETYPE(bp)]++;
5380 		zcb->zcb_embedded_histogram[BPE_GET_ETYPE(bp)]
5381 		    [BPE_GET_PSIZE(bp)]++;
5382 		return;
5383 	}
5384 	/*
5385 	 * The binning histogram bins by powers of two up to
5386 	 * SPA_MAXBLOCKSIZE rather than creating bins for
5387 	 * every possible blocksize found in the pool.
5388 	 */
5389 	int bin = highbit64(BP_GET_PSIZE(bp)) - 1;
5390 
5391 	zcb->zcb_psize_count[bin]++;
5392 	zcb->zcb_psize_len[bin] += BP_GET_PSIZE(bp);
5393 	zcb->zcb_psize_total += BP_GET_PSIZE(bp);
5394 
5395 	bin = highbit64(BP_GET_LSIZE(bp)) - 1;
5396 
5397 	zcb->zcb_lsize_count[bin]++;
5398 	zcb->zcb_lsize_len[bin] += BP_GET_LSIZE(bp);
5399 	zcb->zcb_lsize_total += BP_GET_LSIZE(bp);
5400 
5401 	bin = highbit64(BP_GET_ASIZE(bp)) - 1;
5402 
5403 	zcb->zcb_asize_count[bin]++;
5404 	zcb->zcb_asize_len[bin] += BP_GET_ASIZE(bp);
5405 	zcb->zcb_asize_total += BP_GET_ASIZE(bp);
5406 
5407 	if (dump_opt['L'])
5408 		return;
5409 
5410 	if (BP_GET_DEDUP(bp)) {
5411 		ddt_t *ddt;
5412 		ddt_entry_t *dde;
5413 
5414 		ddt = ddt_select(zcb->zcb_spa, bp);
5415 		ddt_enter(ddt);
5416 		dde = ddt_lookup(ddt, bp, B_FALSE);
5417 
5418 		if (dde == NULL) {
5419 			refcnt = 0;
5420 		} else {
5421 			ddt_phys_t *ddp = ddt_phys_select(dde, bp);
5422 			ddt_phys_decref(ddp);
5423 			refcnt = ddp->ddp_refcnt;
5424 			if (ddt_phys_total_refcnt(dde) == 0)
5425 				ddt_remove(ddt, dde);
5426 		}
5427 		ddt_exit(ddt);
5428 	}
5429 
5430 	VERIFY3U(zio_wait(zio_claim(NULL, zcb->zcb_spa,
5431 	    refcnt ? 0 : spa_min_claim_txg(zcb->zcb_spa),
5432 	    bp, NULL, NULL, ZIO_FLAG_CANFAIL)), ==, 0);
5433 }
5434 
5435 static void
5436 zdb_blkptr_done(zio_t *zio)
5437 {
5438 	spa_t *spa = zio->io_spa;
5439 	blkptr_t *bp = zio->io_bp;
5440 	int ioerr = zio->io_error;
5441 	zdb_cb_t *zcb = zio->io_private;
5442 	zbookmark_phys_t *zb = &zio->io_bookmark;
5443 
5444 	mutex_enter(&spa->spa_scrub_lock);
5445 	spa->spa_load_verify_bytes -= BP_GET_PSIZE(bp);
5446 	cv_broadcast(&spa->spa_scrub_io_cv);
5447 
5448 	if (ioerr && !(zio->io_flags & ZIO_FLAG_SPECULATIVE)) {
5449 		char blkbuf[BP_SPRINTF_LEN];
5450 
5451 		zcb->zcb_haderrors = 1;
5452 		zcb->zcb_errors[ioerr]++;
5453 
5454 		if (dump_opt['b'] >= 2)
5455 			snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
5456 		else
5457 			blkbuf[0] = '\0';
5458 
5459 		(void) printf("zdb_blkptr_cb: "
5460 		    "Got error %d reading "
5461 		    "<%llu, %llu, %lld, %llx> %s -- skipping\n",
5462 		    ioerr,
5463 		    (u_longlong_t)zb->zb_objset,
5464 		    (u_longlong_t)zb->zb_object,
5465 		    (u_longlong_t)zb->zb_level,
5466 		    (u_longlong_t)zb->zb_blkid,
5467 		    blkbuf);
5468 	}
5469 	mutex_exit(&spa->spa_scrub_lock);
5470 
5471 	abd_free(zio->io_abd);
5472 }
5473 
5474 static int
5475 zdb_blkptr_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
5476     const zbookmark_phys_t *zb, const dnode_phys_t *dnp, void *arg)
5477 {
5478 	zdb_cb_t *zcb = arg;
5479 	dmu_object_type_t type;
5480 	boolean_t is_metadata;
5481 
5482 	if (zb->zb_level == ZB_DNODE_LEVEL)
5483 		return (0);
5484 
5485 	if (dump_opt['b'] >= 5 && bp->blk_birth > 0) {
5486 		char blkbuf[BP_SPRINTF_LEN];
5487 		snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
5488 		(void) printf("objset %llu object %llu "
5489 		    "level %lld offset 0x%llx %s\n",
5490 		    (u_longlong_t)zb->zb_objset,
5491 		    (u_longlong_t)zb->zb_object,
5492 		    (longlong_t)zb->zb_level,
5493 		    (u_longlong_t)blkid2offset(dnp, bp, zb),
5494 		    blkbuf);
5495 	}
5496 
5497 	if (BP_IS_HOLE(bp) || BP_IS_REDACTED(bp))
5498 		return (0);
5499 
5500 	type = BP_GET_TYPE(bp);
5501 
5502 	zdb_count_block(zcb, zilog, bp,
5503 	    (type & DMU_OT_NEWTYPE) ? ZDB_OT_OTHER : type);
5504 
5505 	is_metadata = (BP_GET_LEVEL(bp) != 0 || DMU_OT_IS_METADATA(type));
5506 
5507 	if (!BP_IS_EMBEDDED(bp) &&
5508 	    (dump_opt['c'] > 1 || (dump_opt['c'] && is_metadata))) {
5509 		size_t size = BP_GET_PSIZE(bp);
5510 		abd_t *abd = abd_alloc(size, B_FALSE);
5511 		int flags = ZIO_FLAG_CANFAIL | ZIO_FLAG_SCRUB | ZIO_FLAG_RAW;
5512 
5513 		/* If it's an intent log block, failure is expected. */
5514 		if (zb->zb_level == ZB_ZIL_LEVEL)
5515 			flags |= ZIO_FLAG_SPECULATIVE;
5516 
5517 		mutex_enter(&spa->spa_scrub_lock);
5518 		while (spa->spa_load_verify_bytes > max_inflight_bytes)
5519 			cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock);
5520 		spa->spa_load_verify_bytes += size;
5521 		mutex_exit(&spa->spa_scrub_lock);
5522 
5523 		zio_nowait(zio_read(NULL, spa, bp, abd, size,
5524 		    zdb_blkptr_done, zcb, ZIO_PRIORITY_ASYNC_READ, flags, zb));
5525 	}
5526 
5527 	zcb->zcb_readfails = 0;
5528 
5529 	/* only call gethrtime() every 100 blocks */
5530 	static int iters;
5531 	if (++iters > 100)
5532 		iters = 0;
5533 	else
5534 		return (0);
5535 
5536 	if (dump_opt['b'] < 5 && gethrtime() > zcb->zcb_lastprint + NANOSEC) {
5537 		uint64_t now = gethrtime();
5538 		char buf[10];
5539 		uint64_t bytes = zcb->zcb_type[ZB_TOTAL][ZDB_OT_TOTAL].zb_asize;
5540 		uint64_t kb_per_sec =
5541 		    1 + bytes / (1 + ((now - zcb->zcb_start) / 1000 / 1000));
5542 		uint64_t sec_remaining =
5543 		    (zcb->zcb_totalasize - bytes) / 1024 / kb_per_sec;
5544 
5545 		/* make sure nicenum has enough space */
5546 		_Static_assert(sizeof (buf) >= NN_NUMBUF_SZ, "buf truncated");
5547 
5548 		zfs_nicebytes(bytes, buf, sizeof (buf));
5549 		(void) fprintf(stderr,
5550 		    "\r%5s completed (%4"PRIu64"MB/s) "
5551 		    "estimated time remaining: "
5552 		    "%"PRIu64"hr %02"PRIu64"min %02"PRIu64"sec        ",
5553 		    buf, kb_per_sec / 1024,
5554 		    sec_remaining / 60 / 60,
5555 		    sec_remaining / 60 % 60,
5556 		    sec_remaining % 60);
5557 
5558 		zcb->zcb_lastprint = now;
5559 	}
5560 
5561 	return (0);
5562 }
5563 
5564 static void
5565 zdb_leak(void *arg, uint64_t start, uint64_t size)
5566 {
5567 	vdev_t *vd = arg;
5568 
5569 	(void) printf("leaked space: vdev %llu, offset 0x%llx, size %llu\n",
5570 	    (u_longlong_t)vd->vdev_id, (u_longlong_t)start, (u_longlong_t)size);
5571 }
5572 
5573 static metaslab_ops_t zdb_metaslab_ops = {
5574 	NULL	/* alloc */
5575 };
5576 
5577 static int
5578 load_unflushed_svr_segs_cb(spa_t *spa, space_map_entry_t *sme,
5579     uint64_t txg, void *arg)
5580 {
5581 	spa_vdev_removal_t *svr = arg;
5582 
5583 	uint64_t offset = sme->sme_offset;
5584 	uint64_t size = sme->sme_run;
5585 
5586 	/* skip vdevs we don't care about */
5587 	if (sme->sme_vdev != svr->svr_vdev_id)
5588 		return (0);
5589 
5590 	vdev_t *vd = vdev_lookup_top(spa, sme->sme_vdev);
5591 	metaslab_t *ms = vd->vdev_ms[offset >> vd->vdev_ms_shift];
5592 	ASSERT(sme->sme_type == SM_ALLOC || sme->sme_type == SM_FREE);
5593 
5594 	if (txg < metaslab_unflushed_txg(ms))
5595 		return (0);
5596 
5597 	if (sme->sme_type == SM_ALLOC)
5598 		range_tree_add(svr->svr_allocd_segs, offset, size);
5599 	else
5600 		range_tree_remove(svr->svr_allocd_segs, offset, size);
5601 
5602 	return (0);
5603 }
5604 
5605 static void
5606 claim_segment_impl_cb(uint64_t inner_offset, vdev_t *vd, uint64_t offset,
5607     uint64_t size, void *arg)
5608 {
5609 	(void) inner_offset, (void) arg;
5610 
5611 	/*
5612 	 * This callback was called through a remap from
5613 	 * a device being removed. Therefore, the vdev that
5614 	 * this callback is applied to is a concrete
5615 	 * vdev.
5616 	 */
5617 	ASSERT(vdev_is_concrete(vd));
5618 
5619 	VERIFY0(metaslab_claim_impl(vd, offset, size,
5620 	    spa_min_claim_txg(vd->vdev_spa)));
5621 }
5622 
5623 static void
5624 claim_segment_cb(void *arg, uint64_t offset, uint64_t size)
5625 {
5626 	vdev_t *vd = arg;
5627 
5628 	vdev_indirect_ops.vdev_op_remap(vd, offset, size,
5629 	    claim_segment_impl_cb, NULL);
5630 }
5631 
5632 /*
5633  * After accounting for all allocated blocks that are directly referenced,
5634  * we might have missed a reference to a block from a partially complete
5635  * (and thus unused) indirect mapping object. We perform a secondary pass
5636  * through the metaslabs we have already mapped and claim the destination
5637  * blocks.
5638  */
5639 static void
5640 zdb_claim_removing(spa_t *spa, zdb_cb_t *zcb)
5641 {
5642 	if (dump_opt['L'])
5643 		return;
5644 
5645 	if (spa->spa_vdev_removal == NULL)
5646 		return;
5647 
5648 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
5649 
5650 	spa_vdev_removal_t *svr = spa->spa_vdev_removal;
5651 	vdev_t *vd = vdev_lookup_top(spa, svr->svr_vdev_id);
5652 	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
5653 
5654 	ASSERT0(range_tree_space(svr->svr_allocd_segs));
5655 
5656 	range_tree_t *allocs = range_tree_create(NULL, RANGE_SEG64, NULL, 0, 0);
5657 	for (uint64_t msi = 0; msi < vd->vdev_ms_count; msi++) {
5658 		metaslab_t *msp = vd->vdev_ms[msi];
5659 
5660 		ASSERT0(range_tree_space(allocs));
5661 		if (msp->ms_sm != NULL)
5662 			VERIFY0(space_map_load(msp->ms_sm, allocs, SM_ALLOC));
5663 		range_tree_vacate(allocs, range_tree_add, svr->svr_allocd_segs);
5664 	}
5665 	range_tree_destroy(allocs);
5666 
5667 	iterate_through_spacemap_logs(spa, load_unflushed_svr_segs_cb, svr);
5668 
5669 	/*
5670 	 * Clear everything past what has been synced,
5671 	 * because we have not allocated mappings for
5672 	 * it yet.
5673 	 */
5674 	range_tree_clear(svr->svr_allocd_segs,
5675 	    vdev_indirect_mapping_max_offset(vim),
5676 	    vd->vdev_asize - vdev_indirect_mapping_max_offset(vim));
5677 
5678 	zcb->zcb_removing_size += range_tree_space(svr->svr_allocd_segs);
5679 	range_tree_vacate(svr->svr_allocd_segs, claim_segment_cb, vd);
5680 
5681 	spa_config_exit(spa, SCL_CONFIG, FTAG);
5682 }
5683 
5684 static int
5685 increment_indirect_mapping_cb(void *arg, const blkptr_t *bp, boolean_t bp_freed,
5686     dmu_tx_t *tx)
5687 {
5688 	(void) tx;
5689 	zdb_cb_t *zcb = arg;
5690 	spa_t *spa = zcb->zcb_spa;
5691 	vdev_t *vd;
5692 	const dva_t *dva = &bp->blk_dva[0];
5693 
5694 	ASSERT(!bp_freed);
5695 	ASSERT(!dump_opt['L']);
5696 	ASSERT3U(BP_GET_NDVAS(bp), ==, 1);
5697 
5698 	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
5699 	vd = vdev_lookup_top(zcb->zcb_spa, DVA_GET_VDEV(dva));
5700 	ASSERT3P(vd, !=, NULL);
5701 	spa_config_exit(spa, SCL_VDEV, FTAG);
5702 
5703 	ASSERT(vd->vdev_indirect_config.vic_mapping_object != 0);
5704 	ASSERT3P(zcb->zcb_vd_obsolete_counts[vd->vdev_id], !=, NULL);
5705 
5706 	vdev_indirect_mapping_increment_obsolete_count(
5707 	    vd->vdev_indirect_mapping,
5708 	    DVA_GET_OFFSET(dva), DVA_GET_ASIZE(dva),
5709 	    zcb->zcb_vd_obsolete_counts[vd->vdev_id]);
5710 
5711 	return (0);
5712 }
5713 
5714 static uint32_t *
5715 zdb_load_obsolete_counts(vdev_t *vd)
5716 {
5717 	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
5718 	spa_t *spa = vd->vdev_spa;
5719 	spa_condensing_indirect_phys_t *scip =
5720 	    &spa->spa_condensing_indirect_phys;
5721 	uint64_t obsolete_sm_object;
5722 	uint32_t *counts;
5723 
5724 	VERIFY0(vdev_obsolete_sm_object(vd, &obsolete_sm_object));
5725 	EQUIV(obsolete_sm_object != 0, vd->vdev_obsolete_sm != NULL);
5726 	counts = vdev_indirect_mapping_load_obsolete_counts(vim);
5727 	if (vd->vdev_obsolete_sm != NULL) {
5728 		vdev_indirect_mapping_load_obsolete_spacemap(vim, counts,
5729 		    vd->vdev_obsolete_sm);
5730 	}
5731 	if (scip->scip_vdev == vd->vdev_id &&
5732 	    scip->scip_prev_obsolete_sm_object != 0) {
5733 		space_map_t *prev_obsolete_sm = NULL;
5734 		VERIFY0(space_map_open(&prev_obsolete_sm, spa->spa_meta_objset,
5735 		    scip->scip_prev_obsolete_sm_object, 0, vd->vdev_asize, 0));
5736 		vdev_indirect_mapping_load_obsolete_spacemap(vim, counts,
5737 		    prev_obsolete_sm);
5738 		space_map_close(prev_obsolete_sm);
5739 	}
5740 	return (counts);
5741 }
5742 
5743 static void
5744 zdb_ddt_leak_init(spa_t *spa, zdb_cb_t *zcb)
5745 {
5746 	ddt_bookmark_t ddb = {0};
5747 	ddt_entry_t dde;
5748 	int error;
5749 	int p;
5750 
5751 	ASSERT(!dump_opt['L']);
5752 
5753 	while ((error = ddt_walk(spa, &ddb, &dde)) == 0) {
5754 		blkptr_t blk;
5755 		ddt_phys_t *ddp = dde.dde_phys;
5756 
5757 		if (ddb.ddb_class == DDT_CLASS_UNIQUE)
5758 			return;
5759 
5760 		ASSERT(ddt_phys_total_refcnt(&dde) > 1);
5761 
5762 		for (p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
5763 			if (ddp->ddp_phys_birth == 0)
5764 				continue;
5765 			ddt_bp_create(ddb.ddb_checksum,
5766 			    &dde.dde_key, ddp, &blk);
5767 			if (p == DDT_PHYS_DITTO) {
5768 				zdb_count_block(zcb, NULL, &blk, ZDB_OT_DITTO);
5769 			} else {
5770 				zcb->zcb_dedup_asize +=
5771 				    BP_GET_ASIZE(&blk) * (ddp->ddp_refcnt - 1);
5772 				zcb->zcb_dedup_blocks++;
5773 			}
5774 		}
5775 		ddt_t *ddt = spa->spa_ddt[ddb.ddb_checksum];
5776 		ddt_enter(ddt);
5777 		VERIFY(ddt_lookup(ddt, &blk, B_TRUE) != NULL);
5778 		ddt_exit(ddt);
5779 	}
5780 
5781 	ASSERT(error == ENOENT);
5782 }
5783 
5784 typedef struct checkpoint_sm_exclude_entry_arg {
5785 	vdev_t *cseea_vd;
5786 	uint64_t cseea_checkpoint_size;
5787 } checkpoint_sm_exclude_entry_arg_t;
5788 
5789 static int
5790 checkpoint_sm_exclude_entry_cb(space_map_entry_t *sme, void *arg)
5791 {
5792 	checkpoint_sm_exclude_entry_arg_t *cseea = arg;
5793 	vdev_t *vd = cseea->cseea_vd;
5794 	metaslab_t *ms = vd->vdev_ms[sme->sme_offset >> vd->vdev_ms_shift];
5795 	uint64_t end = sme->sme_offset + sme->sme_run;
5796 
5797 	ASSERT(sme->sme_type == SM_FREE);
5798 
5799 	/*
5800 	 * Since the vdev_checkpoint_sm exists in the vdev level
5801 	 * and the ms_sm space maps exist in the metaslab level,
5802 	 * an entry in the checkpoint space map could theoretically
5803 	 * cross the boundaries of the metaslab that it belongs.
5804 	 *
5805 	 * In reality, because of the way that we populate and
5806 	 * manipulate the checkpoint's space maps currently,
5807 	 * there shouldn't be any entries that cross metaslabs.
5808 	 * Hence the assertion below.
5809 	 *
5810 	 * That said, there is no fundamental requirement that
5811 	 * the checkpoint's space map entries should not cross
5812 	 * metaslab boundaries. So if needed we could add code
5813 	 * that handles metaslab-crossing segments in the future.
5814 	 */
5815 	VERIFY3U(sme->sme_offset, >=, ms->ms_start);
5816 	VERIFY3U(end, <=, ms->ms_start + ms->ms_size);
5817 
5818 	/*
5819 	 * By removing the entry from the allocated segments we
5820 	 * also verify that the entry is there to begin with.
5821 	 */
5822 	mutex_enter(&ms->ms_lock);
5823 	range_tree_remove(ms->ms_allocatable, sme->sme_offset, sme->sme_run);
5824 	mutex_exit(&ms->ms_lock);
5825 
5826 	cseea->cseea_checkpoint_size += sme->sme_run;
5827 	return (0);
5828 }
5829 
5830 static void
5831 zdb_leak_init_vdev_exclude_checkpoint(vdev_t *vd, zdb_cb_t *zcb)
5832 {
5833 	spa_t *spa = vd->vdev_spa;
5834 	space_map_t *checkpoint_sm = NULL;
5835 	uint64_t checkpoint_sm_obj;
5836 
5837 	/*
5838 	 * If there is no vdev_top_zap, we are in a pool whose
5839 	 * version predates the pool checkpoint feature.
5840 	 */
5841 	if (vd->vdev_top_zap == 0)
5842 		return;
5843 
5844 	/*
5845 	 * If there is no reference of the vdev_checkpoint_sm in
5846 	 * the vdev_top_zap, then one of the following scenarios
5847 	 * is true:
5848 	 *
5849 	 * 1] There is no checkpoint
5850 	 * 2] There is a checkpoint, but no checkpointed blocks
5851 	 *    have been freed yet
5852 	 * 3] The current vdev is indirect
5853 	 *
5854 	 * In these cases we return immediately.
5855 	 */
5856 	if (zap_contains(spa_meta_objset(spa), vd->vdev_top_zap,
5857 	    VDEV_TOP_ZAP_POOL_CHECKPOINT_SM) != 0)
5858 		return;
5859 
5860 	VERIFY0(zap_lookup(spa_meta_objset(spa), vd->vdev_top_zap,
5861 	    VDEV_TOP_ZAP_POOL_CHECKPOINT_SM, sizeof (uint64_t), 1,
5862 	    &checkpoint_sm_obj));
5863 
5864 	checkpoint_sm_exclude_entry_arg_t cseea;
5865 	cseea.cseea_vd = vd;
5866 	cseea.cseea_checkpoint_size = 0;
5867 
5868 	VERIFY0(space_map_open(&checkpoint_sm, spa_meta_objset(spa),
5869 	    checkpoint_sm_obj, 0, vd->vdev_asize, vd->vdev_ashift));
5870 
5871 	VERIFY0(space_map_iterate(checkpoint_sm,
5872 	    space_map_length(checkpoint_sm),
5873 	    checkpoint_sm_exclude_entry_cb, &cseea));
5874 	space_map_close(checkpoint_sm);
5875 
5876 	zcb->zcb_checkpoint_size += cseea.cseea_checkpoint_size;
5877 }
5878 
5879 static void
5880 zdb_leak_init_exclude_checkpoint(spa_t *spa, zdb_cb_t *zcb)
5881 {
5882 	ASSERT(!dump_opt['L']);
5883 
5884 	vdev_t *rvd = spa->spa_root_vdev;
5885 	for (uint64_t c = 0; c < rvd->vdev_children; c++) {
5886 		ASSERT3U(c, ==, rvd->vdev_child[c]->vdev_id);
5887 		zdb_leak_init_vdev_exclude_checkpoint(rvd->vdev_child[c], zcb);
5888 	}
5889 }
5890 
5891 static int
5892 count_unflushed_space_cb(spa_t *spa, space_map_entry_t *sme,
5893     uint64_t txg, void *arg)
5894 {
5895 	int64_t *ualloc_space = arg;
5896 
5897 	uint64_t offset = sme->sme_offset;
5898 	uint64_t vdev_id = sme->sme_vdev;
5899 
5900 	vdev_t *vd = vdev_lookup_top(spa, vdev_id);
5901 	if (!vdev_is_concrete(vd))
5902 		return (0);
5903 
5904 	metaslab_t *ms = vd->vdev_ms[offset >> vd->vdev_ms_shift];
5905 	ASSERT(sme->sme_type == SM_ALLOC || sme->sme_type == SM_FREE);
5906 
5907 	if (txg < metaslab_unflushed_txg(ms))
5908 		return (0);
5909 
5910 	if (sme->sme_type == SM_ALLOC)
5911 		*ualloc_space += sme->sme_run;
5912 	else
5913 		*ualloc_space -= sme->sme_run;
5914 
5915 	return (0);
5916 }
5917 
5918 static int64_t
5919 get_unflushed_alloc_space(spa_t *spa)
5920 {
5921 	if (dump_opt['L'])
5922 		return (0);
5923 
5924 	int64_t ualloc_space = 0;
5925 	iterate_through_spacemap_logs(spa, count_unflushed_space_cb,
5926 	    &ualloc_space);
5927 	return (ualloc_space);
5928 }
5929 
5930 static int
5931 load_unflushed_cb(spa_t *spa, space_map_entry_t *sme, uint64_t txg, void *arg)
5932 {
5933 	maptype_t *uic_maptype = arg;
5934 
5935 	uint64_t offset = sme->sme_offset;
5936 	uint64_t size = sme->sme_run;
5937 	uint64_t vdev_id = sme->sme_vdev;
5938 
5939 	vdev_t *vd = vdev_lookup_top(spa, vdev_id);
5940 
5941 	/* skip indirect vdevs */
5942 	if (!vdev_is_concrete(vd))
5943 		return (0);
5944 
5945 	metaslab_t *ms = vd->vdev_ms[offset >> vd->vdev_ms_shift];
5946 
5947 	ASSERT(sme->sme_type == SM_ALLOC || sme->sme_type == SM_FREE);
5948 	ASSERT(*uic_maptype == SM_ALLOC || *uic_maptype == SM_FREE);
5949 
5950 	if (txg < metaslab_unflushed_txg(ms))
5951 		return (0);
5952 
5953 	if (*uic_maptype == sme->sme_type)
5954 		range_tree_add(ms->ms_allocatable, offset, size);
5955 	else
5956 		range_tree_remove(ms->ms_allocatable, offset, size);
5957 
5958 	return (0);
5959 }
5960 
5961 static void
5962 load_unflushed_to_ms_allocatables(spa_t *spa, maptype_t maptype)
5963 {
5964 	iterate_through_spacemap_logs(spa, load_unflushed_cb, &maptype);
5965 }
5966 
5967 static void
5968 load_concrete_ms_allocatable_trees(spa_t *spa, maptype_t maptype)
5969 {
5970 	vdev_t *rvd = spa->spa_root_vdev;
5971 	for (uint64_t i = 0; i < rvd->vdev_children; i++) {
5972 		vdev_t *vd = rvd->vdev_child[i];
5973 
5974 		ASSERT3U(i, ==, vd->vdev_id);
5975 
5976 		if (vd->vdev_ops == &vdev_indirect_ops)
5977 			continue;
5978 
5979 		for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
5980 			metaslab_t *msp = vd->vdev_ms[m];
5981 
5982 			(void) fprintf(stderr,
5983 			    "\rloading concrete vdev %llu, "
5984 			    "metaslab %llu of %llu ...",
5985 			    (longlong_t)vd->vdev_id,
5986 			    (longlong_t)msp->ms_id,
5987 			    (longlong_t)vd->vdev_ms_count);
5988 
5989 			mutex_enter(&msp->ms_lock);
5990 			range_tree_vacate(msp->ms_allocatable, NULL, NULL);
5991 
5992 			/*
5993 			 * We don't want to spend the CPU manipulating the
5994 			 * size-ordered tree, so clear the range_tree ops.
5995 			 */
5996 			msp->ms_allocatable->rt_ops = NULL;
5997 
5998 			if (msp->ms_sm != NULL) {
5999 				VERIFY0(space_map_load(msp->ms_sm,
6000 				    msp->ms_allocatable, maptype));
6001 			}
6002 			if (!msp->ms_loaded)
6003 				msp->ms_loaded = B_TRUE;
6004 			mutex_exit(&msp->ms_lock);
6005 		}
6006 	}
6007 
6008 	load_unflushed_to_ms_allocatables(spa, maptype);
6009 }
6010 
6011 /*
6012  * vm_idxp is an in-out parameter which (for indirect vdevs) is the
6013  * index in vim_entries that has the first entry in this metaslab.
6014  * On return, it will be set to the first entry after this metaslab.
6015  */
6016 static void
6017 load_indirect_ms_allocatable_tree(vdev_t *vd, metaslab_t *msp,
6018     uint64_t *vim_idxp)
6019 {
6020 	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
6021 
6022 	mutex_enter(&msp->ms_lock);
6023 	range_tree_vacate(msp->ms_allocatable, NULL, NULL);
6024 
6025 	/*
6026 	 * We don't want to spend the CPU manipulating the
6027 	 * size-ordered tree, so clear the range_tree ops.
6028 	 */
6029 	msp->ms_allocatable->rt_ops = NULL;
6030 
6031 	for (; *vim_idxp < vdev_indirect_mapping_num_entries(vim);
6032 	    (*vim_idxp)++) {
6033 		vdev_indirect_mapping_entry_phys_t *vimep =
6034 		    &vim->vim_entries[*vim_idxp];
6035 		uint64_t ent_offset = DVA_MAPPING_GET_SRC_OFFSET(vimep);
6036 		uint64_t ent_len = DVA_GET_ASIZE(&vimep->vimep_dst);
6037 		ASSERT3U(ent_offset, >=, msp->ms_start);
6038 		if (ent_offset >= msp->ms_start + msp->ms_size)
6039 			break;
6040 
6041 		/*
6042 		 * Mappings do not cross metaslab boundaries,
6043 		 * because we create them by walking the metaslabs.
6044 		 */
6045 		ASSERT3U(ent_offset + ent_len, <=,
6046 		    msp->ms_start + msp->ms_size);
6047 		range_tree_add(msp->ms_allocatable, ent_offset, ent_len);
6048 	}
6049 
6050 	if (!msp->ms_loaded)
6051 		msp->ms_loaded = B_TRUE;
6052 	mutex_exit(&msp->ms_lock);
6053 }
6054 
6055 static void
6056 zdb_leak_init_prepare_indirect_vdevs(spa_t *spa, zdb_cb_t *zcb)
6057 {
6058 	ASSERT(!dump_opt['L']);
6059 
6060 	vdev_t *rvd = spa->spa_root_vdev;
6061 	for (uint64_t c = 0; c < rvd->vdev_children; c++) {
6062 		vdev_t *vd = rvd->vdev_child[c];
6063 
6064 		ASSERT3U(c, ==, vd->vdev_id);
6065 
6066 		if (vd->vdev_ops != &vdev_indirect_ops)
6067 			continue;
6068 
6069 		/*
6070 		 * Note: we don't check for mapping leaks on
6071 		 * removing vdevs because their ms_allocatable's
6072 		 * are used to look for leaks in allocated space.
6073 		 */
6074 		zcb->zcb_vd_obsolete_counts[c] = zdb_load_obsolete_counts(vd);
6075 
6076 		/*
6077 		 * Normally, indirect vdevs don't have any
6078 		 * metaslabs.  We want to set them up for
6079 		 * zio_claim().
6080 		 */
6081 		vdev_metaslab_group_create(vd);
6082 		VERIFY0(vdev_metaslab_init(vd, 0));
6083 
6084 		vdev_indirect_mapping_t *vim __maybe_unused =
6085 		    vd->vdev_indirect_mapping;
6086 		uint64_t vim_idx = 0;
6087 		for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
6088 
6089 			(void) fprintf(stderr,
6090 			    "\rloading indirect vdev %llu, "
6091 			    "metaslab %llu of %llu ...",
6092 			    (longlong_t)vd->vdev_id,
6093 			    (longlong_t)vd->vdev_ms[m]->ms_id,
6094 			    (longlong_t)vd->vdev_ms_count);
6095 
6096 			load_indirect_ms_allocatable_tree(vd, vd->vdev_ms[m],
6097 			    &vim_idx);
6098 		}
6099 		ASSERT3U(vim_idx, ==, vdev_indirect_mapping_num_entries(vim));
6100 	}
6101 }
6102 
6103 static void
6104 zdb_leak_init(spa_t *spa, zdb_cb_t *zcb)
6105 {
6106 	zcb->zcb_spa = spa;
6107 
6108 	if (dump_opt['L'])
6109 		return;
6110 
6111 	dsl_pool_t *dp = spa->spa_dsl_pool;
6112 	vdev_t *rvd = spa->spa_root_vdev;
6113 
6114 	/*
6115 	 * We are going to be changing the meaning of the metaslab's
6116 	 * ms_allocatable.  Ensure that the allocator doesn't try to
6117 	 * use the tree.
6118 	 */
6119 	spa->spa_normal_class->mc_ops = &zdb_metaslab_ops;
6120 	spa->spa_log_class->mc_ops = &zdb_metaslab_ops;
6121 	spa->spa_embedded_log_class->mc_ops = &zdb_metaslab_ops;
6122 
6123 	zcb->zcb_vd_obsolete_counts =
6124 	    umem_zalloc(rvd->vdev_children * sizeof (uint32_t *),
6125 	    UMEM_NOFAIL);
6126 
6127 	/*
6128 	 * For leak detection, we overload the ms_allocatable trees
6129 	 * to contain allocated segments instead of free segments.
6130 	 * As a result, we can't use the normal metaslab_load/unload
6131 	 * interfaces.
6132 	 */
6133 	zdb_leak_init_prepare_indirect_vdevs(spa, zcb);
6134 	load_concrete_ms_allocatable_trees(spa, SM_ALLOC);
6135 
6136 	/*
6137 	 * On load_concrete_ms_allocatable_trees() we loaded all the
6138 	 * allocated entries from the ms_sm to the ms_allocatable for
6139 	 * each metaslab. If the pool has a checkpoint or is in the
6140 	 * middle of discarding a checkpoint, some of these blocks
6141 	 * may have been freed but their ms_sm may not have been
6142 	 * updated because they are referenced by the checkpoint. In
6143 	 * order to avoid false-positives during leak-detection, we
6144 	 * go through the vdev's checkpoint space map and exclude all
6145 	 * its entries from their relevant ms_allocatable.
6146 	 *
6147 	 * We also aggregate the space held by the checkpoint and add
6148 	 * it to zcb_checkpoint_size.
6149 	 *
6150 	 * Note that at this point we are also verifying that all the
6151 	 * entries on the checkpoint_sm are marked as allocated in
6152 	 * the ms_sm of their relevant metaslab.
6153 	 * [see comment in checkpoint_sm_exclude_entry_cb()]
6154 	 */
6155 	zdb_leak_init_exclude_checkpoint(spa, zcb);
6156 	ASSERT3U(zcb->zcb_checkpoint_size, ==, spa_get_checkpoint_space(spa));
6157 
6158 	/* for cleaner progress output */
6159 	(void) fprintf(stderr, "\n");
6160 
6161 	if (bpobj_is_open(&dp->dp_obsolete_bpobj)) {
6162 		ASSERT(spa_feature_is_enabled(spa,
6163 		    SPA_FEATURE_DEVICE_REMOVAL));
6164 		(void) bpobj_iterate_nofree(&dp->dp_obsolete_bpobj,
6165 		    increment_indirect_mapping_cb, zcb, NULL);
6166 	}
6167 
6168 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
6169 	zdb_ddt_leak_init(spa, zcb);
6170 	spa_config_exit(spa, SCL_CONFIG, FTAG);
6171 }
6172 
6173 static boolean_t
6174 zdb_check_for_obsolete_leaks(vdev_t *vd, zdb_cb_t *zcb)
6175 {
6176 	boolean_t leaks = B_FALSE;
6177 	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
6178 	uint64_t total_leaked = 0;
6179 	boolean_t are_precise = B_FALSE;
6180 
6181 	ASSERT(vim != NULL);
6182 
6183 	for (uint64_t i = 0; i < vdev_indirect_mapping_num_entries(vim); i++) {
6184 		vdev_indirect_mapping_entry_phys_t *vimep =
6185 		    &vim->vim_entries[i];
6186 		uint64_t obsolete_bytes = 0;
6187 		uint64_t offset = DVA_MAPPING_GET_SRC_OFFSET(vimep);
6188 		metaslab_t *msp = vd->vdev_ms[offset >> vd->vdev_ms_shift];
6189 
6190 		/*
6191 		 * This is not very efficient but it's easy to
6192 		 * verify correctness.
6193 		 */
6194 		for (uint64_t inner_offset = 0;
6195 		    inner_offset < DVA_GET_ASIZE(&vimep->vimep_dst);
6196 		    inner_offset += 1 << vd->vdev_ashift) {
6197 			if (range_tree_contains(msp->ms_allocatable,
6198 			    offset + inner_offset, 1 << vd->vdev_ashift)) {
6199 				obsolete_bytes += 1 << vd->vdev_ashift;
6200 			}
6201 		}
6202 
6203 		int64_t bytes_leaked = obsolete_bytes -
6204 		    zcb->zcb_vd_obsolete_counts[vd->vdev_id][i];
6205 		ASSERT3U(DVA_GET_ASIZE(&vimep->vimep_dst), >=,
6206 		    zcb->zcb_vd_obsolete_counts[vd->vdev_id][i]);
6207 
6208 		VERIFY0(vdev_obsolete_counts_are_precise(vd, &are_precise));
6209 		if (bytes_leaked != 0 && (are_precise || dump_opt['d'] >= 5)) {
6210 			(void) printf("obsolete indirect mapping count "
6211 			    "mismatch on %llu:%llx:%llx : %llx bytes leaked\n",
6212 			    (u_longlong_t)vd->vdev_id,
6213 			    (u_longlong_t)DVA_MAPPING_GET_SRC_OFFSET(vimep),
6214 			    (u_longlong_t)DVA_GET_ASIZE(&vimep->vimep_dst),
6215 			    (u_longlong_t)bytes_leaked);
6216 		}
6217 		total_leaked += ABS(bytes_leaked);
6218 	}
6219 
6220 	VERIFY0(vdev_obsolete_counts_are_precise(vd, &are_precise));
6221 	if (!are_precise && total_leaked > 0) {
6222 		int pct_leaked = total_leaked * 100 /
6223 		    vdev_indirect_mapping_bytes_mapped(vim);
6224 		(void) printf("cannot verify obsolete indirect mapping "
6225 		    "counts of vdev %llu because precise feature was not "
6226 		    "enabled when it was removed: %d%% (%llx bytes) of mapping"
6227 		    "unreferenced\n",
6228 		    (u_longlong_t)vd->vdev_id, pct_leaked,
6229 		    (u_longlong_t)total_leaked);
6230 	} else if (total_leaked > 0) {
6231 		(void) printf("obsolete indirect mapping count mismatch "
6232 		    "for vdev %llu -- %llx total bytes mismatched\n",
6233 		    (u_longlong_t)vd->vdev_id,
6234 		    (u_longlong_t)total_leaked);
6235 		leaks |= B_TRUE;
6236 	}
6237 
6238 	vdev_indirect_mapping_free_obsolete_counts(vim,
6239 	    zcb->zcb_vd_obsolete_counts[vd->vdev_id]);
6240 	zcb->zcb_vd_obsolete_counts[vd->vdev_id] = NULL;
6241 
6242 	return (leaks);
6243 }
6244 
6245 static boolean_t
6246 zdb_leak_fini(spa_t *spa, zdb_cb_t *zcb)
6247 {
6248 	if (dump_opt['L'])
6249 		return (B_FALSE);
6250 
6251 	boolean_t leaks = B_FALSE;
6252 	vdev_t *rvd = spa->spa_root_vdev;
6253 	for (unsigned c = 0; c < rvd->vdev_children; c++) {
6254 		vdev_t *vd = rvd->vdev_child[c];
6255 
6256 		if (zcb->zcb_vd_obsolete_counts[c] != NULL) {
6257 			leaks |= zdb_check_for_obsolete_leaks(vd, zcb);
6258 		}
6259 
6260 		for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
6261 			metaslab_t *msp = vd->vdev_ms[m];
6262 			ASSERT3P(msp->ms_group, ==, (msp->ms_group->mg_class ==
6263 			    spa_embedded_log_class(spa)) ?
6264 			    vd->vdev_log_mg : vd->vdev_mg);
6265 
6266 			/*
6267 			 * ms_allocatable has been overloaded
6268 			 * to contain allocated segments. Now that
6269 			 * we finished traversing all blocks, any
6270 			 * block that remains in the ms_allocatable
6271 			 * represents an allocated block that we
6272 			 * did not claim during the traversal.
6273 			 * Claimed blocks would have been removed
6274 			 * from the ms_allocatable.  For indirect
6275 			 * vdevs, space remaining in the tree
6276 			 * represents parts of the mapping that are
6277 			 * not referenced, which is not a bug.
6278 			 */
6279 			if (vd->vdev_ops == &vdev_indirect_ops) {
6280 				range_tree_vacate(msp->ms_allocatable,
6281 				    NULL, NULL);
6282 			} else {
6283 				range_tree_vacate(msp->ms_allocatable,
6284 				    zdb_leak, vd);
6285 			}
6286 			if (msp->ms_loaded) {
6287 				msp->ms_loaded = B_FALSE;
6288 			}
6289 		}
6290 	}
6291 
6292 	umem_free(zcb->zcb_vd_obsolete_counts,
6293 	    rvd->vdev_children * sizeof (uint32_t *));
6294 	zcb->zcb_vd_obsolete_counts = NULL;
6295 
6296 	return (leaks);
6297 }
6298 
6299 static int
6300 count_block_cb(void *arg, const blkptr_t *bp, dmu_tx_t *tx)
6301 {
6302 	(void) tx;
6303 	zdb_cb_t *zcb = arg;
6304 
6305 	if (dump_opt['b'] >= 5) {
6306 		char blkbuf[BP_SPRINTF_LEN];
6307 		snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
6308 		(void) printf("[%s] %s\n",
6309 		    "deferred free", blkbuf);
6310 	}
6311 	zdb_count_block(zcb, NULL, bp, ZDB_OT_DEFERRED);
6312 	return (0);
6313 }
6314 
6315 /*
6316  * Iterate over livelists which have been destroyed by the user but
6317  * are still present in the MOS, waiting to be freed
6318  */
6319 static void
6320 iterate_deleted_livelists(spa_t *spa, ll_iter_t func, void *arg)
6321 {
6322 	objset_t *mos = spa->spa_meta_objset;
6323 	uint64_t zap_obj;
6324 	int err = zap_lookup(mos, DMU_POOL_DIRECTORY_OBJECT,
6325 	    DMU_POOL_DELETED_CLONES, sizeof (uint64_t), 1, &zap_obj);
6326 	if (err == ENOENT)
6327 		return;
6328 	ASSERT0(err);
6329 
6330 	zap_cursor_t zc;
6331 	zap_attribute_t attr;
6332 	dsl_deadlist_t ll;
6333 	/* NULL out os prior to dsl_deadlist_open in case it's garbage */
6334 	ll.dl_os = NULL;
6335 	for (zap_cursor_init(&zc, mos, zap_obj);
6336 	    zap_cursor_retrieve(&zc, &attr) == 0;
6337 	    (void) zap_cursor_advance(&zc)) {
6338 		dsl_deadlist_open(&ll, mos, attr.za_first_integer);
6339 		func(&ll, arg);
6340 		dsl_deadlist_close(&ll);
6341 	}
6342 	zap_cursor_fini(&zc);
6343 }
6344 
6345 static int
6346 bpobj_count_block_cb(void *arg, const blkptr_t *bp, boolean_t bp_freed,
6347     dmu_tx_t *tx)
6348 {
6349 	ASSERT(!bp_freed);
6350 	return (count_block_cb(arg, bp, tx));
6351 }
6352 
6353 static int
6354 livelist_entry_count_blocks_cb(void *args, dsl_deadlist_entry_t *dle)
6355 {
6356 	zdb_cb_t *zbc = args;
6357 	bplist_t blks;
6358 	bplist_create(&blks);
6359 	/* determine which blocks have been alloc'd but not freed */
6360 	VERIFY0(dsl_process_sub_livelist(&dle->dle_bpobj, &blks, NULL, NULL));
6361 	/* count those blocks */
6362 	(void) bplist_iterate(&blks, count_block_cb, zbc, NULL);
6363 	bplist_destroy(&blks);
6364 	return (0);
6365 }
6366 
6367 static void
6368 livelist_count_blocks(dsl_deadlist_t *ll, void *arg)
6369 {
6370 	dsl_deadlist_iterate(ll, livelist_entry_count_blocks_cb, arg);
6371 }
6372 
6373 /*
6374  * Count the blocks in the livelists that have been destroyed by the user
6375  * but haven't yet been freed.
6376  */
6377 static void
6378 deleted_livelists_count_blocks(spa_t *spa, zdb_cb_t *zbc)
6379 {
6380 	iterate_deleted_livelists(spa, livelist_count_blocks, zbc);
6381 }
6382 
6383 static void
6384 dump_livelist_cb(dsl_deadlist_t *ll, void *arg)
6385 {
6386 	ASSERT3P(arg, ==, NULL);
6387 	global_feature_count[SPA_FEATURE_LIVELIST]++;
6388 	dump_blkptr_list(ll, "Deleted Livelist");
6389 	dsl_deadlist_iterate(ll, sublivelist_verify_lightweight, NULL);
6390 }
6391 
6392 /*
6393  * Print out, register object references to, and increment feature counts for
6394  * livelists that have been destroyed by the user but haven't yet been freed.
6395  */
6396 static void
6397 deleted_livelists_dump_mos(spa_t *spa)
6398 {
6399 	uint64_t zap_obj;
6400 	objset_t *mos = spa->spa_meta_objset;
6401 	int err = zap_lookup(mos, DMU_POOL_DIRECTORY_OBJECT,
6402 	    DMU_POOL_DELETED_CLONES, sizeof (uint64_t), 1, &zap_obj);
6403 	if (err == ENOENT)
6404 		return;
6405 	mos_obj_refd(zap_obj);
6406 	iterate_deleted_livelists(spa, dump_livelist_cb, NULL);
6407 }
6408 
6409 static int
6410 dump_block_stats(spa_t *spa)
6411 {
6412 	zdb_cb_t zcb = {{{{0}}}};
6413 	zdb_blkstats_t *zb, *tzb;
6414 	uint64_t norm_alloc, norm_space, total_alloc, total_found;
6415 	int flags = TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA |
6416 	    TRAVERSE_NO_DECRYPT | TRAVERSE_HARD;
6417 	boolean_t leaks = B_FALSE;
6418 	int e, c, err;
6419 	bp_embedded_type_t i;
6420 
6421 	(void) printf("\nTraversing all blocks %s%s%s%s%s...\n\n",
6422 	    (dump_opt['c'] || !dump_opt['L']) ? "to verify " : "",
6423 	    (dump_opt['c'] == 1) ? "metadata " : "",
6424 	    dump_opt['c'] ? "checksums " : "",
6425 	    (dump_opt['c'] && !dump_opt['L']) ? "and verify " : "",
6426 	    !dump_opt['L'] ? "nothing leaked " : "");
6427 
6428 	/*
6429 	 * When leak detection is enabled we load all space maps as SM_ALLOC
6430 	 * maps, then traverse the pool claiming each block we discover. If
6431 	 * the pool is perfectly consistent, the segment trees will be empty
6432 	 * when we're done. Anything left over is a leak; any block we can't
6433 	 * claim (because it's not part of any space map) is a double
6434 	 * allocation, reference to a freed block, or an unclaimed log block.
6435 	 *
6436 	 * When leak detection is disabled (-L option) we still traverse the
6437 	 * pool claiming each block we discover, but we skip opening any space
6438 	 * maps.
6439 	 */
6440 	zdb_leak_init(spa, &zcb);
6441 
6442 	/*
6443 	 * If there's a deferred-free bplist, process that first.
6444 	 */
6445 	(void) bpobj_iterate_nofree(&spa->spa_deferred_bpobj,
6446 	    bpobj_count_block_cb, &zcb, NULL);
6447 
6448 	if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
6449 		(void) bpobj_iterate_nofree(&spa->spa_dsl_pool->dp_free_bpobj,
6450 		    bpobj_count_block_cb, &zcb, NULL);
6451 	}
6452 
6453 	zdb_claim_removing(spa, &zcb);
6454 
6455 	if (spa_feature_is_active(spa, SPA_FEATURE_ASYNC_DESTROY)) {
6456 		VERIFY3U(0, ==, bptree_iterate(spa->spa_meta_objset,
6457 		    spa->spa_dsl_pool->dp_bptree_obj, B_FALSE, count_block_cb,
6458 		    &zcb, NULL));
6459 	}
6460 
6461 	deleted_livelists_count_blocks(spa, &zcb);
6462 
6463 	if (dump_opt['c'] > 1)
6464 		flags |= TRAVERSE_PREFETCH_DATA;
6465 
6466 	zcb.zcb_totalasize = metaslab_class_get_alloc(spa_normal_class(spa));
6467 	zcb.zcb_totalasize += metaslab_class_get_alloc(spa_special_class(spa));
6468 	zcb.zcb_totalasize += metaslab_class_get_alloc(spa_dedup_class(spa));
6469 	zcb.zcb_totalasize +=
6470 	    metaslab_class_get_alloc(spa_embedded_log_class(spa));
6471 	zcb.zcb_start = zcb.zcb_lastprint = gethrtime();
6472 	err = traverse_pool(spa, 0, flags, zdb_blkptr_cb, &zcb);
6473 
6474 	/*
6475 	 * If we've traversed the data blocks then we need to wait for those
6476 	 * I/Os to complete. We leverage "The Godfather" zio to wait on
6477 	 * all async I/Os to complete.
6478 	 */
6479 	if (dump_opt['c']) {
6480 		for (c = 0; c < max_ncpus; c++) {
6481 			(void) zio_wait(spa->spa_async_zio_root[c]);
6482 			spa->spa_async_zio_root[c] = zio_root(spa, NULL, NULL,
6483 			    ZIO_FLAG_CANFAIL | ZIO_FLAG_SPECULATIVE |
6484 			    ZIO_FLAG_GODFATHER);
6485 		}
6486 	}
6487 	ASSERT0(spa->spa_load_verify_bytes);
6488 
6489 	/*
6490 	 * Done after zio_wait() since zcb_haderrors is modified in
6491 	 * zdb_blkptr_done()
6492 	 */
6493 	zcb.zcb_haderrors |= err;
6494 
6495 	if (zcb.zcb_haderrors) {
6496 		(void) printf("\nError counts:\n\n");
6497 		(void) printf("\t%5s  %s\n", "errno", "count");
6498 		for (e = 0; e < 256; e++) {
6499 			if (zcb.zcb_errors[e] != 0) {
6500 				(void) printf("\t%5d  %llu\n",
6501 				    e, (u_longlong_t)zcb.zcb_errors[e]);
6502 			}
6503 		}
6504 	}
6505 
6506 	/*
6507 	 * Report any leaked segments.
6508 	 */
6509 	leaks |= zdb_leak_fini(spa, &zcb);
6510 
6511 	tzb = &zcb.zcb_type[ZB_TOTAL][ZDB_OT_TOTAL];
6512 
6513 	norm_alloc = metaslab_class_get_alloc(spa_normal_class(spa));
6514 	norm_space = metaslab_class_get_space(spa_normal_class(spa));
6515 
6516 	total_alloc = norm_alloc +
6517 	    metaslab_class_get_alloc(spa_log_class(spa)) +
6518 	    metaslab_class_get_alloc(spa_embedded_log_class(spa)) +
6519 	    metaslab_class_get_alloc(spa_special_class(spa)) +
6520 	    metaslab_class_get_alloc(spa_dedup_class(spa)) +
6521 	    get_unflushed_alloc_space(spa);
6522 	total_found = tzb->zb_asize - zcb.zcb_dedup_asize +
6523 	    zcb.zcb_removing_size + zcb.zcb_checkpoint_size;
6524 
6525 	if (total_found == total_alloc && !dump_opt['L']) {
6526 		(void) printf("\n\tNo leaks (block sum matches space"
6527 		    " maps exactly)\n");
6528 	} else if (!dump_opt['L']) {
6529 		(void) printf("block traversal size %llu != alloc %llu "
6530 		    "(%s %lld)\n",
6531 		    (u_longlong_t)total_found,
6532 		    (u_longlong_t)total_alloc,
6533 		    (dump_opt['L']) ? "unreachable" : "leaked",
6534 		    (longlong_t)(total_alloc - total_found));
6535 		leaks = B_TRUE;
6536 	}
6537 
6538 	if (tzb->zb_count == 0)
6539 		return (2);
6540 
6541 	(void) printf("\n");
6542 	(void) printf("\t%-16s %14llu\n", "bp count:",
6543 	    (u_longlong_t)tzb->zb_count);
6544 	(void) printf("\t%-16s %14llu\n", "ganged count:",
6545 	    (longlong_t)tzb->zb_gangs);
6546 	(void) printf("\t%-16s %14llu      avg: %6llu\n", "bp logical:",
6547 	    (u_longlong_t)tzb->zb_lsize,
6548 	    (u_longlong_t)(tzb->zb_lsize / tzb->zb_count));
6549 	(void) printf("\t%-16s %14llu      avg: %6llu     compression: %6.2f\n",
6550 	    "bp physical:", (u_longlong_t)tzb->zb_psize,
6551 	    (u_longlong_t)(tzb->zb_psize / tzb->zb_count),
6552 	    (double)tzb->zb_lsize / tzb->zb_psize);
6553 	(void) printf("\t%-16s %14llu      avg: %6llu     compression: %6.2f\n",
6554 	    "bp allocated:", (u_longlong_t)tzb->zb_asize,
6555 	    (u_longlong_t)(tzb->zb_asize / tzb->zb_count),
6556 	    (double)tzb->zb_lsize / tzb->zb_asize);
6557 	(void) printf("\t%-16s %14llu    ref>1: %6llu   deduplication: %6.2f\n",
6558 	    "bp deduped:", (u_longlong_t)zcb.zcb_dedup_asize,
6559 	    (u_longlong_t)zcb.zcb_dedup_blocks,
6560 	    (double)zcb.zcb_dedup_asize / tzb->zb_asize + 1.0);
6561 	(void) printf("\t%-16s %14llu     used: %5.2f%%\n", "Normal class:",
6562 	    (u_longlong_t)norm_alloc, 100.0 * norm_alloc / norm_space);
6563 
6564 	if (spa_special_class(spa)->mc_allocator[0].mca_rotor != NULL) {
6565 		uint64_t alloc = metaslab_class_get_alloc(
6566 		    spa_special_class(spa));
6567 		uint64_t space = metaslab_class_get_space(
6568 		    spa_special_class(spa));
6569 
6570 		(void) printf("\t%-16s %14llu     used: %5.2f%%\n",
6571 		    "Special class", (u_longlong_t)alloc,
6572 		    100.0 * alloc / space);
6573 	}
6574 
6575 	if (spa_dedup_class(spa)->mc_allocator[0].mca_rotor != NULL) {
6576 		uint64_t alloc = metaslab_class_get_alloc(
6577 		    spa_dedup_class(spa));
6578 		uint64_t space = metaslab_class_get_space(
6579 		    spa_dedup_class(spa));
6580 
6581 		(void) printf("\t%-16s %14llu     used: %5.2f%%\n",
6582 		    "Dedup class", (u_longlong_t)alloc,
6583 		    100.0 * alloc / space);
6584 	}
6585 
6586 	if (spa_embedded_log_class(spa)->mc_allocator[0].mca_rotor != NULL) {
6587 		uint64_t alloc = metaslab_class_get_alloc(
6588 		    spa_embedded_log_class(spa));
6589 		uint64_t space = metaslab_class_get_space(
6590 		    spa_embedded_log_class(spa));
6591 
6592 		(void) printf("\t%-16s %14llu     used: %5.2f%%\n",
6593 		    "Embedded log class", (u_longlong_t)alloc,
6594 		    100.0 * alloc / space);
6595 	}
6596 
6597 	for (i = 0; i < NUM_BP_EMBEDDED_TYPES; i++) {
6598 		if (zcb.zcb_embedded_blocks[i] == 0)
6599 			continue;
6600 		(void) printf("\n");
6601 		(void) printf("\tadditional, non-pointer bps of type %u: "
6602 		    "%10llu\n",
6603 		    i, (u_longlong_t)zcb.zcb_embedded_blocks[i]);
6604 
6605 		if (dump_opt['b'] >= 3) {
6606 			(void) printf("\t number of (compressed) bytes:  "
6607 			    "number of bps\n");
6608 			dump_histogram(zcb.zcb_embedded_histogram[i],
6609 			    sizeof (zcb.zcb_embedded_histogram[i]) /
6610 			    sizeof (zcb.zcb_embedded_histogram[i][0]), 0);
6611 		}
6612 	}
6613 
6614 	if (tzb->zb_ditto_samevdev != 0) {
6615 		(void) printf("\tDittoed blocks on same vdev: %llu\n",
6616 		    (longlong_t)tzb->zb_ditto_samevdev);
6617 	}
6618 	if (tzb->zb_ditto_same_ms != 0) {
6619 		(void) printf("\tDittoed blocks in same metaslab: %llu\n",
6620 		    (longlong_t)tzb->zb_ditto_same_ms);
6621 	}
6622 
6623 	for (uint64_t v = 0; v < spa->spa_root_vdev->vdev_children; v++) {
6624 		vdev_t *vd = spa->spa_root_vdev->vdev_child[v];
6625 		vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
6626 
6627 		if (vim == NULL) {
6628 			continue;
6629 		}
6630 
6631 		char mem[32];
6632 		zdb_nicenum(vdev_indirect_mapping_num_entries(vim),
6633 		    mem, vdev_indirect_mapping_size(vim));
6634 
6635 		(void) printf("\tindirect vdev id %llu has %llu segments "
6636 		    "(%s in memory)\n",
6637 		    (longlong_t)vd->vdev_id,
6638 		    (longlong_t)vdev_indirect_mapping_num_entries(vim), mem);
6639 	}
6640 
6641 	if (dump_opt['b'] >= 2) {
6642 		int l, t, level;
6643 		(void) printf("\nBlocks\tLSIZE\tPSIZE\tASIZE"
6644 		    "\t  avg\t comp\t%%Total\tType\n");
6645 
6646 		for (t = 0; t <= ZDB_OT_TOTAL; t++) {
6647 			char csize[32], lsize[32], psize[32], asize[32];
6648 			char avg[32], gang[32];
6649 			const char *typename;
6650 
6651 			/* make sure nicenum has enough space */
6652 			_Static_assert(sizeof (csize) >= NN_NUMBUF_SZ,
6653 			    "csize truncated");
6654 			_Static_assert(sizeof (lsize) >= NN_NUMBUF_SZ,
6655 			    "lsize truncated");
6656 			_Static_assert(sizeof (psize) >= NN_NUMBUF_SZ,
6657 			    "psize truncated");
6658 			_Static_assert(sizeof (asize) >= NN_NUMBUF_SZ,
6659 			    "asize truncated");
6660 			_Static_assert(sizeof (avg) >= NN_NUMBUF_SZ,
6661 			    "avg truncated");
6662 			_Static_assert(sizeof (gang) >= NN_NUMBUF_SZ,
6663 			    "gang truncated");
6664 
6665 			if (t < DMU_OT_NUMTYPES)
6666 				typename = dmu_ot[t].ot_name;
6667 			else
6668 				typename = zdb_ot_extname[t - DMU_OT_NUMTYPES];
6669 
6670 			if (zcb.zcb_type[ZB_TOTAL][t].zb_asize == 0) {
6671 				(void) printf("%6s\t%5s\t%5s\t%5s"
6672 				    "\t%5s\t%5s\t%6s\t%s\n",
6673 				    "-",
6674 				    "-",
6675 				    "-",
6676 				    "-",
6677 				    "-",
6678 				    "-",
6679 				    "-",
6680 				    typename);
6681 				continue;
6682 			}
6683 
6684 			for (l = ZB_TOTAL - 1; l >= -1; l--) {
6685 				level = (l == -1 ? ZB_TOTAL : l);
6686 				zb = &zcb.zcb_type[level][t];
6687 
6688 				if (zb->zb_asize == 0)
6689 					continue;
6690 
6691 				if (dump_opt['b'] < 3 && level != ZB_TOTAL)
6692 					continue;
6693 
6694 				if (level == 0 && zb->zb_asize ==
6695 				    zcb.zcb_type[ZB_TOTAL][t].zb_asize)
6696 					continue;
6697 
6698 				zdb_nicenum(zb->zb_count, csize,
6699 				    sizeof (csize));
6700 				zdb_nicenum(zb->zb_lsize, lsize,
6701 				    sizeof (lsize));
6702 				zdb_nicenum(zb->zb_psize, psize,
6703 				    sizeof (psize));
6704 				zdb_nicenum(zb->zb_asize, asize,
6705 				    sizeof (asize));
6706 				zdb_nicenum(zb->zb_asize / zb->zb_count, avg,
6707 				    sizeof (avg));
6708 				zdb_nicenum(zb->zb_gangs, gang, sizeof (gang));
6709 
6710 				(void) printf("%6s\t%5s\t%5s\t%5s\t%5s"
6711 				    "\t%5.2f\t%6.2f\t",
6712 				    csize, lsize, psize, asize, avg,
6713 				    (double)zb->zb_lsize / zb->zb_psize,
6714 				    100.0 * zb->zb_asize / tzb->zb_asize);
6715 
6716 				if (level == ZB_TOTAL)
6717 					(void) printf("%s\n", typename);
6718 				else
6719 					(void) printf("    L%d %s\n",
6720 					    level, typename);
6721 
6722 				if (dump_opt['b'] >= 3 && zb->zb_gangs > 0) {
6723 					(void) printf("\t number of ganged "
6724 					    "blocks: %s\n", gang);
6725 				}
6726 
6727 				if (dump_opt['b'] >= 4) {
6728 					(void) printf("psize "
6729 					    "(in 512-byte sectors): "
6730 					    "number of blocks\n");
6731 					dump_histogram(zb->zb_psize_histogram,
6732 					    PSIZE_HISTO_SIZE, 0);
6733 				}
6734 			}
6735 		}
6736 
6737 		/* Output a table summarizing block sizes in the pool */
6738 		if (dump_opt['b'] >= 2) {
6739 			dump_size_histograms(&zcb);
6740 		}
6741 	}
6742 
6743 	(void) printf("\n");
6744 
6745 	if (leaks)
6746 		return (2);
6747 
6748 	if (zcb.zcb_haderrors)
6749 		return (3);
6750 
6751 	return (0);
6752 }
6753 
6754 typedef struct zdb_ddt_entry {
6755 	ddt_key_t	zdde_key;
6756 	uint64_t	zdde_ref_blocks;
6757 	uint64_t	zdde_ref_lsize;
6758 	uint64_t	zdde_ref_psize;
6759 	uint64_t	zdde_ref_dsize;
6760 	avl_node_t	zdde_node;
6761 } zdb_ddt_entry_t;
6762 
6763 static int
6764 zdb_ddt_add_cb(spa_t *spa, zilog_t *zilog, const blkptr_t *bp,
6765     const zbookmark_phys_t *zb, const dnode_phys_t *dnp, void *arg)
6766 {
6767 	(void) zilog, (void) dnp;
6768 	avl_tree_t *t = arg;
6769 	avl_index_t where;
6770 	zdb_ddt_entry_t *zdde, zdde_search;
6771 
6772 	if (zb->zb_level == ZB_DNODE_LEVEL || BP_IS_HOLE(bp) ||
6773 	    BP_IS_EMBEDDED(bp))
6774 		return (0);
6775 
6776 	if (dump_opt['S'] > 1 && zb->zb_level == ZB_ROOT_LEVEL) {
6777 		(void) printf("traversing objset %llu, %llu objects, "
6778 		    "%lu blocks so far\n",
6779 		    (u_longlong_t)zb->zb_objset,
6780 		    (u_longlong_t)BP_GET_FILL(bp),
6781 		    avl_numnodes(t));
6782 	}
6783 
6784 	if (BP_IS_HOLE(bp) || BP_GET_CHECKSUM(bp) == ZIO_CHECKSUM_OFF ||
6785 	    BP_GET_LEVEL(bp) > 0 || DMU_OT_IS_METADATA(BP_GET_TYPE(bp)))
6786 		return (0);
6787 
6788 	ddt_key_fill(&zdde_search.zdde_key, bp);
6789 
6790 	zdde = avl_find(t, &zdde_search, &where);
6791 
6792 	if (zdde == NULL) {
6793 		zdde = umem_zalloc(sizeof (*zdde), UMEM_NOFAIL);
6794 		zdde->zdde_key = zdde_search.zdde_key;
6795 		avl_insert(t, zdde, where);
6796 	}
6797 
6798 	zdde->zdde_ref_blocks += 1;
6799 	zdde->zdde_ref_lsize += BP_GET_LSIZE(bp);
6800 	zdde->zdde_ref_psize += BP_GET_PSIZE(bp);
6801 	zdde->zdde_ref_dsize += bp_get_dsize_sync(spa, bp);
6802 
6803 	return (0);
6804 }
6805 
6806 static void
6807 dump_simulated_ddt(spa_t *spa)
6808 {
6809 	avl_tree_t t;
6810 	void *cookie = NULL;
6811 	zdb_ddt_entry_t *zdde;
6812 	ddt_histogram_t ddh_total = {{{0}}};
6813 	ddt_stat_t dds_total = {0};
6814 
6815 	avl_create(&t, ddt_entry_compare,
6816 	    sizeof (zdb_ddt_entry_t), offsetof(zdb_ddt_entry_t, zdde_node));
6817 
6818 	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
6819 
6820 	(void) traverse_pool(spa, 0, TRAVERSE_PRE | TRAVERSE_PREFETCH_METADATA |
6821 	    TRAVERSE_NO_DECRYPT, zdb_ddt_add_cb, &t);
6822 
6823 	spa_config_exit(spa, SCL_CONFIG, FTAG);
6824 
6825 	while ((zdde = avl_destroy_nodes(&t, &cookie)) != NULL) {
6826 		ddt_stat_t dds;
6827 		uint64_t refcnt = zdde->zdde_ref_blocks;
6828 		ASSERT(refcnt != 0);
6829 
6830 		dds.dds_blocks = zdde->zdde_ref_blocks / refcnt;
6831 		dds.dds_lsize = zdde->zdde_ref_lsize / refcnt;
6832 		dds.dds_psize = zdde->zdde_ref_psize / refcnt;
6833 		dds.dds_dsize = zdde->zdde_ref_dsize / refcnt;
6834 
6835 		dds.dds_ref_blocks = zdde->zdde_ref_blocks;
6836 		dds.dds_ref_lsize = zdde->zdde_ref_lsize;
6837 		dds.dds_ref_psize = zdde->zdde_ref_psize;
6838 		dds.dds_ref_dsize = zdde->zdde_ref_dsize;
6839 
6840 		ddt_stat_add(&ddh_total.ddh_stat[highbit64(refcnt) - 1],
6841 		    &dds, 0);
6842 
6843 		umem_free(zdde, sizeof (*zdde));
6844 	}
6845 
6846 	avl_destroy(&t);
6847 
6848 	ddt_histogram_stat(&dds_total, &ddh_total);
6849 
6850 	(void) printf("Simulated DDT histogram:\n");
6851 
6852 	zpool_dump_ddt(&dds_total, &ddh_total);
6853 
6854 	dump_dedup_ratio(&dds_total);
6855 }
6856 
6857 static int
6858 verify_device_removal_feature_counts(spa_t *spa)
6859 {
6860 	uint64_t dr_feature_refcount = 0;
6861 	uint64_t oc_feature_refcount = 0;
6862 	uint64_t indirect_vdev_count = 0;
6863 	uint64_t precise_vdev_count = 0;
6864 	uint64_t obsolete_counts_object_count = 0;
6865 	uint64_t obsolete_sm_count = 0;
6866 	uint64_t obsolete_counts_count = 0;
6867 	uint64_t scip_count = 0;
6868 	uint64_t obsolete_bpobj_count = 0;
6869 	int ret = 0;
6870 
6871 	spa_condensing_indirect_phys_t *scip =
6872 	    &spa->spa_condensing_indirect_phys;
6873 	if (scip->scip_next_mapping_object != 0) {
6874 		vdev_t *vd = spa->spa_root_vdev->vdev_child[scip->scip_vdev];
6875 		ASSERT(scip->scip_prev_obsolete_sm_object != 0);
6876 		ASSERT3P(vd->vdev_ops, ==, &vdev_indirect_ops);
6877 
6878 		(void) printf("Condensing indirect vdev %llu: new mapping "
6879 		    "object %llu, prev obsolete sm %llu\n",
6880 		    (u_longlong_t)scip->scip_vdev,
6881 		    (u_longlong_t)scip->scip_next_mapping_object,
6882 		    (u_longlong_t)scip->scip_prev_obsolete_sm_object);
6883 		if (scip->scip_prev_obsolete_sm_object != 0) {
6884 			space_map_t *prev_obsolete_sm = NULL;
6885 			VERIFY0(space_map_open(&prev_obsolete_sm,
6886 			    spa->spa_meta_objset,
6887 			    scip->scip_prev_obsolete_sm_object,
6888 			    0, vd->vdev_asize, 0));
6889 			dump_spacemap(spa->spa_meta_objset, prev_obsolete_sm);
6890 			(void) printf("\n");
6891 			space_map_close(prev_obsolete_sm);
6892 		}
6893 
6894 		scip_count += 2;
6895 	}
6896 
6897 	for (uint64_t i = 0; i < spa->spa_root_vdev->vdev_children; i++) {
6898 		vdev_t *vd = spa->spa_root_vdev->vdev_child[i];
6899 		vdev_indirect_config_t *vic = &vd->vdev_indirect_config;
6900 
6901 		if (vic->vic_mapping_object != 0) {
6902 			ASSERT(vd->vdev_ops == &vdev_indirect_ops ||
6903 			    vd->vdev_removing);
6904 			indirect_vdev_count++;
6905 
6906 			if (vd->vdev_indirect_mapping->vim_havecounts) {
6907 				obsolete_counts_count++;
6908 			}
6909 		}
6910 
6911 		boolean_t are_precise;
6912 		VERIFY0(vdev_obsolete_counts_are_precise(vd, &are_precise));
6913 		if (are_precise) {
6914 			ASSERT(vic->vic_mapping_object != 0);
6915 			precise_vdev_count++;
6916 		}
6917 
6918 		uint64_t obsolete_sm_object;
6919 		VERIFY0(vdev_obsolete_sm_object(vd, &obsolete_sm_object));
6920 		if (obsolete_sm_object != 0) {
6921 			ASSERT(vic->vic_mapping_object != 0);
6922 			obsolete_sm_count++;
6923 		}
6924 	}
6925 
6926 	(void) feature_get_refcount(spa,
6927 	    &spa_feature_table[SPA_FEATURE_DEVICE_REMOVAL],
6928 	    &dr_feature_refcount);
6929 	(void) feature_get_refcount(spa,
6930 	    &spa_feature_table[SPA_FEATURE_OBSOLETE_COUNTS],
6931 	    &oc_feature_refcount);
6932 
6933 	if (dr_feature_refcount != indirect_vdev_count) {
6934 		ret = 1;
6935 		(void) printf("Number of indirect vdevs (%llu) " \
6936 		    "does not match feature count (%llu)\n",
6937 		    (u_longlong_t)indirect_vdev_count,
6938 		    (u_longlong_t)dr_feature_refcount);
6939 	} else {
6940 		(void) printf("Verified device_removal feature refcount " \
6941 		    "of %llu is correct\n",
6942 		    (u_longlong_t)dr_feature_refcount);
6943 	}
6944 
6945 	if (zap_contains(spa_meta_objset(spa), DMU_POOL_DIRECTORY_OBJECT,
6946 	    DMU_POOL_OBSOLETE_BPOBJ) == 0) {
6947 		obsolete_bpobj_count++;
6948 	}
6949 
6950 
6951 	obsolete_counts_object_count = precise_vdev_count;
6952 	obsolete_counts_object_count += obsolete_sm_count;
6953 	obsolete_counts_object_count += obsolete_counts_count;
6954 	obsolete_counts_object_count += scip_count;
6955 	obsolete_counts_object_count += obsolete_bpobj_count;
6956 	obsolete_counts_object_count += remap_deadlist_count;
6957 
6958 	if (oc_feature_refcount != obsolete_counts_object_count) {
6959 		ret = 1;
6960 		(void) printf("Number of obsolete counts objects (%llu) " \
6961 		    "does not match feature count (%llu)\n",
6962 		    (u_longlong_t)obsolete_counts_object_count,
6963 		    (u_longlong_t)oc_feature_refcount);
6964 		(void) printf("pv:%llu os:%llu oc:%llu sc:%llu "
6965 		    "ob:%llu rd:%llu\n",
6966 		    (u_longlong_t)precise_vdev_count,
6967 		    (u_longlong_t)obsolete_sm_count,
6968 		    (u_longlong_t)obsolete_counts_count,
6969 		    (u_longlong_t)scip_count,
6970 		    (u_longlong_t)obsolete_bpobj_count,
6971 		    (u_longlong_t)remap_deadlist_count);
6972 	} else {
6973 		(void) printf("Verified indirect_refcount feature refcount " \
6974 		    "of %llu is correct\n",
6975 		    (u_longlong_t)oc_feature_refcount);
6976 	}
6977 	return (ret);
6978 }
6979 
6980 static void
6981 zdb_set_skip_mmp(char *target)
6982 {
6983 	spa_t *spa;
6984 
6985 	/*
6986 	 * Disable the activity check to allow examination of
6987 	 * active pools.
6988 	 */
6989 	mutex_enter(&spa_namespace_lock);
6990 	if ((spa = spa_lookup(target)) != NULL) {
6991 		spa->spa_import_flags |= ZFS_IMPORT_SKIP_MMP;
6992 	}
6993 	mutex_exit(&spa_namespace_lock);
6994 }
6995 
6996 #define	BOGUS_SUFFIX "_CHECKPOINTED_UNIVERSE"
6997 /*
6998  * Import the checkpointed state of the pool specified by the target
6999  * parameter as readonly. The function also accepts a pool config
7000  * as an optional parameter, else it attempts to infer the config by
7001  * the name of the target pool.
7002  *
7003  * Note that the checkpointed state's pool name will be the name of
7004  * the original pool with the above suffix appended to it. In addition,
7005  * if the target is not a pool name (e.g. a path to a dataset) then
7006  * the new_path parameter is populated with the updated path to
7007  * reflect the fact that we are looking into the checkpointed state.
7008  *
7009  * The function returns a newly-allocated copy of the name of the
7010  * pool containing the checkpointed state. When this copy is no
7011  * longer needed it should be freed with free(3C). Same thing
7012  * applies to the new_path parameter if allocated.
7013  */
7014 static char *
7015 import_checkpointed_state(char *target, nvlist_t *cfg, char **new_path)
7016 {
7017 	int error = 0;
7018 	char *poolname, *bogus_name = NULL;
7019 	boolean_t freecfg = B_FALSE;
7020 
7021 	/* If the target is not a pool, the extract the pool name */
7022 	char *path_start = strchr(target, '/');
7023 	if (path_start != NULL) {
7024 		size_t poolname_len = path_start - target;
7025 		poolname = strndup(target, poolname_len);
7026 	} else {
7027 		poolname = target;
7028 	}
7029 
7030 	if (cfg == NULL) {
7031 		zdb_set_skip_mmp(poolname);
7032 		error = spa_get_stats(poolname, &cfg, NULL, 0);
7033 		if (error != 0) {
7034 			fatal("Tried to read config of pool \"%s\" but "
7035 			    "spa_get_stats() failed with error %d\n",
7036 			    poolname, error);
7037 		}
7038 		freecfg = B_TRUE;
7039 	}
7040 
7041 	if (asprintf(&bogus_name, "%s%s", poolname, BOGUS_SUFFIX) == -1)
7042 		return (NULL);
7043 	fnvlist_add_string(cfg, ZPOOL_CONFIG_POOL_NAME, bogus_name);
7044 
7045 	error = spa_import(bogus_name, cfg, NULL,
7046 	    ZFS_IMPORT_MISSING_LOG | ZFS_IMPORT_CHECKPOINT |
7047 	    ZFS_IMPORT_SKIP_MMP);
7048 	if (freecfg)
7049 		nvlist_free(cfg);
7050 	if (error != 0) {
7051 		fatal("Tried to import pool \"%s\" but spa_import() failed "
7052 		    "with error %d\n", bogus_name, error);
7053 	}
7054 
7055 	if (new_path != NULL && path_start != NULL) {
7056 		if (asprintf(new_path, "%s%s", bogus_name, path_start) == -1) {
7057 			if (path_start != NULL)
7058 				free(poolname);
7059 			return (NULL);
7060 		}
7061 	}
7062 
7063 	if (target != poolname)
7064 		free(poolname);
7065 
7066 	return (bogus_name);
7067 }
7068 
7069 typedef struct verify_checkpoint_sm_entry_cb_arg {
7070 	vdev_t *vcsec_vd;
7071 
7072 	/* the following fields are only used for printing progress */
7073 	uint64_t vcsec_entryid;
7074 	uint64_t vcsec_num_entries;
7075 } verify_checkpoint_sm_entry_cb_arg_t;
7076 
7077 #define	ENTRIES_PER_PROGRESS_UPDATE 10000
7078 
7079 static int
7080 verify_checkpoint_sm_entry_cb(space_map_entry_t *sme, void *arg)
7081 {
7082 	verify_checkpoint_sm_entry_cb_arg_t *vcsec = arg;
7083 	vdev_t *vd = vcsec->vcsec_vd;
7084 	metaslab_t *ms = vd->vdev_ms[sme->sme_offset >> vd->vdev_ms_shift];
7085 	uint64_t end = sme->sme_offset + sme->sme_run;
7086 
7087 	ASSERT(sme->sme_type == SM_FREE);
7088 
7089 	if ((vcsec->vcsec_entryid % ENTRIES_PER_PROGRESS_UPDATE) == 0) {
7090 		(void) fprintf(stderr,
7091 		    "\rverifying vdev %llu, space map entry %llu of %llu ...",
7092 		    (longlong_t)vd->vdev_id,
7093 		    (longlong_t)vcsec->vcsec_entryid,
7094 		    (longlong_t)vcsec->vcsec_num_entries);
7095 	}
7096 	vcsec->vcsec_entryid++;
7097 
7098 	/*
7099 	 * See comment in checkpoint_sm_exclude_entry_cb()
7100 	 */
7101 	VERIFY3U(sme->sme_offset, >=, ms->ms_start);
7102 	VERIFY3U(end, <=, ms->ms_start + ms->ms_size);
7103 
7104 	/*
7105 	 * The entries in the vdev_checkpoint_sm should be marked as
7106 	 * allocated in the checkpointed state of the pool, therefore
7107 	 * their respective ms_allocateable trees should not contain them.
7108 	 */
7109 	mutex_enter(&ms->ms_lock);
7110 	range_tree_verify_not_present(ms->ms_allocatable,
7111 	    sme->sme_offset, sme->sme_run);
7112 	mutex_exit(&ms->ms_lock);
7113 
7114 	return (0);
7115 }
7116 
7117 /*
7118  * Verify that all segments in the vdev_checkpoint_sm are allocated
7119  * according to the checkpoint's ms_sm (i.e. are not in the checkpoint's
7120  * ms_allocatable).
7121  *
7122  * Do so by comparing the checkpoint space maps (vdev_checkpoint_sm) of
7123  * each vdev in the current state of the pool to the metaslab space maps
7124  * (ms_sm) of the checkpointed state of the pool.
7125  *
7126  * Note that the function changes the state of the ms_allocatable
7127  * trees of the current spa_t. The entries of these ms_allocatable
7128  * trees are cleared out and then repopulated from with the free
7129  * entries of their respective ms_sm space maps.
7130  */
7131 static void
7132 verify_checkpoint_vdev_spacemaps(spa_t *checkpoint, spa_t *current)
7133 {
7134 	vdev_t *ckpoint_rvd = checkpoint->spa_root_vdev;
7135 	vdev_t *current_rvd = current->spa_root_vdev;
7136 
7137 	load_concrete_ms_allocatable_trees(checkpoint, SM_FREE);
7138 
7139 	for (uint64_t c = 0; c < ckpoint_rvd->vdev_children; c++) {
7140 		vdev_t *ckpoint_vd = ckpoint_rvd->vdev_child[c];
7141 		vdev_t *current_vd = current_rvd->vdev_child[c];
7142 
7143 		space_map_t *checkpoint_sm = NULL;
7144 		uint64_t checkpoint_sm_obj;
7145 
7146 		if (ckpoint_vd->vdev_ops == &vdev_indirect_ops) {
7147 			/*
7148 			 * Since we don't allow device removal in a pool
7149 			 * that has a checkpoint, we expect that all removed
7150 			 * vdevs were removed from the pool before the
7151 			 * checkpoint.
7152 			 */
7153 			ASSERT3P(current_vd->vdev_ops, ==, &vdev_indirect_ops);
7154 			continue;
7155 		}
7156 
7157 		/*
7158 		 * If the checkpoint space map doesn't exist, then nothing
7159 		 * here is checkpointed so there's nothing to verify.
7160 		 */
7161 		if (current_vd->vdev_top_zap == 0 ||
7162 		    zap_contains(spa_meta_objset(current),
7163 		    current_vd->vdev_top_zap,
7164 		    VDEV_TOP_ZAP_POOL_CHECKPOINT_SM) != 0)
7165 			continue;
7166 
7167 		VERIFY0(zap_lookup(spa_meta_objset(current),
7168 		    current_vd->vdev_top_zap, VDEV_TOP_ZAP_POOL_CHECKPOINT_SM,
7169 		    sizeof (uint64_t), 1, &checkpoint_sm_obj));
7170 
7171 		VERIFY0(space_map_open(&checkpoint_sm, spa_meta_objset(current),
7172 		    checkpoint_sm_obj, 0, current_vd->vdev_asize,
7173 		    current_vd->vdev_ashift));
7174 
7175 		verify_checkpoint_sm_entry_cb_arg_t vcsec;
7176 		vcsec.vcsec_vd = ckpoint_vd;
7177 		vcsec.vcsec_entryid = 0;
7178 		vcsec.vcsec_num_entries =
7179 		    space_map_length(checkpoint_sm) / sizeof (uint64_t);
7180 		VERIFY0(space_map_iterate(checkpoint_sm,
7181 		    space_map_length(checkpoint_sm),
7182 		    verify_checkpoint_sm_entry_cb, &vcsec));
7183 		if (dump_opt['m'] > 3)
7184 			dump_spacemap(current->spa_meta_objset, checkpoint_sm);
7185 		space_map_close(checkpoint_sm);
7186 	}
7187 
7188 	/*
7189 	 * If we've added vdevs since we took the checkpoint, ensure
7190 	 * that their checkpoint space maps are empty.
7191 	 */
7192 	if (ckpoint_rvd->vdev_children < current_rvd->vdev_children) {
7193 		for (uint64_t c = ckpoint_rvd->vdev_children;
7194 		    c < current_rvd->vdev_children; c++) {
7195 			vdev_t *current_vd = current_rvd->vdev_child[c];
7196 			VERIFY3P(current_vd->vdev_checkpoint_sm, ==, NULL);
7197 		}
7198 	}
7199 
7200 	/* for cleaner progress output */
7201 	(void) fprintf(stderr, "\n");
7202 }
7203 
7204 /*
7205  * Verifies that all space that's allocated in the checkpoint is
7206  * still allocated in the current version, by checking that everything
7207  * in checkpoint's ms_allocatable (which is actually allocated, not
7208  * allocatable/free) is not present in current's ms_allocatable.
7209  *
7210  * Note that the function changes the state of the ms_allocatable
7211  * trees of both spas when called. The entries of all ms_allocatable
7212  * trees are cleared out and then repopulated from their respective
7213  * ms_sm space maps. In the checkpointed state we load the allocated
7214  * entries, and in the current state we load the free entries.
7215  */
7216 static void
7217 verify_checkpoint_ms_spacemaps(spa_t *checkpoint, spa_t *current)
7218 {
7219 	vdev_t *ckpoint_rvd = checkpoint->spa_root_vdev;
7220 	vdev_t *current_rvd = current->spa_root_vdev;
7221 
7222 	load_concrete_ms_allocatable_trees(checkpoint, SM_ALLOC);
7223 	load_concrete_ms_allocatable_trees(current, SM_FREE);
7224 
7225 	for (uint64_t i = 0; i < ckpoint_rvd->vdev_children; i++) {
7226 		vdev_t *ckpoint_vd = ckpoint_rvd->vdev_child[i];
7227 		vdev_t *current_vd = current_rvd->vdev_child[i];
7228 
7229 		if (ckpoint_vd->vdev_ops == &vdev_indirect_ops) {
7230 			/*
7231 			 * See comment in verify_checkpoint_vdev_spacemaps()
7232 			 */
7233 			ASSERT3P(current_vd->vdev_ops, ==, &vdev_indirect_ops);
7234 			continue;
7235 		}
7236 
7237 		for (uint64_t m = 0; m < ckpoint_vd->vdev_ms_count; m++) {
7238 			metaslab_t *ckpoint_msp = ckpoint_vd->vdev_ms[m];
7239 			metaslab_t *current_msp = current_vd->vdev_ms[m];
7240 
7241 			(void) fprintf(stderr,
7242 			    "\rverifying vdev %llu of %llu, "
7243 			    "metaslab %llu of %llu ...",
7244 			    (longlong_t)current_vd->vdev_id,
7245 			    (longlong_t)current_rvd->vdev_children,
7246 			    (longlong_t)current_vd->vdev_ms[m]->ms_id,
7247 			    (longlong_t)current_vd->vdev_ms_count);
7248 
7249 			/*
7250 			 * We walk through the ms_allocatable trees that
7251 			 * are loaded with the allocated blocks from the
7252 			 * ms_sm spacemaps of the checkpoint. For each
7253 			 * one of these ranges we ensure that none of them
7254 			 * exists in the ms_allocatable trees of the
7255 			 * current state which are loaded with the ranges
7256 			 * that are currently free.
7257 			 *
7258 			 * This way we ensure that none of the blocks that
7259 			 * are part of the checkpoint were freed by mistake.
7260 			 */
7261 			range_tree_walk(ckpoint_msp->ms_allocatable,
7262 			    (range_tree_func_t *)range_tree_verify_not_present,
7263 			    current_msp->ms_allocatable);
7264 		}
7265 	}
7266 
7267 	/* for cleaner progress output */
7268 	(void) fprintf(stderr, "\n");
7269 }
7270 
7271 static void
7272 verify_checkpoint_blocks(spa_t *spa)
7273 {
7274 	ASSERT(!dump_opt['L']);
7275 
7276 	spa_t *checkpoint_spa;
7277 	char *checkpoint_pool;
7278 	int error = 0;
7279 
7280 	/*
7281 	 * We import the checkpointed state of the pool (under a different
7282 	 * name) so we can do verification on it against the current state
7283 	 * of the pool.
7284 	 */
7285 	checkpoint_pool = import_checkpointed_state(spa->spa_name, NULL,
7286 	    NULL);
7287 	ASSERT(strcmp(spa->spa_name, checkpoint_pool) != 0);
7288 
7289 	error = spa_open(checkpoint_pool, &checkpoint_spa, FTAG);
7290 	if (error != 0) {
7291 		fatal("Tried to open pool \"%s\" but spa_open() failed with "
7292 		    "error %d\n", checkpoint_pool, error);
7293 	}
7294 
7295 	/*
7296 	 * Ensure that ranges in the checkpoint space maps of each vdev
7297 	 * are allocated according to the checkpointed state's metaslab
7298 	 * space maps.
7299 	 */
7300 	verify_checkpoint_vdev_spacemaps(checkpoint_spa, spa);
7301 
7302 	/*
7303 	 * Ensure that allocated ranges in the checkpoint's metaslab
7304 	 * space maps remain allocated in the metaslab space maps of
7305 	 * the current state.
7306 	 */
7307 	verify_checkpoint_ms_spacemaps(checkpoint_spa, spa);
7308 
7309 	/*
7310 	 * Once we are done, we get rid of the checkpointed state.
7311 	 */
7312 	spa_close(checkpoint_spa, FTAG);
7313 	free(checkpoint_pool);
7314 }
7315 
7316 static void
7317 dump_leftover_checkpoint_blocks(spa_t *spa)
7318 {
7319 	vdev_t *rvd = spa->spa_root_vdev;
7320 
7321 	for (uint64_t i = 0; i < rvd->vdev_children; i++) {
7322 		vdev_t *vd = rvd->vdev_child[i];
7323 
7324 		space_map_t *checkpoint_sm = NULL;
7325 		uint64_t checkpoint_sm_obj;
7326 
7327 		if (vd->vdev_top_zap == 0)
7328 			continue;
7329 
7330 		if (zap_contains(spa_meta_objset(spa), vd->vdev_top_zap,
7331 		    VDEV_TOP_ZAP_POOL_CHECKPOINT_SM) != 0)
7332 			continue;
7333 
7334 		VERIFY0(zap_lookup(spa_meta_objset(spa), vd->vdev_top_zap,
7335 		    VDEV_TOP_ZAP_POOL_CHECKPOINT_SM,
7336 		    sizeof (uint64_t), 1, &checkpoint_sm_obj));
7337 
7338 		VERIFY0(space_map_open(&checkpoint_sm, spa_meta_objset(spa),
7339 		    checkpoint_sm_obj, 0, vd->vdev_asize, vd->vdev_ashift));
7340 		dump_spacemap(spa->spa_meta_objset, checkpoint_sm);
7341 		space_map_close(checkpoint_sm);
7342 	}
7343 }
7344 
7345 static int
7346 verify_checkpoint(spa_t *spa)
7347 {
7348 	uberblock_t checkpoint;
7349 	int error;
7350 
7351 	if (!spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT))
7352 		return (0);
7353 
7354 	error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
7355 	    DMU_POOL_ZPOOL_CHECKPOINT, sizeof (uint64_t),
7356 	    sizeof (uberblock_t) / sizeof (uint64_t), &checkpoint);
7357 
7358 	if (error == ENOENT && !dump_opt['L']) {
7359 		/*
7360 		 * If the feature is active but the uberblock is missing
7361 		 * then we must be in the middle of discarding the
7362 		 * checkpoint.
7363 		 */
7364 		(void) printf("\nPartially discarded checkpoint "
7365 		    "state found:\n");
7366 		if (dump_opt['m'] > 3)
7367 			dump_leftover_checkpoint_blocks(spa);
7368 		return (0);
7369 	} else if (error != 0) {
7370 		(void) printf("lookup error %d when looking for "
7371 		    "checkpointed uberblock in MOS\n", error);
7372 		return (error);
7373 	}
7374 	dump_uberblock(&checkpoint, "\nCheckpointed uberblock found:\n", "\n");
7375 
7376 	if (checkpoint.ub_checkpoint_txg == 0) {
7377 		(void) printf("\nub_checkpoint_txg not set in checkpointed "
7378 		    "uberblock\n");
7379 		error = 3;
7380 	}
7381 
7382 	if (error == 0 && !dump_opt['L'])
7383 		verify_checkpoint_blocks(spa);
7384 
7385 	return (error);
7386 }
7387 
7388 static void
7389 mos_leaks_cb(void *arg, uint64_t start, uint64_t size)
7390 {
7391 	(void) arg;
7392 	for (uint64_t i = start; i < size; i++) {
7393 		(void) printf("MOS object %llu referenced but not allocated\n",
7394 		    (u_longlong_t)i);
7395 	}
7396 }
7397 
7398 static void
7399 mos_obj_refd(uint64_t obj)
7400 {
7401 	if (obj != 0 && mos_refd_objs != NULL)
7402 		range_tree_add(mos_refd_objs, obj, 1);
7403 }
7404 
7405 /*
7406  * Call on a MOS object that may already have been referenced.
7407  */
7408 static void
7409 mos_obj_refd_multiple(uint64_t obj)
7410 {
7411 	if (obj != 0 && mos_refd_objs != NULL &&
7412 	    !range_tree_contains(mos_refd_objs, obj, 1))
7413 		range_tree_add(mos_refd_objs, obj, 1);
7414 }
7415 
7416 static void
7417 mos_leak_vdev_top_zap(vdev_t *vd)
7418 {
7419 	uint64_t ms_flush_data_obj;
7420 	int error = zap_lookup(spa_meta_objset(vd->vdev_spa),
7421 	    vd->vdev_top_zap, VDEV_TOP_ZAP_MS_UNFLUSHED_PHYS_TXGS,
7422 	    sizeof (ms_flush_data_obj), 1, &ms_flush_data_obj);
7423 	if (error == ENOENT)
7424 		return;
7425 	ASSERT0(error);
7426 
7427 	mos_obj_refd(ms_flush_data_obj);
7428 }
7429 
7430 static void
7431 mos_leak_vdev(vdev_t *vd)
7432 {
7433 	mos_obj_refd(vd->vdev_dtl_object);
7434 	mos_obj_refd(vd->vdev_ms_array);
7435 	mos_obj_refd(vd->vdev_indirect_config.vic_births_object);
7436 	mos_obj_refd(vd->vdev_indirect_config.vic_mapping_object);
7437 	mos_obj_refd(vd->vdev_leaf_zap);
7438 	if (vd->vdev_checkpoint_sm != NULL)
7439 		mos_obj_refd(vd->vdev_checkpoint_sm->sm_object);
7440 	if (vd->vdev_indirect_mapping != NULL) {
7441 		mos_obj_refd(vd->vdev_indirect_mapping->
7442 		    vim_phys->vimp_counts_object);
7443 	}
7444 	if (vd->vdev_obsolete_sm != NULL)
7445 		mos_obj_refd(vd->vdev_obsolete_sm->sm_object);
7446 
7447 	for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
7448 		metaslab_t *ms = vd->vdev_ms[m];
7449 		mos_obj_refd(space_map_object(ms->ms_sm));
7450 	}
7451 
7452 	if (vd->vdev_top_zap != 0) {
7453 		mos_obj_refd(vd->vdev_top_zap);
7454 		mos_leak_vdev_top_zap(vd);
7455 	}
7456 
7457 	for (uint64_t c = 0; c < vd->vdev_children; c++) {
7458 		mos_leak_vdev(vd->vdev_child[c]);
7459 	}
7460 }
7461 
7462 static void
7463 mos_leak_log_spacemaps(spa_t *spa)
7464 {
7465 	uint64_t spacemap_zap;
7466 	int error = zap_lookup(spa_meta_objset(spa),
7467 	    DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_LOG_SPACEMAP_ZAP,
7468 	    sizeof (spacemap_zap), 1, &spacemap_zap);
7469 	if (error == ENOENT)
7470 		return;
7471 	ASSERT0(error);
7472 
7473 	mos_obj_refd(spacemap_zap);
7474 	for (spa_log_sm_t *sls = avl_first(&spa->spa_sm_logs_by_txg);
7475 	    sls; sls = AVL_NEXT(&spa->spa_sm_logs_by_txg, sls))
7476 		mos_obj_refd(sls->sls_sm_obj);
7477 }
7478 
7479 static int
7480 dump_mos_leaks(spa_t *spa)
7481 {
7482 	int rv = 0;
7483 	objset_t *mos = spa->spa_meta_objset;
7484 	dsl_pool_t *dp = spa->spa_dsl_pool;
7485 
7486 	/* Visit and mark all referenced objects in the MOS */
7487 
7488 	mos_obj_refd(DMU_POOL_DIRECTORY_OBJECT);
7489 	mos_obj_refd(spa->spa_pool_props_object);
7490 	mos_obj_refd(spa->spa_config_object);
7491 	mos_obj_refd(spa->spa_ddt_stat_object);
7492 	mos_obj_refd(spa->spa_feat_desc_obj);
7493 	mos_obj_refd(spa->spa_feat_enabled_txg_obj);
7494 	mos_obj_refd(spa->spa_feat_for_read_obj);
7495 	mos_obj_refd(spa->spa_feat_for_write_obj);
7496 	mos_obj_refd(spa->spa_history);
7497 	mos_obj_refd(spa->spa_errlog_last);
7498 	mos_obj_refd(spa->spa_errlog_scrub);
7499 	mos_obj_refd(spa->spa_all_vdev_zaps);
7500 	mos_obj_refd(spa->spa_dsl_pool->dp_bptree_obj);
7501 	mos_obj_refd(spa->spa_dsl_pool->dp_tmp_userrefs_obj);
7502 	mos_obj_refd(spa->spa_dsl_pool->dp_scan->scn_phys.scn_queue_obj);
7503 	bpobj_count_refd(&spa->spa_deferred_bpobj);
7504 	mos_obj_refd(dp->dp_empty_bpobj);
7505 	bpobj_count_refd(&dp->dp_obsolete_bpobj);
7506 	bpobj_count_refd(&dp->dp_free_bpobj);
7507 	mos_obj_refd(spa->spa_l2cache.sav_object);
7508 	mos_obj_refd(spa->spa_spares.sav_object);
7509 
7510 	if (spa->spa_syncing_log_sm != NULL)
7511 		mos_obj_refd(spa->spa_syncing_log_sm->sm_object);
7512 	mos_leak_log_spacemaps(spa);
7513 
7514 	mos_obj_refd(spa->spa_condensing_indirect_phys.
7515 	    scip_next_mapping_object);
7516 	mos_obj_refd(spa->spa_condensing_indirect_phys.
7517 	    scip_prev_obsolete_sm_object);
7518 	if (spa->spa_condensing_indirect_phys.scip_next_mapping_object != 0) {
7519 		vdev_indirect_mapping_t *vim =
7520 		    vdev_indirect_mapping_open(mos,
7521 		    spa->spa_condensing_indirect_phys.scip_next_mapping_object);
7522 		mos_obj_refd(vim->vim_phys->vimp_counts_object);
7523 		vdev_indirect_mapping_close(vim);
7524 	}
7525 	deleted_livelists_dump_mos(spa);
7526 
7527 	if (dp->dp_origin_snap != NULL) {
7528 		dsl_dataset_t *ds;
7529 
7530 		dsl_pool_config_enter(dp, FTAG);
7531 		VERIFY0(dsl_dataset_hold_obj(dp,
7532 		    dsl_dataset_phys(dp->dp_origin_snap)->ds_next_snap_obj,
7533 		    FTAG, &ds));
7534 		count_ds_mos_objects(ds);
7535 		dump_blkptr_list(&ds->ds_deadlist, "Deadlist");
7536 		dsl_dataset_rele(ds, FTAG);
7537 		dsl_pool_config_exit(dp, FTAG);
7538 
7539 		count_ds_mos_objects(dp->dp_origin_snap);
7540 		dump_blkptr_list(&dp->dp_origin_snap->ds_deadlist, "Deadlist");
7541 	}
7542 	count_dir_mos_objects(dp->dp_mos_dir);
7543 	if (dp->dp_free_dir != NULL)
7544 		count_dir_mos_objects(dp->dp_free_dir);
7545 	if (dp->dp_leak_dir != NULL)
7546 		count_dir_mos_objects(dp->dp_leak_dir);
7547 
7548 	mos_leak_vdev(spa->spa_root_vdev);
7549 
7550 	for (uint64_t class = 0; class < DDT_CLASSES; class++) {
7551 		for (uint64_t type = 0; type < DDT_TYPES; type++) {
7552 			for (uint64_t cksum = 0;
7553 			    cksum < ZIO_CHECKSUM_FUNCTIONS; cksum++) {
7554 				ddt_t *ddt = spa->spa_ddt[cksum];
7555 				mos_obj_refd(ddt->ddt_object[type][class]);
7556 			}
7557 		}
7558 	}
7559 
7560 	/*
7561 	 * Visit all allocated objects and make sure they are referenced.
7562 	 */
7563 	uint64_t object = 0;
7564 	while (dmu_object_next(mos, &object, B_FALSE, 0) == 0) {
7565 		if (range_tree_contains(mos_refd_objs, object, 1)) {
7566 			range_tree_remove(mos_refd_objs, object, 1);
7567 		} else {
7568 			dmu_object_info_t doi;
7569 			const char *name;
7570 			dmu_object_info(mos, object, &doi);
7571 			if (doi.doi_type & DMU_OT_NEWTYPE) {
7572 				dmu_object_byteswap_t bswap =
7573 				    DMU_OT_BYTESWAP(doi.doi_type);
7574 				name = dmu_ot_byteswap[bswap].ob_name;
7575 			} else {
7576 				name = dmu_ot[doi.doi_type].ot_name;
7577 			}
7578 
7579 			(void) printf("MOS object %llu (%s) leaked\n",
7580 			    (u_longlong_t)object, name);
7581 			rv = 2;
7582 		}
7583 	}
7584 	(void) range_tree_walk(mos_refd_objs, mos_leaks_cb, NULL);
7585 	if (!range_tree_is_empty(mos_refd_objs))
7586 		rv = 2;
7587 	range_tree_vacate(mos_refd_objs, NULL, NULL);
7588 	range_tree_destroy(mos_refd_objs);
7589 	return (rv);
7590 }
7591 
7592 typedef struct log_sm_obsolete_stats_arg {
7593 	uint64_t lsos_current_txg;
7594 
7595 	uint64_t lsos_total_entries;
7596 	uint64_t lsos_valid_entries;
7597 
7598 	uint64_t lsos_sm_entries;
7599 	uint64_t lsos_valid_sm_entries;
7600 } log_sm_obsolete_stats_arg_t;
7601 
7602 static int
7603 log_spacemap_obsolete_stats_cb(spa_t *spa, space_map_entry_t *sme,
7604     uint64_t txg, void *arg)
7605 {
7606 	log_sm_obsolete_stats_arg_t *lsos = arg;
7607 
7608 	uint64_t offset = sme->sme_offset;
7609 	uint64_t vdev_id = sme->sme_vdev;
7610 
7611 	if (lsos->lsos_current_txg == 0) {
7612 		/* this is the first log */
7613 		lsos->lsos_current_txg = txg;
7614 	} else if (lsos->lsos_current_txg < txg) {
7615 		/* we just changed log - print stats and reset */
7616 		(void) printf("%-8llu valid entries out of %-8llu - txg %llu\n",
7617 		    (u_longlong_t)lsos->lsos_valid_sm_entries,
7618 		    (u_longlong_t)lsos->lsos_sm_entries,
7619 		    (u_longlong_t)lsos->lsos_current_txg);
7620 		lsos->lsos_valid_sm_entries = 0;
7621 		lsos->lsos_sm_entries = 0;
7622 		lsos->lsos_current_txg = txg;
7623 	}
7624 	ASSERT3U(lsos->lsos_current_txg, ==, txg);
7625 
7626 	lsos->lsos_sm_entries++;
7627 	lsos->lsos_total_entries++;
7628 
7629 	vdev_t *vd = vdev_lookup_top(spa, vdev_id);
7630 	if (!vdev_is_concrete(vd))
7631 		return (0);
7632 
7633 	metaslab_t *ms = vd->vdev_ms[offset >> vd->vdev_ms_shift];
7634 	ASSERT(sme->sme_type == SM_ALLOC || sme->sme_type == SM_FREE);
7635 
7636 	if (txg < metaslab_unflushed_txg(ms))
7637 		return (0);
7638 	lsos->lsos_valid_sm_entries++;
7639 	lsos->lsos_valid_entries++;
7640 	return (0);
7641 }
7642 
7643 static void
7644 dump_log_spacemap_obsolete_stats(spa_t *spa)
7645 {
7646 	if (!spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP))
7647 		return;
7648 
7649 	log_sm_obsolete_stats_arg_t lsos = {0};
7650 
7651 	(void) printf("Log Space Map Obsolete Entry Statistics:\n");
7652 
7653 	iterate_through_spacemap_logs(spa,
7654 	    log_spacemap_obsolete_stats_cb, &lsos);
7655 
7656 	/* print stats for latest log */
7657 	(void) printf("%-8llu valid entries out of %-8llu - txg %llu\n",
7658 	    (u_longlong_t)lsos.lsos_valid_sm_entries,
7659 	    (u_longlong_t)lsos.lsos_sm_entries,
7660 	    (u_longlong_t)lsos.lsos_current_txg);
7661 
7662 	(void) printf("%-8llu valid entries out of %-8llu - total\n\n",
7663 	    (u_longlong_t)lsos.lsos_valid_entries,
7664 	    (u_longlong_t)lsos.lsos_total_entries);
7665 }
7666 
7667 static void
7668 dump_zpool(spa_t *spa)
7669 {
7670 	dsl_pool_t *dp = spa_get_dsl(spa);
7671 	int rc = 0;
7672 
7673 	if (dump_opt['y']) {
7674 		livelist_metaslab_validate(spa);
7675 	}
7676 
7677 	if (dump_opt['S']) {
7678 		dump_simulated_ddt(spa);
7679 		return;
7680 	}
7681 
7682 	if (!dump_opt['e'] && dump_opt['C'] > 1) {
7683 		(void) printf("\nCached configuration:\n");
7684 		dump_nvlist(spa->spa_config, 8);
7685 	}
7686 
7687 	if (dump_opt['C'])
7688 		dump_config(spa);
7689 
7690 	if (dump_opt['u'])
7691 		dump_uberblock(&spa->spa_uberblock, "\nUberblock:\n", "\n");
7692 
7693 	if (dump_opt['D'])
7694 		dump_all_ddts(spa);
7695 
7696 	if (dump_opt['d'] > 2 || dump_opt['m'])
7697 		dump_metaslabs(spa);
7698 	if (dump_opt['M'])
7699 		dump_metaslab_groups(spa, dump_opt['M'] > 1);
7700 	if (dump_opt['d'] > 2 || dump_opt['m']) {
7701 		dump_log_spacemaps(spa);
7702 		dump_log_spacemap_obsolete_stats(spa);
7703 	}
7704 
7705 	if (dump_opt['d'] || dump_opt['i']) {
7706 		spa_feature_t f;
7707 		mos_refd_objs = range_tree_create(NULL, RANGE_SEG64, NULL, 0,
7708 		    0);
7709 		dump_objset(dp->dp_meta_objset);
7710 
7711 		if (dump_opt['d'] >= 3) {
7712 			dsl_pool_t *dp = spa->spa_dsl_pool;
7713 			dump_full_bpobj(&spa->spa_deferred_bpobj,
7714 			    "Deferred frees", 0);
7715 			if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
7716 				dump_full_bpobj(&dp->dp_free_bpobj,
7717 				    "Pool snapshot frees", 0);
7718 			}
7719 			if (bpobj_is_open(&dp->dp_obsolete_bpobj)) {
7720 				ASSERT(spa_feature_is_enabled(spa,
7721 				    SPA_FEATURE_DEVICE_REMOVAL));
7722 				dump_full_bpobj(&dp->dp_obsolete_bpobj,
7723 				    "Pool obsolete blocks", 0);
7724 			}
7725 
7726 			if (spa_feature_is_active(spa,
7727 			    SPA_FEATURE_ASYNC_DESTROY)) {
7728 				dump_bptree(spa->spa_meta_objset,
7729 				    dp->dp_bptree_obj,
7730 				    "Pool dataset frees");
7731 			}
7732 			dump_dtl(spa->spa_root_vdev, 0);
7733 		}
7734 
7735 		for (spa_feature_t f = 0; f < SPA_FEATURES; f++)
7736 			global_feature_count[f] = UINT64_MAX;
7737 		global_feature_count[SPA_FEATURE_REDACTION_BOOKMARKS] = 0;
7738 		global_feature_count[SPA_FEATURE_BOOKMARK_WRITTEN] = 0;
7739 		global_feature_count[SPA_FEATURE_LIVELIST] = 0;
7740 
7741 		(void) dmu_objset_find(spa_name(spa), dump_one_objset,
7742 		    NULL, DS_FIND_SNAPSHOTS | DS_FIND_CHILDREN);
7743 
7744 		if (rc == 0 && !dump_opt['L'])
7745 			rc = dump_mos_leaks(spa);
7746 
7747 		for (f = 0; f < SPA_FEATURES; f++) {
7748 			uint64_t refcount;
7749 
7750 			uint64_t *arr;
7751 			if (!(spa_feature_table[f].fi_flags &
7752 			    ZFEATURE_FLAG_PER_DATASET)) {
7753 				if (global_feature_count[f] == UINT64_MAX)
7754 					continue;
7755 				if (!spa_feature_is_enabled(spa, f)) {
7756 					ASSERT0(global_feature_count[f]);
7757 					continue;
7758 				}
7759 				arr = global_feature_count;
7760 			} else {
7761 				if (!spa_feature_is_enabled(spa, f)) {
7762 					ASSERT0(dataset_feature_count[f]);
7763 					continue;
7764 				}
7765 				arr = dataset_feature_count;
7766 			}
7767 			if (feature_get_refcount(spa, &spa_feature_table[f],
7768 			    &refcount) == ENOTSUP)
7769 				continue;
7770 			if (arr[f] != refcount) {
7771 				(void) printf("%s feature refcount mismatch: "
7772 				    "%lld consumers != %lld refcount\n",
7773 				    spa_feature_table[f].fi_uname,
7774 				    (longlong_t)arr[f], (longlong_t)refcount);
7775 				rc = 2;
7776 			} else {
7777 				(void) printf("Verified %s feature refcount "
7778 				    "of %llu is correct\n",
7779 				    spa_feature_table[f].fi_uname,
7780 				    (longlong_t)refcount);
7781 			}
7782 		}
7783 
7784 		if (rc == 0)
7785 			rc = verify_device_removal_feature_counts(spa);
7786 	}
7787 
7788 	if (rc == 0 && (dump_opt['b'] || dump_opt['c']))
7789 		rc = dump_block_stats(spa);
7790 
7791 	if (rc == 0)
7792 		rc = verify_spacemap_refcounts(spa);
7793 
7794 	if (dump_opt['s'])
7795 		show_pool_stats(spa);
7796 
7797 	if (dump_opt['h'])
7798 		dump_history(spa);
7799 
7800 	if (rc == 0)
7801 		rc = verify_checkpoint(spa);
7802 
7803 	if (rc != 0) {
7804 		dump_debug_buffer();
7805 		exit(rc);
7806 	}
7807 }
7808 
7809 #define	ZDB_FLAG_CHECKSUM	0x0001
7810 #define	ZDB_FLAG_DECOMPRESS	0x0002
7811 #define	ZDB_FLAG_BSWAP		0x0004
7812 #define	ZDB_FLAG_GBH		0x0008
7813 #define	ZDB_FLAG_INDIRECT	0x0010
7814 #define	ZDB_FLAG_RAW		0x0020
7815 #define	ZDB_FLAG_PRINT_BLKPTR	0x0040
7816 #define	ZDB_FLAG_VERBOSE	0x0080
7817 
7818 static int flagbits[256];
7819 static char flagbitstr[16];
7820 
7821 static void
7822 zdb_print_blkptr(const blkptr_t *bp, int flags)
7823 {
7824 	char blkbuf[BP_SPRINTF_LEN];
7825 
7826 	if (flags & ZDB_FLAG_BSWAP)
7827 		byteswap_uint64_array((void *)bp, sizeof (blkptr_t));
7828 
7829 	snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
7830 	(void) printf("%s\n", blkbuf);
7831 }
7832 
7833 static void
7834 zdb_dump_indirect(blkptr_t *bp, int nbps, int flags)
7835 {
7836 	int i;
7837 
7838 	for (i = 0; i < nbps; i++)
7839 		zdb_print_blkptr(&bp[i], flags);
7840 }
7841 
7842 static void
7843 zdb_dump_gbh(void *buf, int flags)
7844 {
7845 	zdb_dump_indirect((blkptr_t *)buf, SPA_GBH_NBLKPTRS, flags);
7846 }
7847 
7848 static void
7849 zdb_dump_block_raw(void *buf, uint64_t size, int flags)
7850 {
7851 	if (flags & ZDB_FLAG_BSWAP)
7852 		byteswap_uint64_array(buf, size);
7853 	VERIFY(write(fileno(stdout), buf, size) == size);
7854 }
7855 
7856 static void
7857 zdb_dump_block(char *label, void *buf, uint64_t size, int flags)
7858 {
7859 	uint64_t *d = (uint64_t *)buf;
7860 	unsigned nwords = size / sizeof (uint64_t);
7861 	int do_bswap = !!(flags & ZDB_FLAG_BSWAP);
7862 	unsigned i, j;
7863 	const char *hdr;
7864 	char *c;
7865 
7866 
7867 	if (do_bswap)
7868 		hdr = " 7 6 5 4 3 2 1 0   f e d c b a 9 8";
7869 	else
7870 		hdr = " 0 1 2 3 4 5 6 7   8 9 a b c d e f";
7871 
7872 	(void) printf("\n%s\n%6s   %s  0123456789abcdef\n", label, "", hdr);
7873 
7874 #ifdef _LITTLE_ENDIAN
7875 	/* correct the endianness */
7876 	do_bswap = !do_bswap;
7877 #endif
7878 	for (i = 0; i < nwords; i += 2) {
7879 		(void) printf("%06llx:  %016llx  %016llx  ",
7880 		    (u_longlong_t)(i * sizeof (uint64_t)),
7881 		    (u_longlong_t)(do_bswap ? BSWAP_64(d[i]) : d[i]),
7882 		    (u_longlong_t)(do_bswap ? BSWAP_64(d[i + 1]) : d[i + 1]));
7883 
7884 		c = (char *)&d[i];
7885 		for (j = 0; j < 2 * sizeof (uint64_t); j++)
7886 			(void) printf("%c", isprint(c[j]) ? c[j] : '.');
7887 		(void) printf("\n");
7888 	}
7889 }
7890 
7891 /*
7892  * There are two acceptable formats:
7893  *	leaf_name	  - For example: c1t0d0 or /tmp/ztest.0a
7894  *	child[.child]*    - For example: 0.1.1
7895  *
7896  * The second form can be used to specify arbitrary vdevs anywhere
7897  * in the hierarchy.  For example, in a pool with a mirror of
7898  * RAID-Zs, you can specify either RAID-Z vdev with 0.0 or 0.1 .
7899  */
7900 static vdev_t *
7901 zdb_vdev_lookup(vdev_t *vdev, const char *path)
7902 {
7903 	char *s, *p, *q;
7904 	unsigned i;
7905 
7906 	if (vdev == NULL)
7907 		return (NULL);
7908 
7909 	/* First, assume the x.x.x.x format */
7910 	i = strtoul(path, &s, 10);
7911 	if (s == path || (s && *s != '.' && *s != '\0'))
7912 		goto name;
7913 	if (i >= vdev->vdev_children)
7914 		return (NULL);
7915 
7916 	vdev = vdev->vdev_child[i];
7917 	if (s && *s == '\0')
7918 		return (vdev);
7919 	return (zdb_vdev_lookup(vdev, s+1));
7920 
7921 name:
7922 	for (i = 0; i < vdev->vdev_children; i++) {
7923 		vdev_t *vc = vdev->vdev_child[i];
7924 
7925 		if (vc->vdev_path == NULL) {
7926 			vc = zdb_vdev_lookup(vc, path);
7927 			if (vc == NULL)
7928 				continue;
7929 			else
7930 				return (vc);
7931 		}
7932 
7933 		p = strrchr(vc->vdev_path, '/');
7934 		p = p ? p + 1 : vc->vdev_path;
7935 		q = &vc->vdev_path[strlen(vc->vdev_path) - 2];
7936 
7937 		if (strcmp(vc->vdev_path, path) == 0)
7938 			return (vc);
7939 		if (strcmp(p, path) == 0)
7940 			return (vc);
7941 		if (strcmp(q, "s0") == 0 && strncmp(p, path, q - p) == 0)
7942 			return (vc);
7943 	}
7944 
7945 	return (NULL);
7946 }
7947 
7948 static int
7949 name_from_objset_id(spa_t *spa, uint64_t objset_id, char *outstr)
7950 {
7951 	dsl_dataset_t *ds;
7952 
7953 	dsl_pool_config_enter(spa->spa_dsl_pool, FTAG);
7954 	int error = dsl_dataset_hold_obj(spa->spa_dsl_pool, objset_id,
7955 	    NULL, &ds);
7956 	if (error != 0) {
7957 		(void) fprintf(stderr, "failed to hold objset %llu: %s\n",
7958 		    (u_longlong_t)objset_id, strerror(error));
7959 		dsl_pool_config_exit(spa->spa_dsl_pool, FTAG);
7960 		return (error);
7961 	}
7962 	dsl_dataset_name(ds, outstr);
7963 	dsl_dataset_rele(ds, NULL);
7964 	dsl_pool_config_exit(spa->spa_dsl_pool, FTAG);
7965 	return (0);
7966 }
7967 
7968 static boolean_t
7969 zdb_parse_block_sizes(char *sizes, uint64_t *lsize, uint64_t *psize)
7970 {
7971 	char *s0, *s1, *tmp = NULL;
7972 
7973 	if (sizes == NULL)
7974 		return (B_FALSE);
7975 
7976 	s0 = strtok_r(sizes, "/", &tmp);
7977 	if (s0 == NULL)
7978 		return (B_FALSE);
7979 	s1 = strtok_r(NULL, "/", &tmp);
7980 	*lsize = strtoull(s0, NULL, 16);
7981 	*psize = s1 ? strtoull(s1, NULL, 16) : *lsize;
7982 	return (*lsize >= *psize && *psize > 0);
7983 }
7984 
7985 #define	ZIO_COMPRESS_MASK(alg)	(1ULL << (ZIO_COMPRESS_##alg))
7986 
7987 static boolean_t
7988 zdb_decompress_block(abd_t *pabd, void *buf, void *lbuf, uint64_t lsize,
7989     uint64_t psize, int flags)
7990 {
7991 	(void) buf;
7992 	boolean_t exceeded = B_FALSE;
7993 	/*
7994 	 * We don't know how the data was compressed, so just try
7995 	 * every decompress function at every inflated blocksize.
7996 	 */
7997 	void *lbuf2 = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
7998 	int cfuncs[ZIO_COMPRESS_FUNCTIONS] = { 0 };
7999 	int *cfuncp = cfuncs;
8000 	uint64_t maxlsize = SPA_MAXBLOCKSIZE;
8001 	uint64_t mask = ZIO_COMPRESS_MASK(ON) | ZIO_COMPRESS_MASK(OFF) |
8002 	    ZIO_COMPRESS_MASK(INHERIT) | ZIO_COMPRESS_MASK(EMPTY) |
8003 	    (getenv("ZDB_NO_ZLE") ? ZIO_COMPRESS_MASK(ZLE) : 0);
8004 	*cfuncp++ = ZIO_COMPRESS_LZ4;
8005 	*cfuncp++ = ZIO_COMPRESS_LZJB;
8006 	mask |= ZIO_COMPRESS_MASK(LZ4) | ZIO_COMPRESS_MASK(LZJB);
8007 	for (int c = 0; c < ZIO_COMPRESS_FUNCTIONS; c++)
8008 		if (((1ULL << c) & mask) == 0)
8009 			*cfuncp++ = c;
8010 
8011 	/*
8012 	 * On the one hand, with SPA_MAXBLOCKSIZE at 16MB, this
8013 	 * could take a while and we should let the user know
8014 	 * we are not stuck.  On the other hand, printing progress
8015 	 * info gets old after a while.  User can specify 'v' flag
8016 	 * to see the progression.
8017 	 */
8018 	if (lsize == psize)
8019 		lsize += SPA_MINBLOCKSIZE;
8020 	else
8021 		maxlsize = lsize;
8022 	for (; lsize <= maxlsize; lsize += SPA_MINBLOCKSIZE) {
8023 		for (cfuncp = cfuncs; *cfuncp; cfuncp++) {
8024 			if (flags & ZDB_FLAG_VERBOSE) {
8025 				(void) fprintf(stderr,
8026 				    "Trying %05llx -> %05llx (%s)\n",
8027 				    (u_longlong_t)psize,
8028 				    (u_longlong_t)lsize,
8029 				    zio_compress_table[*cfuncp].\
8030 				    ci_name);
8031 			}
8032 
8033 			/*
8034 			 * We randomize lbuf2, and decompress to both
8035 			 * lbuf and lbuf2. This way, we will know if
8036 			 * decompression fill exactly to lsize.
8037 			 */
8038 			VERIFY0(random_get_pseudo_bytes(lbuf2, lsize));
8039 
8040 			if (zio_decompress_data(*cfuncp, pabd,
8041 			    lbuf, psize, lsize, NULL) == 0 &&
8042 			    zio_decompress_data(*cfuncp, pabd,
8043 			    lbuf2, psize, lsize, NULL) == 0 &&
8044 			    memcmp(lbuf, lbuf2, lsize) == 0)
8045 				break;
8046 		}
8047 		if (*cfuncp != 0)
8048 			break;
8049 	}
8050 	umem_free(lbuf2, SPA_MAXBLOCKSIZE);
8051 
8052 	if (lsize > maxlsize) {
8053 		exceeded = B_TRUE;
8054 	}
8055 	if (*cfuncp == ZIO_COMPRESS_ZLE) {
8056 		printf("\nZLE decompression was selected. If you "
8057 		    "suspect the results are wrong,\ntry avoiding ZLE "
8058 		    "by setting and exporting ZDB_NO_ZLE=\"true\"\n");
8059 	}
8060 
8061 	return (exceeded);
8062 }
8063 
8064 /*
8065  * Read a block from a pool and print it out.  The syntax of the
8066  * block descriptor is:
8067  *
8068  *	pool:vdev_specifier:offset:[lsize/]psize[:flags]
8069  *
8070  *	pool           - The name of the pool you wish to read from
8071  *	vdev_specifier - Which vdev (see comment for zdb_vdev_lookup)
8072  *	offset         - offset, in hex, in bytes
8073  *	size           - Amount of data to read, in hex, in bytes
8074  *	flags          - A string of characters specifying options
8075  *		 b: Decode a blkptr at given offset within block
8076  *		 c: Calculate and display checksums
8077  *		 d: Decompress data before dumping
8078  *		 e: Byteswap data before dumping
8079  *		 g: Display data as a gang block header
8080  *		 i: Display as an indirect block
8081  *		 r: Dump raw data to stdout
8082  *		 v: Verbose
8083  *
8084  */
8085 static void
8086 zdb_read_block(char *thing, spa_t *spa)
8087 {
8088 	blkptr_t blk, *bp = &blk;
8089 	dva_t *dva = bp->blk_dva;
8090 	int flags = 0;
8091 	uint64_t offset = 0, psize = 0, lsize = 0, blkptr_offset = 0;
8092 	zio_t *zio;
8093 	vdev_t *vd;
8094 	abd_t *pabd;
8095 	void *lbuf, *buf;
8096 	char *s, *p, *dup, *vdev, *flagstr, *sizes, *tmp = NULL;
8097 	int i, error;
8098 	boolean_t borrowed = B_FALSE, found = B_FALSE;
8099 
8100 	dup = strdup(thing);
8101 	s = strtok_r(dup, ":", &tmp);
8102 	vdev = s ? s : "";
8103 	s = strtok_r(NULL, ":", &tmp);
8104 	offset = strtoull(s ? s : "", NULL, 16);
8105 	sizes = strtok_r(NULL, ":", &tmp);
8106 	s = strtok_r(NULL, ":", &tmp);
8107 	flagstr = strdup(s ? s : "");
8108 
8109 	s = NULL;
8110 	tmp = NULL;
8111 	if (!zdb_parse_block_sizes(sizes, &lsize, &psize))
8112 		s = "invalid size(s)";
8113 	if (!IS_P2ALIGNED(psize, DEV_BSIZE) || !IS_P2ALIGNED(lsize, DEV_BSIZE))
8114 		s = "size must be a multiple of sector size";
8115 	if (!IS_P2ALIGNED(offset, DEV_BSIZE))
8116 		s = "offset must be a multiple of sector size";
8117 	if (s) {
8118 		(void) printf("Invalid block specifier: %s  - %s\n", thing, s);
8119 		goto done;
8120 	}
8121 
8122 	for (s = strtok_r(flagstr, ":", &tmp);
8123 	    s != NULL;
8124 	    s = strtok_r(NULL, ":", &tmp)) {
8125 		for (i = 0; i < strlen(flagstr); i++) {
8126 			int bit = flagbits[(uchar_t)flagstr[i]];
8127 
8128 			if (bit == 0) {
8129 				(void) printf("***Ignoring flag: %c\n",
8130 				    (uchar_t)flagstr[i]);
8131 				continue;
8132 			}
8133 			found = B_TRUE;
8134 			flags |= bit;
8135 
8136 			p = &flagstr[i + 1];
8137 			if (*p != ':' && *p != '\0') {
8138 				int j = 0, nextbit = flagbits[(uchar_t)*p];
8139 				char *end, offstr[8] = { 0 };
8140 				if ((bit == ZDB_FLAG_PRINT_BLKPTR) &&
8141 				    (nextbit == 0)) {
8142 					/* look ahead to isolate the offset */
8143 					while (nextbit == 0 &&
8144 					    strchr(flagbitstr, *p) == NULL) {
8145 						offstr[j] = *p;
8146 						j++;
8147 						if (i + j > strlen(flagstr))
8148 							break;
8149 						p++;
8150 						nextbit = flagbits[(uchar_t)*p];
8151 					}
8152 					blkptr_offset = strtoull(offstr, &end,
8153 					    16);
8154 					i += j;
8155 				} else if (nextbit == 0) {
8156 					(void) printf("***Ignoring flag arg:"
8157 					    " '%c'\n", (uchar_t)*p);
8158 				}
8159 			}
8160 		}
8161 	}
8162 	if (blkptr_offset % sizeof (blkptr_t)) {
8163 		printf("Block pointer offset 0x%llx "
8164 		    "must be divisible by 0x%x\n",
8165 		    (longlong_t)blkptr_offset, (int)sizeof (blkptr_t));
8166 		goto done;
8167 	}
8168 	if (found == B_FALSE && strlen(flagstr) > 0) {
8169 		printf("Invalid flag arg: '%s'\n", flagstr);
8170 		goto done;
8171 	}
8172 
8173 	vd = zdb_vdev_lookup(spa->spa_root_vdev, vdev);
8174 	if (vd == NULL) {
8175 		(void) printf("***Invalid vdev: %s\n", vdev);
8176 		free(dup);
8177 		return;
8178 	} else {
8179 		if (vd->vdev_path)
8180 			(void) fprintf(stderr, "Found vdev: %s\n",
8181 			    vd->vdev_path);
8182 		else
8183 			(void) fprintf(stderr, "Found vdev type: %s\n",
8184 			    vd->vdev_ops->vdev_op_type);
8185 	}
8186 
8187 	pabd = abd_alloc_for_io(SPA_MAXBLOCKSIZE, B_FALSE);
8188 	lbuf = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
8189 
8190 	BP_ZERO(bp);
8191 
8192 	DVA_SET_VDEV(&dva[0], vd->vdev_id);
8193 	DVA_SET_OFFSET(&dva[0], offset);
8194 	DVA_SET_GANG(&dva[0], !!(flags & ZDB_FLAG_GBH));
8195 	DVA_SET_ASIZE(&dva[0], vdev_psize_to_asize(vd, psize));
8196 
8197 	BP_SET_BIRTH(bp, TXG_INITIAL, TXG_INITIAL);
8198 
8199 	BP_SET_LSIZE(bp, lsize);
8200 	BP_SET_PSIZE(bp, psize);
8201 	BP_SET_COMPRESS(bp, ZIO_COMPRESS_OFF);
8202 	BP_SET_CHECKSUM(bp, ZIO_CHECKSUM_OFF);
8203 	BP_SET_TYPE(bp, DMU_OT_NONE);
8204 	BP_SET_LEVEL(bp, 0);
8205 	BP_SET_DEDUP(bp, 0);
8206 	BP_SET_BYTEORDER(bp, ZFS_HOST_BYTEORDER);
8207 
8208 	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
8209 	zio = zio_root(spa, NULL, NULL, 0);
8210 
8211 	if (vd == vd->vdev_top) {
8212 		/*
8213 		 * Treat this as a normal block read.
8214 		 */
8215 		zio_nowait(zio_read(zio, spa, bp, pabd, psize, NULL, NULL,
8216 		    ZIO_PRIORITY_SYNC_READ,
8217 		    ZIO_FLAG_CANFAIL | ZIO_FLAG_RAW, NULL));
8218 	} else {
8219 		/*
8220 		 * Treat this as a vdev child I/O.
8221 		 */
8222 		zio_nowait(zio_vdev_child_io(zio, bp, vd, offset, pabd,
8223 		    psize, ZIO_TYPE_READ, ZIO_PRIORITY_SYNC_READ,
8224 		    ZIO_FLAG_DONT_CACHE | ZIO_FLAG_DONT_PROPAGATE |
8225 		    ZIO_FLAG_DONT_RETRY | ZIO_FLAG_CANFAIL | ZIO_FLAG_RAW |
8226 		    ZIO_FLAG_OPTIONAL, NULL, NULL));
8227 	}
8228 
8229 	error = zio_wait(zio);
8230 	spa_config_exit(spa, SCL_STATE, FTAG);
8231 
8232 	if (error) {
8233 		(void) printf("Read of %s failed, error: %d\n", thing, error);
8234 		goto out;
8235 	}
8236 
8237 	uint64_t orig_lsize = lsize;
8238 	buf = lbuf;
8239 	if (flags & ZDB_FLAG_DECOMPRESS) {
8240 		boolean_t failed = zdb_decompress_block(pabd, buf, lbuf,
8241 		    lsize, psize, flags);
8242 		if (failed) {
8243 			(void) printf("Decompress of %s failed\n", thing);
8244 			goto out;
8245 		}
8246 	} else {
8247 		buf = abd_borrow_buf_copy(pabd, lsize);
8248 		borrowed = B_TRUE;
8249 	}
8250 	/*
8251 	 * Try to detect invalid block pointer.  If invalid, try
8252 	 * decompressing.
8253 	 */
8254 	if ((flags & ZDB_FLAG_PRINT_BLKPTR || flags & ZDB_FLAG_INDIRECT) &&
8255 	    !(flags & ZDB_FLAG_DECOMPRESS)) {
8256 		const blkptr_t *b = (const blkptr_t *)(void *)
8257 		    ((uintptr_t)buf + (uintptr_t)blkptr_offset);
8258 		if (zfs_blkptr_verify(spa, b, B_FALSE, BLK_VERIFY_ONLY) ==
8259 		    B_FALSE) {
8260 			abd_return_buf_copy(pabd, buf, lsize);
8261 			borrowed = B_FALSE;
8262 			buf = lbuf;
8263 			boolean_t failed = zdb_decompress_block(pabd, buf,
8264 			    lbuf, lsize, psize, flags);
8265 			b = (const blkptr_t *)(void *)
8266 			    ((uintptr_t)buf + (uintptr_t)blkptr_offset);
8267 			if (failed || zfs_blkptr_verify(spa, b, B_FALSE,
8268 			    BLK_VERIFY_LOG) == B_FALSE) {
8269 				printf("invalid block pointer at this DVA\n");
8270 				goto out;
8271 			}
8272 		}
8273 	}
8274 
8275 	if (flags & ZDB_FLAG_PRINT_BLKPTR)
8276 		zdb_print_blkptr((blkptr_t *)(void *)
8277 		    ((uintptr_t)buf + (uintptr_t)blkptr_offset), flags);
8278 	else if (flags & ZDB_FLAG_RAW)
8279 		zdb_dump_block_raw(buf, lsize, flags);
8280 	else if (flags & ZDB_FLAG_INDIRECT)
8281 		zdb_dump_indirect((blkptr_t *)buf,
8282 		    orig_lsize / sizeof (blkptr_t), flags);
8283 	else if (flags & ZDB_FLAG_GBH)
8284 		zdb_dump_gbh(buf, flags);
8285 	else
8286 		zdb_dump_block(thing, buf, lsize, flags);
8287 
8288 	/*
8289 	 * If :c was specified, iterate through the checksum table to
8290 	 * calculate and display each checksum for our specified
8291 	 * DVA and length.
8292 	 */
8293 	if ((flags & ZDB_FLAG_CHECKSUM) && !(flags & ZDB_FLAG_RAW) &&
8294 	    !(flags & ZDB_FLAG_GBH)) {
8295 		zio_t *czio;
8296 		(void) printf("\n");
8297 		for (enum zio_checksum ck = ZIO_CHECKSUM_LABEL;
8298 		    ck < ZIO_CHECKSUM_FUNCTIONS; ck++) {
8299 
8300 			if ((zio_checksum_table[ck].ci_flags &
8301 			    ZCHECKSUM_FLAG_EMBEDDED) ||
8302 			    ck == ZIO_CHECKSUM_NOPARITY) {
8303 				continue;
8304 			}
8305 			BP_SET_CHECKSUM(bp, ck);
8306 			spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
8307 			czio = zio_root(spa, NULL, NULL, ZIO_FLAG_CANFAIL);
8308 			czio->io_bp = bp;
8309 
8310 			if (vd == vd->vdev_top) {
8311 				zio_nowait(zio_read(czio, spa, bp, pabd, psize,
8312 				    NULL, NULL,
8313 				    ZIO_PRIORITY_SYNC_READ,
8314 				    ZIO_FLAG_CANFAIL | ZIO_FLAG_RAW |
8315 				    ZIO_FLAG_DONT_RETRY, NULL));
8316 			} else {
8317 				zio_nowait(zio_vdev_child_io(czio, bp, vd,
8318 				    offset, pabd, psize, ZIO_TYPE_READ,
8319 				    ZIO_PRIORITY_SYNC_READ,
8320 				    ZIO_FLAG_DONT_CACHE |
8321 				    ZIO_FLAG_DONT_PROPAGATE |
8322 				    ZIO_FLAG_DONT_RETRY |
8323 				    ZIO_FLAG_CANFAIL | ZIO_FLAG_RAW |
8324 				    ZIO_FLAG_SPECULATIVE |
8325 				    ZIO_FLAG_OPTIONAL, NULL, NULL));
8326 			}
8327 			error = zio_wait(czio);
8328 			if (error == 0 || error == ECKSUM) {
8329 				zio_t *ck_zio = zio_root(spa, NULL, NULL, 0);
8330 				ck_zio->io_offset =
8331 				    DVA_GET_OFFSET(&bp->blk_dva[0]);
8332 				ck_zio->io_bp = bp;
8333 				zio_checksum_compute(ck_zio, ck, pabd, lsize);
8334 				printf("%12s\tcksum=%llx:%llx:%llx:%llx\n",
8335 				    zio_checksum_table[ck].ci_name,
8336 				    (u_longlong_t)bp->blk_cksum.zc_word[0],
8337 				    (u_longlong_t)bp->blk_cksum.zc_word[1],
8338 				    (u_longlong_t)bp->blk_cksum.zc_word[2],
8339 				    (u_longlong_t)bp->blk_cksum.zc_word[3]);
8340 				zio_wait(ck_zio);
8341 			} else {
8342 				printf("error %d reading block\n", error);
8343 			}
8344 			spa_config_exit(spa, SCL_STATE, FTAG);
8345 		}
8346 	}
8347 
8348 	if (borrowed)
8349 		abd_return_buf_copy(pabd, buf, lsize);
8350 
8351 out:
8352 	abd_free(pabd);
8353 	umem_free(lbuf, SPA_MAXBLOCKSIZE);
8354 done:
8355 	free(flagstr);
8356 	free(dup);
8357 }
8358 
8359 static void
8360 zdb_embedded_block(char *thing)
8361 {
8362 	blkptr_t bp = {{{{0}}}};
8363 	unsigned long long *words = (void *)&bp;
8364 	char *buf;
8365 	int err;
8366 
8367 	err = sscanf(thing, "%llx:%llx:%llx:%llx:%llx:%llx:%llx:%llx:"
8368 	    "%llx:%llx:%llx:%llx:%llx:%llx:%llx:%llx",
8369 	    words + 0, words + 1, words + 2, words + 3,
8370 	    words + 4, words + 5, words + 6, words + 7,
8371 	    words + 8, words + 9, words + 10, words + 11,
8372 	    words + 12, words + 13, words + 14, words + 15);
8373 	if (err != 16) {
8374 		(void) fprintf(stderr, "invalid input format\n");
8375 		exit(1);
8376 	}
8377 	ASSERT3U(BPE_GET_LSIZE(&bp), <=, SPA_MAXBLOCKSIZE);
8378 	buf = malloc(SPA_MAXBLOCKSIZE);
8379 	if (buf == NULL) {
8380 		(void) fprintf(stderr, "out of memory\n");
8381 		exit(1);
8382 	}
8383 	err = decode_embedded_bp(&bp, buf, BPE_GET_LSIZE(&bp));
8384 	if (err != 0) {
8385 		(void) fprintf(stderr, "decode failed: %u\n", err);
8386 		exit(1);
8387 	}
8388 	zdb_dump_block_raw(buf, BPE_GET_LSIZE(&bp), 0);
8389 	free(buf);
8390 }
8391 
8392 /* check for valid hex or decimal numeric string */
8393 static boolean_t
8394 zdb_numeric(char *str)
8395 {
8396 	int i = 0;
8397 
8398 	if (strlen(str) == 0)
8399 		return (B_FALSE);
8400 	if (strncmp(str, "0x", 2) == 0 || strncmp(str, "0X", 2) == 0)
8401 		i = 2;
8402 	for (; i < strlen(str); i++) {
8403 		if (!isxdigit(str[i]))
8404 			return (B_FALSE);
8405 	}
8406 	return (B_TRUE);
8407 }
8408 
8409 int
8410 main(int argc, char **argv)
8411 {
8412 	int c;
8413 	spa_t *spa = NULL;
8414 	objset_t *os = NULL;
8415 	int dump_all = 1;
8416 	int verbose = 0;
8417 	int error = 0;
8418 	char **searchdirs = NULL;
8419 	int nsearch = 0;
8420 	char *target, *target_pool, dsname[ZFS_MAX_DATASET_NAME_LEN];
8421 	nvlist_t *policy = NULL;
8422 	uint64_t max_txg = UINT64_MAX;
8423 	int64_t objset_id = -1;
8424 	uint64_t object;
8425 	int flags = ZFS_IMPORT_MISSING_LOG;
8426 	int rewind = ZPOOL_NEVER_REWIND;
8427 	char *spa_config_path_env, *objset_str;
8428 	boolean_t target_is_spa = B_TRUE, dataset_lookup = B_FALSE;
8429 	nvlist_t *cfg = NULL;
8430 
8431 	dprintf_setup(&argc, argv);
8432 
8433 	/*
8434 	 * If there is an environment variable SPA_CONFIG_PATH it overrides
8435 	 * default spa_config_path setting. If -U flag is specified it will
8436 	 * override this environment variable settings once again.
8437 	 */
8438 	spa_config_path_env = getenv("SPA_CONFIG_PATH");
8439 	if (spa_config_path_env != NULL)
8440 		spa_config_path = spa_config_path_env;
8441 
8442 	/*
8443 	 * For performance reasons, we set this tunable down. We do so before
8444 	 * the arg parsing section so that the user can override this value if
8445 	 * they choose.
8446 	 */
8447 	zfs_btree_verify_intensity = 3;
8448 
8449 	struct option long_options[] = {
8450 		{"ignore-assertions",	no_argument,		NULL, 'A'},
8451 		{"block-stats",		no_argument,		NULL, 'b'},
8452 		{"checksum",		no_argument,		NULL, 'c'},
8453 		{"config",		no_argument,		NULL, 'C'},
8454 		{"datasets",		no_argument,		NULL, 'd'},
8455 		{"dedup-stats",		no_argument,		NULL, 'D'},
8456 		{"exported",		no_argument,		NULL, 'e'},
8457 		{"embedded-block-pointer",	no_argument,	NULL, 'E'},
8458 		{"automatic-rewind",	no_argument,		NULL, 'F'},
8459 		{"dump-debug-msg",	no_argument,		NULL, 'G'},
8460 		{"history",		no_argument,		NULL, 'h'},
8461 		{"intent-logs",		no_argument,		NULL, 'i'},
8462 		{"inflight",		required_argument,	NULL, 'I'},
8463 		{"checkpointed-state",	no_argument,		NULL, 'k'},
8464 		{"label",		no_argument,		NULL, 'l'},
8465 		{"disable-leak-tracking",	no_argument,	NULL, 'L'},
8466 		{"metaslabs",		no_argument,		NULL, 'm'},
8467 		{"metaslab-groups",	no_argument,		NULL, 'M'},
8468 		{"numeric",		no_argument,		NULL, 'N'},
8469 		{"option",		required_argument,	NULL, 'o'},
8470 		{"object-lookups",	no_argument,		NULL, 'O'},
8471 		{"path",		required_argument,	NULL, 'p'},
8472 		{"parseable",		no_argument,		NULL, 'P'},
8473 		{"skip-label",		no_argument,		NULL, 'q'},
8474 		{"copy-object",		no_argument,		NULL, 'r'},
8475 		{"read-block",		no_argument,		NULL, 'R'},
8476 		{"io-stats",		no_argument,		NULL, 's'},
8477 		{"simulate-dedup",	no_argument,		NULL, 'S'},
8478 		{"txg",			required_argument,	NULL, 't'},
8479 		{"uberblock",		no_argument,		NULL, 'u'},
8480 		{"cachefile",		required_argument,	NULL, 'U'},
8481 		{"verbose",		no_argument,		NULL, 'v'},
8482 		{"verbatim",		no_argument,		NULL, 'V'},
8483 		{"dump-blocks",		required_argument,	NULL, 'x'},
8484 		{"extreme-rewind",	no_argument,		NULL, 'X'},
8485 		{"all-reconstruction",	no_argument,		NULL, 'Y'},
8486 		{"livelist",		no_argument,		NULL, 'y'},
8487 		{"zstd-headers",	no_argument,		NULL, 'Z'},
8488 		{0, 0, 0, 0}
8489 	};
8490 
8491 	while ((c = getopt_long(argc, argv,
8492 	    "AbcCdDeEFGhiI:klLmMNo:Op:PqrRsSt:uU:vVx:XYyZ",
8493 	    long_options, NULL)) != -1) {
8494 		switch (c) {
8495 		case 'b':
8496 		case 'c':
8497 		case 'C':
8498 		case 'd':
8499 		case 'D':
8500 		case 'E':
8501 		case 'G':
8502 		case 'h':
8503 		case 'i':
8504 		case 'l':
8505 		case 'm':
8506 		case 'M':
8507 		case 'N':
8508 		case 'O':
8509 		case 'r':
8510 		case 'R':
8511 		case 's':
8512 		case 'S':
8513 		case 'u':
8514 		case 'y':
8515 		case 'Z':
8516 			dump_opt[c]++;
8517 			dump_all = 0;
8518 			break;
8519 		case 'A':
8520 		case 'e':
8521 		case 'F':
8522 		case 'k':
8523 		case 'L':
8524 		case 'P':
8525 		case 'q':
8526 		case 'X':
8527 			dump_opt[c]++;
8528 			break;
8529 		case 'Y':
8530 			zfs_reconstruct_indirect_combinations_max = INT_MAX;
8531 			zfs_deadman_enabled = 0;
8532 			break;
8533 		/* NB: Sort single match options below. */
8534 		case 'I':
8535 			max_inflight_bytes = strtoull(optarg, NULL, 0);
8536 			if (max_inflight_bytes == 0) {
8537 				(void) fprintf(stderr, "maximum number "
8538 				    "of inflight bytes must be greater "
8539 				    "than 0\n");
8540 				usage();
8541 			}
8542 			break;
8543 		case 'o':
8544 			error = set_global_var(optarg);
8545 			if (error != 0)
8546 				usage();
8547 			break;
8548 		case 'p':
8549 			if (searchdirs == NULL) {
8550 				searchdirs = umem_alloc(sizeof (char *),
8551 				    UMEM_NOFAIL);
8552 			} else {
8553 				char **tmp = umem_alloc((nsearch + 1) *
8554 				    sizeof (char *), UMEM_NOFAIL);
8555 				memcpy(tmp, searchdirs, nsearch *
8556 				    sizeof (char *));
8557 				umem_free(searchdirs,
8558 				    nsearch * sizeof (char *));
8559 				searchdirs = tmp;
8560 			}
8561 			searchdirs[nsearch++] = optarg;
8562 			break;
8563 		case 't':
8564 			max_txg = strtoull(optarg, NULL, 0);
8565 			if (max_txg < TXG_INITIAL) {
8566 				(void) fprintf(stderr, "incorrect txg "
8567 				    "specified: %s\n", optarg);
8568 				usage();
8569 			}
8570 			break;
8571 		case 'U':
8572 			spa_config_path = optarg;
8573 			if (spa_config_path[0] != '/') {
8574 				(void) fprintf(stderr,
8575 				    "cachefile must be an absolute path "
8576 				    "(i.e. start with a slash)\n");
8577 				usage();
8578 			}
8579 			break;
8580 		case 'v':
8581 			verbose++;
8582 			break;
8583 		case 'V':
8584 			flags = ZFS_IMPORT_VERBATIM;
8585 			break;
8586 		case 'x':
8587 			vn_dumpdir = optarg;
8588 			break;
8589 		default:
8590 			usage();
8591 			break;
8592 		}
8593 	}
8594 
8595 	if (!dump_opt['e'] && searchdirs != NULL) {
8596 		(void) fprintf(stderr, "-p option requires use of -e\n");
8597 		usage();
8598 	}
8599 #if defined(_LP64)
8600 	/*
8601 	 * ZDB does not typically re-read blocks; therefore limit the ARC
8602 	 * to 256 MB, which can be used entirely for metadata.
8603 	 */
8604 	zfs_arc_min = zfs_arc_meta_min = 2ULL << SPA_MAXBLOCKSHIFT;
8605 	zfs_arc_max = zfs_arc_meta_limit = 256 * 1024 * 1024;
8606 #endif
8607 
8608 	/*
8609 	 * "zdb -c" uses checksum-verifying scrub i/os which are async reads.
8610 	 * "zdb -b" uses traversal prefetch which uses async reads.
8611 	 * For good performance, let several of them be active at once.
8612 	 */
8613 	zfs_vdev_async_read_max_active = 10;
8614 
8615 	/*
8616 	 * Disable reference tracking for better performance.
8617 	 */
8618 	reference_tracking_enable = B_FALSE;
8619 
8620 	/*
8621 	 * Do not fail spa_load when spa_load_verify fails. This is needed
8622 	 * to load non-idle pools.
8623 	 */
8624 	spa_load_verify_dryrun = B_TRUE;
8625 
8626 	/*
8627 	 * ZDB should have ability to read spacemaps.
8628 	 */
8629 	spa_mode_readable_spacemaps = B_TRUE;
8630 
8631 	kernel_init(SPA_MODE_READ);
8632 
8633 	if (dump_all)
8634 		verbose = MAX(verbose, 1);
8635 
8636 	for (c = 0; c < 256; c++) {
8637 		if (dump_all && strchr("AeEFklLNOPrRSXy", c) == NULL)
8638 			dump_opt[c] = 1;
8639 		if (dump_opt[c])
8640 			dump_opt[c] += verbose;
8641 	}
8642 
8643 	libspl_set_assert_ok((dump_opt['A'] == 1) || (dump_opt['A'] > 2));
8644 	zfs_recover = (dump_opt['A'] > 1);
8645 
8646 	argc -= optind;
8647 	argv += optind;
8648 	if (argc < 2 && dump_opt['R'])
8649 		usage();
8650 
8651 	if (dump_opt['E']) {
8652 		if (argc != 1)
8653 			usage();
8654 		zdb_embedded_block(argv[0]);
8655 		return (0);
8656 	}
8657 
8658 	if (argc < 1) {
8659 		if (!dump_opt['e'] && dump_opt['C']) {
8660 			dump_cachefile(spa_config_path);
8661 			return (0);
8662 		}
8663 		usage();
8664 	}
8665 
8666 	if (dump_opt['l'])
8667 		return (dump_label(argv[0]));
8668 
8669 	if (dump_opt['O']) {
8670 		if (argc != 2)
8671 			usage();
8672 		dump_opt['v'] = verbose + 3;
8673 		return (dump_path(argv[0], argv[1], NULL));
8674 	}
8675 	if (dump_opt['r']) {
8676 		target_is_spa = B_FALSE;
8677 		if (argc != 3)
8678 			usage();
8679 		dump_opt['v'] = verbose;
8680 		error = dump_path(argv[0], argv[1], &object);
8681 	}
8682 
8683 	if (dump_opt['X'] || dump_opt['F'])
8684 		rewind = ZPOOL_DO_REWIND |
8685 		    (dump_opt['X'] ? ZPOOL_EXTREME_REWIND : 0);
8686 
8687 	/* -N implies -d */
8688 	if (dump_opt['N'] && dump_opt['d'] == 0)
8689 		dump_opt['d'] = dump_opt['N'];
8690 
8691 	if (nvlist_alloc(&policy, NV_UNIQUE_NAME_TYPE, 0) != 0 ||
8692 	    nvlist_add_uint64(policy, ZPOOL_LOAD_REQUEST_TXG, max_txg) != 0 ||
8693 	    nvlist_add_uint32(policy, ZPOOL_LOAD_REWIND_POLICY, rewind) != 0)
8694 		fatal("internal error: %s", strerror(ENOMEM));
8695 
8696 	error = 0;
8697 	target = argv[0];
8698 
8699 	if (strpbrk(target, "/@") != NULL) {
8700 		size_t targetlen;
8701 
8702 		target_pool = strdup(target);
8703 		*strpbrk(target_pool, "/@") = '\0';
8704 
8705 		target_is_spa = B_FALSE;
8706 		targetlen = strlen(target);
8707 		if (targetlen && target[targetlen - 1] == '/')
8708 			target[targetlen - 1] = '\0';
8709 
8710 		/*
8711 		 * See if an objset ID was supplied (-d <pool>/<objset ID>).
8712 		 * To disambiguate tank/100, consider the 100 as objsetID
8713 		 * if -N was given, otherwise 100 is an objsetID iff
8714 		 * tank/100 as a named dataset fails on lookup.
8715 		 */
8716 		objset_str = strchr(target, '/');
8717 		if (objset_str && strlen(objset_str) > 1 &&
8718 		    zdb_numeric(objset_str + 1)) {
8719 			char *endptr;
8720 			errno = 0;
8721 			objset_str++;
8722 			objset_id = strtoull(objset_str, &endptr, 0);
8723 			/* dataset 0 is the same as opening the pool */
8724 			if (errno == 0 && endptr != objset_str &&
8725 			    objset_id != 0) {
8726 				if (dump_opt['N'])
8727 					dataset_lookup = B_TRUE;
8728 			}
8729 			/* normal dataset name not an objset ID */
8730 			if (endptr == objset_str) {
8731 				objset_id = -1;
8732 			}
8733 		} else if (objset_str && !zdb_numeric(objset_str + 1) &&
8734 		    dump_opt['N']) {
8735 			printf("Supply a numeric objset ID with -N\n");
8736 			exit(1);
8737 		}
8738 	} else {
8739 		target_pool = target;
8740 	}
8741 
8742 	if (dump_opt['e']) {
8743 		importargs_t args = { 0 };
8744 
8745 		args.paths = nsearch;
8746 		args.path = searchdirs;
8747 		args.can_be_active = B_TRUE;
8748 
8749 		error = zpool_find_config(NULL, target_pool, &cfg, &args,
8750 		    &libzpool_config_ops);
8751 
8752 		if (error == 0) {
8753 
8754 			if (nvlist_add_nvlist(cfg,
8755 			    ZPOOL_LOAD_POLICY, policy) != 0) {
8756 				fatal("can't open '%s': %s",
8757 				    target, strerror(ENOMEM));
8758 			}
8759 
8760 			if (dump_opt['C'] > 1) {
8761 				(void) printf("\nConfiguration for import:\n");
8762 				dump_nvlist(cfg, 8);
8763 			}
8764 
8765 			/*
8766 			 * Disable the activity check to allow examination of
8767 			 * active pools.
8768 			 */
8769 			error = spa_import(target_pool, cfg, NULL,
8770 			    flags | ZFS_IMPORT_SKIP_MMP);
8771 		}
8772 	}
8773 
8774 	if (searchdirs != NULL) {
8775 		umem_free(searchdirs, nsearch * sizeof (char *));
8776 		searchdirs = NULL;
8777 	}
8778 
8779 	/*
8780 	 * import_checkpointed_state makes the assumption that the
8781 	 * target pool that we pass it is already part of the spa
8782 	 * namespace. Because of that we need to make sure to call
8783 	 * it always after the -e option has been processed, which
8784 	 * imports the pool to the namespace if it's not in the
8785 	 * cachefile.
8786 	 */
8787 	char *checkpoint_pool = NULL;
8788 	char *checkpoint_target = NULL;
8789 	if (dump_opt['k']) {
8790 		checkpoint_pool = import_checkpointed_state(target, cfg,
8791 		    &checkpoint_target);
8792 
8793 		if (checkpoint_target != NULL)
8794 			target = checkpoint_target;
8795 	}
8796 
8797 	if (cfg != NULL) {
8798 		nvlist_free(cfg);
8799 		cfg = NULL;
8800 	}
8801 
8802 	if (target_pool != target)
8803 		free(target_pool);
8804 
8805 	if (error == 0) {
8806 		if (dump_opt['k'] && (target_is_spa || dump_opt['R'])) {
8807 			ASSERT(checkpoint_pool != NULL);
8808 			ASSERT(checkpoint_target == NULL);
8809 
8810 			error = spa_open(checkpoint_pool, &spa, FTAG);
8811 			if (error != 0) {
8812 				fatal("Tried to open pool \"%s\" but "
8813 				    "spa_open() failed with error %d\n",
8814 				    checkpoint_pool, error);
8815 			}
8816 
8817 		} else if (target_is_spa || dump_opt['R'] || objset_id == 0) {
8818 			zdb_set_skip_mmp(target);
8819 			error = spa_open_rewind(target, &spa, FTAG, policy,
8820 			    NULL);
8821 			if (error) {
8822 				/*
8823 				 * If we're missing the log device then
8824 				 * try opening the pool after clearing the
8825 				 * log state.
8826 				 */
8827 				mutex_enter(&spa_namespace_lock);
8828 				if ((spa = spa_lookup(target)) != NULL &&
8829 				    spa->spa_log_state == SPA_LOG_MISSING) {
8830 					spa->spa_log_state = SPA_LOG_CLEAR;
8831 					error = 0;
8832 				}
8833 				mutex_exit(&spa_namespace_lock);
8834 
8835 				if (!error) {
8836 					error = spa_open_rewind(target, &spa,
8837 					    FTAG, policy, NULL);
8838 				}
8839 			}
8840 		} else if (strpbrk(target, "#") != NULL) {
8841 			dsl_pool_t *dp;
8842 			error = dsl_pool_hold(target, FTAG, &dp);
8843 			if (error != 0) {
8844 				fatal("can't dump '%s': %s", target,
8845 				    strerror(error));
8846 			}
8847 			error = dump_bookmark(dp, target, B_TRUE, verbose > 1);
8848 			dsl_pool_rele(dp, FTAG);
8849 			if (error != 0) {
8850 				fatal("can't dump '%s': %s", target,
8851 				    strerror(error));
8852 			}
8853 			return (error);
8854 		} else {
8855 			target_pool = strdup(target);
8856 			if (strpbrk(target, "/@") != NULL)
8857 				*strpbrk(target_pool, "/@") = '\0';
8858 
8859 			zdb_set_skip_mmp(target);
8860 			/*
8861 			 * If -N was supplied, the user has indicated that
8862 			 * zdb -d <pool>/<objsetID> is in effect.  Otherwise
8863 			 * we first assume that the dataset string is the
8864 			 * dataset name.  If dmu_objset_hold fails with the
8865 			 * dataset string, and we have an objset_id, retry the
8866 			 * lookup with the objsetID.
8867 			 */
8868 			boolean_t retry = B_TRUE;
8869 retry_lookup:
8870 			if (dataset_lookup == B_TRUE) {
8871 				/*
8872 				 * Use the supplied id to get the name
8873 				 * for open_objset.
8874 				 */
8875 				error = spa_open(target_pool, &spa, FTAG);
8876 				if (error == 0) {
8877 					error = name_from_objset_id(spa,
8878 					    objset_id, dsname);
8879 					spa_close(spa, FTAG);
8880 					if (error == 0)
8881 						target = dsname;
8882 				}
8883 			}
8884 			if (error == 0) {
8885 				if (objset_id > 0 && retry) {
8886 					int err = dmu_objset_hold(target, FTAG,
8887 					    &os);
8888 					if (err) {
8889 						dataset_lookup = B_TRUE;
8890 						retry = B_FALSE;
8891 						goto retry_lookup;
8892 					} else {
8893 						dmu_objset_rele(os, FTAG);
8894 					}
8895 				}
8896 				error = open_objset(target, FTAG, &os);
8897 			}
8898 			if (error == 0)
8899 				spa = dmu_objset_spa(os);
8900 			free(target_pool);
8901 		}
8902 	}
8903 	nvlist_free(policy);
8904 
8905 	if (error)
8906 		fatal("can't open '%s': %s", target, strerror(error));
8907 
8908 	/*
8909 	 * Set the pool failure mode to panic in order to prevent the pool
8910 	 * from suspending.  A suspended I/O will have no way to resume and
8911 	 * can prevent the zdb(8) command from terminating as expected.
8912 	 */
8913 	if (spa != NULL)
8914 		spa->spa_failmode = ZIO_FAILURE_MODE_PANIC;
8915 
8916 	argv++;
8917 	argc--;
8918 	if (dump_opt['r']) {
8919 		error = zdb_copy_object(os, object, argv[1]);
8920 	} else if (!dump_opt['R']) {
8921 		flagbits['d'] = ZOR_FLAG_DIRECTORY;
8922 		flagbits['f'] = ZOR_FLAG_PLAIN_FILE;
8923 		flagbits['m'] = ZOR_FLAG_SPACE_MAP;
8924 		flagbits['z'] = ZOR_FLAG_ZAP;
8925 		flagbits['A'] = ZOR_FLAG_ALL_TYPES;
8926 
8927 		if (argc > 0 && dump_opt['d']) {
8928 			zopt_object_args = argc;
8929 			zopt_object_ranges = calloc(zopt_object_args,
8930 			    sizeof (zopt_object_range_t));
8931 			for (unsigned i = 0; i < zopt_object_args; i++) {
8932 				int err;
8933 				char *msg = NULL;
8934 
8935 				err = parse_object_range(argv[i],
8936 				    &zopt_object_ranges[i], &msg);
8937 				if (err != 0)
8938 					fatal("Bad object or range: '%s': %s\n",
8939 					    argv[i], msg ? msg : "");
8940 			}
8941 		} else if (argc > 0 && dump_opt['m']) {
8942 			zopt_metaslab_args = argc;
8943 			zopt_metaslab = calloc(zopt_metaslab_args,
8944 			    sizeof (uint64_t));
8945 			for (unsigned i = 0; i < zopt_metaslab_args; i++) {
8946 				errno = 0;
8947 				zopt_metaslab[i] = strtoull(argv[i], NULL, 0);
8948 				if (zopt_metaslab[i] == 0 && errno != 0)
8949 					fatal("bad number %s: %s", argv[i],
8950 					    strerror(errno));
8951 			}
8952 		}
8953 		if (os != NULL) {
8954 			dump_objset(os);
8955 		} else if (zopt_object_args > 0 && !dump_opt['m']) {
8956 			dump_objset(spa->spa_meta_objset);
8957 		} else {
8958 			dump_zpool(spa);
8959 		}
8960 	} else {
8961 		flagbits['b'] = ZDB_FLAG_PRINT_BLKPTR;
8962 		flagbits['c'] = ZDB_FLAG_CHECKSUM;
8963 		flagbits['d'] = ZDB_FLAG_DECOMPRESS;
8964 		flagbits['e'] = ZDB_FLAG_BSWAP;
8965 		flagbits['g'] = ZDB_FLAG_GBH;
8966 		flagbits['i'] = ZDB_FLAG_INDIRECT;
8967 		flagbits['r'] = ZDB_FLAG_RAW;
8968 		flagbits['v'] = ZDB_FLAG_VERBOSE;
8969 
8970 		for (int i = 0; i < argc; i++)
8971 			zdb_read_block(argv[i], spa);
8972 	}
8973 
8974 	if (dump_opt['k']) {
8975 		free(checkpoint_pool);
8976 		if (!target_is_spa)
8977 			free(checkpoint_target);
8978 	}
8979 
8980 	if (os != NULL) {
8981 		close_objset(os, FTAG);
8982 	} else {
8983 		spa_close(spa, FTAG);
8984 	}
8985 
8986 	fuid_table_destroy();
8987 
8988 	dump_debug_buffer();
8989 
8990 	kernel_fini();
8991 
8992 	return (error);
8993 }
8994