/*

 * 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 <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/zio_compress.h>

#ifndef _KERNEL

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

#endif

#ifdef _KERNEL

#define	ZFS_OBJ_NAME	"zfs"

#else

#define	ZFS_OBJ_NAME	"libzpool.so.1"

#endif

static char *

local_strdup(const char *s)

{

	char *s1 = mdb_alloc(strlen(s) + 1, UM_SLEEP);

	(void) strcpy(s1, s);

	return (s1);

}

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

read_symbol(char *sym_name, void **bufp)

{

	GElf_Sym sym;

	if (mdb_lookup_by_obj(MDB_TGT_OBJ_EVERY, sym_name, &sym)) {

		mdb_warn("can't find symbol %s", sym_name);

		return (DCMD_ERR);

	}

	*bufp = mdb_alloc(sym.st_size, UM_SLEEP);

	if (mdb_vread(*bufp, sym.st_size, sym.st_value) == -1) {

		mdb_warn("can't read data for symbol %s", sym_name);

		mdb_free(*bufp, sym.st_size);

		return (DCMD_ERR);

	}

	return (DCMD_OK);

}

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;

	static mdb_ctf_id_t osi_id, ds_id;

	uintptr_t os_dsl_dataset;

	char ds_snapname[MAXNAMELEN];

	uintptr_t ds_dir;

	buf[0] = '\0';

	if (!gotid) {

		if (mdb_ctf_lookup_by_name("struct objset_impl",

		    &osi_id) == -1) {

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

			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;

	}

	if (GETMEMBID(addr, &osi_id, os_dsl_dataset, os_dsl_dataset))

		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

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

{

	mdb_ctf_id_t pipe_enum;

	int i;

	char stage[1024];

	if (mdb_ctf_lookup_by_name("enum zio_stage", &pipe_enum) == -1) {

		mdb_warn("Could not find enum zio_stage");

		return (DCMD_ERR);

	}

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

		if (addr & (1U << i)) {

			enum_lookup(stage, sizeof (stage), pipe_enum, i,

			    "ZIO_STAGE_");

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

		}

	}

	return (DCMD_OK);

}

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

		"zio_taskq_threads",

		"spa_max_replication_override",

		"spa_mode",

		"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_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",

		"zio_injection_enabled",

		"zvol_immediate_write_sz",

	};

	int i;

	for (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)

{

	blkptr_t bp;

	dmu_object_type_info_t *doti;

	zio_compress_info_t *zct;

	zio_checksum_info_t *zci;

	int i;

	char buf[MAXPATHLEN];

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

		mdb_warn("failed to read blkptr_t");

		return (DCMD_ERR);

	}

	if (read_symbol("dmu_ot", (void **)&doti) != DCMD_OK)

		return (DCMD_ERR);

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

		mdb_readstr(buf, sizeof (buf), (uintptr_t)doti[i].ot_name);

		doti[i].ot_name = local_strdup(buf);

	}

	if (read_symbol("zio_checksum_table", (void **)&zci) != DCMD_OK)

		return (DCMD_ERR);

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

		mdb_readstr(buf, sizeof (buf), (uintptr_t)zci[i].ci_name);

		zci[i].ci_name = local_strdup(buf);

	}

	if (read_symbol("zio_compress_table", (void **)&zct) != DCMD_OK)

		return (DCMD_ERR);

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

		mdb_readstr(buf, sizeof (buf), (uintptr_t)zct[i].ci_name);

		zct[i].ci_name = local_strdup(buf);

	}

	/*

	 * Super-ick warning:  This code is also duplicated in

	 * cmd/zdb.c .   Yeah, I hate code replication, too.

	 */

	for (i = 0; i < BP_GET_NDVAS(&bp); i++) {

		dva_t *dva = &bp.blk_dva[i];

		mdb_printf("DVA[%d]: vdev_id %lld / %llx\n", i,

		    DVA_GET_VDEV(dva), DVA_GET_OFFSET(dva));

		mdb_printf("DVA[%d]:       GANG: %-5s  GRID:  %04x\t"

		    "ASIZE: %llx\n", i, DVA_GET_GANG(dva) ? "TRUE" : "FALSE",

		    DVA_GET_GRID(dva), DVA_GET_ASIZE(dva));

		mdb_printf("DVA[%d]: :%llu:%llx:%llx:%s%s%s%s\n", i,

		    DVA_GET_VDEV(dva), DVA_GET_OFFSET(dva), BP_GET_PSIZE(&bp),

		    BP_SHOULD_BYTESWAP(&bp) ? "e" : "",

		    !DVA_GET_GANG(dva) && BP_GET_LEVEL(&bp) != 0 ? "i" : "",

		    DVA_GET_GANG(dva) ? "g" : "",

		    BP_GET_COMPRESS(&bp) != 0 ? "d" : "");

	}

	mdb_printf("LSIZE:  %-16llx\t\tPSIZE: %llx\n",

	    BP_GET_LSIZE(&bp), BP_GET_PSIZE(&bp));

	mdb_printf("ENDIAN: %6s\t\t\t\t\tTYPE:  %s\n",

	    BP_GET_BYTEORDER(&bp) ? "LITTLE" : "BIG",

	    doti[BP_GET_TYPE(&bp)].ot_name);

	mdb_printf("BIRTH:  %-16llx   LEVEL: %-2d\tFILL:  %llx\n",

	    bp.blk_birth, BP_GET_LEVEL(&bp), bp.blk_fill);

	mdb_printf("CKFUNC: %-16s\t\tCOMP:  %s\n",

	    zci[BP_GET_CHECKSUM(&bp)].ci_name,

	    zct[BP_GET_COMPRESS(&bp)].ci_name);

	mdb_printf("CKSUM:  %llx:%llx:%llx:%llx\n",

	    bp.blk_cksum.zc_word[0],

	    bp.blk_cksum.zc_word[1],

	    bp.blk_cksum.zc_word[2],

	    bp.blk_cksum.zc_word[3]);

	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 == DB_BONUS_BLKID)

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

	else