/*

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

 * Use is subject to license terms.

 */

#include <mdb/mdb_ctf.h>

#include <sys/zfs_context.h>

#include <sys/mdb_modapi.h>

#include <sys/dbuf.h>

#include <sys/dmu_objset.h>

#include <sys/dsl_dir.h>

#include <sys/dsl_pool.h>

#include <sys/metaslab_impl.h>

#include <sys/space_map.h>

#include <sys/list.h>

#include <sys/spa_impl.h>

#include <sys/vdev_impl.h>

#include <sys/zap_leaf.h>

#include <sys/zap_impl.h>

#include <ctype.h>

#include <sys/zfs_acl.h>

#include <sys/sa_impl.h>

#ifndef _KERNEL

#include "../genunix/list.h"

#endif

#ifdef _KERNEL

#define	ZFS_OBJ_NAME	"zfs"

#else

#define	ZFS_OBJ_NAME	"libzpool.so.1"

#endif

#ifndef _KERNEL

int aok;

#endif

static int

getmember(uintptr_t addr, const char *type, mdb_ctf_id_t *idp,

    const char *member, int len, void *buf)

{

	mdb_ctf_id_t id;

	ulong_t off;

	char name[64];

	if (idp == NULL) {

		if (mdb_ctf_lookup_by_name(type, &id) == -1) {

			mdb_warn("couldn't find type %s", type);

			return (DCMD_ERR);

		}

		idp = &id;

	} else {

		type = name;

		mdb_ctf_type_name(*idp, name, sizeof (name));

	}

	if (mdb_ctf_offsetof(*idp, member, &off) == -1) {

		mdb_warn("couldn't find member %s of type %s\n", member, type);

		return (DCMD_ERR);

	}

	if (off % 8 != 0) {

		mdb_warn("member %s of type %s is unsupported bitfield",

		    member, type);

		return (DCMD_ERR);

	}

	off /= 8;

	if (mdb_vread(buf, len, addr + off) == -1) {

		mdb_warn("failed to read %s from %s at %p",

		    member, type, addr + off);

		return (DCMD_ERR);

	}

	/* mdb_warn("read %s from %s at %p+%llx\n", member, type, addr, off); */

	return (0);

}

