/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.

 */

#include <stdio.h>

#include <stdio_ext.h>

#include <stdlib.h>

#include <ctype.h>

#include <sys/zfs_context.h>

#include <sys/spa.h>

#include <sys/spa_impl.h>

#include <sys/dmu.h>

#include <sys/zap.h>

#include <sys/fs/zfs.h>

#include <sys/zfs_znode.h>

#include <sys/zfs_sa.h>

#include <sys/sa.h>

#include <sys/sa_impl.h>

#include <sys/vdev.h>

#include <sys/vdev_impl.h>

#include <sys/metaslab_impl.h>

#include <sys/dmu_objset.h>

#include <sys/dsl_dir.h>

#include <sys/dsl_dataset.h>

#include <sys/dsl_pool.h>

#include <sys/dbuf.h>

#include <sys/zil.h>

#include <sys/zil_impl.h>

#include <sys/stat.h>

#include <sys/resource.h>

#include <sys/dmu_traverse.h>

#include <sys/zio_checksum.h>

#include <sys/zio_compress.h>

#include <sys/zfs_fuid.h>

#include <sys/arc.h>

#include <sys/ddt.h>

#undef ZFS_MAXNAMELEN

#undef verify

#include <libzfs.h>

#define	ZDB_COMPRESS_NAME(idx) ((idx) < ZIO_COMPRESS_FUNCTIONS ? \

    zio_compress_table[(idx)].ci_name : "UNKNOWN")

#define	ZDB_CHECKSUM_NAME(idx) ((idx) < ZIO_CHECKSUM_FUNCTIONS ? \

    zio_checksum_table[(idx)].ci_name : "UNKNOWN")

#define	ZDB_OT_NAME(idx) ((idx) < DMU_OT_NUMTYPES ? \

#define	ZDB_OT_TYPE(idx) ((idx) < DMU_OT_NUMTYPES ? (idx) : DMU_OT_NUMTYPES)

#ifndef lint

extern int zfs_recover;

#else

int zfs_recover;

#endif

const char cmdname[] = "zdb";

uint8_t dump_opt[256];

typedef void object_viewer_t(objset_t *, uint64_t, void *data, size_t size);

extern void dump_intent_log(zilog_t *);

uint64_t *zopt_object = NULL;

int zopt_objects = 0;

libzfs_handle_t *g_zfs;

/*

 * These libumem hooks provide a reasonable set of defaults for the allocator's

 * debugging facilities.

 */

const char *

_umem_debug_init()

{

	return ("default,verbose"); /* $UMEM_DEBUG setting */

}

const char *

_umem_logging_init(void)

{

	return ("fail,contents"); /* $UMEM_LOGGING setting */

}

static void

usage(void)

{

	(void) fprintf(stderr,

	    "Usage: %s [-CumdibcsDvhLXFPA] [-t txg] [-e [-p path...]] "

	    "poolname [object...]\n"

	    "       %s [-divPA] [-e -p path...] dataset [object...]\n"

	    "       %s -m [-LXFPA] [-t txg] [-e [-p path...]] "

	    "poolname [vdev [metaslab...]]\n"

	    "       %s -R [-A] [-e [-p path...]] poolname "

	    "vdev:offset:size[:flags]\n"

	    "       %s -S [-PA] [-e [-p path...]] poolname\n"

	    "       %s -l [-uA] device\n"

	    "       %s -C [-A] [-U config]\n\n",

	    cmdname, cmdname, cmdname, cmdname, cmdname, cmdname, cmdname);

	(void) fprintf(stderr, "    Dataset name must include at least one "

	    "separator character '/' or '@'\n");

	(void) fprintf(stderr, "    If dataset name is specified, only that "

	    "dataset is dumped\n");

	(void) fprintf(stderr, "    If object numbers are specified, only "

	    "those objects are dumped\n\n");

	(void) fprintf(stderr, "    Options to control amount of output:\n");

	(void) fprintf(stderr, "        -u uberblock\n");

	(void) fprintf(stderr, "        -d dataset(s)\n");

	(void) fprintf(stderr, "        -i intent logs\n");

	(void) fprintf(stderr, "        -C config (or cachefile if alone)\n");

	(void) fprintf(stderr, "        -h pool history\n");

	(void) fprintf(stderr, "        -b block statistics\n");

	(void) fprintf(stderr, "        -m metaslabs\n");

	(void) fprintf(stderr, "        -c checksum all metadata (twice for "

	    "all data) blocks\n");

	(void) fprintf(stderr, "        -s report stats on zdb's I/O\n");

	(void) fprintf(stderr, "        -D dedup statistics\n");

	(void) fprintf(stderr, "        -S simulate dedup to measure effect\n");

	(void) fprintf(stderr, "        -v verbose (applies to all others)\n");

	(void) fprintf(stderr, "        -l dump label contents\n");

	(void) fprintf(stderr, "        -L disable leak tracking (do not "

	    "load spacemaps)\n");

	(void) fprintf(stderr, "        -R read and display block from a "

	    "device\n\n");

	(void) fprintf(stderr, "    Below options are intended for use "

	    "with other options (except -l):\n");

	(void) fprintf(stderr, "        -A ignore assertions (-A), enable "

	    "panic recovery (-AA) or both (-AAA)\n");

	(void) fprintf(stderr, "        -F attempt automatic rewind within "

	    "safe range of transaction groups\n");

	(void) fprintf(stderr, "        -U <cachefile_path> -- use alternate "

	    "cachefile\n");

	(void) fprintf(stderr, "        -X attempt extreme rewind (does not "

	    "work with dataset)\n");

	(void) fprintf(stderr, "        -e pool is exported/destroyed/"

	    "has altroot/not in a cachefile\n");

	(void) fprintf(stderr, "        -p <path> -- use one or more with "

	    "-e to specify path to vdev dir\n");

	(void) fprintf(stderr, "        -P print numbers in parseable form\n");

	(void) fprintf(stderr, "        -t <txg> -- highest txg to use when "

	    "searching for uberblocks\n");

	(void) fprintf(stderr, "Specify an option more than once (e.g. -bb) "

	    "to make only that option verbose\n");

	(void) fprintf(stderr, "Default is to dump everything non-verbosely\n");

	exit(1);

}

