zdb.c revision 3f9d6ad73e45c6823b409f93b0c8d4f62861d2d5
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 */
21fa9e406ahrens/*
228f2529dMark Shellenbaum * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23fa9e406ahrens */
24fa9e406ahrens
25fa9e406ahrens#include <stdio.h>
26004388ecasper#include <stdio_ext.h>
27fa9e406ahrens#include <stdlib.h>
2844cd46cbillm#include <ctype.h>
29fa9e406ahrens#include <sys/zfs_context.h>
30fa9e406ahrens#include <sys/spa.h>
31fa9e406ahrens#include <sys/spa_impl.h>
32fa9e406ahrens#include <sys/dmu.h>
33fa9e406ahrens#include <sys/zap.h>
34fa9e406ahrens#include <sys/fs/zfs.h>
35fa9e406ahrens#include <sys/zfs_znode.h>
360a586ceMark Shellenbaum#include <sys/zfs_sa.h>
370a586ceMark Shellenbaum#include <sys/sa.h>
380a586ceMark Shellenbaum#include <sys/sa_impl.h>
39fa9e406ahrens#include <sys/vdev.h>
40fa9e406ahrens#include <sys/vdev_impl.h>
41fa9e406ahrens#include <sys/metaslab_impl.h>
42fa9e406ahrens#include <sys/dmu_objset.h>
43fa9e406ahrens#include <sys/dsl_dir.h>
44fa9e406ahrens#include <sys/dsl_dataset.h>
45fa9e406ahrens#include <sys/dsl_pool.h>
46fa9e406ahrens#include <sys/dbuf.h>
47fa9e406ahrens#include <sys/zil.h>
48fa9e406ahrens#include <sys/zil_impl.h>
49fa9e406ahrens#include <sys/stat.h>
50fa9e406ahrens#include <sys/resource.h>
51fa9e406ahrens#include <sys/dmu_traverse.h>
52fa9e406ahrens#include <sys/zio_checksum.h>
53fa9e406ahrens#include <sys/zio_compress.h>
54e0d35c4marks#include <sys/zfs_fuid.h>
5588b7b0fMatthew Ahrens#include <sys/arc.h>
56b24ab67Jeff Bonwick#include <sys/ddt.h>
57de6628fck#undef ZFS_MAXNAMELEN
58de6628fck#undef verify
59de6628fck#include <libzfs.h>
60fa9e406ahrens
616de8f41Victor Latushkin#define	ZDB_COMPRESS_NAME(idx) ((idx) < ZIO_COMPRESS_FUNCTIONS ? \
626de8f41Victor Latushkin    zio_compress_table[(idx)].ci_name : "UNKNOWN")
636de8f41Victor Latushkin#define	ZDB_CHECKSUM_NAME(idx) ((idx) < ZIO_CHECKSUM_FUNCTIONS ? \
646de8f41Victor Latushkin    zio_checksum_table[(idx)].ci_name : "UNKNOWN")
656de8f41Victor Latushkin#define	ZDB_OT_NAME(idx) ((idx) < DMU_OT_NUMTYPES ? \
666de8f41Victor Latushkin    dmu_ot[(idx)].ot_name : "UNKNOWN")
676de8f41Victor Latushkin#define	ZDB_OT_TYPE(idx) ((idx) < DMU_OT_NUMTYPES ? (idx) : DMU_OT_NUMTYPES)
686de8f41Victor Latushkin
69feef89cVictor Latushkin#ifndef lint
70feef89cVictor Latushkinextern int zfs_recover;
71feef89cVictor Latushkin#else
72feef89cVictor Latushkinint zfs_recover;
73feef89cVictor Latushkin#endif
74feef89cVictor Latushkin
75fa9e406ahrensconst char cmdname[] = "zdb";
76fa9e406ahrensuint8_t dump_opt[256];
77fa9e406ahrens
78fa9e406ahrenstypedef void object_viewer_t(objset_t *, uint64_t, void *data, size_t size);
79fa9e406ahrens
80fa9e406ahrensextern void dump_intent_log(zilog_t *);
81fa9e406ahrensuint64_t *zopt_object = NULL;
82fa9e406ahrensint zopt_objects = 0;
83de6628fcklibzfs_handle_t *g_zfs;
84fa9e406ahrens
85fa9e406ahrens/*
86fa9e406ahrens * These libumem hooks provide a reasonable set of defaults for the allocator's
87fa9e406ahrens * debugging facilities.
88fa9e406ahrens */
89fa9e406ahrensconst char *
90fa9e406ahrens_umem_debug_init()
91fa9e406ahrens{
92fa9e406ahrens	return ("default,verbose"); /* $UMEM_DEBUG setting */
93fa9e406ahrens}
94fa9e406ahrens
95fa9e406ahrensconst char *
96fa9e406ahrens_umem_logging_init(void)
97fa9e406ahrens{
98fa9e406ahrens	return ("fail,contents"); /* $UMEM_LOGGING setting */
99fa9e406ahrens}
100fa9e406ahrens
101fa9e406ahrensstatic void
102fa9e406ahrensusage(void)
103fa9e406ahrens{
104fa9e406ahrens	(void) fprintf(stderr,
105f0ba89bJeff Bonwick	    "Usage: %s [-CumdibcsDvhL] poolname [object...]\n"
1063ad6c7fVictor Latushkin	    "       %s [-div] dataset [object...]\n"
10787219dbVictor Latushkin	    "       %s -m [-L] poolname [vdev [metaslab...]]\n"
10807428bdVictor Latushkin	    "       %s -R poolname vdev:offset:size[:flags]\n"
109bbfd46cJeff Bonwick	    "       %s -S poolname\n"
11053b9a4aVictor Latushkin	    "       %s -l [-u] device\n"
11107428bdVictor Latushkin	    "       %s -C\n\n",
112bbfd46cJeff Bonwick	    cmdname, cmdname, cmdname, cmdname, cmdname, cmdname, cmdname);
1133ad6c7fVictor Latushkin
1143ad6c7fVictor Latushkin	(void) fprintf(stderr, "    Dataset name must include at least one "
1153ad6c7fVictor Latushkin	    "separator character '/' or '@'\n");
1163ad6c7fVictor Latushkin	(void) fprintf(stderr, "    If dataset name is specified, only that "
1173ad6c7fVictor Latushkin	    "dataset is dumped\n");
1183ad6c7fVictor Latushkin	(void) fprintf(stderr, "    If object numbers are specified, only "
1193ad6c7fVictor Latushkin	    "those objects are dumped\n\n");
1203ad6c7fVictor Latushkin	(void) fprintf(stderr, "    Options to control amount of output:\n");
1213ad6c7fVictor Latushkin	(void) fprintf(stderr, "        -u uberblock\n");
1223ad6c7fVictor Latushkin	(void) fprintf(stderr, "        -d dataset(s)\n");
1233ad6c7fVictor Latushkin	(void) fprintf(stderr, "        -i intent logs\n");
12407428bdVictor Latushkin	(void) fprintf(stderr, "        -C config (or cachefile if alone)\n");
1258f18d1fGeorge Wilson	(void) fprintf(stderr, "        -h pool history\n");
1263ad6c7fVictor Latushkin	(void) fprintf(stderr, "        -b block statistics\n");
1273ad6c7fVictor Latushkin	(void) fprintf(stderr, "        -m metaslabs\n");
1283ad6c7fVictor Latushkin	(void) fprintf(stderr, "        -c checksum all metadata (twice for "
1296365109Victor Latushkin	    "all data) blocks\n");
1303ad6c7fVictor Latushkin	(void) fprintf(stderr, "        -s report stats on zdb's I/O\n");
131f0ba89bJeff Bonwick	(void) fprintf(stderr, "        -D dedup statistics\n");
132b24ab67Jeff Bonwick	(void) fprintf(stderr, "        -S simulate dedup to measure effect\n");
1333ad6c7fVictor Latushkin	(void) fprintf(stderr, "        -v verbose (applies to all others)\n");
134fa9e406ahrens	(void) fprintf(stderr, "        -l dump label contents\n");
13582a0a98Victor Latushkin	(void) fprintf(stderr, "        -L disable leak tracking (do not "
13682a0a98Victor Latushkin	    "load spacemaps)\n");
137d41e764ek	(void) fprintf(stderr, "        -R read and display block from a "
1383ad6c7fVictor Latushkin	    "device\n\n");
1393ad6c7fVictor Latushkin	(void) fprintf(stderr, "    Below options are intended for use "
1403ad6c7fVictor Latushkin	    "with other options (except -l):\n");
141feef89cVictor Latushkin	(void) fprintf(stderr, "        -A ignore assertions (-A), enable "
142feef89cVictor Latushkin	    "panic recovery (-AA) or both (-AAA)\n");
143c8ee184Victor Latushkin	(void) fprintf(stderr, "        -F attempt automatic rewind within "
144c8ee184Victor Latushkin	    "safe range of transaction groups\n");
1453ad6c7fVictor Latushkin	(void) fprintf(stderr, "        -U <cachefile_path> -- use alternate "
1463ad6c7fVictor Latushkin	    "cachefile\n");
147c8ee184Victor Latushkin	(void) fprintf(stderr, "        -X attempt extreme rewind (does not "
148c8ee184Victor Latushkin	    "work with dataset)\n");
1493ad6c7fVictor Latushkin	(void) fprintf(stderr, "        -e pool is exported/destroyed/"
1503ad6c7fVictor Latushkin	    "has altroot/not in a cachefile\n");
1513ad6c7fVictor Latushkin	(void) fprintf(stderr, "        -p <path> -- use one or more with "
1523ad6c7fVictor Latushkin	    "-e to specify path to vdev dir\n");
1533f9d6adLin Ling	(void) fprintf(stderr, "	-P print numbers parsable\n");
1543ad6c7fVictor Latushkin	(void) fprintf(stderr, "        -t <txg> -- highest txg to use when "
1552e55192Victor Latushkin	    "searching for uberblocks\n");
156fa9e406ahrens	(void) fprintf(stderr, "Specify an option more than once (e.g. -bb) "
157fa9e406ahrens	    "to make only that option verbose\n");
158fa9e406ahrens	(void) fprintf(stderr, "Default is to dump everything non-verbosely\n");
159fa9e406ahrens	exit(1);
160fa9e406ahrens}
161fa9e406ahrens
162ccba080Rich Morris/*
163ccba080Rich Morris * Called for usage errors that are discovered after a call to spa_open(),
164ccba080Rich Morris * dmu_bonus_hold(), or pool_match().  abort() is called for other errors.
165ccba080Rich Morris */
166ccba080Rich Morris
167fa9e406ahrensstatic void
168fa9e406ahrensfatal(const char *fmt, ...)
169fa9e406ahrens{
170fa9e406ahrens	va_list ap;
171fa9e406ahrens
172fa9e406ahrens	va_start(ap, fmt);
173fa9e406ahrens	(void) fprintf(stderr, "%s: ", cmdname);
174fa9e406ahrens	(void) vfprintf(stderr, fmt, ap);
175fa9e406ahrens	va_end(ap);
176fa9e406ahrens	(void) fprintf(stderr, "\n");
177fa9e406ahrens
178ccba080Rich Morris	exit(1);
179fa9e406ahrens}
180fa9e406ahrens
181fa9e406ahrens/* ARGSUSED */
182fa9e406ahrensstatic void
183fa9e406ahrensdump_packed_nvlist(objset_t *os, uint64_t object, void *data, size_t size)
184fa9e406ahrens{
185fa9e406ahrens	nvlist_t *nv;
186fa9e406ahrens	size_t nvsize = *(uint64_t *)data;
187fa9e406ahrens	char *packed = umem_alloc(nvsize, UMEM_NOFAIL);
188fa9e406ahrens
1897bfdf01Neil Perrin	VERIFY(0 == dmu_read(os, object, 0, nvsize, packed, DMU_READ_PREFETCH));
190fa9e406ahrens
191fa9e406ahrens	VERIFY(nvlist_unpack(packed, nvsize, &nv, 0) == 0);
192fa9e406ahrens
193fa9e406ahrens	umem_free(packed, nvsize);
194fa9e406ahrens
195fa9e406ahrens	dump_nvlist(nv, 8);
196fa9e406ahrens
197fa9e406ahrens	nvlist_free(nv);
198fa9e406ahrens}
199fa9e406ahrens
2003f9d6adLin Lingstatic void
2013f9d6adLin Lingzdb_nicenum(uint64_t num, char *buf)
2023f9d6adLin Ling{
2033f9d6adLin Ling	if (dump_opt['P'])
2043f9d6adLin Ling		(void) sprintf(buf, "%llu", (longlong_t)num);
2053f9d6adLin Ling	else
2063f9d6adLin Ling		nicenum(num, buf);
2073f9d6adLin Ling}
2083f9d6adLin Ling
209fa9e406ahrensconst char dump_zap_stars[] = "****************************************";
210fa9e406ahrensconst int dump_zap_width = sizeof (dump_zap_stars) - 1;
211fa9e406ahrens
212fa9e406ahrensstatic void
213fa9e406ahrensdump_zap_histogram(uint64_t histo[ZAP_HISTOGRAM_SIZE])
214fa9e406ahrens{
215fa9e406ahrens	int i;
216fa9e406ahrens	int minidx = ZAP_HISTOGRAM_SIZE - 1;
217fa9e406ahrens	int maxidx = 0;
218fa9e406ahrens	uint64_t max = 0;
219fa9e406ahrens
220fa9e406ahrens	for (i = 0; i < ZAP_HISTOGRAM_SIZE; i++) {
221fa9e406ahrens		if (histo[i] > max)
222fa9e406ahrens			max = histo[i];
223fa9e406ahrens		if (histo[i] > 0 && i > maxidx)
224fa9e406ahrens			maxidx = i;
225fa9e406ahrens		if (histo[i] > 0 && i < minidx)
226fa9e406ahrens			minidx = i;
227fa9e406ahrens	}
228fa9e406ahrens
229fa9e406ahrens	if (max < dump_zap_width)
230fa9e406ahrens		max = dump_zap_width;
231fa9e406ahrens
232fa9e406ahrens	for (i = minidx; i <= maxidx; i++)
233fa9e406ahrens		(void) printf("\t\t\t%u: %6llu %s\n", i, (u_longlong_t)histo[i],
234fa9e406ahrens		    &dump_zap_stars[(max - histo[i]) * dump_zap_width / max]);
235fa9e406ahrens}
236fa9e406ahrens
237fa9e406ahrensstatic void
238fa9e406ahrensdump_zap_stats(objset_t *os, uint64_t object)
239fa9e406ahrens{
240fa9e406ahrens	int error;
241fa9e406ahrens	zap_stats_t zs;
242fa9e406ahrens
243fa9e406ahrens	error = zap_get_stats(os, object, &zs);
244fa9e406ahrens	if (error)
245fa9e406ahrens		return;
246fa9e406ahrens
247fa9e406ahrens	if (zs.zs_ptrtbl_len == 0) {
248fa9e406ahrens		ASSERT(zs.zs_num_blocks == 1);
249fa9e406ahrens		(void) printf("\tmicrozap: %llu bytes, %llu entries\n",
250fa9e406ahrens		    (u_longlong_t)zs.zs_blocksize,
251fa9e406ahrens		    (u_longlong_t)zs.zs_num_entries);
252fa9e406ahrens		return;
253fa9e406ahrens	}
254fa9e406ahrens
255fa9e406ahrens	(void) printf("\tFat ZAP stats:\n");
2568248818nd
2578248818nd	(void) printf("\t\tPointer table:\n");
2588248818nd	(void) printf("\t\t\t%llu elements\n",
259fa9e406ahrens	    (u_longlong_t)zs.zs_ptrtbl_len);
2608248818nd	(void) printf("\t\t\tzt_blk: %llu\n",
2618248818nd	    (u_longlong_t)zs.zs_ptrtbl_zt_blk);
2628248818nd	(void) printf("\t\t\tzt_numblks: %llu\n",
2638248818nd	    (u_longlong_t)zs.zs_ptrtbl_zt_numblks);
2648248818nd	(void) printf("\t\t\tzt_shift: %llu\n",
2658248818nd	    (u_longlong_t)zs.zs_ptrtbl_zt_shift);
2668248818nd	(void) printf("\t\t\tzt_blks_copied: %llu\n",
2678248818nd	    (u_longlong_t)zs.zs_ptrtbl_blks_copied);
2688248818nd	(void) printf("\t\t\tzt_nextblk: %llu\n",
2698248818nd	    (u_longlong_t)zs.zs_ptrtbl_nextblk);
2708248818nd
271fa9e406ahrens	(void) printf("\t\tZAP entries: %llu\n",
272fa9e406ahrens	    (u_longlong_t)zs.zs_num_entries);
273fa9e406ahrens	(void) printf("\t\tLeaf blocks: %llu\n",
274fa9e406ahrens	    (u_longlong_t)zs.zs_num_leafs);
275fa9e406ahrens	(void) printf("\t\tTotal blocks: %llu\n",
276fa9e406ahrens	    (u_longlong_t)zs.zs_num_blocks);
2778248818nd	(void) printf("\t\tzap_block_type: 0x%llx\n",
2788248818nd	    (u_longlong_t)zs.zs_block_type);
2798248818nd	(void) printf("\t\tzap_magic: 0x%llx\n",
2808248818nd	    (u_longlong_t)zs.zs_magic);
2818248818nd	(void) printf("\t\tzap_salt: 0x%llx\n",
2828248818nd	    (u_longlong_t)zs.zs_salt);
283fa9e406ahrens
284fa9e406ahrens	(void) printf("\t\tLeafs with 2^n pointers:\n");
285fa9e406ahrens	dump_zap_histogram(zs.zs_leafs_with_2n_pointers);
286fa9e406ahrens
287fa9e406ahrens	(void) printf("\t\tBlocks with n*5 entries:\n");
288fa9e406ahrens	dump_zap_histogram(zs.zs_blocks_with_n5_entries);
289fa9e406ahrens
290fa9e406ahrens	(void) printf("\t\tBlocks n/10 full:\n");
291fa9e406ahrens	dump_zap_histogram(zs.zs_blocks_n_tenths_full);
292fa9e406ahrens
293fa9e406ahrens	(void) printf("\t\tEntries with n chunks:\n");
294fa9e406ahrens	dump_zap_histogram(zs.zs_entries_using_n_chunks);
295fa9e406ahrens
296fa9e406ahrens	(void) printf("\t\tBuckets with n entries:\n");
297fa9e406ahrens	dump_zap_histogram(zs.zs_buckets_with_n_entries);
298fa9e406ahrens}
299fa9e406ahrens
300fa9e406ahrens/*ARGSUSED*/
301fa9e406ahrensstatic void
302fa9e406ahrensdump_none(objset_t *os, uint64_t object, void *data, size_t size)
303fa9e406ahrens{
304fa9e406ahrens}
305fa9e406ahrens
306fa9e406ahrens/*ARGSUSED*/
3076de8f41Victor Latushkinstatic void
3086de8f41Victor Latushkindump_unknown(objset_t *os, uint64_t object, void *data, size_t size)
3096de8f41Victor Latushkin{
3106de8f41Victor Latushkin	(void) printf("\tUNKNOWN OBJECT TYPE\n");
3116de8f41Victor Latushkin}
3126de8f41Victor Latushkin
3136de8f41Victor Latushkin/*ARGSUSED*/
314fa9e406ahrensvoid
315fa9e406ahrensdump_uint8(objset_t *os, uint64_t object, void *data, size_t size)
316fa9e406ahrens{
317fa9e406ahrens}
318fa9e406ahrens
319fa9e406ahrens/*ARGSUSED*/
320fa9e406ahrensstatic void
321fa9e406ahrensdump_uint64(objset_t *os, uint64_t object, void *data, size_t size)
322fa9e406ahrens{
323fa9e406ahrens}
324fa9e406ahrens
325fa9e406ahrens/*ARGSUSED*/
326fa9e406ahrensstatic void
327fa9e406ahrensdump_zap(objset_t *os, uint64_t object, void *data, size_t size)
328fa9e406ahrens{
329fa9e406ahrens	zap_cursor_t zc;
330fa9e406ahrens	zap_attribute_t attr;
331fa9e406ahrens	void *prop;
332fa9e406ahrens	int i;
333fa9e406ahrens
334fa9e406ahrens	dump_zap_stats(os, object);
335fa9e406ahrens	(void) printf("\n");
336fa9e406ahrens
337fa9e406ahrens	for (zap_cursor_init(&zc, os, object);
338fa9e406ahrens	    zap_cursor_retrieve(&zc, &attr) == 0;
339fa9e406ahrens	    zap_cursor_advance(&zc)) {
340fa9e406ahrens		(void) printf("\t\t%s = ", attr.za_name);
341fa9e406ahrens		if (attr.za_num_integers == 0) {
342fa9e406ahrens			(void) printf("\n");
343fa9e406ahrens			continue;
344fa9e406ahrens		}
345fa9e406ahrens		prop = umem_zalloc(attr.za_num_integers *
346fa9e406ahrens		    attr.za_integer_length, UMEM_NOFAIL);
347fa9e406ahrens		(void) zap_lookup(os, object, attr.za_name,
348fa9e406ahrens		    attr.za_integer_length, attr.za_num_integers, prop);
349fa9e406ahrens		if (attr.za_integer_length == 1) {
350fa9e406ahrens			(void) printf("%s", (char *)prop);
351fa9e406ahrens		} else {
352fa9e406ahrens			for (i = 0; i < attr.za_num_integers; i++) {
353fa9e406ahrens				switch (attr.za_integer_length) {
354fa9e406ahrens				case 2:
355fa9e406ahrens					(void) printf("%u ",
356fa9e406ahrens					    ((uint16_t *)prop)[i]);
357fa9e406ahrens					break;
358fa9e406ahrens				case 4:
359fa9e406ahrens					(void) printf("%u ",
360fa9e406ahrens					    ((uint32_t *)prop)[i]);
361fa9e406ahrens					break;
362fa9e406ahrens				case 8:
363fa9e406ahrens					(void) printf("%lld ",
364fa9e406ahrens					    (u_longlong_t)((int64_t *)prop)[i]);
365fa9e406ahrens					break;
366fa9e406ahrens				}
367fa9e406ahrens			}
368fa9e406ahrens		}
369fa9e406ahrens		(void) printf("\n");
370fa9e406ahrens		umem_free(prop, attr.za_num_integers * attr.za_integer_length);
371fa9e406ahrens	}
37287e5029ahrens	zap_cursor_fini(&zc);
373fa9e406ahrens}
374fa9e406ahrens
375e743726ahrens/*ARGSUSED*/
376e743726ahrensstatic void
377486ae71Matthew Ahrensdump_ddt_zap(objset_t *os, uint64_t object, void *data, size_t size)
378486ae71Matthew Ahrens{
379486ae71Matthew Ahrens	dump_zap_stats(os, object);
380486ae71Matthew Ahrens	/* contents are printed elsewhere, properly decoded */
381486ae71Matthew Ahrens}
382486ae71Matthew Ahrens
383486ae71Matthew Ahrens/*ARGSUSED*/
384486ae71Matthew Ahrensstatic void
3850a586ceMark Shellenbaumdump_sa_attrs(objset_t *os, uint64_t object, void *data, size_t size)
3860a586ceMark Shellenbaum{
3870a586ceMark Shellenbaum	zap_cursor_t zc;
3880a586ceMark Shellenbaum	zap_attribute_t attr;
3890a586ceMark Shellenbaum
3900a586ceMark Shellenbaum	dump_zap_stats(os, object);
3910a586ceMark Shellenbaum	(void) printf("\n");
3920a586ceMark Shellenbaum
3930a586ceMark Shellenbaum	for (zap_cursor_init(&zc, os, object);
3940a586ceMark Shellenbaum	    zap_cursor_retrieve(&zc, &attr) == 0;
3950a586ceMark Shellenbaum	    zap_cursor_advance(&zc)) {
3960a586ceMark Shellenbaum		(void) printf("\t\t%s = ", attr.za_name);
3970a586ceMark Shellenbaum		if (attr.za_num_integers == 0) {
3980a586ceMark Shellenbaum			(void) printf("\n");
3990a586ceMark Shellenbaum			continue;
4000a586ceMark Shellenbaum		}
4010a586ceMark Shellenbaum		(void) printf(" %llx : [%d:%d:%d]\n",
4020a586ceMark Shellenbaum		    (u_longlong_t)attr.za_first_integer,
4030a586ceMark Shellenbaum		    (int)ATTR_LENGTH(attr.za_first_integer),
4040a586ceMark Shellenbaum		    (int)ATTR_BSWAP(attr.za_first_integer),
4050a586ceMark Shellenbaum		    (int)ATTR_NUM(attr.za_first_integer));
4060a586ceMark Shellenbaum	}
4070a586ceMark Shellenbaum	zap_cursor_fini(&zc);
4080a586ceMark Shellenbaum}
4090a586ceMark Shellenbaum
4100a586ceMark Shellenbaum/*ARGSUSED*/
4110a586ceMark Shellenbaumstatic void
4120a586ceMark Shellenbaumdump_sa_layouts(objset_t *os, uint64_t object, void *data, size_t size)
4130a586ceMark Shellenbaum{
4140a586ceMark Shellenbaum	zap_cursor_t zc;
4150a586ceMark Shellenbaum	zap_attribute_t attr;
4160a586ceMark Shellenbaum	uint16_t *layout_attrs;
4170a586ceMark Shellenbaum	int i;
4180a586ceMark Shellenbaum
4190a586ceMark Shellenbaum	dump_zap_stats(os, object);
4200a586ceMark Shellenbaum	(void) printf("\n");
4210a586ceMark Shellenbaum
4220a586ceMark Shellenbaum	for (zap_cursor_init(&zc, os, object);
4230a586ceMark Shellenbaum	    zap_cursor_retrieve(&zc, &attr) == 0;
4240a586ceMark Shellenbaum	    zap_cursor_advance(&zc)) {
4250a586ceMark Shellenbaum		(void) printf("\t\t%s = [", attr.za_name);
4260a586ceMark Shellenbaum		if (attr.za_num_integers == 0) {
4270a586ceMark Shellenbaum			(void) printf("\n");
4280a586ceMark Shellenbaum			continue;
4290a586ceMark Shellenbaum		}
4300a586ceMark Shellenbaum
4310a586ceMark Shellenbaum		VERIFY(attr.za_integer_length == 2);
4320a586ceMark Shellenbaum		layout_attrs = umem_zalloc(attr.za_num_integers *
4330a586ceMark Shellenbaum		    attr.za_integer_length, UMEM_NOFAIL);
4340a586ceMark Shellenbaum
4350a586ceMark Shellenbaum		VERIFY(zap_lookup(os, object, attr.za_name,
4360a586ceMark Shellenbaum		    attr.za_integer_length,
4370a586ceMark Shellenbaum		    attr.za_num_integers, layout_attrs) == 0);
4380a586ceMark Shellenbaum
4390a586ceMark Shellenbaum		for (i = 0; i != attr.za_num_integers; i++)
4400a586ceMark Shellenbaum			(void) printf(" %d ", (int)layout_attrs[i]);
4410a586ceMark Shellenbaum		(void) printf("]\n");
4420a586ceMark Shellenbaum		umem_free(layout_attrs,
4430a586ceMark Shellenbaum		    attr.za_num_integers * attr.za_integer_length);
4440a586ceMark Shellenbaum	}
4450a586ceMark Shellenbaum	zap_cursor_fini(&zc);
4460a586ceMark Shellenbaum}
4470a586ceMark Shellenbaum
4480a586ceMark Shellenbaum/*ARGSUSED*/
4490a586ceMark Shellenbaumstatic void
450e743726ahrensdump_zpldir(objset_t *os, uint64_t object, void *data, size_t size)
451e743726ahrens{
452e743726ahrens	zap_cursor_t zc;
453e743726ahrens	zap_attribute_t attr;
454e743726ahrens	const char *typenames[] = {
455e743726ahrens		/* 0 */ "not specified",
456e743726ahrens		/* 1 */ "FIFO",
457e743726ahrens		/* 2 */ "Character Device",
458e743726ahrens		/* 3 */ "3 (invalid)",
459e743726ahrens		/* 4 */ "Directory",
460e743726ahrens		/* 5 */ "5 (invalid)",
461e743726ahrens		/* 6 */ "Block Device",
462e743726ahrens		/* 7 */ "7 (invalid)",
463e743726ahrens		/* 8 */ "Regular File",
464e743726ahrens		/* 9 */ "9 (invalid)",
465e743726ahrens		/* 10 */ "Symbolic Link",
466e743726ahrens		/* 11 */ "11 (invalid)",
467e743726ahrens		/* 12 */ "Socket",
468e743726ahrens		/* 13 */ "Door",
469e743726ahrens		/* 14 */ "Event Port",
470e743726ahrens		/* 15 */ "15 (invalid)",
471e743726ahrens	};
472e743726ahrens
473e743726ahrens	dump_zap_stats(os, object);
474e743726ahrens	(void) printf("\n");
475e743726ahrens
476e743726ahrens	for (zap_cursor_init(&zc, os, object);
477e743726ahrens	    zap_cursor_retrieve(&zc, &attr) == 0;
478e743726ahrens	    zap_cursor_advance(&zc)) {
479e743726ahrens		(void) printf("\t\t%s = %lld (type: %s)\n",
480e743726ahrens		    attr.za_name, ZFS_DIRENT_OBJ(attr.za_first_integer),
481e743726ahrens		    typenames[ZFS_DIRENT_TYPE(attr.za_first_integer)]);
482e743726ahrens	}
483e743726ahrens	zap_cursor_fini(&zc);
484e743726ahrens}
485e743726ahrens
486fa9e406ahrensstatic void
487fa9e406ahrensdump_spacemap(objset_t *os, space_map_obj_t *smo, space_map_t *sm)
488fa9e406ahrens{
489fa9e406ahrens	uint64_t alloc, offset, entry;
490ecc2d60bonwick	uint8_t mapshift = sm->sm_shift;
491fa9e406ahrens	uint64_t mapstart = sm->sm_start;
4928053a26ck	char *ddata[] = { "ALLOC", "FREE", "CONDENSE", "INVALID",
4938053a26ck			    "INVALID", "INVALID", "INVALID", "INVALID" };
494fa9e406ahrens
495fa9e406ahrens	if (smo->smo_object == 0)
496fa9e406ahrens		return;
497fa9e406ahrens
498fa9e406ahrens	/*
499fa9e406ahrens	 * Print out the freelist entries in both encoded and decoded form.
500fa9e406ahrens	 */
501fa9e406ahrens	alloc = 0;
502fa9e406ahrens	for (offset = 0; offset < smo->smo_objsize; offset += sizeof (entry)) {
5033f9d6adLin Ling		VERIFY3U(0, ==, dmu_read(os, smo->smo_object, offset,
5047bfdf01Neil Perrin		    sizeof (entry), &entry, DMU_READ_PREFETCH));
505fa9e406ahrens		if (SM_DEBUG_DECODE(entry)) {
50687219dbVictor Latushkin			(void) printf("\t    [%6llu] %s: txg %llu, pass %llu\n",
507fa9e406ahrens			    (u_longlong_t)(offset / sizeof (entry)),
508fa9e406ahrens			    ddata[SM_DEBUG_ACTION_DECODE(entry)],
5095ad8204nd			    (u_longlong_t)SM_DEBUG_TXG_DECODE(entry),
5105ad8204nd			    (u_longlong_t)SM_DEBUG_SYNCPASS_DECODE(entry));
511fa9e406ahrens		} else {
51287219dbVictor Latushkin			(void) printf("\t    [%6llu]    %c  range:"
51387219dbVictor Latushkin			    " %010llx-%010llx  size: %06llx\n",
514fa9e406ahrens			    (u_longlong_t)(offset / sizeof (entry)),
515fa9e406ahrens			    SM_TYPE_DECODE(entry) == SM_ALLOC ? 'A' : 'F',
5165ad8204nd			    (u_longlong_t)((SM_OFFSET_DECODE(entry) <<
5175ad8204nd			    mapshift) + mapstart),
5185ad8204nd			    (u_longlong_t)((SM_OFFSET_DECODE(entry) <<
5195ad8204nd			    mapshift) + mapstart + (SM_RUN_DECODE(entry) <<
5205ad8204nd			    mapshift)),
5215ad8204nd			    (u_longlong_t)(SM_RUN_DECODE(entry) << mapshift));
522fa9e406ahrens			if (SM_TYPE_DECODE(entry) == SM_ALLOC)
523fa9e406ahrens				alloc += SM_RUN_DECODE(entry) << mapshift;
524fa9e406ahrens			else
525fa9e406ahrens				alloc -= SM_RUN_DECODE(entry) << mapshift;
526fa9e406ahrens		}
527fa9e406ahrens	}
528fa9e406ahrens	if (alloc != smo->smo_alloc) {
529fa9e406ahrens		(void) printf("space_map_object alloc (%llu) INCONSISTENT "
530fa9e406ahrens		    "with space map summary (%llu)\n",
531fa9e406ahrens		    (u_longlong_t)smo->smo_alloc, (u_longlong_t)alloc);
532fa9e406ahrens	}
533fa9e406ahrens}
534fa9e406ahrens
535fa9e406ahrensstatic void
536d6e555bGeorge Wilsondump_metaslab_stats(metaslab_t *msp)
537d6e555bGeorge Wilson{
5383f9d6adLin Ling	char maxbuf[32];
539d6e555bGeorge Wilson	space_map_t *sm = &msp->ms_map;
540d6e555bGeorge Wilson	avl_tree_t *t = sm->sm_pp_root;
541d6e555bGeorge Wilson	int free_pct = sm->sm_space * 100 / sm->sm_size;
542d6e555bGeorge Wilson
5433f9d6adLin Ling	zdb_nicenum(space_map_maxsize(sm), maxbuf);
544d6e555bGeorge Wilson
54587219dbVictor Latushkin	(void) printf("\t %25s %10lu   %7s  %6s   %4s %4d%%\n",
546d6e555bGeorge Wilson	    "segments", avl_numnodes(t), "maxsize", maxbuf,
547d6e555bGeorge Wilson	    "freepct", free_pct);
548d6e555bGeorge Wilson}
549d6e555bGeorge Wilson
550d6e555bGeorge Wilsonstatic void
551fa9e406ahrensdump_metaslab(metaslab_t *msp)
552fa9e406ahrens{
553fa9e406ahrens	vdev_t *vd = msp->ms_group->mg_vd;
554fa9e406ahrens	spa_t *spa = vd->vdev_spa;
55580eb36fGeorge Wilson	space_map_t *sm = &msp->ms_map;
55680eb36fGeorge Wilson	space_map_obj_t *smo = &msp->ms_smo;
5573f9d6adLin Ling	char freebuf[32];
558fa9e406ahrens
5593f9d6adLin Ling	zdb_nicenum(sm->sm_size - smo->smo_alloc, freebuf);
560fa9e406ahrens
561fa9e406ahrens	(void) printf(
56287219dbVictor Latushkin	    "\tmetaslab %6llu   offset %12llx   spacemap %6llu   free    %5s\n",
56380eb36fGeorge Wilson	    (u_longlong_t)(sm->sm_start / sm->sm_size),
56480eb36fGeorge Wilson	    (u_longlong_t)sm->sm_start, (u_longlong_t)smo->smo_object, freebuf);
565fa9e406ahrens
56687219dbVictor Latushkin	if (dump_opt['m'] > 1 && !dump_opt['L']) {
567d6e555bGeorge Wilson		mutex_enter(&msp->ms_lock);
56880eb36fGeorge Wilson		space_map_load_wait(sm);
569bc3975bVictor Latushkin		if (!sm->sm_loaded)
57080eb36fGeorge Wilson			VERIFY(space_map_load(sm, zfs_metaslab_ops,
57180eb36fGeorge Wilson			    SM_FREE, smo, spa->spa_meta_objset) == 0);
572bc3975bVictor Latushkin		dump_metaslab_stats(msp);
573bc3975bVictor Latushkin		space_map_unload(sm);
574d6e555bGeorge Wilson		mutex_exit(&msp->ms_lock);
575d6e555bGeorge Wilson	}
576d6e555bGeorge Wilson
577d6e555bGeorge Wilson	if (dump_opt['d'] > 5 || dump_opt['m'] > 2) {
57880eb36fGeorge Wilson		ASSERT(sm->sm_size == (1ULL << vd->vdev_ms_shift));
579d6e555bGeorge Wilson
580d6e555bGeorge Wilson		mutex_enter(&msp->ms_lock);
58180eb36fGeorge Wilson		dump_spacemap(spa->spa_meta_objset, smo, sm);
582d6e555bGeorge Wilson		mutex_exit(&msp->ms_lock);
583d6e555bGeorge Wilson	}
58487219dbVictor Latushkin}
585fa9e406ahrens
58687219dbVictor Latushkinstatic void
58787219dbVictor Latushkinprint_vdev_metaslab_header(vdev_t *vd)
58887219dbVictor Latushkin{
58987219dbVictor Latushkin	(void) printf("\tvdev %10llu\n\t%-10s%5llu   %-19s   %-15s   %-10s\n",
59087219dbVictor Latushkin	    (u_longlong_t)vd->vdev_id,
59187219dbVictor Latushkin	    "metaslabs", (u_longlong_t)vd->vdev_ms_count,
59287219dbVictor Latushkin	    "offset", "spacemap", "free");
59387219dbVictor Latushkin	(void) printf("\t%15s   %19s   %15s   %10s\n",
59487219dbVictor Latushkin	    "---------------", "-------------------",
59587219dbVictor Latushkin	    "---------------", "-------------");
596fa9e406ahrens}
597fa9e406ahrens
598fa9e406ahrensstatic void
599fa9e406ahrensdump_metaslabs(spa_t *spa)
600fa9e406ahrens{
60187219dbVictor Latushkin	vdev_t *vd, *rvd = spa->spa_root_vdev;
60287219dbVictor Latushkin	uint64_t m, c = 0, children = rvd->vdev_children;
603fa9e406ahrens
604fa9e406ahrens	(void) printf("\nMetaslabs:\n");
605fa9e406ahrens
60687219dbVictor Latushkin	if (!dump_opt['d'] && zopt_objects > 0) {
60787219dbVictor Latushkin		c = zopt_object[0];
60887219dbVictor Latushkin
60987219dbVictor Latushkin		if (c >= children)
61087219dbVictor Latushkin			(void) fatal("bad vdev id: %llu", (u_longlong_t)c);
611fa9e406ahrens
61287219dbVictor Latushkin		if (zopt_objects > 1) {
61387219dbVictor Latushkin			vd = rvd->vdev_child[c];
61487219dbVictor Latushkin			print_vdev_metaslab_header(vd);
61587219dbVictor Latushkin
61687219dbVictor Latushkin			for (m = 1; m < zopt_objects; m++) {
61787219dbVictor Latushkin				if (zopt_object[m] < vd->vdev_ms_count)
61887219dbVictor Latushkin					dump_metaslab(
61987219dbVictor Latushkin					    vd->vdev_ms[zopt_object[m]]);
62087219dbVictor Latushkin				else
62187219dbVictor Latushkin					(void) fprintf(stderr, "bad metaslab "
62287219dbVictor Latushkin					    "number %llu\n",
62387219dbVictor Latushkin					    (u_longlong_t)zopt_object[m]);
62487219dbVictor Latushkin			}
62587219dbVictor Latushkin			(void) printf("\n");
62687219dbVictor Latushkin			return;
62787219dbVictor Latushkin		}
62887219dbVictor Latushkin		children = c + 1;
62987219dbVictor Latushkin	}
63087219dbVictor Latushkin	for (; c < children; c++) {
63187219dbVictor Latushkin		vd = rvd->vdev_child[c];
63287219dbVictor Latushkin		print_vdev_metaslab_header(vd);
633fa9e406ahrens
634fa9e406ahrens		for (m = 0; m < vd->vdev_ms_count; m++)
635fa9e406ahrens			dump_metaslab(vd->vdev_ms[m]);
636fa9e406ahrens		(void) printf("\n");
637fa9e406ahrens	}
638fa9e406ahrens}
639fa9e406ahrens
640fa9e406ahrensstatic void
641b24ab67Jeff Bonwickdump_dde(const ddt_t *ddt, const ddt_entry_t *dde, uint64_t index)
642b24ab67Jeff Bonwick{
643b24ab67Jeff Bonwick	const ddt_phys_t *ddp = dde->dde_phys;
644b24ab67Jeff Bonwick	const ddt_key_t *ddk = &dde->dde_key;
645b24ab67Jeff Bonwick	char *types[4] = { "ditto", "single", "double", "triple" };
646b24ab67Jeff Bonwick	char blkbuf[BP_SPRINTF_LEN];
647b24ab67Jeff Bonwick	blkptr_t blk;
648b24ab67Jeff Bonwick
649b24ab67Jeff Bonwick	for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
650b24ab67Jeff Bonwick		if (ddp->ddp_phys_birth == 0)
651b24ab67Jeff Bonwick			continue;
652bbfd46cJeff Bonwick		ddt_bp_create(ddt->ddt_checksum, ddk, ddp, &blk);
653b24ab67Jeff Bonwick		sprintf_blkptr(blkbuf, &blk);
654b24ab67Jeff Bonwick		(void) printf("index %llx refcnt %llu %s %s\n",
655b24ab67Jeff Bonwick		    (u_longlong_t)index, (u_longlong_t)ddp->ddp_refcnt,
656b24ab67Jeff Bonwick		    types[p], blkbuf);
657b24ab67Jeff Bonwick	}
658b24ab67Jeff Bonwick}
659b24ab67Jeff Bonwick
660b24ab67Jeff Bonwickstatic void
661b24ab67Jeff Bonwickdump_dedup_ratio(const ddt_stat_t *dds)
662b24ab67Jeff Bonwick{
663b24ab67Jeff Bonwick	double rL, rP, rD, D, dedup, compress, copies;
664b24ab67Jeff Bonwick
665b24ab67Jeff Bonwick	if (dds->dds_blocks == 0)
666b24ab67Jeff Bonwick		return;
667b24ab67Jeff Bonwick
668b24ab67Jeff Bonwick	rL = (double)dds->dds_ref_lsize;
669b24ab67Jeff Bonwick	rP = (double)dds->dds_ref_psize;
670b24ab67Jeff Bonwick	rD = (double)dds->dds_ref_dsize;
671b24ab67Jeff Bonwick	D = (double)dds->dds_dsize;
672b24ab67Jeff Bonwick
673b24ab67Jeff Bonwick	dedup = rD / D;
674b24ab67Jeff Bonwick	compress = rL / rP;
675b24ab67Jeff Bonwick	copies = rD / rP;
676b24ab67Jeff Bonwick
677b24ab67Jeff Bonwick	(void) printf("dedup = %.2f, compress = %.2f, copies = %.2f, "
678b24ab67Jeff Bonwick	    "dedup * compress / copies = %.2f\n\n",
679b24ab67Jeff Bonwick	    dedup, compress, copies, dedup * compress / copies);
680b24ab67Jeff Bonwick}
681b24ab67Jeff Bonwick
682b24ab67Jeff Bonwickstatic void
683b24ab67Jeff Bonwickdump_ddt(ddt_t *ddt, enum ddt_type type, enum ddt_class class)
684b24ab67Jeff Bonwick{
685b24ab67Jeff Bonwick	char name[DDT_NAMELEN];
686b24ab67Jeff Bonwick	ddt_entry_t dde;
687b24ab67Jeff Bonwick	uint64_t walk = 0;
688b24ab67Jeff Bonwick	dmu_object_info_t doi;
689b24ab67Jeff Bonwick	uint64_t count, dspace, mspace;
690b24ab67Jeff Bonwick	int error;
691b24ab67Jeff Bonwick
692b24ab67Jeff Bonwick	error = ddt_object_info(ddt, type, class, &doi);
693b24ab67Jeff Bonwick
694b24ab67Jeff Bonwick	if (error == ENOENT)
695b24ab67Jeff Bonwick		return;
696b24ab67Jeff Bonwick	ASSERT(error == 0);
697b24ab67Jeff Bonwick
698b24ab67Jeff Bonwick	count = ddt_object_count(ddt, type, class);
699b24ab67Jeff Bonwick	dspace = doi.doi_physical_blocks_512 << 9;
700b24ab67Jeff Bonwick	mspace = doi.doi_fill_count * doi.doi_data_block_size;
701b24ab67Jeff Bonwick
702b24ab67Jeff Bonwick	ASSERT(count != 0);	/* we should have destroyed it */
703b24ab67Jeff Bonwick
704b24ab67Jeff Bonwick	ddt_object_name(ddt, type, class, name);
705b24ab67Jeff Bonwick
706b24ab67Jeff Bonwick	(void) printf("%s: %llu entries, size %llu on disk, %llu in core\n",
707b24ab67Jeff Bonwick	    name,
708b24ab67Jeff Bonwick	    (u_longlong_t)count,
709b24ab67Jeff Bonwick	    (u_longlong_t)(dspace / count),
710b24ab67Jeff Bonwick	    (u_longlong_t)(mspace / count));
711b24ab67Jeff Bonwick
712b24ab67Jeff Bonwick	if (dump_opt['D'] < 3)
713b24ab67Jeff Bonwick		return;
714b24ab67Jeff Bonwick
7159eb19f4George Wilson	zpool_dump_ddt(NULL, &ddt->ddt_histogram[type][class]);
716b24ab67Jeff Bonwick
717b24ab67Jeff Bonwick	if (dump_opt['D'] < 4)
718b24ab67Jeff Bonwick		return;
719b24ab67Jeff Bonwick
720b24ab67Jeff Bonwick	if (dump_opt['D'] < 5 && class == DDT_CLASS_UNIQUE)
721b24ab67Jeff Bonwick		return;
722b24ab67Jeff Bonwick
723b24ab67Jeff Bonwick	(void) printf("%s contents:\n\n", name);
724b24ab67Jeff Bonwick
725bbfd46cJeff Bonwick	while ((error = ddt_object_walk(ddt, type, class, &walk, &dde)) == 0)
726b24ab67Jeff Bonwick		dump_dde(ddt, &dde, walk);
727b24ab67Jeff Bonwick
728b24ab67Jeff Bonwick	ASSERT(error == ENOENT);
729b24ab67Jeff Bonwick
730b24ab67Jeff Bonwick	(void) printf("\n");
731b24ab67Jeff Bonwick}
732b24ab67Jeff Bonwick
733b24ab67Jeff Bonwickstatic void
734b24ab67Jeff Bonwickdump_all_ddts(spa_t *spa)
735b24ab67Jeff Bonwick{
736b24ab67Jeff Bonwick	ddt_histogram_t ddh_total = { 0 };
737b24ab67Jeff Bonwick	ddt_stat_t dds_total = { 0 };
738b24ab67Jeff Bonwick
739b24ab67Jeff Bonwick	for (enum zio_checksum c = 0; c < ZIO_CHECKSUM_FUNCTIONS; c++) {
740b24ab67Jeff Bonwick		ddt_t *ddt = spa->spa_ddt[c];
741b24ab67Jeff Bonwick		for (enum ddt_type type = 0; type < DDT_TYPES; type++) {
742b24ab67Jeff Bonwick			for (enum ddt_class class = 0; class < DDT_CLASSES;
743b24ab67Jeff Bonwick			    class++) {
744b24ab67Jeff Bonwick				dump_ddt(ddt, type, class);
745b24ab67Jeff Bonwick			}
746b24ab67Jeff Bonwick		}
747b24ab67Jeff Bonwick	}
748b24ab67Jeff Bonwick
7499eb19f4George Wilson	ddt_get_dedup_stats(spa, &dds_total);
750b24ab67Jeff Bonwick
751b24ab67Jeff Bonwick	if (dds_total.dds_blocks == 0) {
752b24ab67Jeff Bonwick		(void) printf("All DDTs are empty\n");
753b24ab67Jeff Bonwick		return;
754b24ab67Jeff Bonwick	}
755b24ab67Jeff Bonwick
756b24ab67Jeff Bonwick	(void) printf("\n");
757b24ab67Jeff Bonwick
758b24ab67Jeff Bonwick	if (dump_opt['D'] > 1) {
759b24ab67Jeff Bonwick		(void) printf("DDT histogram (aggregated over all DDTs):\n");
7609eb19f4George Wilson		ddt_get_dedup_histogram(spa, &ddh_total);
7619eb19f4George Wilson		zpool_dump_ddt(&dds_total, &ddh_total);
762b24ab67Jeff Bonwick	}
763b24ab67Jeff Bonwick
764b24ab67Jeff Bonwick	dump_dedup_ratio(&dds_total);
765b24ab67Jeff Bonwick}
766b24ab67Jeff Bonwick
767b24ab67Jeff Bonwickstatic void
7688ad4d6dJeff Bonwickdump_dtl_seg(space_map_t *sm, uint64_t start, uint64_t size)
7698ad4d6dJeff Bonwick{
7708ad4d6dJeff Bonwick	char *prefix = (void *)sm;
7718ad4d6dJeff Bonwick
7728ad4d6dJeff Bonwick	(void) printf("%s [%llu,%llu) length %llu\n",
7738ad4d6dJeff Bonwick	    prefix,
7748ad4d6dJeff Bonwick	    (u_longlong_t)start,
7758ad4d6dJeff Bonwick	    (u_longlong_t)(start + size),
7768ad4d6dJeff Bonwick	    (u_longlong_t)(size));
7778ad4d6dJeff Bonwick}
7788ad4d6dJeff Bonwick
7798ad4d6dJeff Bonwickstatic void
780fa9e406ahrensdump_dtl(vdev_t *vd, int indent)
781fa9e406ahrens{
7828ad4d6dJeff Bonwick	spa_t *spa = vd->vdev_spa;
7838ad4d6dJeff Bonwick	boolean_t required;
7848ad4d6dJeff Bonwick	char *name[DTL_TYPES] = { "missing", "partial", "scrub", "outage" };
7858ad4d6dJeff Bonwick	char prefix[256];
7868ad4d6dJeff Bonwick
7878f18d1fGeorge Wilson	spa_vdev_state_enter(spa, SCL_NONE);
7888ad4d6dJeff Bonwick	required = vdev_dtl_required(vd);
7898ad4d6dJeff Bonwick	(void) spa_vdev_state_exit(spa, NULL, 0);
790fa9e406ahrens
791fa9e406ahrens	if (indent == 0)
792fa9e406ahrens		(void) printf("\nDirty time logs:\n\n");
793fa9e406ahrens
7948ad4d6dJeff Bonwick	(void) printf("\t%*s%s [%s]\n", indent, "",
795e14bb32Jeff Bonwick	    vd->vdev_path ? vd->vdev_path :
7968ad4d6dJeff Bonwick	    vd->vdev_parent ? vd->vdev_ops->vdev_op_type : spa_name(spa),
7978ad4d6dJeff Bonwick	    required ? "DTL-required" : "DTL-expendable");
798fa9e406ahrens
7998ad4d6dJeff Bonwick	for (int t = 0; t < DTL_TYPES; t++) {
8008ad4d6dJeff Bonwick		space_map_t *sm = &vd->vdev_dtl[t];
8018ad4d6dJeff Bonwick		if (sm->sm_space == 0)
8028ad4d6dJeff Bonwick			continue;
8038ad4d6dJeff Bonwick		(void) snprintf(prefix, sizeof (prefix), "\t%*s%s",
8048ad4d6dJeff Bonwick		    indent + 2, "", name[t]);
8058ad4d6dJeff Bonwick		mutex_enter(sm->sm_lock);
8068ad4d6dJeff Bonwick		space_map_walk(sm, dump_dtl_seg, (void *)prefix);
8078ad4d6dJeff Bonwick		mutex_exit(sm->sm_lock);
8088ad4d6dJeff Bonwick		if (dump_opt['d'] > 5 && vd->vdev_children == 0)
8098ad4d6dJeff Bonwick			dump_spacemap(spa->spa_meta_objset,
8108ad4d6dJeff Bonwick			    &vd->vdev_dtl_smo, sm);
811fa9e406ahrens	}
812fa9e406ahrens
8138ad4d6dJeff Bonwick	for (int c = 0; c < vd->vdev_children; c++)
814fa9e406ahrens		dump_dtl(vd->vdev_child[c], indent + 4);
815fa9e406ahrens}
816fa9e406ahrens
8178f18d1fGeorge Wilsonstatic void
8188f18d1fGeorge Wilsondump_history(spa_t *spa)
8198f18d1fGeorge Wilson{
8208f18d1fGeorge Wilson	nvlist_t **events = NULL;
8218f18d1fGeorge Wilson	char buf[SPA_MAXBLOCKSIZE];
822e4161dfVictor Latushkin	uint64_t resid, len, off = 0;
8238f18d1fGeorge Wilson	uint_t num = 0;
8248f18d1fGeorge Wilson	int error;
8258f18d1fGeorge Wilson	time_t tsec;
8268f18d1fGeorge Wilson	struct tm t;
8278f18d1fGeorge Wilson	char tbuf[30];
8288f18d1fGeorge Wilson	char internalstr[MAXPATHLEN];
8298f18d1fGeorge Wilson
8308f18d1fGeorge Wilson	do {
831e4161dfVictor Latushkin		len = sizeof (buf);
832e4161dfVictor Latushkin
8338f18d1fGeorge Wilson		if ((error = spa_history_get(spa, &off, &len, buf)) != 0) {
8348f18d1fGeorge Wilson			(void) fprintf(stderr, "Unable to read history: "
8358f18d1fGeorge Wilson			    "error %d\n", error);
8368f18d1fGeorge Wilson			return;
8378f18d1fGeorge Wilson		}
8388f18d1fGeorge Wilson
8398f18d1fGeorge Wilson		if (zpool_history_unpack(buf, len, &resid, &events, &num) != 0)
8408f18d1fGeorge Wilson			break;
8418f18d1fGeorge Wilson
8428f18d1fGeorge Wilson		off -= resid;
8438f18d1fGeorge Wilson	} while (len != 0);
8448f18d1fGeorge Wilson
8458f18d1fGeorge Wilson	(void) printf("\nHistory:\n");
8468f18d1fGeorge Wilson	for (int i = 0; i < num; i++) {
8478f18d1fGeorge Wilson		uint64_t time, txg, ievent;
8488f18d1fGeorge Wilson		char *cmd, *intstr;
8498f18d1fGeorge Wilson
8508f18d1fGeorge Wilson		if (nvlist_lookup_uint64(events[i], ZPOOL_HIST_TIME,
8518f18d1fGeorge Wilson		    &time) != 0)
8528f18d1fGeorge Wilson			continue;
8538f18d1fGeorge Wilson		if (nvlist_lookup_string(events[i], ZPOOL_HIST_CMD,
8548f18d1fGeorge Wilson		    &cmd) != 0) {
8558f18d1fGeorge Wilson			if (nvlist_lookup_uint64(events[i],
8568f18d1fGeorge Wilson			    ZPOOL_HIST_INT_EVENT, &ievent) != 0)
8578f18d1fGeorge Wilson				continue;
8588f18d1fGeorge Wilson			verify(nvlist_lookup_uint64(events[i],
8598f18d1fGeorge Wilson			    ZPOOL_HIST_TXG, &txg) == 0);
8608f18d1fGeorge Wilson			verify(nvlist_lookup_string(events[i],
8618f18d1fGeorge Wilson			    ZPOOL_HIST_INT_STR, &intstr) == 0);
8628f18d1fGeorge Wilson			if (ievent >= LOG_END)
8638f18d1fGeorge Wilson				continue;
8648f18d1fGeorge Wilson
8658f18d1fGeorge Wilson			(void) snprintf(internalstr,
8668f18d1fGeorge Wilson			    sizeof (internalstr),
8678f18d1fGeorge Wilson			    "[internal %s txg:%lld] %s",
8683f9d6adLin Ling			    zfs_history_event_names[ievent], txg,
8698f18d1fGeorge Wilson			    intstr);
8708f18d1fGeorge Wilson			cmd = internalstr;
8718f18d1fGeorge Wilson		}
8728f18d1fGeorge Wilson		tsec = time;
8738f18d1fGeorge Wilson		(void) localtime_r(&tsec, &t);
8748f18d1fGeorge Wilson		(void) strftime(tbuf, sizeof (tbuf), "%F.%T", &t);
8758f18d1fGeorge Wilson		(void) printf("%s %s\n", tbuf, cmd);
8768f18d1fGeorge Wilson	}
8778f18d1fGeorge Wilson}
8788f18d1fGeorge Wilson
879fa9e406ahrens/*ARGSUSED*/
880fa9e406ahrensstatic void
881fa9e406ahrensdump_dnode(objset_t *os, uint64_t object, void *data, size_t size)
882fa9e406ahrens{
883fa9e406ahrens}
884fa9e406ahrens
885fa9e406ahrensstatic uint64_t
886b24ab67Jeff Bonwickblkid2offset(const dnode_phys_t *dnp, const blkptr_t *bp, const zbookmark_t *zb)
887fa9e406ahrens{
888b24ab67Jeff Bonwick	if (dnp == NULL) {
889b24ab67Jeff Bonwick		ASSERT(zb->zb_level < 0);
890b24ab67Jeff Bonwick		if (zb->zb_object == 0)
891b24ab67Jeff Bonwick			return (zb->zb_blkid);
892b24ab67Jeff Bonwick		return (zb->zb_blkid * BP_GET_LSIZE(bp));
893b24ab67Jeff Bonwick	}
894b24ab67Jeff Bonwick
895b24ab67Jeff Bonwick	ASSERT(zb->zb_level >= 0);
896fa9e406ahrens
897b24ab67Jeff Bonwick	return ((zb->zb_blkid <<
898b24ab67Jeff Bonwick	    (zb->zb_level * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT))) *
899fa9e406ahrens	    dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT);
900fa9e406ahrens}
901fa9e406ahrens
90244cd46cbillmstatic void
903b24ab67Jeff Bonwicksprintf_blkptr_compact(char *blkbuf, blkptr_t *bp)
90444cd46cbillm{
90544cd46cbillm	dva_t *dva = bp->blk_dva;
906b24ab67Jeff Bonwick	int ndvas = dump_opt['d'] > 5 ? BP_GET_NDVAS(bp) : 1;
907b24ab67Jeff Bonwick
908b24ab67Jeff Bonwick	if (dump_opt['b'] >= 5) {
909b24ab67Jeff Bonwick		sprintf_blkptr(blkbuf, bp);
910b24ab67Jeff Bonwick		return;
911b24ab67Jeff Bonwick	}
91244cd46cbillm
91344cd46cbillm	blkbuf[0] = '\0';
91444cd46cbillm
915b24ab67Jeff Bonwick	for (int i = 0; i < ndvas; i++)
91644cd46cbillm		(void) sprintf(blkbuf + strlen(blkbuf), "%llu:%llx:%llx ",
91744cd46cbillm		    (u_longlong_t)DVA_GET_VDEV(&dva[i]),
91844cd46cbillm		    (u_longlong_t)DVA_GET_OFFSET(&dva[i]),
91944cd46cbillm		    (u_longlong_t)DVA_GET_ASIZE(&dva[i]));
92044cd46cbillm
921b24ab67Jeff Bonwick	(void) sprintf(blkbuf + strlen(blkbuf),
922b24ab67Jeff Bonwick	    "%llxL/%llxP F=%llu B=%llu/%llu",
92344cd46cbillm	    (u_longlong_t)BP_GET_LSIZE(bp),
92444cd46cbillm	    (u_longlong_t)BP_GET_PSIZE(bp),
92544cd46cbillm	    (u_longlong_t)bp->blk_fill,
926b24ab67Jeff Bonwick	    (u_longlong_t)bp->blk_birth,
927b24ab67Jeff Bonwick	    (u_longlong_t)BP_PHYSICAL_BIRTH(bp));
92844cd46cbillm}
92944cd46cbillm
93088b7b0fMatthew Ahrensstatic void
93188b7b0fMatthew Ahrensprint_indirect(blkptr_t *bp, const zbookmark_t *zb,
93288b7b0fMatthew Ahrens    const dnode_phys_t *dnp)
933fa9e406ahrens{
93488b7b0fMatthew Ahrens	char blkbuf[BP_SPRINTF_LEN];
935fa9e406ahrens	int l;
936fa9e406ahrens
93788b7b0fMatthew Ahrens	ASSERT3U(BP_GET_TYPE(bp), ==, dnp->dn_type);
93888b7b0fMatthew Ahrens	ASSERT3U(BP_GET_LEVEL(bp), ==, zb->zb_level);
939fa9e406ahrens
940b24ab67Jeff Bonwick	(void) printf("%16llx ", (u_longlong_t)blkid2offset(dnp, bp, zb));
941fa9e406ahrens
942fa9e406ahrens	ASSERT(zb->zb_level >= 0);
943fa9e406ahrens
944fa9e406ahrens	for (l = dnp->dn_nlevels - 1; l >= -1; l--) {
945fa9e406ahrens		if (l == zb->zb_level) {
94688b7b0fMatthew Ahrens			(void) printf("L%llx", (u_longlong_t)zb->zb_level);
947fa9e406ahrens		} else {
94888b7b0fMatthew Ahrens			(void) printf(" ");
949fa9e406ahrens		}
950fa9e406ahrens	}
951fa9e406ahrens
952b24ab67Jeff Bonwick	sprintf_blkptr_compact(blkbuf, bp);
95388b7b0fMatthew Ahrens	(void) printf("%s\n", blkbuf);
95488b7b0fMatthew Ahrens}
95588b7b0fMatthew Ahrens
95688b7b0fMatthew Ahrensstatic int
95788b7b0fMatthew Ahrensvisit_indirect(spa_t *spa, const dnode_phys_t *dnp,
95888b7b0fMatthew Ahrens    blkptr_t *bp, const zbookmark_t *zb)
95988b7b0fMatthew Ahrens{
960e4161dfVictor Latushkin	int err = 0;
96188b7b0fMatthew Ahrens
96288b7b0fMatthew Ahrens	if (bp->blk_birth == 0)
96388b7b0fMatthew Ahrens		return (0);
96488b7b0fMatthew Ahrens
96588b7b0fMatthew Ahrens	print_indirect(bp, zb, dnp);
96688b7b0fMatthew Ahrens
96788b7b0fMatthew Ahrens	if (BP_GET_LEVEL(bp) > 0) {
96888b7b0fMatthew Ahrens		uint32_t flags = ARC_WAIT;
96988b7b0fMatthew Ahrens		int i;
97088b7b0fMatthew Ahrens		blkptr_t *cbp;
97188b7b0fMatthew Ahrens		int epb = BP_GET_LSIZE(bp) >> SPA_BLKPTRSHIFT;
97288b7b0fMatthew Ahrens		arc_buf_t *buf;
97388b7b0fMatthew Ahrens		uint64_t fill = 0;
97488b7b0fMatthew Ahrens
97588b7b0fMatthew Ahrens		err = arc_read_nolock(NULL, spa, bp, arc_getbuf_func, &buf,
97688b7b0fMatthew Ahrens		    ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, zb);
97788b7b0fMatthew Ahrens		if (err)
97888b7b0fMatthew Ahrens			return (err);
9793f9d6adLin Ling		ASSERT(buf->b_data);
98088b7b0fMatthew Ahrens
98188b7b0fMatthew Ahrens		/* recursively visit blocks below this */
98288b7b0fMatthew Ahrens		cbp = buf->b_data;
98388b7b0fMatthew Ahrens		for (i = 0; i < epb; i++, cbp++) {
98488b7b0fMatthew Ahrens			zbookmark_t czb;
98588b7b0fMatthew Ahrens
98688b7b0fMatthew Ahrens			SET_BOOKMARK(&czb, zb->zb_objset, zb->zb_object,
98788b7b0fMatthew Ahrens			    zb->zb_level - 1,
988