#define	GETMEMB(addr, type, member, dest) \

	getmember(addr, #type, NULL, #member, sizeof (dest), &(dest))

#define	GETMEMBID(addr, ctfid, member, dest) \

	getmember(addr, NULL, ctfid, #member, sizeof (dest), &(dest))

static int

getrefcount(uintptr_t addr, mdb_ctf_id_t *id,

    const char *member, uint64_t *rc)

{

	static int gotid;

	static mdb_ctf_id_t rc_id;

	ulong_t off;

	if (!gotid) {

		if (mdb_ctf_lookup_by_name("struct refcount", &rc_id) == -1) {

			mdb_warn("couldn't find struct refcount");

			return (DCMD_ERR);

		}

		gotid = TRUE;

	}

	if (mdb_ctf_offsetof(*id, member, &off) == -1) {

		char name[64];

		mdb_ctf_type_name(*id, name, sizeof (name));

		mdb_warn("couldn't find member %s of type %s\n", member, name);

		return (DCMD_ERR);

	}

	off /= 8;

	return (GETMEMBID(addr + off, &rc_id, rc_count, *rc));

}

static int verbose;

static int

freelist_walk_init(mdb_walk_state_t *wsp)

{

	if (wsp->walk_addr == NULL) {

		mdb_warn("must supply starting address\n");

		return (WALK_ERR);

	}

	wsp->walk_data = 0;  /* Index into the freelist */

	return (WALK_NEXT);

}

static int

freelist_walk_step(mdb_walk_state_t *wsp)

{

	uint64_t entry;

	uintptr_t number = (uintptr_t)wsp->walk_data;

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

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

	int mapshift = SPA_MINBLOCKSHIFT;

	if (mdb_vread(&entry, sizeof (entry), wsp->walk_addr) == -1) {

		mdb_warn("failed to read freelist entry %p", wsp->walk_addr);

		return (WALK_DONE);

	}

	wsp->walk_addr += sizeof (entry);

	wsp->walk_data = (void *)(number + 1);

	if (SM_DEBUG_DECODE(entry)) {

		mdb_printf("DEBUG: %3u  %10s: txg=%llu  pass=%llu\n",

		    number,

		    ddata[SM_DEBUG_ACTION_DECODE(entry)],

		    SM_DEBUG_TXG_DECODE(entry),

		    SM_DEBUG_SYNCPASS_DECODE(entry));

	} else {

		mdb_printf("Entry: %3u  offsets=%08llx-%08llx  type=%c  "

		    "size=%06llx", number,

		    SM_OFFSET_DECODE(entry) << mapshift,

		    (SM_OFFSET_DECODE(entry) + SM_RUN_DECODE(entry)) <<

		    mapshift,

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

		    SM_RUN_DECODE(entry) << mapshift);

		if (verbose)

			mdb_printf("      (raw=%012llx)\n", entry);

		mdb_printf("\n");

	}

	return (WALK_NEXT);

}

static int

dataset_name(uintptr_t addr, char *buf)

{

	static int gotid;

	static mdb_ctf_id_t dd_id;

	uintptr_t dd_parent;

	char dd_myname[MAXNAMELEN];

	if (!gotid) {

		if (mdb_ctf_lookup_by_name("struct dsl_dir",

		    &dd_id) == -1) {

			mdb_warn("couldn't find struct dsl_dir");

			return (DCMD_ERR);

		}

		gotid = TRUE;

	}

	if (GETMEMBID(addr, &dd_id, dd_parent, dd_parent) ||

	    GETMEMBID(addr, &dd_id, dd_myname, dd_myname)) {

		return (DCMD_ERR);

	}

	if (dd_parent) {

		if (dataset_name(dd_parent, buf))

			return (DCMD_ERR);

		strcat(buf, "/");

	}

	if (dd_myname[0])

		strcat(buf, dd_myname);

	else

		strcat(buf, "???");

	return (0);

}

static int

objset_name(uintptr_t addr, char *buf)

{

	static int gotid;

	uintptr_t os_dsl_dataset;

	char ds_snapname[MAXNAMELEN];

	uintptr_t ds_dir;

	buf[0] = '\0';

	if (!gotid) {

			return (DCMD_ERR);

		}

		if (mdb_ctf_lookup_by_name("struct dsl_dataset",

		    &ds_id) == -1) {

			mdb_warn("couldn't find struct dsl_dataset");

			return (DCMD_ERR);

		}

		gotid = TRUE;

	}

		return (DCMD_ERR);

	if (os_dsl_dataset == 0) {

		strcat(buf, "mos");

		return (0);

	}

	if (GETMEMBID(os_dsl_dataset, &ds_id, ds_snapname, ds_snapname) ||

	    GETMEMBID(os_dsl_dataset, &ds_id, ds_dir, ds_dir)) {

		return (DCMD_ERR);

	}

	if (ds_dir && dataset_name(ds_dir, buf))

		return (DCMD_ERR);

	if (ds_snapname[0]) {

		strcat(buf, "@");

		strcat(buf, ds_snapname);

	}

	return (0);

}

static void

enum_lookup(char *out, size_t size, mdb_ctf_id_t id, int val,

    const char *prefix)

{

	const char *cp;

	size_t len = strlen(prefix);

	if ((cp = mdb_ctf_enum_name(id, val)) != NULL) {

		if (strncmp(cp, prefix, len) == 0)

			cp += len;

		(void) strncpy(out, cp, size);

	} else {

		mdb_snprintf(out, size, "? (%d)", val);

	}

}

/* ARGSUSED */

static int

zfs_params(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)

{

	/*

	 * This table can be approximately generated by running:

	 * egrep "^[a-z0-9_]+ [a-z0-9_]+( =.*)?;" *.c | cut -d ' ' -f 2

	 */

	static const char *params[] = {

		"arc_reduce_dnlc_percent",

		"zfs_arc_max",

		"zfs_arc_min",

		"arc_shrink_shift",

		"zfs_mdcomp_disable",

		"zfs_prefetch_disable",

		"zfetch_max_streams",

		"zfetch_min_sec_reap",

		"zfetch_block_cap",

		"zfetch_array_rd_sz",

		"zfs_default_bs",

		"zfs_default_ibs",

		"metaslab_aliquot",

		"reference_tracking_enable",

		"reference_history",

		"spa_max_replication_override",

		"spa_mode_global",

		"zfs_flags",

		"zfs_txg_synctime",

		"zfs_txg_timeout",

		"zfs_write_limit_min",

		"zfs_write_limit_max",

		"zfs_write_limit_shift",

		"zfs_write_limit_override",

		"zfs_no_write_throttle",

		"zfs_vdev_cache_max",

		"zfs_vdev_cache_size",

		"zfs_vdev_cache_bshift",

		"vdev_mirror_shift",

		"zfs_vdev_max_pending",

		"zfs_vdev_min_pending",

		"zfs_scrub_limit",

		"zfs_no_scrub_io",

		"zfs_no_scrub_prefetch",

		"zfs_vdev_time_shift",

		"zfs_vdev_ramp_rate",

		"zfs_vdev_aggregation_limit",

		"fzap_default_block_shift",

		"zfs_immediate_write_sz",

		"zfs_read_chunk_size",

		"zil_disable",

		"zfs_nocacheflush",

		"metaslab_gang_bang",

		"metaslab_df_alloc_threshold",

		"metaslab_df_free_pct",

		"zio_injection_enabled",

		"zvol_immediate_write_sz",

	};

	for (int i = 0; i < sizeof (params) / sizeof (params[0]); i++) {

		int sz;

		uint64_t val64;

		uint32_t *val32p = (uint32_t *)&val64;

		sz = mdb_readvar(&val64, params[i]);

		if (sz == 4) {

			mdb_printf("%s = 0x%x\n", params[i], *val32p);

		} else if (sz == 8) {

			mdb_printf("%s = 0x%llx\n", params[i], val64);

		} else {

			mdb_warn("variable %s not found", params[i]);

		}

	}

	return (DCMD_OK);

}

/* ARGSUSED */

static int

blkptr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)