/*

 * Called for usage errors that are discovered after a call to spa_open(),

 * dmu_bonus_hold(), or pool_match().  abort() is called for other errors.

 */

static void

fatal(const char *fmt, ...)

{

	va_list ap;

	va_start(ap, fmt);

	(void) fprintf(stderr, "%s: ", cmdname);

	(void) vfprintf(stderr, fmt, ap);

	va_end(ap);

	(void) fprintf(stderr, "\n");

	exit(1);

}

/* ARGSUSED */

static void

dump_packed_nvlist(objset_t *os, uint64_t object, void *data, size_t size)

{

	nvlist_t *nv;

	size_t nvsize = *(uint64_t *)data;

	char *packed = umem_alloc(nvsize, UMEM_NOFAIL);

	VERIFY(0 == dmu_read(os, object, 0, nvsize, packed, DMU_READ_PREFETCH));

	VERIFY(nvlist_unpack(packed, nvsize, &nv, 0) == 0);

	umem_free(packed, nvsize);

	dump_nvlist(nv, 8);

	nvlist_free(nv);

}

static void

zdb_nicenum(uint64_t num, char *buf)

{

	if (dump_opt['P'])

		(void) sprintf(buf, "%llu", (longlong_t)num);

	else

		nicenum(num, buf);

}

const char dump_zap_stars[] = "****************************************";

const int dump_zap_width = sizeof (dump_zap_stars) - 1;

static void

dump_zap_histogram(uint64_t histo[ZAP_HISTOGRAM_SIZE])

{

	int i;

	int minidx = ZAP_HISTOGRAM_SIZE - 1;

	int maxidx = 0;

	uint64_t max = 0;

	for (i = 0; i < ZAP_HISTOGRAM_SIZE; i++) {

		if (histo[i] > max)

			max = histo[i];

		if (histo[i] > 0 && i > maxidx)

			maxidx = i;

		if (histo[i] > 0 && i < minidx)

			minidx = i;

	}

	if (max < dump_zap_width)

		max = dump_zap_width;

	for (i = minidx; i <= maxidx; i++)

		(void) printf("\t\t\t%u: %6llu %s\n", i, (u_longlong_t)histo[i],

		    &dump_zap_stars[(max - histo[i]) * dump_zap_width / max]);

}

static void

dump_zap_stats(objset_t *os, uint64_t object)

