zdb.c revision 20b5dafb425396adaebd0267d29e1026fc4dc413
1fa9e406ahrens/*
2fa9e406ahrens * CDDL HEADER START
3fa9e406ahrens *
4fa9e406ahrens * The contents of this file are subject to the terms of the
5ea8dc4beschrock * Common Development and Distribution License (the "License").
6ea8dc4beschrock * You may not use this file except in compliance with the License.
7fa9e406ahrens *
8fa9e406ahrens * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9fa9e406ahrens * or http://www.opensolaris.org/os/licensing.
10fa9e406ahrens * See the License for the specific language governing permissions
11fa9e406ahrens * and limitations under the License.
12fa9e406ahrens *
13fa9e406ahrens * When distributing Covered Code, include this CDDL HEADER in each
14fa9e406ahrens * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15fa9e406ahrens * If applicable, add the following below this CDDL HEADER, with the
16fa9e406ahrens * fields enclosed by brackets "[]" replaced with your own identifying
17fa9e406ahrens * information: Portions Copyright [yyyy] [name of copyright owner]
18fa9e406ahrens *
19fa9e406ahrens * CDDL HEADER END
20fa9e406ahrens */
21ad135b5Christopher Siden
22fa9e406ahrens/*
238f2529dMark Shellenbaum * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
245cabbc6Prashanth Sreenivasa * Copyright (c) 2011, 2017 by Delphix. All rights reserved.
25c3d26abMatthew Ahrens * Copyright (c) 2014 Integros [integros.com]
26ed61ec1Yuri Pankov * Copyright 2017 Nexenta Systems, Inc.
27f06dce2Andrew Stormont * Copyright 2017 RackTop Systems.
28fa9e406ahrens */
29fa9e406ahrens
30fa9e406ahrens#include <stdio.h>
31490d05bMatthew Ahrens#include <unistd.h>
32004388ecasper#include <stdio_ext.h>
33fa9e406ahrens#include <stdlib.h>
3444cd46cbillm#include <ctype.h>
35fa9e406ahrens#include <sys/zfs_context.h>
36fa9e406ahrens#include <sys/spa.h>
37fa9e406ahrens#include <sys/spa_impl.h>
38fa9e406ahrens#include <sys/dmu.h>
39fa9e406ahrens#include <sys/zap.h>
40fa9e406ahrens#include <sys/fs/zfs.h>
41fa9e406ahrens#include <sys/zfs_znode.h>
420a586ceMark Shellenbaum#include <sys/zfs_sa.h>
430a586ceMark Shellenbaum#include <sys/sa.h>
440a586ceMark Shellenbaum#include <sys/sa_impl.h>
45fa9e406ahrens#include <sys/vdev.h>
46fa9e406ahrens#include <sys/vdev_impl.h>
47fa9e406ahrens#include <sys/metaslab_impl.h>
48fa9e406ahrens#include <sys/dmu_objset.h>
49fa9e406ahrens#include <sys/dsl_dir.h>
50fa9e406ahrens#include <sys/dsl_dataset.h>
51fa9e406ahrens#include <sys/dsl_pool.h>
52fa9e406ahrens#include <sys/dbuf.h>
53fa9e406ahrens#include <sys/zil.h>
54fa9e406ahrens#include <sys/zil_impl.h>
55fa9e406ahrens#include <sys/stat.h>
56fa9e406ahrens#include <sys/resource.h>
57fa9e406ahrens#include <sys/dmu_traverse.h>
58fa9e406ahrens#include <sys/zio_checksum.h>
59fa9e406ahrens#include <sys/zio_compress.h>
60e0d35c4marks#include <sys/zfs_fuid.h>
6188b7b0fMatthew Ahrens#include <sys/arc.h>
62b24ab67Jeff Bonwick#include <sys/ddt.h>
63ad135b5Christopher Siden#include <sys/zfeature.h>
64770499eDan Kimmel#include <sys/abd.h>
654923c69Matthew Ahrens#include <sys/blkptr.h>
664445fffMatthew Ahrens#include <zfs_comutil.h>
670a05512Jason King#include <libcmdutils.h>
68de6628fck#undef verify
69de6628fck#include <libzfs.h>
70fa9e406ahrens
713f7978dAlan Somers#include "zdb.h"
723f7978dAlan Somers
73e690fb2Christopher Siden#define	ZDB_COMPRESS_NAME(idx) ((idx) < ZIO_COMPRESS_FUNCTIONS ?	\
74e690fb2Christopher Siden	zio_compress_table[(idx)].ci_name : "UNKNOWN")
75e690fb2Christopher Siden#define	ZDB_CHECKSUM_NAME(idx) ((idx) < ZIO_CHECKSUM_FUNCTIONS ?	\
76e690fb2Christopher Siden	zio_checksum_table[(idx)].ci_name : "UNKNOWN")
77e690fb2Christopher Siden#define	ZDB_OT_NAME(idx) ((idx) < DMU_OT_NUMTYPES ?	\
78e690fb2Christopher Siden	dmu_ot[(idx)].ot_name : DMU_OT_IS_VALID(idx) ?	\
79e690fb2Christopher Siden	dmu_ot_byteswap[DMU_OT_BYTESWAP(idx)].ob_name : "UNKNOWN")
80e690fb2Christopher Siden#define	ZDB_OT_TYPE(idx) ((idx) < DMU_OT_NUMTYPES ? (idx) :		\
815cabbc6Prashanth Sreenivasa	(idx) == DMU_OTN_ZAP_DATA || (idx) == DMU_OTN_ZAP_METADATA ?	\
825cabbc6Prashanth Sreenivasa	DMU_OT_ZAP_OTHER : \
835cabbc6Prashanth Sreenivasa	(idx) == DMU_OTN_UINT64_DATA || (idx) == DMU_OTN_UINT64_METADATA ? \
845cabbc6Prashanth Sreenivasa	DMU_OT_UINT64_OTHER : DMU_OT_NUMTYPES)
856de8f41Victor Latushkin
86feef89cVictor Latushkin#ifndef lint
874dd77f9Matthew Ahrensextern int reference_tracking_enable;
887fd05acMatthew Ahrensextern boolean_t zfs_recover;
8906be980Matthew Ahrensextern uint64_t zfs_arc_max, zfs_arc_meta_limit;
90f7950bfMatthew Ahrensextern int zfs_vdev_async_read_max_active;
91f06dce2Andrew Stormontextern int aok;
92e144c4ePavel Zakharovextern boolean_t spa_load_verify_dryrun;
93feef89cVictor Latushkin#else
944dd77f9Matthew Ahrensint reference_tracking_enable;
957fd05acMatthew Ahrensboolean_t zfs_recover;
9606be980Matthew Ahrensuint64_t zfs_arc_max, zfs_arc_meta_limit;
97f7950bfMatthew Ahrensint zfs_vdev_async_read_max_active;
98f06dce2Andrew Stormontint aok;
99e144c4ePavel Zakharovboolean_t spa_load_verify_dryrun;
100feef89cVictor Latushkin#endif
101feef89cVictor Latushkin
1023f7978dAlan Somersstatic const char cmdname[] = "zdb";
103fa9e406ahrensuint8_t dump_opt[256];
104fa9e406ahrens
105fa9e406ahrenstypedef void object_viewer_t(objset_t *, uint64_t, void *data, size_t size);
106fa9e406ahrens
107fa9e406ahrensuint64_t *zopt_object = NULL;
1083f7978dAlan Somersstatic unsigned zopt_objects = 0;
109de6628fcklibzfs_handle_t *g_zfs;
11006be980Matthew Ahrensuint64_t max_inflight = 1000;
11120b5dafPaul Dagneliestatic int leaked_objects = 0;
112fa9e406ahrens
113732885fMatthew Ahrensstatic void snprintf_blkptr_compact(char *, size_t, const blkptr_t *);
114732885fMatthew Ahrens
115fa9e406ahrens/*
116fa9e406ahrens * These libumem hooks provide a reasonable set of defaults for the allocator's
117fa9e406ahrens * debugging facilities.
118fa9e406ahrens */
119fa9e406ahrensconst char *
120fa9e406ahrens_umem_debug_init()
121fa9e406ahrens{
122fa9e406ahrens	return ("default,verbose"); /* $UMEM_DEBUG setting */
123fa9e406ahrens}
124fa9e406ahrens
125fa9e406ahrensconst char *
126fa9e406ahrens_umem_logging_init(void)
127fa9e406ahrens{
128fa9e406ahrens	return ("fail,contents"); /* $UMEM_LOGGING setting */
129fa9e406ahrens}
130fa9e406ahrens
131fa9e406ahrensstatic void
132fa9e406ahrensusage(void)
133fa9e406ahrens{
134fa9e406ahrens	(void) fprintf(stderr,
1358671400Serapheim Dimitropoulos	    "Usage:\t%s [-AbcdDFGhikLMPsvX] [-e [-V] [-p <path> ...]] "
136ed61ec1Yuri Pankov	    "[-I <inflight I/Os>]\n"
137ed61ec1Yuri Pankov	    "\t\t[-o <var>=<value>]... [-t <txg>] [-U <cache>] [-x <dumpdir>]\n"
138ed61ec1Yuri Pankov	    "\t\t[<poolname> [<object> ...]]\n"
139dfd5965Richard Yao	    "\t%s [-AdiPv] [-e [-V] [-p <path> ...]] [-U <cache>] <dataset> "
140ed61ec1Yuri Pankov	    "[<object> ...]\n"
141ed61ec1Yuri Pankov	    "\t%s -C [-A] [-U <cache>]\n"
142ed61ec1Yuri Pankov	    "\t%s -l [-Aqu] <device>\n"
143dfd5965Richard Yao	    "\t%s -m [-AFLPX] [-e [-V] [-p <path> ...]] [-t <txg>] "
144dfd5965Richard Yao	    "[-U <cache>]\n\t\t<poolname> [<vdev> [<metaslab> ...]]\n"
145ed61ec1Yuri Pankov	    "\t%s -O <dataset> <path>\n"
146dfd5965Richard Yao	    "\t%s -R [-A] [-e [-V] [-p <path> ...]] [-U <cache>]\n"
147ed61ec1Yuri Pankov	    "\t\t<poolname> <vdev>:<offset>:<size>[:<flags>]\n"
1484923c69Matthew Ahrens	    "\t%s -E [-A] word0:word1:...:word15\n"
149dfd5965Richard Yao	    "\t%s -S [-AP] [-e [-V] [-p <path> ...]] [-U <cache>] "
150dfd5965Richard Yao	    "<poolname>\n\n",
151ed61ec1Yuri Pankov	    cmdname, cmdname, cmdname, cmdname, cmdname, cmdname, cmdname,
1524923c69Matthew Ahrens	    cmdname, cmdname);
1533ad6c7fVictor Latushkin
1543ad6c7fVictor Latushkin	(void) fprintf(stderr, "    Dataset name must include at least one "
1553ad6c7fVictor Latushkin	    "separator character '/' or '@'\n");
1563ad6c7fVictor Latushkin	(void) fprintf(stderr, "    If dataset name is specified, only that "
1573ad6c7fVictor Latushkin	    "dataset is dumped\n");
1583ad6c7fVictor Latushkin	(void) fprintf(stderr, "    If object numbers are specified, only "
1593ad6c7fVictor Latushkin	    "those objects are dumped\n\n");
1603ad6c7fVictor Latushkin	(void) fprintf(stderr, "    Options to control amount of output:\n");
1613ad6c7fVictor Latushkin	(void) fprintf(stderr, "        -b block statistics\n");
1623ad6c7fVictor Latushkin	(void) fprintf(stderr, "        -c checksum all metadata (twice for "
1636365109Victor Latushkin	    "all data) blocks\n");
164ed61ec1Yuri Pankov	(void) fprintf(stderr, "        -C config (or cachefile if alone)\n");
165ed61ec1Yuri Pankov	(void) fprintf(stderr, "        -d dataset(s)\n");
166f0ba89bJeff Bonwick	(void) fprintf(stderr, "        -D dedup statistics\n");
1674923c69Matthew Ahrens	(void) fprintf(stderr, "        -E decode and display block from an "
1684923c69Matthew Ahrens	    "embedded block pointer\n");
169ed61ec1Yuri Pankov	(void) fprintf(stderr, "        -h pool history\n");
170ed61ec1Yuri Pankov	(void) fprintf(stderr, "        -i intent logs\n");
17164723e3Yuri Pankov	(void) fprintf(stderr, "        -l read label contents\n");
1728671400Serapheim Dimitropoulos	(void) fprintf(stderr, "        -k examine the checkpointed state "
1738671400Serapheim Dimitropoulos	    "of the pool\n");
17482a0a98Victor Latushkin	(void) fprintf(stderr, "        -L disable leak tracking (do not "
17582a0a98Victor Latushkin	    "load spacemaps)\n");
176ed61ec1Yuri Pankov	(void) fprintf(stderr, "        -m metaslabs\n");
177ed61ec1Yuri Pankov	(void) fprintf(stderr, "        -M metaslab groups\n");
178ed61ec1Yuri Pankov	(void) fprintf(stderr, "        -O perform object lookups by path\n");
179d41e764ek	(void) fprintf(stderr, "        -R read and display block from a "
180ed61ec1Yuri Pankov	    "device\n");
181ed61ec1Yuri Pankov	(void) fprintf(stderr, "        -s report stats on zdb's I/O\n");
182ed61ec1Yuri Pankov	(void) fprintf(stderr, "        -S simulate dedup to measure effect\n");
183ed61ec1Yuri Pankov	(void) fprintf(stderr, "        -v verbose (applies to all "
184ed61ec1Yuri Pankov	    "others)\n\n");
1853ad6c7fVictor Latushkin	(void) fprintf(stderr, "    Below options are intended for use "
186df15e41Matthew Ahrens	    "with other options:\n");
187feef89cVictor Latushkin	(void) fprintf(stderr, "        -A ignore assertions (-A), enable "
188feef89cVictor Latushkin	    "panic recovery (-AA) or both (-AAA)\n");
1893ad6c7fVictor Latushkin	(void) fprintf(stderr, "        -e pool is exported/destroyed/"
1903ad6c7fVictor Latushkin	    "has altroot/not in a cachefile\n");
191ed61ec1Yuri Pankov	(void) fprintf(stderr, "        -F attempt automatic rewind within "
192ed61ec1Yuri Pankov	    "safe range of transaction groups\n");
193ed61ec1Yuri Pankov	(void) fprintf(stderr, "        -G dump zfs_dbgmsg buffer before "
194ed61ec1Yuri Pankov	    "exiting\n");
1952e4c998George Wilson	(void) fprintf(stderr, "        -I <number of inflight I/Os> -- "
196df15e41Matthew Ahrens	    "specify the maximum number of "
197df15e41Matthew Ahrens	    "checksumming I/Os [default is 200]\n");
1980e60744Pavel Zakharov	(void) fprintf(stderr, "        -o <variable>=<value> set global "
1990e60744Pavel Zakharov	    "variable to an unsigned 32-bit integer value\n");
200ed61ec1Yuri Pankov	(void) fprintf(stderr, "        -p <path> -- use one or more with "
201ed61ec1Yuri Pankov	    "-e to specify path to vdev dir\n");
202ed61ec1Yuri Pankov	(void) fprintf(stderr, "        -P print numbers in parseable form\n");
20364723e3Yuri Pankov	(void) fprintf(stderr, "        -q don't print label contents\n");
204ed61ec1Yuri Pankov	(void) fprintf(stderr, "        -t <txg> -- highest txg to use when "
205ed61ec1Yuri Pankov	    "searching for uberblocks\n");
20664723e3Yuri Pankov	(void) fprintf(stderr, "        -u uberblock\n");
207ed61ec1Yuri Pankov	(void) fprintf(stderr, "        -U <cachefile_path> -- use alternate "
208ed61ec1Yuri Pankov	    "cachefile\n");
209dfd5965Richard Yao	(void) fprintf(stderr, "        -V do verbatim import\n");
210ed61ec1Yuri Pankov	(void) fprintf(stderr, "        -x <dumpdir> -- "
211ed61ec1Yuri Pankov	    "dump all read blocks into specified directory\n");
212ed61ec1Yuri Pankov	(void) fprintf(stderr, "        -X attempt extreme rewind (does not "
213ed61ec1Yuri Pankov	    "work with dataset)\n\n");
214fa9e406ahrens	(void) fprintf(stderr, "Specify an option more than once (e.g. -bb) "
215fa9e406ahrens	    "to make only that option verbose\n");
216fa9e406ahrens	(void) fprintf(stderr, "Default is to dump everything non-verbosely\n");
217fa9e406ahrens	exit(1);
218fa9e406ahrens}
219fa9e406ahrens
22029bdd2fPavel Zakharovstatic void
22129bdd2fPavel Zakharovdump_debug_buffer()
22229bdd2fPavel Zakharov{
22329bdd2fPavel Zakharov	if (dump_opt['G']) {
22429bdd2fPavel Zakharov		(void) printf("\n");
22529bdd2fPavel Zakharov		zfs_dbgmsg_print("zdb");
22629bdd2fPavel Zakharov	}
22729bdd2fPavel Zakharov}
22829bdd2fPavel Zakharov
229ccba080Rich Morris/*
230ccba080Rich Morris * Called for usage errors that are discovered after a call to spa_open(),
231ccba080Rich Morris * dmu_bonus_hold(), or pool_match().  abort() is called for other errors.
232ccba080Rich Morris */
233ccba080Rich Morris
234fa9e406ahrensstatic void
235fa9e406ahrensfatal(const char *fmt, ...)
236fa9e406ahrens{
237fa9e406ahrens	va_list ap;
238fa9e406ahrens
239fa9e406ahrens	va_start(ap, fmt);
240fa9e406ahrens	(void) fprintf(stderr, "%s: ", cmdname);
241fa9e406ahrens	(void) vfprintf(stderr, fmt, ap);
242fa9e406ahrens	va_end(ap);
243fa9e406ahrens	(void) fprintf(stderr, "\n");
244fa9e406ahrens
24529bdd2fPavel Zakharov	dump_debug_buffer();
24629bdd2fPavel Zakharov
247ccba080Rich Morris	exit(1);
248fa9e406ahrens}
249fa9e406ahrens
250fa9e406ahrens/* ARGSUSED */
251fa9e406ahrensstatic void
252fa9e406ahrensdump_packed_nvlist(objset_t *os, uint64_t object, void *data, size_t size)
253fa9e406ahrens{
254fa9e406ahrens	nvlist_t *nv;
255fa9e406ahrens	size_t nvsize = *(uint64_t *)data;
256fa9e406ahrens	char *packed = umem_alloc(nvsize, UMEM_NOFAIL);
257fa9e406ahrens
2587bfdf01Neil Perrin	VERIFY(0 == dmu_read(os, object, 0, nvsize, packed, DMU_READ_PREFETCH));
259fa9e406ahrens
260fa9e406ahrens	VERIFY(nvlist_unpack(packed, nvsize, &nv, 0) == 0);
261fa9e406ahrens
262fa9e406ahrens	umem_free(packed, nvsize);
263fa9e406ahrens
264fa9e406ahrens	dump_nvlist(nv, 8);
265fa9e406ahrens
266fa9e406ahrens	nvlist_free(nv);
267fa9e406ahrens}
268fa9e406ahrens
2694445fffMatthew Ahrens/* ARGSUSED */
2704445fffMatthew Ahrensstatic void
2714445fffMatthew Ahrensdump_history_offsets(objset_t *os, uint64_t object, void *data, size_t size)
2724445fffMatthew Ahrens{
2734445fffMatthew Ahrens	spa_history_phys_t *shp = data;
2744445fffMatthew Ahrens
2754445fffMatthew Ahrens	if (shp == NULL)
2764445fffMatthew Ahrens		return;
2774445fffMatthew Ahrens
2784445fffMatthew Ahrens	(void) printf("\t\tpool_create_len = %llu\n",
2794445fffMatthew Ahrens	    (u_longlong_t)shp->sh_pool_create_len);
2804445fffMatthew Ahrens	(void) printf("\t\tphys_max_off = %llu\n",
2814445fffMatthew Ahrens	    (u_longlong_t)shp->sh_phys_max_off);
2824445fffMatthew Ahrens	(void) printf("\t\tbof = %llu\n",
2834445fffMatthew Ahrens	    (u_longlong_t)shp->sh_bof);
2844445fffMatthew Ahrens	(void) printf("\t\teof = %llu\n",
2854445fffMatthew Ahrens	    (u_longlong_t)shp->sh_eof);
2864445fffMatthew Ahrens	(void) printf("\t\trecords_lost = %llu\n",
2874445fffMatthew Ahrens	    (u_longlong_t)shp->sh_records_lost);
2884445fffMatthew Ahrens}
2894445fffMatthew Ahrens
2903f9d6adLin Lingstatic void
2910a05512Jason Kingzdb_nicenum(uint64_t num, char *buf, size_t buflen)
2923f9d6adLin Ling{
2933f9d6adLin Ling	if (dump_opt['P'])
2940a05512Jason King		(void) snprintf(buf, buflen, "%llu", (longlong_t)num);
2953f9d6adLin Ling	else
2960a05512Jason King		nicenum(num, buf, sizeof (buf));
2973f9d6adLin Ling}
2983f9d6adLin Ling
2993f7978dAlan Somersstatic const char histo_stars[] = "****************************************";
3003f7978dAlan Somersstatic const uint64_t histo_width = sizeof (histo_stars) - 1;
301fa9e406ahrens
302fa9e406ahrensstatic void
3030713e23George Wilsondump_histogram(const uint64_t *histo, int size, int offset)
304fa9e406ahrens{
305fa9e406ahrens	int i;
306490d05bMatthew Ahrens	int minidx = size - 1;
307fa9e406ahrens	int maxidx = 0;
308fa9e406ahrens	uint64_t max = 0;
309fa9e406ahrens
310490d05bMatthew Ahrens	for (i = 0; i < size; i++) {
311fa9e406ahrens		if (histo[i] > max)
312fa9e406ahrens			max = histo[i];
313fa9e406ahrens		if (histo[i] > 0 && i > maxidx)
314fa9e406ahrens			maxidx = i;
315fa9e406ahrens		if (histo[i] > 0 && i < minidx)
316fa9e406ahrens			minidx = i;
317fa9e406ahrens	}
318fa9e406ahrens
319490d05bMatthew Ahrens	if (max < histo_width)
320490d05bMatthew Ahrens		max = histo_width;
321fa9e406ahrens
322490d05bMatthew Ahrens	for (i = minidx; i <= maxidx; i++) {
323490d05bMatthew Ahrens		(void) printf("\t\t\t%3u: %6llu %s\n",
3240713e23George Wilson		    i + offset, (u_longlong_t)histo[i],
325490d05bMatthew Ahrens		    &histo_stars[(max - histo[i]) * histo_width / max]);
326490d05bMatthew Ahrens	}
327fa9e406ahrens}
328fa9e406ahrens
329fa9e406ahrensstatic void
330fa9e406ahrensdump_zap_stats(objset_t *os, uint64_t object)
331fa9e406ahrens{
332fa9e406ahrens	int error;
333fa9e406ahrens	zap_stats_t zs;
334fa9e406ahrens
335fa9e406ahrens	error = zap_get_stats(os, object, &zs);
336fa9e406ahrens	if (error)
337fa9e406ahrens		return;
338fa9e406ahrens
339fa9e406ahrens	if (zs.zs_ptrtbl_len == 0) {
340fa9e406ahrens		ASSERT(zs.zs_num_blocks == 1);
341fa9e406ahrens		(void) printf("\tmicrozap: %llu bytes, %llu entries\n",
342fa9e406ahrens		    (u_longlong_t)zs.zs_blocksize,
343fa9e406ahrens		    (u_longlong_t)zs.zs_num_entries);
344fa9e406ahrens		return;
345fa9e406ahrens	}
346fa9e406ahrens
347fa9e406ahrens	(void) printf("\tFat ZAP stats:\n");
3488248818nd
3498248818nd	(void) printf("\t\tPointer table:\n");
3508248818nd	(void) printf("\t\t\t%llu elements\n",
351fa9e406ahrens	    (u_longlong_t)zs.zs_ptrtbl_len);
3528248818nd	(void) printf("\t\t\tzt_blk: %llu\n",
3538248818nd	    (u_longlong_t)zs.zs_ptrtbl_zt_blk);
3548248818nd	(void) printf("\t\t\tzt_numblks: %llu\n",
3558248818nd	    (u_longlong_t)zs.zs_ptrtbl_zt_numblks);
3568248818nd	(void) printf("\t\t\tzt_shift: %llu\n",
3578248818nd	    (u_longlong_t)zs.zs_ptrtbl_zt_shift);
3588248818nd	(void) printf("\t\t\tzt_blks_copied: %llu\n",
3598248818nd	    (u_longlong_t)zs.zs_ptrtbl_blks_copied);
3608248818nd	(void) printf("\t\t\tzt_nextblk: %llu\n",
3618248818nd	    (u_longlong_t)zs.zs_ptrtbl_nextblk);
3628248818nd
363fa9e406ahrens	(void) printf("\t\tZAP entries: %llu\n",
364fa9e406ahrens	    (u_longlong_t)zs.zs_num_entries);
365fa9e406ahrens	(void) printf("\t\tLeaf blocks: %llu\n",
366fa9e406ahrens	    (u_longlong_t)zs.zs_num_leafs);
367fa9e406ahrens	(void) printf("\t\tTotal blocks: %llu\n",
368fa9e406ahrens	    (u_longlong_t)zs.zs_num_blocks);
3698248818nd	(void) printf("\t\tzap_block_type: 0x%llx\n",
3708248818nd	    (u_longlong_t)zs.zs_block_type);
3718248818nd	(void) printf("\t\tzap_magic: 0x%llx\n",
3728248818nd	    (u_longlong_t)zs.zs_magic);
3738248818nd	(void) printf("\t\tzap_salt: 0x%llx\n",
3748248818nd	    (u_longlong_t)zs.zs_salt);
375fa9e406ahrens
376fa9e406ahrens	(void) printf("\t\tLeafs with 2^n pointers:\n");
3770713e23George Wilson	dump_histogram(zs.zs_leafs_with_2n_pointers, ZAP_HISTOGRAM_SIZE, 0);
378fa9e406ahrens
379fa9e406ahrens	(void) printf("\t\tBlocks with n*5 entries:\n");
3800713e23George Wilson	dump_histogram(zs.zs_blocks_with_n5_entries, ZAP_HISTOGRAM_SIZE, 0);
381fa9e406ahrens
382fa9e406ahrens	(void) printf("\t\tBlocks n/10 full:\n");
3830713e23George Wilson	dump_histogram(zs.zs_blocks_n_tenths_full, ZAP_HISTOGRAM_SIZE, 0);
384fa9e406ahrens
385fa9e406ahrens	(void) printf("\t\tEntries with n chunks:\n");
3860713e23George Wilson	dump_histogram(zs.zs_entries_using_n_chunks, ZAP_HISTOGRAM_SIZE, 0);
387fa9e406ahrens
388fa9e406ahrens	(void) printf("\t\tBuckets with n entries:\n");
3890713e23George Wilson	dump_histogram(zs.zs_buckets_with_n_entries, ZAP_HISTOGRAM_SIZE, 0);
390fa9e406ahrens}
391fa9e406ahrens
392fa9e406ahrens/*ARGSUSED*/
393fa9e406ahrensstatic void
394fa9e406ahrensdump_none(objset_t *os, uint64_t object, void *data, size_t size)
395fa9e406ahrens{
396fa9e406ahrens}
397fa9e406ahrens
398fa9e406ahrens/*ARGSUSED*/
3996de8f41Victor Latushkinstatic void
4006de8f41Victor Latushkindump_unknown(objset_t *os, uint64_t object, void *data, size_t size)
4016de8f41Victor Latushkin{
4026de8f41Victor Latushkin	(void) printf("\tUNKNOWN OBJECT TYPE\n");
4036de8f41Victor Latushkin}
4046de8f41Victor Latushkin
4056de8f41Victor Latushkin/*ARGSUSED*/
4063f7978dAlan Somersstatic void
407fa9e406ahrensdump_uint8(objset_t *os, uint64_t object, void *data, size_t size)
408fa9e406ahrens{
409fa9e406ahrens}
410fa9e406ahrens
411fa9e406ahrens/*ARGSUSED*/
412fa9e406ahrensstatic void
413fa9e406ahrensdump_uint64(objset_t *os, uint64_t object, void *data, size_t size)
414fa9e406ahrens{
415fa9e406ahrens}
416fa9e406ahrens
417fa9e406ahrens/*ARGSUSED*/
418fa9e406ahrensstatic void
419fa9e406ahrensdump_zap(objset_t *os, uint64_t object, void *data, size_t size)
420fa9e406ahrens{
421fa9e406ahrens	zap_cursor_t zc;
422fa9e406ahrens	zap_attribute_t attr;
423fa9e406ahrens	void *prop;
4243f7978dAlan Somers	unsigned i;
425fa9e406ahrens
426fa9e406ahrens	dump_zap_stats(os, object);
427fa9e406ahrens	(void) printf("\n");
428fa9e406ahrens
429fa9e406ahrens	for (zap_cursor_init(&zc, os, object);
430fa9e406ahrens	    zap_cursor_retrieve(&zc, &attr) == 0;
431fa9e406ahrens	    zap_cursor_advance(&zc)) {
432fa9e406ahrens		(void) printf("\t\t%s = ", attr.za_name);
433fa9e406ahrens		if (attr.za_num_integers == 0) {
434fa9e406ahrens			(void) printf("\n");
435fa9e406ahrens			continue;
436fa9e406ahrens		}
437fa9e406ahrens		prop = umem_zalloc(attr.za_num_integers *
438fa9e406ahrens		    attr.za_integer_length, UMEM_NOFAIL);
439fa9e406ahrens		(void) zap_lookup(os, object, attr.za_name,
440fa9e406ahrens		    attr.za_integer_length, attr.za_num_integers, prop);
441fa9e406ahrens		if (attr.za_integer_length == 1) {
442fa9e406ahrens			(void) printf("%s", (char *)prop);
443fa9e406ahrens		} else {
444fa9e406ahrens			for (i = 0; i < attr.za_num_integers; i++) {
445fa9e406ahrens				switch (attr.za_integer_length) {
446fa9e406ahrens				case 2:
447fa9e406ahrens					(void) printf("%u ",
448fa9e406ahrens					    ((uint16_t *)prop)[i]);
449fa9e406ahrens					break;
450fa9e406ahrens				case 4:
451fa9e406ahrens					(void) printf("%u ",
452fa9e406ahrens					    ((uint32_t *)prop)[i]);
453fa9e406ahrens					break;
454fa9e406ahrens				case 8:
455fa9e406ahrens					(void) printf("%lld ",
456fa9e406ahrens					    (u_longlong_t)((int64_t *)prop)[i]);
457fa9e406ahrens					break;
458fa9e406ahrens				}
459fa9e406ahrens			}
460fa9e406ahrens		}
461fa9e406ahrens		(void) printf("\n");
462fa9e406ahrens		umem_free(prop, attr.za_num_integers * attr.za_integer_length);
463fa9e406ahrens	}
46487e5029ahrens	zap_cursor_fini(&zc);
465fa9e406ahrens}
466fa9e406ahrens
467732885fMatthew Ahrensstatic void
468732885fMatthew Ahrensdump_bpobj(objset_t *os, uint64_t object, void *data, size_t size)
469732885fMatthew Ahrens{
470732885fMatthew Ahrens	bpobj_phys_t *bpop = data;
471732885fMatthew Ahrens	char bytes[32], comp[32], uncomp[32];
472732885fMatthew Ahrens
4730a05512Jason King	/* make sure the output won't get truncated */
4740a05512Jason King	CTASSERT(sizeof (bytes) >= NN_NUMBUF_SZ);
4750a05512Jason King	CTASSERT(sizeof (comp) >= NN_NUMBUF_SZ);
4760a05512Jason King	CTASSERT(sizeof (uncomp) >= NN_NUMBUF_SZ);
4770a05512Jason King
478732885fMatthew Ahrens	if (bpop == NULL)
479732885fMatthew Ahrens		return;
480732885fMatthew Ahrens
4810a05512Jason King	zdb_nicenum(bpop->bpo_bytes, bytes, sizeof (bytes));
4820a05512Jason King	zdb_nicenum(bpop->bpo_comp, comp, sizeof (comp));
4830a05512Jason King	zdb_nicenum(bpop->bpo_uncomp, uncomp, sizeof (uncomp));
484732885fMatthew Ahrens
485732885fMatthew Ahrens	(void) printf("\t\tnum_blkptrs = %llu\n",
486732885fMatthew Ahrens	    (u_longlong_t)bpop->bpo_num_blkptrs);
487732885fMatthew Ahrens	(void) printf("\t\tbytes = %s\n", bytes);
488732885fMatthew Ahrens	if (size >= BPOBJ_SIZE_V1) {
489732885fMatthew Ahrens		(void) printf("\t\tcomp = %s\n", comp);
490732885fMatthew Ahrens		(void) printf("\t\tuncomp = %s\n", uncomp);
491732885fMatthew Ahrens	}
492732885fMatthew Ahrens	if (size >= sizeof (*bpop)) {
493732885fMatthew Ahrens		(void) printf("\t\tsubobjs = %llu\n",
494732885fMatthew Ahrens		    (u_longlong_t)bpop->bpo_subobjs);
495732885fMatthew Ahrens		(void) printf("\t\tnum_subobjs = %llu\n",
496732885fMatthew Ahrens		    (u_longlong_t)bpop->bpo_num_subobjs);
497732885fMatthew Ahrens	}
498732885fMatthew Ahrens
499732885fMatthew Ahrens	if (dump_opt['d'] < 5)
500732885fMatthew Ahrens		return;
501732885fMatthew Ahrens
502732885fMatthew Ahrens	for (uint64_t i = 0; i < bpop->bpo_num_blkptrs; i++) {
503732885fMatthew Ahrens		char blkbuf[BP_SPRINTF_LEN];
504732885fMatthew Ahrens		blkptr_t bp;
505732885fMatthew Ahrens
506732885fMatthew Ahrens		int err = dmu_read(os, object,
507732885fMatthew Ahrens		    i * sizeof (bp), sizeof (bp), &bp, 0);
508732885fMatthew Ahrens		if (err != 0) {
509732885fMatthew Ahrens			(void) printf("got error %u from dmu_read\n", err);
510732885fMatthew Ahrens			break;
511732885fMatthew Ahrens		}
512732885fMatthew Ahrens		snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), &bp);
513732885fMatthew Ahrens		(void) printf("\t%s\n", blkbuf);
514732885fMatthew Ahrens	}
515732885fMatthew Ahrens}
516732885fMatthew Ahrens
517732885fMatthew Ahrens/* ARGSUSED */
518732885fMatthew Ahrensstatic void
519732885fMatthew Ahrensdump_bpobj_subobjs(objset_t *os, uint64_t object, void *data, size_t size)
520732885fMatthew Ahrens{
521732885fMatthew Ahrens	dmu_object_info_t doi;
522732885fMatthew Ahrens
523732885fMatthew Ahrens	VERIFY0(dmu_object_info(os, object, &doi));
524732885fMatthew Ahrens	uint64_t *subobjs = kmem_alloc(doi.doi_max_offset, KM_SLEEP);
525732885fMatthew Ahrens
526732885fMatthew Ahrens	int err = dmu_read(os, object, 0, doi.doi_max_offset, subobjs, 0);
527732885fMatthew Ahrens	if (err != 0) {
528732885fMatthew Ahrens		(void) printf("got error %u from dmu_read\n", err);
529732885fMatthew Ahrens		kmem_free(subobjs, doi.doi_max_offset);
530732885fMatthew Ahrens		return;
531732885fMatthew Ahrens	}
532732885fMatthew Ahrens
533732885fMatthew Ahrens	int64_t last_nonzero = -1;
534732885fMatthew Ahrens	for (uint64_t i = 0; i < doi.doi_max_offset / 8; i++) {
535732885fMatthew Ahrens		if (subobjs[i] != 0)
536732885fMatthew Ahrens			last_nonzero = i;
537732885fMatthew Ahrens	}
538732885fMatthew Ahrens
539732885fMatthew Ahrens	for (int64_t i = 0; i <= last_nonzero; i++) {
540732885fMatthew Ahrens		(void) printf("\t%llu\n", (longlong_t)subobjs[i]);
541732885fMatthew Ahrens	}
542732885fMatthew Ahrens	kmem_free(subobjs, doi.doi_max_offset);
543732885fMatthew Ahrens}
544732885fMatthew Ahrens
545e743726ahrens/*ARGSUSED*/
546e743726ahrensstatic void
547486ae71Matthew Ahrensdump_ddt_zap(objset_t *os, uint64_t object, void *data, size_t size)
548486ae71Matthew Ahrens{
549486ae71Matthew Ahrens	dump_zap_stats(os, object);
550486ae71Matthew Ahrens	/* contents are printed elsewhere, properly decoded */
551486ae71Matthew Ahrens}
552486ae71Matthew Ahrens
553486ae71Matthew Ahrens/*ARGSUSED*/
554486ae71Matthew Ahrensstatic void
5550a586ceMark Shellenbaumdump_sa_attrs(objset_t *os, uint64_t object, void *data, size_t size)
5560a586ceMark Shellenbaum{
5570a586ceMark Shellenbaum	zap_cursor_t zc;
5580a586ceMark Shellenbaum	zap_attribute_t attr;
5590a586ceMark Shellenbaum
5600a586ceMark Shellenbaum	dump_zap_stats(os, object);
5610a586ceMark Shellenbaum	(void) printf("\n");
5620a586ceMark Shellenbaum
5630a586ceMark Shellenbaum	for (zap_cursor_init(&zc, os, object);
5640a586ceMark Shellenbaum	    zap_cursor_retrieve(&zc, &attr) == 0;
5650a586ceMark Shellenbaum	    zap_cursor_advance(&zc)) {
5660a586ceMark Shellenbaum		(void) printf("\t\t%s = ", attr.za_name);
5670a586ceMark Shellenbaum		if (attr.za_num_integers == 0) {
5680a586ceMark Shellenbaum			(void) printf("\n");
5690a586ceMark Shellenbaum			continue;
5700a586ceMark Shellenbaum		}
5710a586ceMark Shellenbaum		(void) printf(" %llx : [%d:%d:%d]\n",
5720a586ceMark Shellenbaum		    (u_longlong_t)attr.za_first_integer,
5730a586ceMark Shellenbaum		    (int)ATTR_LENGTH(attr.za_first_integer),
5740a586ceMark Shellenbaum		    (int)ATTR_BSWAP(attr.za_first_integer),
5750a586ceMark Shellenbaum		    (int)ATTR_NUM(attr.za_first_integer));
5760a586ceMark Shellenbaum	}
5770a586ceMark Shellenbaum	zap_cursor_fini(&zc);
5780a586ceMark Shellenbaum}
5790a586ceMark Shellenbaum
5800a586ceMark Shellenbaum/*ARGSUSED*/
5810a586ceMark Shellenbaumstatic void
5820a586ceMark Shellenbaumdump_sa_layouts(objset_t *os, uint64_t object, void *data, size_t size)
5830a586ceMark Shellenbaum{
5840a586ceMark Shellenbaum	zap_cursor_t zc;
5850a586ceMark Shellenbaum	zap_attribute_t attr;
5860a586ceMark Shellenbaum	uint16_t *layout_attrs;
5873f7978dAlan Somers	unsigned i;
5880a586ceMark Shellenbaum
5890a586ceMark Shellenbaum	dump_zap_stats(os, object);
5900a586ceMark Shellenbaum	(void) printf("\n");
5910a586ceMark Shellenbaum
5920a586ceMark Shellenbaum	for (zap_cursor_init(&zc, os, object);
5930a586ceMark Shellenbaum	    zap_cursor_retrieve(&zc, &attr) == 0;
5940a586ceMark Shellenbaum	    zap_cursor_advance(&zc)) {
5950a586ceMark Shellenbaum		(void) printf("\t\t%s = [", attr.za_name);
5960a586ceMark Shellenbaum		if (attr.za_num_integers == 0) {
5970a586ceMark Shellenbaum			(void) printf("\n");
5980a586ceMark Shellenbaum			continue;
5990a586ceMark Shellenbaum		}
6000a586ceMark Shellenbaum
6010a586ceMark Shellenbaum		VERIFY(attr.za_integer_length == 2);
6020a586ceMark Shellenbaum		layout_attrs = umem_zalloc(attr.za_num_integers *
6030a586ceMark Shellenbaum		    attr.za_integer_length, UMEM_NOFAIL);
6040a586ceMark Shellenbaum
6050a586ceMark Shellenbaum		VERIFY(zap_lookup(os, object, attr.za_name,
6060a586ceMark Shellenbaum		    attr.za_integer_length,
6070a586ceMark Shellenbaum		    attr.za_num_integers, layout_attrs) == 0);
6080a586ceMark Shellenbaum
6090a586ceMark Shellenbaum		for (i = 0; i != attr.za_num_integers; i++)
6100a586ceMark Shellenbaum			(void) printf(" %d ", (int)layout_attrs[i]);
6110a586ceMark Shellenbaum		(void) printf("]\n");
6120a586ceMark Shellenbaum		umem_free(layout_attrs,
6130a586ceMark Shellenbaum		    attr.za_num_integers * attr.za_integer_length);
6140a586ceMark Shellenbaum	}
6150a586ceMark Shellenbaum	zap_cursor_fini(&zc);
6160a586ceMark Shellenbaum}
6170a586ceMark Shellenbaum
6180a586ceMark Shellenbaum/*ARGSUSED*/
6190a586ceMark Shellenbaumstatic void
620e743726ahrensdump_zpldir(objset_t *os, uint64_t object, void *data, size_t size)
621e743726ahrens{
622e743726ahrens	zap_cursor_t zc;
623e743726ahrens	zap_attribute_t attr;
624e743726ahrens	const char *typenames[] = {
625e743726ahrens		/* 0 */ "not specified",
626e743726ahrens		/* 1 */ "FIFO",
627e743726ahrens		/* 2 */ "Character Device",
628e743726ahrens		/* 3 */ "3 (invalid)",
629e743726ahrens		/* 4 */ "Directory",
630e743726ahrens		/* 5 */ "5 (invalid)",
631e743726ahrens		/* 6 */ "Block Device",
632e743726ahrens		/* 7 */ "7 (invalid)",
633e743726ahrens		/* 8 */ "Regular File",
634e743726ahrens		/* 9 */ "9 (invalid)",
635e743726ahrens		/* 10 */ "Symbolic Link",
636e743726ahrens		/* 11 */ "11 (invalid)",
637e743726ahrens		/* 12 */ "Socket",
638e743726ahrens		/* 13 */ "Door",
639e743726ahrens		/* 14 */ "Event Port",
640e743726ahrens		/* 15 */ "15 (invalid)",
641e743726ahrens	};
642e743726ahrens
643e743726ahrens	dump_zap_stats(os, object);
644e743726ahrens	(void) printf("\n");
645e743726ahrens
646e743726ahrens	for (zap_cursor_init(&zc, os, object);
647e743726ahrens	    zap_cursor_retrieve(&zc, &attr) == 0;
648e743726ahrens	    zap_cursor_advance(&zc)) {
649e743726ahrens		(void) printf("\t\t%s = %lld (type: %s)\n",
650e743726ahrens		    attr.za_name, ZFS_DIRENT_OBJ(attr.za_first_integer),
651e743726ahrens		    typenames[ZFS_DIRENT_TYPE(attr.za_first_integer)]);
652e743726ahrens	}
653e743726ahrens	zap_cursor_fini(&zc);
654e743726ahrens}
655e743726ahrens
6563f7978dAlan Somersstatic int
6570713e23George Wilsonget_dtl_refcount(vdev_t *vd)
6580713e23George Wilson{
6590713e23George Wilson	int refcount = 0;
6600713e23George Wilson
6610713e23George Wilson	if (vd->vdev_ops->vdev_op_leaf) {
6620713e23George Wilson		space_map_t *sm = vd->vdev_dtl_sm;
6630713e23George Wilson
6640713e23George Wilson		if (sm != NULL &&
6650713e23George Wilson		    sm->sm_dbuf->db_size == sizeof (space_map_phys_t))
6660713e23George Wilson			return (1);
6670713e23George Wilson		return (0);
6680713e23George Wilson	}
6690713e23George Wilson
6703f7978dAlan Somers	for (unsigned c = 0; c < vd->vdev_children; c++)
6710713e23George Wilson		refcount += get_dtl_refcount(vd->vdev_child[c]);
6720713e23George Wilson	return (refcount);
6730713e23George Wilson}
6740713e23George Wilson
6753f7978dAlan Somersstatic int
6760713e23George Wilsonget_metaslab_refcount(vdev_t *vd)
6770713e23George Wilson{
6780713e23George Wilson	int refcount = 0;
6790713e23George Wilson
6805cabbc6Prashanth Sreenivasa	if (vd->vdev_top == vd) {
6815cabbc6Prashanth Sreenivasa		for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
6820713e23George Wilson			space_map_t *sm = vd->vdev_ms[m]->ms_sm;
6830713e23George Wilson
6840713e23George Wilson			if (sm != NULL &&
6850713e23George Wilson			    sm->sm_dbuf->db_size == sizeof (space_map_phys_t))
6860713e23George Wilson				refcount++;
6870713e23George Wilson		}
6880713e23George Wilson	}
6893f7978dAlan Somers	for (unsigned c = 0; c < vd->vdev_children; c++)
6900713e23George Wilson		refcount += get_metaslab_refcount(vd->vdev_child[c]);
6910713e23George Wilson
6920713e23George Wilson	return (refcount);
6930713e23George Wilson}
6940713e23George Wilson
6950713e23George Wilsonstatic int
6965cabbc6Prashanth Sreenivasaget_obsolete_refcount(vdev_t *vd)
6975cabbc6Prashanth Sreenivasa{
6985cabbc6Prashanth Sreenivasa	int refcount = 0;
6995cabbc6Prashanth Sreenivasa
7005cabbc6Prashanth Sreenivasa	uint64_t obsolete_sm_obj = vdev_obsolete_sm_object(vd);
7015cabbc6Prashanth Sreenivasa	if (vd->vdev_top == vd && obsolete_sm_obj != 0) {
7025cabbc6Prashanth Sreenivasa		dmu_object_info_t doi;
7035cabbc6Prashanth Sreenivasa		VERIFY0(dmu_object_info(vd->vdev_spa->spa_meta_objset,
7045cabbc6Prashanth Sreenivasa		    obsolete_sm_obj, &doi));
7055cabbc6Prashanth Sreenivasa		if (doi.doi_bonus_size == sizeof (space_map_phys_t)) {
7065cabbc6Prashanth Sreenivasa			refcount++;
7075cabbc6Prashanth Sreenivasa		}
7085cabbc6Prashanth Sreenivasa	} else {
7095cabbc6Prashanth Sreenivasa		ASSERT3P(vd->vdev_obsolete_sm, ==, NULL);
7105cabbc6Prashanth Sreenivasa		ASSERT3U(obsolete_sm_obj, ==, 0);
7115cabbc6Prashanth Sreenivasa	}
7125cabbc6Prashanth Sreenivasa	for (unsigned c = 0; c < vd->vdev_children; c++) {
7135cabbc6Prashanth Sreenivasa		refcount += get_obsolete_refcount(vd->vdev_child[c]);
7145cabbc6Prashanth Sreenivasa	}
7155cabbc6Prashanth Sreenivasa
7165cabbc6Prashanth Sreenivasa	return (refcount);
7175cabbc6Prashanth Sreenivasa}
7185cabbc6Prashanth Sreenivasa
7195cabbc6Prashanth Sreenivasastatic int
7205cabbc6Prashanth Sreenivasaget_prev_obsolete_spacemap_refcount(spa_t *spa)
7215cabbc6Prashanth Sreenivasa{
7225cabbc6Prashanth Sreenivasa	uint64_t prev_obj =
7235cabbc6Prashanth Sreenivasa	    spa->spa_condensing_indirect_phys.scip_prev_obsolete_sm_object;
7245cabbc6Prashanth Sreenivasa	if (prev_obj != 0) {
7255cabbc6Prashanth Sreenivasa		dmu_object_info_t doi;
7265cabbc6Prashanth Sreenivasa		VERIFY0(dmu_object_info(spa->spa_meta_objset, prev_obj, &doi));
7275cabbc6Prashanth Sreenivasa		if (doi.doi_bonus_size == sizeof (space_map_phys_t)) {
7285cabbc6Prashanth Sreenivasa			return (1);
7295cabbc6Prashanth Sreenivasa		}
7305cabbc6Prashanth Sreenivasa	}
7315cabbc6Prashanth Sreenivasa	return (0);
7325cabbc6Prashanth Sreenivasa}
7335cabbc6Prashanth Sreenivasa
7345cabbc6Prashanth Sreenivasastatic int
7358671400Serapheim Dimitropoulosget_checkpoint_refcount(vdev_t *vd)
7368671400Serapheim Dimitropoulos{
7378671400Serapheim Dimitropoulos	int refcount = 0;
7388671400Serapheim Dimitropoulos
7398671400Serapheim Dimitropoulos	if (vd->vdev_top == vd && vd->vdev_top_zap != 0 &&
7408671400Serapheim Dimitropoulos	    zap_contains(spa_meta_objset(vd->vdev_spa),
7418671400Serapheim Dimitropoulos	    vd->vdev_top_zap, VDEV_TOP_ZAP_POOL_CHECKPOINT_SM) == 0)
7428671400Serapheim Dimitropoulos		refcount++;
7438671400Serapheim Dimitropoulos
7448671400Serapheim Dimitropoulos	for (uint64_t c = 0; c < vd->vdev_children; c++)
7458671400Serapheim Dimitropoulos		refcount += get_checkpoint_refcount(vd->vdev_child[c]);
7468671400Serapheim Dimitropoulos
7478671400Serapheim Dimitropoulos	return (refcount);
7488671400Serapheim Dimitropoulos}
7498671400Serapheim Dimitropoulos
7508671400Serapheim Dimitropoulosstatic int
7510713e23George Wilsonverify_spacemap_refcounts(spa_t *spa)
7520713e23George Wilson{
7532acef22Matthew Ahrens	uint64_t expected_refcount = 0;
7542acef22Matthew Ahrens	uint64_t actual_refcount;
7550713e23George Wilson
7562acef22Matthew Ahrens	(void) feature_get_refcount(spa,
7572acef22Matthew Ahrens	    &spa_feature_table[SPA_FEATURE_SPACEMAP_HISTOGRAM],
7582acef22Matthew Ahrens	    &expected_refcount);
7590713e23George Wilson	actual_refcount = get_dtl_refcount(spa->spa_root_vdev);
7600713e23George Wilson	actual_refcount += get_metaslab_refcount(spa->spa_root_vdev);
7615cabbc6Prashanth Sreenivasa	actual_refcount += get_obsolete_refcount(spa->spa_root_vdev);
7625cabbc6Prashanth Sreenivasa	actual_refcount += get_prev_obsolete_spacemap_refcount(spa);
7638671400Serapheim Dimitropoulos	actual_refcount += get_checkpoint_refcount(spa->spa_root_vdev);
7640713e23George Wilson
7650713e23George Wilson	if (expected_refcount != actual_refcount) {
7662acef22Matthew Ahrens		(void) printf("space map refcount mismatch: expected %lld != "
7672acef22Matthew Ahrens		    "actual %lld\n",
7682acef22Matthew Ahrens		    (longlong_t)expected_refcount,
7692acef22Matthew Ahrens		    (longlong_t)actual_refcount);
7700713e23George Wilson		return (2);
7710713e23George Wilson	}
7720713e23George Wilson	return (0);
7730713e23George Wilson}
7740713e23George Wilson
775fa9e406ahrensstatic void
7760713e23George Wilsondump_spacemap(objset_t *os, space_map_t *sm)
777fa9e406ahrens{
7785cabbc6Prashanth Sreenivasa	char *ddata[] = { "ALLOC", "FREE", "CONDENSE", "INVALID",
7795cabbc6Prashanth Sreenivasa	    "INVALID", "INVALID", "INVALID", "INVALID" };
780fa9e406ahrens
7810713e23George Wilson	if (sm == NULL)
782fa9e406ahrens		return;
783fa9e406ahrens
7845cabbc6Prashanth Sreenivasa	(void) printf("space map object %llu:\n",
7855cabbc6Prashanth Sreenivasa	    (longlong_t)sm->sm_phys->smp_object);
7865cabbc6Prashanth Sreenivasa	(void) printf("  smp_objsize = 0x%llx\n",
7875cabbc6Prashanth Sreenivasa	    (longlong_t)sm->sm_phys->smp_objsize);
7885cabbc6Prashanth Sreenivasa	(void) printf("  smp_alloc = 0x%llx\n",
7895cabbc6Prashanth Sreenivasa	    (longlong_t)sm->sm_phys->smp_alloc);
7905cabbc6Prashanth Sreenivasa
791fa9e406ahrens	/*
792fa9e406ahrens	 * Print out the freelist entries in both encoded and decoded form.
793fa9e406ahrens	 */
79417f1128Serapheim Dimitropoulos	uint8_t mapshift = sm->sm_shift;
79517f1128Serapheim Dimitropoulos	int64_t alloc = 0;
79617f1128Serapheim Dimitropoulos	uint64_t word;
79717f1128Serapheim Dimitropoulos	for (uint64_t offset = 0; offset < space_map_length(sm);
79817f1128Serapheim Dimitropoulos	    offset += sizeof (word)) {
7990713e23George Wilson
8000713e23George Wilson		VERIFY0(dmu_read(os, space_map_object(sm), offset,
80117f1128Serapheim Dimitropoulos		    sizeof (word), &word, DMU_READ_PREFETCH));
8020713e23George Wilson
80317f1128Serapheim Dimitropoulos		if (sm_entry_is_debug(word)) {
80487219dbVictor Latushkin			(void) printf("\t    [%6llu] %s: txg %llu, pass %llu\n",
80517f1128Serapheim Dimitropoulos			    (u_longlong_t)(offset / sizeof (word)),
80617f1128Serapheim Dimitropoulos			    ddata[SM_DEBUG_ACTION_DECODE(word)],
80717f1128Serapheim Dimitropoulos			    (u_longlong_t)SM_DEBUG_TXG_DECODE(word),
80817f1128Serapheim Dimitropoulos			    (u_longlong_t)SM_DEBUG_SYNCPASS_DECODE(word));
80917f1128Serapheim Dimitropoulos			continue;
81017f1128Serapheim Dimitropoulos		}
81117f1128Serapheim Dimitropoulos
81217f1128Serapheim Dimitropoulos		uint8_t words;
81317f1128Serapheim Dimitropoulos		char entry_type;
81417f1128Serapheim Dimitropoulos		uint64_t entry_off, entry_run, entry_vdev = SM_NO_VDEVID;
81517f1128Serapheim Dimitropoulos
81617f1128Serapheim Dimitropoulos		if (sm_entry_is_single_word(word)) {
81717f1128Serapheim Dimitropoulos			entry_type = (SM_TYPE_DECODE(word) == SM_ALLOC) ?
81817f1128Serapheim Dimitropoulos			    'A' : 'F';
81917f1128Serapheim Dimitropoulos			entry_off = (SM_OFFSET_DECODE(word) << mapshift) +
82017f1128Serapheim Dimitropoulos			    sm->sm_start;
82117f1128Serapheim Dimitropoulos			entry_run = SM_RUN_DECODE(word) << mapshift;
82217f1128Serapheim Dimitropoulos			words = 1;
823fa9e406ahrens		} else {
82417f1128Serapheim Dimitropoulos			/* it is a two-word entry so we read another word */
82517f1128Serapheim Dimitropoulos			ASSERT(sm_entry_is_double_word(word));
82617f1128Serapheim Dimitropoulos
82717f1128Serapheim Dimitropoulos			uint64_t extra_word;
82817f1128Serapheim Dimitropoulos			offset += sizeof (extra_word);
82917f1128Serapheim Dimitropoulos			VERIFY0(dmu_read(os, space_map_object(sm), offset,
83017f1128Serapheim Dimitropoulos			    sizeof (extra_word), &extra_word,
83117f1128Serapheim Dimitropoulos			    DMU_READ_PREFETCH));
83217f1128Serapheim Dimitropoulos
83317f1128Serapheim Dimitropoulos			ASSERT3U(offset, <=, space_map_length(sm));
83417f1128Serapheim Dimitropoulos
83517f1128Serapheim Dimitropoulos			entry_run = SM2_RUN_DECODE(word) << mapshift;
83617f1128Serapheim Dimitropoulos			entry_vdev = SM2_VDEV_DECODE(word);
83717f1128Serapheim Dimitropoulos			entry_type = (SM2_TYPE_DECODE(extra_word) == SM_ALLOC) ?
83817f1128Serapheim Dimitropoulos			    'A' : 'F';
83917f1128Serapheim Dimitropoulos			entry_off = (SM2_OFFSET_DECODE(extra_word) <<
84017f1128Serapheim Dimitropoulos			    mapshift) + sm->sm_start;
84117f1128Serapheim Dimitropoulos			words = 2;
842fa9e406ahrens		}
84317f1128Serapheim Dimitropoulos
84417f1128Serapheim Dimitropoulos		(void) printf("\t    [%6llu]    %c  range:"
84517f1128Serapheim Dimitropoulos		    " %010llx-%010llx  size: %06llx vdev: %06llu words: %u\n",
84617f1128Serapheim Dimitropoulos		    (u_longlong_t)(offset / sizeof (word)),
84717f1128Serapheim Dimitropoulos		    entry_type, (u_longlong_t)entry_off,
84817f1128Serapheim Dimitropoulos		    (u_longlong_t)(entry_off + entry_run),
84917f1128Serapheim Dimitropoulos		    (u_longlong_t)entry_run,
85017f1128Serapheim Dimitropoulos		    (u_longlong_t)entry_vdev, words);
85117f1128Serapheim Dimitropoulos
85217f1128Serapheim Dimitropoulos		if (entry_type == 'A')
85317f1128Serapheim Dimitropoulos			alloc += entry_run;
85417f1128Serapheim Dimitropoulos		else
85517f1128Serapheim Dimitropoulos			alloc -= entry_run;
856fa9e406ahrens	}
85717f1128Serapheim Dimitropoulos	if ((uint64_t)alloc != space_map_allocated(sm)) {
85817f1128Serapheim Dimitropoulos		(void) printf("space_map_object alloc (%lld) INCONSISTENT "
85917f1128Serapheim Dimitropoulos		    "with space map summary (%lld)\n",
86017f1128Serapheim Dimitropoulos		    (longlong_t)space_map_allocated(sm), (longlong_t)alloc);
861fa9e406ahrens	}
862fa9e406ahrens}
863fa9e406ahrens
864fa9e406ahrensstatic void
865d6e555bGeorge Wilsondump_metaslab_stats(metaslab_t *msp)
866d6e555bGeorge Wilson{
8673f9d6adLin Ling	char maxbuf[32];
8688671400Serapheim Dimitropoulos	range_tree_t *rt = msp->ms_allocatable;
8698671400Serapheim Dimitropoulos	avl_tree_t *t = &msp->ms_allocatable_by_size;
8700713e23George Wilson	int free_pct = range_tree_space(rt) * 100 / msp->ms_size;
871d6e555bGeorge Wilson
8720a05512Jason King	/* max sure nicenum has enough space */
8730a05512Jason King	CTASSERT(sizeof (maxbuf) >= NN_NUMBUF_SZ);
8740a05512Jason King
8750a05512Jason King	zdb_nicenum(metaslab_block_maxsize(msp), maxbuf, sizeof (maxbuf));
876d6e555bGeorge Wilson
87787219dbVictor Latushkin	(void) printf("\t %25s %10lu   %7s  %6s   %4s %4d%%\n",
878d6e555bGeorge Wilson	    "segments", avl_numnodes(t), "maxsize", maxbuf,
879d6e555bGeorge Wilson	    "freepct", free_pct);
8800713e23George Wilson	(void) printf("\tIn-memory histogram:\n");
8810713e23George Wilson	dump_histogram(rt->rt_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
882d6e555bGeorge Wilson}
883d6e555bGeorge Wilson
884d6e555bGeorge Wilsonstatic void
885fa9e406ahrensdump_metaslab(metaslab_t *msp)
886fa9e406ahrens{
887fa9e406ahrens	vdev_t *vd = msp->ms_group->mg_vd;
888fa9e406ahrens	spa_t *spa = vd->vdev_spa;
8890713e23George Wilson	space_map_t *sm = msp->ms_sm;
890