/*

 * 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 2008 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#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/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>

#undef ZFS_MAXNAMELEN

#undef verify

#include <libzfs.h>

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;

boolean_t zdb_sig_user_data = B_TRUE;

int zdb_sig_cksumalg = ZIO_CHECKSUM_SHA256;

/*

 * 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,

	    "[-S user:cksumalg] "

	    "dataset [object...]\n"

	    "       %s -C [pool]\n"

	    "       %s -l dev\n"

	    "       %s -R pool:vdev:offset:size:flags\n"

	    "       %s [-p path_to_vdev_dir]\n"

	    "       %s -e pool | GUID | devid ...\n",

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

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

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

	(void) fprintf(stderr, "        -C cached pool configuration\n");

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

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

	(void) fprintf(stderr, "	-c checksum all data blocks\n");

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

	(void) fprintf(stderr, "	-S <user|all>:<cksum_alg|all> -- "

	    "dump blkptr signatures\n");

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

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

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

	    "cachefile\n");

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

	    "device\n");

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

	    "has altroot\n");

	(void) fprintf(stderr, "	-p <Path to vdev dir> (use with -e)\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);

}

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");

	abort();

}

static void

dump_nvlist(nvlist_t *list, int indent)

{

	nvpair_t *elem = NULL;

	while ((elem = nvlist_next_nvpair(list, elem)) != NULL) {

		switch (nvpair_type(elem)) {

		case DATA_TYPE_STRING:

			{

				char *value;

				VERIFY(nvpair_value_string(elem, &value) == 0);

				(void) printf("%*s%s='%s'\n", indent, "",

				    nvpair_name(elem), value);

			}

			break;

		case DATA_TYPE_UINT64:

			{

				uint64_t value;

				VERIFY(nvpair_value_uint64(elem, &value) == 0);

				(void) printf("%*s%s=%llu\n", indent, "",

				    nvpair_name(elem), (u_longlong_t)value);

			}

			break;

		case DATA_TYPE_NVLIST:

			{

				nvlist_t *value;

				VERIFY(nvpair_value_nvlist(elem, &value) == 0);

				(void) printf("%*s%s\n", indent, "",

				    nvpair_name(elem));

				dump_nvlist(value, indent + 4);

			}

			break;

		case DATA_TYPE_NVLIST_ARRAY:

			{

				nvlist_t **value;

				uint_t c, count;

				VERIFY(nvpair_value_nvlist_array(elem, &value,

				    &count) == 0);

				for (c = 0; c < count; c++) {

					(void) printf("%*s%s[%u]\n", indent, "",

					    nvpair_name(elem), c);

					dump_nvlist(value[c], indent + 8);

				}

			}

			break;

		default:

			(void) printf("bad config type %d for %s\n",

			    nvpair_type(elem), nvpair_name(elem));

		}

	}

}

/* 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));

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

	umem_free(packed, nvsize);

	dump_nvlist(nv, 8);

	nvlist_free(nv);

}

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*/

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_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.

	 */

	alloc = 0;

	for (offset = 0; offset < smo->smo_objsize; offset += sizeof (entry)) {

		VERIFY(0 == dmu_read(os, smo->smo_object, offset,

		    sizeof (entry), &entry));

		if (SM_DEBUG_DECODE(entry)) {

			(void) printf("\t\t[%4llu] %s: txg %llu, pass %llu\n",

			    (u_longlong_t)(offset / sizeof (entry)),

			    ddata[SM_DEBUG_ACTION_DECODE(entry)],

			    (u_longlong_t)SM_DEBUG_TXG_DECODE(entry),

			    (u_longlong_t)SM_DEBUG_SYNCPASS_DECODE(entry));

		} else {

			(void) printf("\t\t[%4llu]    %c  range:"

			    " %08llx-%08llx  size: %06llx\n",

			    (u_longlong_t)(offset / sizeof (entry)),

			    SM_TYPE_DECODE(entry) == SM_ALLOC ? 'A' : 'F',

			    (u_longlong_t)((SM_OFFSET_DECODE(entry) <<

			    mapshift) + mapstart),

			    (u_longlong_t)((SM_OFFSET_DECODE(entry) <<

			    mapshift) + mapstart + (SM_RUN_DECODE(entry) <<

			    mapshift)),

			    (u_longlong_t)(SM_RUN_DECODE(entry) << mapshift));

			if (SM_TYPE_DECODE(entry) == SM_ALLOC)

				alloc += SM_RUN_DECODE(entry) << mapshift;

			else

				alloc -= SM_RUN_DECODE(entry) << mapshift;

		}

	}

	if (alloc != smo->smo_alloc) {

		(void) printf("space_map_object alloc (%llu) INCONSISTENT "

		    "with space map summary (%llu)\n",

		    (u_longlong_t)smo->smo_alloc, (u_longlong_t)alloc);

	}

}

static void

dump_metaslab(metaslab_t *msp)

{

	char freebuf[5];

	space_map_obj_t *smo = &msp->ms_smo;

	vdev_t *vd = msp->ms_group->mg_vd;

	spa_t *spa = vd->vdev_spa;

	nicenum(msp->ms_map.sm_size - smo->smo_alloc, freebuf);

	if (dump_opt['d'] <= 5) {

		(void) printf("\t%10llx   %10llu   %5s\n",

		    (u_longlong_t)msp->ms_map.sm_start,

		    (u_longlong_t)smo->smo_object,

		    freebuf);

		return;

	}

	(void) printf(

	    "\tvdev %llu   offset %08llx   spacemap %4llu   free %5s\n",

	    (u_longlong_t)vd->vdev_id, (u_longlong_t)msp->ms_map.sm_start,

	    (u_longlong_t)smo->smo_object, freebuf);

	ASSERT(msp->ms_map.sm_size == (1ULL << vd->vdev_ms_shift));

	dump_spacemap(spa->spa_meta_objset, smo, &msp->ms_map);

}

static void

dump_metaslabs(spa_t *spa)

{

	vdev_t *rvd = spa->spa_root_vdev;

	vdev_t *vd;

	int c, m;

	(void) printf("\nMetaslabs:\n");

	for (c = 0; c < rvd->vdev_children; c++) {

		vd = rvd->vdev_child[c];

		(void) printf("\n    vdev %llu\n\n", (u_longlong_t)vd->vdev_id);

		if (dump_opt['d'] <= 5) {

			(void) printf("\t%10s   %10s   %5s\n",

			    "offset", "spacemap", "free");

			(void) printf("\t%10s   %10s   %5s\n",

			    "------", "--------", "----");

		}

		for (m = 0; m < vd->vdev_ms_count; m++)

			dump_metaslab(vd->vdev_ms[m]);

		(void) printf("\n");