{

	int error;

	zap_stats_t zs;

	error = zap_get_stats(os, object, &zs);

	if (error)

		return;

	if (zs.zs_ptrtbl_len == 0) {

		ASSERT(zs.zs_num_blocks == 1);

		(void) printf("\tmicrozap: %llu bytes, %llu entries\n",

		    (u_longlong_t)zs.zs_blocksize,

		    (u_longlong_t)zs.zs_num_entries);

		return;

	}

	(void) printf("\tFat ZAP stats:\n");

	(void) printf("\t\tPointer table:\n");

	(void) printf("\t\t\t%llu elements\n",

	    (u_longlong_t)zs.zs_ptrtbl_len);

	(void) printf("\t\t\tzt_blk: %llu\n",

	    (u_longlong_t)zs.zs_ptrtbl_zt_blk);

	(void) printf("\t\t\tzt_numblks: %llu\n",

	    (u_longlong_t)zs.zs_ptrtbl_zt_numblks);

	(void) printf("\t\t\tzt_shift: %llu\n",

	    (u_longlong_t)zs.zs_ptrtbl_zt_shift);

	(void) printf("\t\t\tzt_blks_copied: %llu\n",

	    (u_longlong_t)zs.zs_ptrtbl_blks_copied);

	(void) printf("\t\t\tzt_nextblk: %llu\n",

	    (u_longlong_t)zs.zs_ptrtbl_nextblk);

	(void) printf("\t\tZAP entries: %llu\n",

	    (u_longlong_t)zs.zs_num_entries);

	(void) printf("\t\tLeaf blocks: %llu\n",

	    (u_longlong_t)zs.zs_num_leafs);

	(void) printf("\t\tTotal blocks: %llu\n",

	    (u_longlong_t)zs.zs_num_blocks);

	(void) printf("\t\tzap_block_type: 0x%llx\n",

	    (u_longlong_t)zs.zs_block_type);

	(void) printf("\t\tzap_magic: 0x%llx\n",

	    (u_longlong_t)zs.zs_magic);

	(void) printf("\t\tzap_salt: 0x%llx\n",

	    (u_longlong_t)zs.zs_salt);

	(void) printf("\t\tLeafs with 2^n pointers:\n");

	dump_zap_histogram(zs.zs_leafs_with_2n_pointers);

	(void) printf("\t\tBlocks with n*5 entries:\n");

	dump_zap_histogram(zs.zs_blocks_with_n5_entries);

	(void) printf("\t\tBlocks n/10 full:\n");

	dump_zap_histogram(zs.zs_blocks_n_tenths_full);

	(void) printf("\t\tEntries with n chunks:\n");

	dump_zap_histogram(zs.zs_entries_using_n_chunks);

	(void) printf("\t\tBuckets with n entries:\n");

	dump_zap_histogram(zs.zs_buckets_with_n_entries);

}

/*ARGSUSED*/

static void

dump_none(objset_t *os, uint64_t object, void *data, size_t size)

{

}

/*ARGSUSED*/

static void

dump_unknown(objset_t *os, uint64_t object, void *data, size_t size)

{

	(void) printf("\tUNKNOWN OBJECT TYPE\n");

}

/*ARGSUSED*/

void

dump_uint8(objset_t *os, uint64_t object, void *data, size_t size)

{

}

/*ARGSUSED*/

static void

dump_uint64(objset_t *os, uint64_t object, void *data, size_t size)

{

}

/*ARGSUSED*/

static void

dump_zap(objset_t *os, uint64_t object, void *data, size_t size)

{

	zap_cursor_t zc;

	zap_attribute_t attr;

	void *prop;

	int i;

	dump_zap_stats(os, object);

	(void) printf("\n");

	for (zap_cursor_init(&zc, os, object);

	    zap_cursor_retrieve(&zc, &attr) == 0;

	    zap_cursor_advance(&zc)) {

		(void) printf("\t\t%s = ", attr.za_name);

		if (attr.za_num_integers == 0) {

			(void) printf("\n");

			continue;

		}

		prop = umem_zalloc(attr.za_num_integers *

		    attr.za_integer_length, UMEM_NOFAIL);

		(void) zap_lookup(os, object, attr.za_name,

		    attr.za_integer_length, attr.za_num_integers, prop);

		if (attr.za_integer_length == 1) {

			(void) printf("%s", (char *)prop);

		} else {

			for (i = 0; i < attr.za_num_integers; i++) {

				switch (attr.za_integer_length) {

				case 2:

					(void) printf("%u ",

					    ((uint16_t *)prop)[i]);

					break;

				case 4:

					(void) printf("%u ",

					    ((uint32_t *)prop)[i]);

					break;

				case 8:

					(void) printf("%lld ",

					    (u_longlong_t)((int64_t *)prop)[i]);

					break;

				}

			}

		}

		(void) printf("\n");

		umem_free(prop, attr.za_num_integers * attr.za_integer_length);

	}

	zap_cursor_fini(&zc);

}