{

	mdb_ctf_id_t type_enum, checksum_enum, compress_enum;

	char type[80], checksum[80], compress[80];

	blkptr_t blk, *bp = &blk;

	char buf[BP_SPRINTF_LEN];

	if (mdb_vread(&blk, sizeof (blkptr_t), addr) == -1) {

		mdb_warn("failed to read blkptr_t");

		return (DCMD_ERR);

	}

	if (mdb_ctf_lookup_by_name("enum dmu_object_type", &type_enum) == -1 ||

	    mdb_ctf_lookup_by_name("enum zio_checksum", &checksum_enum) == -1 ||

	    mdb_ctf_lookup_by_name("enum zio_compress", &compress_enum) == -1) {

		mdb_warn("Could not find blkptr enumerated types");

		return (DCMD_ERR);

	}

	enum_lookup(type, sizeof (type), type_enum,

	    BP_GET_TYPE(bp), "DMU_OT_");

	enum_lookup(checksum, sizeof (checksum), checksum_enum,

	    BP_GET_CHECKSUM(bp), "ZIO_CHECKSUM_");

	enum_lookup(compress, sizeof (compress), compress_enum,

	    BP_GET_COMPRESS(bp), "ZIO_COMPRESS_");

	SPRINTF_BLKPTR(mdb_snprintf, '\n', buf, bp, type, checksum, compress);

	mdb_printf("%s\n", buf);

	return (DCMD_OK);

}

/* ARGSUSED */

static int