/*ARGSUSED*/

static void

dump_ddt_zap(objset_t *os, uint64_t object, void *data, size_t size)

{

	dump_zap_stats(os, object);

	/* contents are printed elsewhere, properly decoded */

}

/*ARGSUSED*/

static void

dump_sa_attrs(objset_t *os, uint64_t object, void *data, size_t size)

{

	zap_cursor_t zc;

	zap_attribute_t attr;

	dump_zap_stats(os, object);

	(void) printf("\n");

	for (zap_cursor_init(&zc, os, object);

	    zap_cursor_retrieve(&zc, &attr) == 0;

	    zap_cursor_advance(&zc)) {

		(void) printf("\t\t%s = ", attr.za_name);

		if (attr.za_num_integers == 0) {

			(void) printf("\n");

			continue;

		}

		(void) printf(" %llx : [%d:%d:%d]\n",

		    (u_longlong_t)attr.za_first_integer,

		    (int)ATTR_LENGTH(attr.za_first_integer),

		    (int)ATTR_BSWAP(attr.za_first_integer),

		    (int)ATTR_NUM(attr.za_first_integer));

	}

	zap_cursor_fini(&zc);

}

/*ARGSUSED*/

static void

dump_sa_layouts(objset_t *os, uint64_t object, void *data, size_t size)

{

	zap_cursor_t zc;

	zap_attribute_t attr;

	uint16_t *layout_attrs;

	int i;

	dump_zap_stats(os, object);

	(void) printf("\n");

	for (zap_cursor_init(&zc, os, object);

	    zap_cursor_retrieve(&zc, &attr) == 0;

	    zap_cursor_advance(&zc)) {

		(void) printf("\t\t%s = [", attr.za_name);

		if (attr.za_num_integers == 0) {

			(void) printf("\n");

			continue;

		}

		VERIFY(attr.za_integer_length == 2);

		layout_attrs = umem_zalloc(attr.za_num_integers *

		    attr.za_integer_length, UMEM_NOFAIL);

		VERIFY(zap_lookup(os, object, attr.za_name,

		    attr.za_integer_length,

		    attr.za_num_integers, layout_attrs) == 0);

		for (i = 0; i != attr.za_num_integers; i++)

			(void) printf(" %d ", (int)layout_attrs[i]);

		(void) printf("]\n");

		umem_free(layout_attrs,

		    attr.za_num_integers * attr.za_integer_length);

	}

	zap_cursor_fini(&zc);

}

/*ARGSUSED*/

static void

dump_zpldir(objset_t *os, uint64_t object, void *data, size_t size)

{

	zap_cursor_t zc;

	zap_attribute_t attr;

	const char *typenames[] = {

		/* 0 */ "not specified",

		/* 1 */ "FIFO",

		/* 2 */ "Character Device",

		/* 3 */ "3 (invalid)",

		/* 4 */ "Directory",

		/* 5 */ "5 (invalid)",

		/* 6 */ "Block Device",

		/* 7 */ "7 (invalid)",

		/* 8 */ "Regular File",

		/* 9 */ "9 (invalid)",

		/* 10 */ "Symbolic Link",

		/* 11 */ "11 (invalid)",

		/* 12 */ "Socket",

		/* 13 */ "Door",

		/* 14 */ "Event Port",

		/* 15 */ "15 (invalid)",

	};

	dump_zap_stats(os, object);

	(void) printf("\n");

	for (zap_cursor_init(&zc, os, object);

	    zap_cursor_retrieve(&zc, &attr) == 0;

	    zap_cursor_advance(&zc)) {

		(void) printf("\t\t%s = %lld (type: %s)\n",

		    attr.za_name, ZFS_DIRENT_OBJ(attr.za_first_integer),

		    typenames[ZFS_DIRENT_TYPE(attr.za_first_integer)]);

	}

	zap_cursor_fini(&zc);

}

static void

dump_spacemap(objset_t *os, space_map_obj_t *smo, space_map_t *sm)

{

	uint64_t alloc, offset, entry;

	uint8_t mapshift = sm->sm_shift;

	uint64_t mapstart = sm->sm_start;

	char *ddata[] = { "ALLOC", "FREE", "CONDENSE", "INVALID",

			    "INVALID", "INVALID", "INVALID", "INVALID" };

	if (smo->smo_object == 0)

		return;

	/*

	 * Print out the freelist entries in both encoded and decoded form.

	 */