dbuf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)

{

	mdb_ctf_id_t id;

	dmu_buf_t db;

	uintptr_t objset;

	uint8_t level;

	uint64_t blkid;

	uint64_t holds;

	char objectname[32];

	char blkidname[32];

	char path[MAXNAMELEN];

	if (DCMD_HDRSPEC(flags)) {

		mdb_printf("        addr object lvl blkid holds os\n");

	}

	if (mdb_ctf_lookup_by_name("struct dmu_buf_impl", &id) == -1) {

		mdb_warn("couldn't find struct dmu_buf_impl_t");

		return (DCMD_ERR);

	}

	if (GETMEMBID(addr, &id, db_objset, objset) ||

	    GETMEMBID(addr, &id, db, db) ||

	    GETMEMBID(addr, &id, db_level, level) ||

	    GETMEMBID(addr, &id, db_blkid, blkid)) {

		return (WALK_ERR);

	}

	if (getrefcount(addr, &id, "db_holds", &holds)) {

		return (WALK_ERR);

	}

	if (db.db_object == DMU_META_DNODE_OBJECT)

		(void) strcpy(objectname, "mdn");

	else

		(void) mdb_snprintf(objectname, sizeof (objectname), "%llx",

		    (u_longlong_t)db.db_object);

	if (blkid == DMU_BONUS_BLKID)

		(void) strcpy(blkidname, "bonus");

	else

		(void) mdb_snprintf(blkidname, sizeof (blkidname), "%llx",

		    (u_longlong_t)blkid);

	if (objset_name(objset, path)) {

		return (WALK_ERR);

	}

	mdb_printf("%p %8s %1u %9s %2llu %s\n",

	    addr, objectname, level, blkidname, holds, path);

	return (DCMD_OK);

}

/* ARGSUSED */

static int

dbuf_stats(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)

{

#define	HISTOSZ 32

	uintptr_t dbp;

	dmu_buf_impl_t db;

	dbuf_hash_table_t ht;

	uint64_t bucket, ndbufs;

	uint64_t histo[HISTOSZ];

	uint64_t histo2[HISTOSZ];

	int i, maxidx;

	if (mdb_readvar(&ht, "dbuf_hash_table") == -1) {

		mdb_warn("failed to read 'dbuf_hash_table'");

		return (DCMD_ERR);

	}

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

		histo[i] = 0;

		histo2[i] = 0;

	}

	ndbufs = 0;

	for (bucket = 0; bucket < ht.hash_table_mask+1; bucket++) {

		int len;

		if (mdb_vread(&dbp, sizeof (void *),

		    (uintptr_t)(ht.hash_table+bucket)) == -1) {

			mdb_warn("failed to read hash bucket %u at %p",

			    bucket, ht.hash_table+bucket);

			return (DCMD_ERR);

		}

		len = 0;

		while (dbp != 0) {

			if (mdb_vread(&db, sizeof (dmu_buf_impl_t),

			    dbp) == -1) {

				mdb_warn("failed to read dbuf at %p", dbp);

				return (DCMD_ERR);

			}

			dbp = (uintptr_t)db.db_hash_next;

			for (i = MIN(len, HISTOSZ - 1); i >= 0; i--)

				histo2[i]++;

			len++;

			ndbufs++;

		}

		if (len >= HISTOSZ)

			len = HISTOSZ-1;

		histo[len]++;

	}

	mdb_printf("hash table has %llu buckets, %llu dbufs "

	    "(avg %llu buckets/dbuf)\n",

	    ht.hash_table_mask+1, ndbufs,

	    (ht.hash_table_mask+1)/ndbufs);

	mdb_printf("\n");

	maxidx = 0;

	for (i = 0; i < HISTOSZ; i++)

		if (histo[i] > 0)

			maxidx = i;

	mdb_printf("hash chain length	number of buckets\n");

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

		mdb_printf("%u			%llu\n", i, histo[i]);

	mdb_printf("\n");

	maxidx = 0;