xref: /onnv-gate/usr/src/cmd/mdb/common/modules/sdbc/sdbc.c (revision 7836:4e95154b5b7a)

/*
 * 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 <sys/mdb_modapi.h>
#include <sys/nsc_thread.h>

/* needed to maintain identical _sd_bitmap_t sizes */
#define	_SD_8K_BLKSIZE
#include <sys/nsctl/sd_bcache.h>

#include <ns/sdbc/sd_io.h>
#include <ns/sdbc/sd_ft.h>
#include <ns/sdbc/safestore.h>

/*
 * initialize cd filter options to this
 * to differentiate with kernel values in range [-1, sdbc_max_devs]
 */
#define	MDB_CD ((uintptr_t)~1)
#define	OPT_C_SELECTED (opt_c != MDB_CD)

/* initialize block filters to this */
#define	MDB_BLKNUM ((uintptr_t)~1)
#define	OPT_B_SELECTED (opt_b != MDB_BLKNUM)

enum vartype { UINTTYPE = 0, ADDRTYPE, LOCKTYPE, CVTYPE };

static void display_var(char *, enum vartype);
#ifdef SAFESTORE
static void print_wrq(_sd_writeq_t *, uint_t);
#endif

struct walk_info {
		uintptr_t w_start;
		uintptr_t w_end;
};


mdb_bitmask_t host_states[] = {
	{ "HOST_NONE", 0xff, _SD_HOST_NONE },
	{ "HOST_CONFIGURED", 0xff, _SD_HOST_CONFIGURED },
	{ "HOST_DECONFIGURED", 0xff, _SD_HOST_DECONFIGURED },
	{ "HOST_NOCACHE", 0xff, _SD_HOST_NOCACHE },
	{ NULL, 0, 0 }

};

mdb_bitmask_t cache_hints[] = {
	{ "WRTHRU", NSC_WRTHRU, NSC_WRTHRU },
	{ "FORCED_WRTHRU", NSC_FORCED_WRTHRU, NSC_FORCED_WRTHRU },
	{ "NOCACHE", NSC_NOCACHE, NSC_NOCACHE },
	{ "QUEUE", NSC_QUEUE, NSC_QUEUE },
	{ "RDAHEAD", NSC_RDAHEAD, NSC_RDAHEAD },
	{ "NO_FORCED_WRTHRU", NSC_NO_FORCED_WRTHRU, NSC_NO_FORCED_WRTHRU },
	{ "METADATA", NSC_METADATA, NSC_METADATA },
	{ "SEQ_IO", NSC_SEQ_IO, NSC_SEQ_IO },
	{ NULL, 0, 0 }

};


/*
 * some cache general dcmds that do not use walkers
 */
/*ARGSUSED*/
static int
sdbc_config(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	_sd_cache_param_t _sd_cache_config;
	_sd_net_t _sd_net_config;
	_sd_ft_info_t  _sd_ft_data;
	uint_t _sd_node_hint;
	char sdbc_version[17];

	if (mdb_readvar(sdbc_version, "sdbc_version") == -1) {
		mdb_warn("failed to read sdbc_version symbol");
	} else {
		sdbc_version[16] = '\0';  /* make sure string is terminated */
		mdb_printf("sdbc_version %s\n", sdbc_version);
	}

	if (mdb_readvar(&_sd_cache_config, "_sd_cache_config") == -1) {
		mdb_warn("failed to read _sd_cache_config symbol");
	} else {

		mdb_printf("SDBC Configuration:\n");
		mdb_inc_indent(4);
		mdb_printf("user magic: %X kernel magic: %X (should match)\n",
			    _SD_MAGIC, _sd_cache_config.magic);
		mdb_printf(
		    "mirror host: %2d Block size: %4d threads %4d "
		    "write cache: %4dM\n",
			    _sd_cache_config.mirror_host,
			    _sd_cache_config.blk_size,
			    _sd_cache_config.threads,
			    _sd_cache_config.write_cache);
		mdb_printf("num_handles %4-d cache_mem %4dM prot_lru %d\n",
			    _sd_cache_config.num_handles,
			    _sd_cache_config.cache_mem[0],
			    _sd_cache_config.prot_lru);
		mdb_printf("gen_pattern %d fill_pattern %?-p num_nodes %d\n",
			    _sd_cache_config.gen_pattern,
			    _sd_cache_config.fill_pattern,
			    _sd_cache_config.num_nodes);
		mdb_dec_indent(4);
	}

	if (mdb_readvar(&_sd_net_config, "_sd_net_config") == -1) {
		mdb_warn("failed to read _sd_net_config symbol");
	} else {
		mdb_inc_indent(4);
		mdb_printf(
	"psize %4-d configured %d csize %10-d wsize %10-d cpages %6d\n",
			_sd_net_config.sn_psize,
			_sd_net_config.sn_configured,
			_sd_net_config.sn_csize,
			_sd_net_config.sn_wsize,
			_sd_net_config.sn_cpages);

		mdb_dec_indent(4);
#ifdef SAFESTORE
		print_wrq(&(_sd_net_config.sn_wr_queue), FALSE);
#endif
	}


	if (mdb_readvar(&_sd_ft_data, "_sd_ft_data") == -1) {
		mdb_warn("failed to read _sd_ft_data symbol");

	} else {
		mdb_printf("FT data:\n");
		mdb_inc_indent(4);
		mdb_printf("crashed %d host_state <%b> numio %d\n",
			_sd_ft_data.fi_crashed,
			_sd_ft_data.fi_host_state, host_states,
			_sd_ft_data.fi_numio);
		mdb_printf("lock %?-p (owner) rem_sv %h-x sleep %?-p (owner)\n",
			_sd_ft_data.fi_lock._opaque[0],
			_sd_ft_data.fi_rem_sv._opaque,
			_sd_ft_data.fi_sleep._opaque[0]);
		mdb_dec_indent(4);
	}

	if (mdb_readvar(&_sd_node_hint, "_sd_node_hint") == -1) {
		mdb_warn("failed to read _sd_node_hint symbol");

	} else
		mdb_printf("Node Hints: %08x <%b>\n",
			_sd_node_hint, cache_hints);

	display_var("sdbc_wrthru_len", UINTTYPE);
	display_var("_sd_debug_level", UINTTYPE);
	display_var("_sdbc_attached", UINTTYPE);

	return (DCMD_OK);
}

static void
sdbc_hit_percent(uint_t hits, uint_t misses, char *type)
{
	uint64_t dhits, dmisses;
	uint64_t hit_rate = 0;

	mdb_printf("%s hits: %u\t %s misses: %u\n", type, hits, type, misses);

	/* a little crude. anything less than 1 percent will show as 0 */
	if (hits > 0 || misses > 0) {
		dhits = (uint64_t)hits;
		dmisses = (uint64_t)misses;
		hit_rate = (dhits * 100)/ (dhits + dmisses);
		mdb_printf("%s hit rate: %lld %%\n", type, hit_rate);
	}
	mdb_printf("\n");
}

/*ARGSUSED*/
static int
sdbc_stats(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	int i;
	char *fn;
	_sd_stats_t *_sd_cache_stats; /* local memory */
	uintptr_t _sd_cache_statsp; /* kernel pointer */
	_sd_shared_t *sh;
	int statssize;
	GElf_Sym sym;
	int maxdevs;

	if (argc != 0)
		return (DCMD_USAGE);

	/* get the number of volumes */
	if (mdb_readvar(&maxdevs, "sdbc_max_devs") == -1) {
		mdb_warn("failed to read  sdbc_max_devs");
		return (DCMD_ERR);
	}

	statssize = sizeof (_sd_stats_t) + (maxdevs - 1) *
						sizeof (_sd_shared_t);

	_sd_cache_stats = mdb_zalloc(statssize, UM_SLEEP);

	if (mdb_lookup_by_obj("sdbc", "_sd_cache_stats", &sym) == -1) {
		mdb_warn("failed to lookup _sd_cache_stats symbol");
		return (DCMD_ERR);
	}

	if (mdb_vread(&_sd_cache_statsp, sizeof (uintptr_t),
						sym.st_value) == -1) {
		mdb_warn("failed to read _sd_stats_t pointer");
		return (DCMD_ERR);
	}

	if (mdb_vread(_sd_cache_stats, statssize, _sd_cache_statsp) == -1) {
		mdb_warn("failed to read _sd_stats_t structure");
		return (DCMD_ERR);
	}

	mdb_printf("Storage Device Block Cache Statistics\n");
	mdb_printf("-------------------------------------\n");

	i = _sd_cache_stats->st_blksize;
	mdb_printf("Blocksize: 0x%x (%d)\n", i, i);

	mdb_printf("\n");
	sdbc_hit_percent(_sd_cache_stats->st_rdhits, _sd_cache_stats->st_rdmiss,
				"Read");
	sdbc_hit_percent(_sd_cache_stats->st_wrhits, _sd_cache_stats->st_wrmiss,
				"Write");

	mdb_printf("%3s %10s %8s %8s %8s %8s %8s %7s %4s %4s %s\n",
		"Cd", "Dev", "Size",
		"CacheRd", "CacheWr", "DiskRd", "DiskWr",
		"DirtyBl", "#IO", "Fail", "F");
	for (i = 0; i < maxdevs; i++) {
		sh = &_sd_cache_stats->st_shared[i];
		if (!sh->sh_alloc)
			continue;
		fn = strrchr(sh->sh_filename, '/');
		fn = fn ? fn+1 : sh->sh_filename;
		mdb_printf("%3d %10s %7d %8d %8d %8d %8d %7d %4d %4d %d\n",
			sh->sh_cd, fn, sh->sh_filesize,
			sh->sh_cache_read, sh->sh_cache_write,
			sh->sh_disk_read, sh->sh_disk_write,
			sh->sh_numdirty, sh->sh_numio, sh->sh_numfail,
			sh->sh_failed);
	}

	mdb_free(_sd_cache_stats, statssize);
	return (DCMD_OK);
}

/*
 * display some variables and counters
 */
static void
display_var(char *name, enum vartype type)
{
	uint_t		uintval;
	uintptr_t	addrval;
	kmutex_t	lockval;
	kcondvar_t	cvval;

	switch (type) {
		case UINTTYPE:
			if (mdb_readvar(&uintval, name) == -1) {
				mdb_warn("failed to read %s variable", name);
			} else
				mdb_printf("%s =\t%8x %12u\n",
						    name, uintval, uintval);
			break;
		case ADDRTYPE:
			if (mdb_readvar(&addrval, name) == -1) {
				mdb_warn("failed to read %s variable", name);
			} else
				mdb_printf("%s =\t%?-p\n",
						    name, addrval);
			break;
		case LOCKTYPE:
			if (mdb_readvar(&lockval, name) == -1) {
				mdb_warn("failed to read %s lock variable",
								name);
			} else
				mdb_printf("%s =\t%-p (owner)\n",
						name, lockval._opaque[0]);
			break;
		case CVTYPE:
			if (mdb_readvar(&cvval, name) == -1) {
				mdb_warn("failed to read %s condvar variable",
								name);
			} else
				mdb_printf("%s = \t%h-x\n",
						name, cvval._opaque);
			break;
		default:
			mdb_warn("display_var: unknown type");
	}
}

mdb_bitmask_t dealloc_flag_vals[] = {
	{ "PROCESS_CACHE_DM", (u_longlong_t)~0, PROCESS_CACHE_DM },
	{ "CACHE_SHUTDOWN_DM", (u_longlong_t)~0, CACHE_SHUTDOWN_DM },
	{ "CACHE_THREAD_TERMINATED_DM",
	    (u_longlong_t)~0, CACHE_THREAD_TERMINATED_DM },
	{ "TIME_DELAY_LVL0", (u_longlong_t)~0, TIME_DELAY_LVL0 },
	{ "TIME_DELAY_LVL1", (u_longlong_t)~0, TIME_DELAY_LVL1 },
	{ "TIME_DELAY_LVL2", (u_longlong_t)~0, TIME_DELAY_LVL2 },
	{ NULL, 0, 0 }
};

mdb_bitmask_t mdp_bits[] = {
	{ "MONITOR_DYNMEM_PROCESS_DEFAULT",
	    (u_longlong_t)~0, MONITOR_DYNMEM_PROCESS_DEFAULT},
	{ "RPT_SHUTDOWN_PROCESS_DM",
	    RPT_SHUTDOWN_PROCESS_DM, RPT_SHUTDOWN_PROCESS_DM },
	{ "RPT_DEALLOC_STATS1_DM",
	    RPT_DEALLOC_STATS1_DM, RPT_DEALLOC_STATS1_DM },
	{ "RPT_DEALLOC_STATS2_DM",
	    RPT_DEALLOC_STATS2_DM, RPT_DEALLOC_STATS2_DM },
	{ NULL, 0, 0 }
};

mdb_bitmask_t process_directive_bits[] = {
	{ "PROCESS_DIRECTIVE_DEFAULT",
	    (u_longlong_t)~0, PROCESS_DIRECTIVE_DEFAULT },
	{ "WAKE_DEALLOC_THREAD_DM",
	    WAKE_DEALLOC_THREAD_DM, WAKE_DEALLOC_THREAD_DM },
	{ "MAX_OUT_ACCEL_HIST_FLAG_DM",
	    MAX_OUT_ACCEL_HIST_FLAG_DM, MAX_OUT_ACCEL_HIST_FLAG_DM},
	{ NULL, 0, 0 }
};

/*ARGSUSED*/
static int
sdbc_vars(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	int sd_dealloc_flag_dm;
	_dm_process_vars_t dynmem_processing_dm;

	if (argc != 0)
		return (DCMD_USAGE);

	mdb_printf("counters and other variables:\n");
	mdb_inc_indent(4);

	display_var("xmem_inval_hit", UINTTYPE);
	display_var("xmem_inval_miss", UINTTYPE);
	display_var("xmem_inval_inuse", UINTTYPE);

	display_var("sdbc_allocb_pageio1", UINTTYPE);
	display_var("sdbc_allocb_pageio2", UINTTYPE);
	display_var("sdbc_allocb_inuse", UINTTYPE);
	display_var("sdbc_allocb_hit", UINTTYPE);
	display_var("sdbc_allocb_lost", UINTTYPE);
	display_var("sdbc_pageio_always", UINTTYPE);
	display_var("sdbc_do_page", UINTTYPE);
	display_var("sdbc_flush_pageio", UINTTYPE);

	display_var("sdbc_centry_hit", UINTTYPE);
	display_var("sdbc_centry_inuse", UINTTYPE);
	display_var("sdbc_centry_lost", UINTTYPE);
	display_var("sdbc_centry_deallocd", UINTTYPE);

	display_var("_sd_prefetch_opt", UINTTYPE);

	display_var("sdbc_ra_hash", UINTTYPE);
	display_var("sdbc_ra_none", UINTTYPE);

	display_var("sdbc_static_cache", UINTTYPE);
	display_var("sdbc_use_dmchain", UINTTYPE);

	/* in no particular order ... */
	display_var("sdbc_check_cot", UINTTYPE);
	display_var("_sd_cctl_groupsz", UINTTYPE);
	display_var("CBLOCKS", UINTTYPE);
	display_var("_SD_SELF_HOST", UINTTYPE);
	display_var("_SD_MIRROR_HOST", UINTTYPE);
	display_var("sdbc_bio_count", UINTTYPE);
	display_var("_sd_cblock_shift", UINTTYPE);
	display_var("_sd_nodes_configured", UINTTYPE);
	display_var("nv_alloc_factor", UINTTYPE);
	display_var("_sd_ft_exit", UINTTYPE);
	display_var("_sd_flush_exit", UINTTYPE);
	display_var("_sd_node_recovery", UINTTYPE);
	display_var("_sd_async_recovery", UINTTYPE);
	display_var("_sdbc_ft_hold_io", UINTTYPE);
	display_var("mirror_clean_shutdown", UINTTYPE);
	display_var("_sd_ft_warm_start", UINTTYPE);
	mdb_dec_indent(4);
	mdb_printf("\n");

	/* some addresses of various lists and tables */
	mdb_printf("Addresses:\n");
	mdb_inc_indent(4);
	display_var("_sd_htable", ADDRTYPE);
	display_var("_sdbc_gl_centry_info", ADDRTYPE);
	display_var("_sdbc_gl_centry_info_nvmem", ADDRTYPE);
	display_var("_sdbc_gl_centry_info_size", ADDRTYPE); /* size_t */
	display_var("_sdbc_gl_file_info", ADDRTYPE);
	display_var("_sdbc_gl_file_info_size", ADDRTYPE); /* size_t */
	mdb_dec_indent(4);
	mdb_printf("\n");

	/* dynamic memory variables */
	mdb_printf("Dynamic Memory variables and stats:\n");
	mdb_inc_indent(4);
	display_var("_sdbc_memtype_deconfigure_delayed", UINTTYPE);

	if (mdb_readvar(&sd_dealloc_flag_dm, "sd_dealloc_flag_dm") == -1) {
		mdb_warn("failed to read sd_dealloc_flag_dm symbol");
	} else
		mdb_printf("sd_dealloc_flag_dm %08x <%b>\n",
				sd_dealloc_flag_dm,
				sd_dealloc_flag_dm, dealloc_flag_vals);

	if (mdb_readvar(&dynmem_processing_dm, "dynmem_processing_dm") == -1) {
		mdb_warn("failed to read dynmem_processing_dm structure");
	} else {
		_dm_process_vars_t *dp;

		dp = &dynmem_processing_dm;

		mdb_printf(
		"thread_dm_cv %h-x thread_dm_lock %?-p (owner)\n",
			dp->thread_dm_cv._opaque,
			dp->thread_dm_lock._opaque[0]);

		mdb_printf("sd_dealloc_flagx %x %8Tmax_dyn_list %3-d\n",
			dp->sd_dealloc_flagx,
			dp->max_dyn_list);

		mdb_printf("monitor_dynmem_process <%b>\n",
			dp->monitor_dynmem_process, mdp_bits);

		mdb_printf(
	"cache_aging_ct1 %3-d  %8Tcache_aging_ct2 %3-d cache_aging_ct3 %3-d\n",
			dp->cache_aging_ct1,
			dp->cache_aging_ct2,
			dp->cache_aging_ct3);

		mdb_printf(
			"cache_aging_sec1 %3-d %8Tcache_aging_sec2 %3-d"
			" cache_aging_sec3 %3-d\n",
			dp->cache_aging_sec1,
			dp->cache_aging_sec2,
			dp->cache_aging_sec3);

		mdb_printf("cache_aging_pcnt1 %3-d %8Tcache_aging_pcnt2 %3-d\n",
			dp->cache_aging_pcnt1,
			dp->cache_aging_pcnt2);

		mdb_printf(
		    "max_holds_pcnt %3-d %8Talloc_ct %8-d dealloc_ct %8-d\n",
			dp->max_holds_pcnt,
			dp->alloc_ct,
			dp->dealloc_ct);

		mdb_printf(
		"history %4x %8Tnodatas %8-d notavail %8-d candidates %8-d\n",
			dp->history,
			dp->nodatas,
			dp->notavail,
			dp->candidates);

		mdb_printf(
			"deallocs %8-d %8Thosts %8-d pests %8-d metas %8-d\n",
			dp->deallocs,
			dp->hosts,
			dp->pests,
			dp->metas);

		mdb_printf("holds %8-d %8Tothers %8-d\n",
			dp->holds,
			dp->others);

		mdb_printf("process_directive <%b>\n",
			dp->process_directive, process_directive_bits);

		mdb_printf("read_hits %8-d %8Tread_misses %8-d\n",
			dp->read_hits,
			dp->read_misses);

		mdb_printf(
		    "write_thru %8-d %8Twrite_hits %8-d write_misses %8-d\n",
			dp->write_hits,
			dp->write_misses,
			dp->write_thru);

		mdb_printf("prefetch_hits %8-d prefetch_misses %8-d\n",
			dp->prefetch_hits,
			dp->prefetch_misses);
	}
	mdb_dec_indent(4);
	mdb_printf("\n");

	/* some locks and condition variables */
	mdb_printf("Locks:\n");
	mdb_inc_indent(4);
	display_var("mutex_and_condvar_flag", UINTTYPE);
	display_var("_sd_cache_lock", LOCKTYPE);
	display_var("_sd_block_lk", LOCKTYPE);
	display_var("_sdbc_config_lock", LOCKTYPE);
	display_var("_sdbc_ft_hold_io_lk", LOCKTYPE);
	display_var("_sd_flush_cv", CVTYPE);
	display_var("_sdbc_ft_hold_io_cv", CVTYPE);
	mdb_dec_indent(4);
	mdb_printf("\n");

	return (DCMD_OK);
}

const mdb_bitmask_t nsc_buf_bits[] = {
	{"HALLOCATED", NSC_HALLOCATED, NSC_HALLOCATED},
	{"HACTIVE", NSC_HACTIVE, NSC_HACTIVE},
	{"RDBUF", NSC_RDBUF, NSC_RDBUF},
	{"WRBUF", NSC_WRBUF, NSC_WRBUF},
	{"NOBLOCK", NSC_NOBLOCK, NSC_NOBLOCK},
	{"WRTHRU", NSC_WRTHRU, NSC_WRTHRU},
	{"NOCACHE", NSC_NOCACHE, NSC_NOCACHE},
	{"BCOPY", NSC_BCOPY, NSC_BCOPY},
	{"PAGEIO", NSC_PAGEIO, NSC_PAGEIO},
	{"PINNABLE", NSC_PINNABLE, NSC_PINNABLE},
	{"FORCED_WRTHRU", NSC_FORCED_WRTHRU, NSC_FORCED_WRTHRU},
	{"METADATA", NSC_METADATA, NSC_METADATA},
	{"MIXED", NSC_MIXED, NSC_MIXED},
	{NULL, 0, 0}
};


/*
 * HELP functions for cache ctl type dcmds
 */

static void
cctl_help_common(char *name)
{
	mdb_inc_indent(4);
	mdb_printf("-c cd displays cctls for cache descriptor 'cd'\n");
	mdb_dec_indent(4);
	mdb_printf("inclusive filters:\n");
	mdb_inc_indent(4);
	mdb_printf("-b blk displays cctls for cache block number 'blk'\n");
	mdb_printf("-d displays cctls with dirty bits\n");
	mdb_printf("-h displays cctls that are hashed\n");
	mdb_printf("-i displays cctls that are inuse\n");
	mdb_printf("-o displays cctls that have I/O in progress\n");
	mdb_printf("-p displays cctls that have pagio set\n");
	mdb_printf("-B displays cctls that are marked BAD\n");
	mdb_printf("-H displays cctls that are HOSTS\n");
	mdb_printf("-P displays cctls that are PARASITES\n");
	mdb_printf("-R displays cctls that are explicit (NSC_RDAHEAD) "
			"Prefetch bufs\n");
	mdb_printf("-r displays cctls that are implicit Prefetch bufs\n");
	mdb_printf("-V displays cctls that have valid bits set\n");
	mdb_printf("-v verbose\n");
	mdb_dec_indent(4);

	mdb_printf("Default: %s displays all cctls in the list\n", name);
	mdb_printf("\n");

	mdb_printf("Example:\n");
	mdb_inc_indent(4);

	mdb_printf("%s -io -c 5 displays all cctls for cd 5 that are\n"
			"in use or have I/O in progress\n", name);
	mdb_dec_indent(4);
}

#define	CCTL_OPTIONSTRING "[-vdhiopBHPV][-c cd][-b blknum]"
void
cctl_help()
{
	mdb_printf("sdbc_cctl displays cache ctl structures\n");
	mdb_printf("Usage: [address]::sdbc_cctl " CCTL_OPTIONSTRING "\n");
	cctl_help_common("sdbc_cctl");
}

void
cchain_help()
{
	mdb_printf("sdbc_cchain displays cache ctl structures in a"
			" (alloc) cc_chain\n");
	mdb_printf("Usage: address::sdbc_cchain " CCTL_OPTIONSTRING "\n");
	cctl_help_common("sdbc_cchain");
}

void
dchain_help()
{
	mdb_printf("sdbc_dchain displays cache ctl structures in a"
			" dirty chain\n");
	mdb_printf("Usage: address::sdbc_dchain " CCTL_OPTIONSTRING "\n");
	cctl_help_common("sdbc_dchain");
}

void
dmchain_help()
{
	mdb_printf("sdbc_dmchain displays cache ctl structures in a"
			" dynamic memory allocation chain\n");
	mdb_printf("order of display is:\n"
		    "the cctl represented by the given address,\n"
		    "the cc_head_dm cctl,\n"
		    "the chain starting at cc_next_dm of the head cctl\n");
	mdb_printf("Usage: address::sdbc_dmchain " CCTL_OPTIONSTRING "\n");
	cctl_help_common("sdbc_dmchain");
}

void
hashchain_help()
{
	mdb_printf("sdbc_hashchain displays cache ctl structures in a"
			" hash chain\n");
	mdb_printf("Usage: address::sdbc_hashchain " CCTL_OPTIONSTRING "\n");
	cctl_help_common("sdbc_hashchain");
}

void
hashtable_help()
{
	mdb_printf("sdbc_hashtable displays the hash table and its chains\n");
	mdb_printf("Usage: address::sdbc_hashtable " CCTL_OPTIONSTRING "\n");
	cctl_help_common("sdbc_hashtable");
}


void
lru_help()
{
	mdb_printf("sdbc_lru displays cache ctl structures in the LRU queue\n");
	mdb_printf("Usage: [address]::sdbc_lru " CCTL_OPTIONSTRING "\n");
	cctl_help_common("sdbc_lru");
}

/*
 * help functions for write ctl dcmds
 */
void
wctl_help_common(char *name)
{
	mdb_inc_indent(4);
	mdb_printf("-v verbose\n");
	mdb_printf("-c cd show ctl structs for cache descriptor 'cd'\n");
	mdb_printf("-d show ctl structs that have dirty bits set\n");
	mdb_dec_indent(4);
	mdb_printf("Default: %s displays all write ctl in the list\n", name);
}

void
wctl_help()
{
	mdb_printf(
	    "sdbc_wctl displays the allocated array of write ctl structures\n");
	mdb_printf("Usage: [address]::sdbc_wctl [-vd][-c cd]\n");
	wctl_help_common("sdbc_wctl");
}

void
wrq_help()
{
	mdb_printf("sdbc_wrq displays the write ctl queue (wctl free list)\n");
	mdb_printf("Usage: [address]::sdbc_wrq [-vd][-c cd]\n");
	wctl_help_common("sdbc_wrq");
}

/* help function for the sdbc_cdinfo dcmd */
void
cdinfo_help()
{
	mdb_printf(
	"sdbc_cdinfo displays cd information from the _sd_cache_files table\n");
	mdb_printf("Usage: [address]::sdbc_cdfinfo [-av][-c cd]\n");
	mdb_inc_indent(4);
	mdb_printf("-a displays info for all cd_info structures\n");
	mdb_printf("-c cd displays info for cache descriptor 'cd'\n");
	mdb_printf("-v verbose\n");
	mdb_dec_indent(4);
	mdb_printf("Default: display info for cd's that are allocated\n");
}

void
ftctl_help()
{
	mdb_printf(
	    "sdbc_ftctl displays the array of fault tolerant structures \n");
	mdb_printf("Usage: [address]::sdbc_ftctl [-vd][-c cd]\n");
	wctl_help_common("sdbc_ftctl");
}

/*
 * help function for the sdbc_handles dcmd
 */
void
handle_help()
{
	mdb_printf("sdbc_handles displays active or allocated"
			" cache buffer handles\n");
	mdb_printf("Usage: [address]::sdbc_handles [-avC][-c cd]\n");
	mdb_inc_indent(4);
	mdb_printf("-a displays all handles\n");
	mdb_printf("-c n displays handle for cd n\n");
	mdb_printf("-v displays detailed handle data\n");
	mdb_printf("-C displays the handle cc_chain\n");
	mdb_dec_indent(4);
	mdb_printf("Default: display only allocated or active handles\n");
}

/*
 * help functions for the "global" memory dcmds
 */
void
glcinfo_help()
{
	mdb_printf("sdbc_glcinfo displays the global cache entry info\n");
	mdb_printf("Usage: [address]::sdbc_glcinfo [-adC][-c cd][-b fbapos]\n");
	mdb_inc_indent(4);
	mdb_printf("-a displays all global info structs\n");
	mdb_printf("-b fbapos displays structs that match FBA block"
			"(not cache block) 'fbapos'\n");
	mdb_printf("-c cd displays structs that match cache descriptor 'cd'\n");
	mdb_printf("-d displays structs with dirty bits set\n");
	mdb_printf("-C does consistency check against nvram copy\n");
	mdb_dec_indent(4);
	mdb_printf("Default: display entries with a valid cd\n");
}

void
glfinfo_help()
{
	mdb_printf("sdbc_glfinfo displays the global file info\n");
	mdb_printf("Usage: [address]::sdbc_glfinfo [-aptC]\n");
	mdb_inc_indent(4);
	mdb_printf("-a displays all global info structs\n");
	mdb_printf("-p displays structs for pinned volumes\n");
	mdb_printf("-t displays structs for attached volumes\n");
	mdb_printf("-C does consistency check against nvram copy\n");
	mdb_dec_indent(4);
	mdb_printf("Default: display entries with non-null filename\n");
}


/*
 * WALKERS
 */

/*
 * walker for the cctl list using the cc_link_list_dm pointers
 */
static int
sdbc_cctl_winit(mdb_walk_state_t *wsp)
{
	_sd_cctl_t *_sd_cctl[_SD_CCTL_GROUPS]; /* for getting first entry */
	struct walk_info *winfo;

	winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP);

	if (wsp->walk_addr == NULL) {
		/*
		 * we get the "first" cctl from memory and then traverse
		 * the cc_link_list_dm pointers.
		 * this traversal could start from any cctl.  here we start with
		 * the first cctl in the _sd_cctl[] array.
		 */
		if (mdb_readvar(_sd_cctl, "_sd_cctl") == -1) {
			mdb_warn("failed to read _sd_cctl array");
			return (DCMD_ERR);
		}

		wsp->walk_addr = (uintptr_t)_sd_cctl[0];
	}

	winfo->w_start = 0;
	winfo->w_end = wsp->walk_addr;
	wsp->walk_data = winfo;

	return (WALK_NEXT);
}

static int
sdbc_cctl_wstep(mdb_walk_state_t *wsp)
{
	struct walk_info *winfo = wsp->walk_data;
	_sd_cctl_t centry;
	int status;

	if (wsp->walk_addr == NULL) /* should not happen */
		return (WALK_DONE);

	/*
	 * w_start is 0 on the first iteration so the test
	 * will fail, allowing the first centry to be processed
	 */
	if (wsp->walk_addr == winfo->w_start)
		return (WALK_DONE);

	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
		wsp->walk_cbdata);

	if (mdb_vread(&centry, sizeof (_sd_cctl_t), wsp->walk_addr) == -1) {
		mdb_warn("failed to read centry at %p", wsp->walk_addr);
		return (WALK_ERR);
	}
	wsp->walk_addr = (uintptr_t)(centry.cc_link_list_dm);
	/* set termination condition. only needs to be done once */
	winfo->w_start = winfo->w_end;

	return (status);
}

static void
sdbc_cctl_wfini(mdb_walk_state_t *wsp)
{
	mdb_free(wsp->walk_data, sizeof (struct walk_info));
}

/*
 * walk the cc_chain list of a _sd_cctl_t
 * no global walks -- must be called with an address
 */
static int
sdbc_cchain_winit(mdb_walk_state_t *wsp)
{
	if (wsp->walk_addr == NULL)
		return (WALK_ERR);

	wsp->walk_data = mdb_zalloc(sizeof (_sd_cctl_t), UM_SLEEP);

	return (WALK_NEXT);
}

static int
sdbc_cchain_wstep(mdb_walk_state_t *wsp)
{
	int status;

	if (wsp->walk_addr == NULL)
		return (WALK_DONE);

	if (mdb_vread(wsp->walk_data, sizeof (_sd_cctl_t), wsp->walk_addr)
				== -1) {
		mdb_warn("sdbc_cchain_wstep failed to read centry at %p",
			wsp->walk_addr);
		return (WALK_ERR);
	}

	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
						wsp->walk_cbdata);

	wsp->walk_addr = (uintptr_t)(((_sd_cctl_t *)
				(wsp->walk_data))->cc_chain);
	return (status);
}

static void
sdbc_cchain_wfini(mdb_walk_state_t *wsp)
{
	mdb_free(wsp->walk_data, sizeof (_sd_cctl_t));
}


/*
 * walk the dirty chain list of a _sd_cctl_t
 * no global walks -- must be called with an address
 */
static int
sdbc_dchain_winit(mdb_walk_state_t *wsp)
{
	if (wsp->walk_addr == NULL)
		return (WALK_ERR);

	wsp->walk_data = mdb_zalloc(sizeof (_sd_cctl_t), UM_SLEEP);

	/* walk data stores the first and subsequent cc_dirty_link */
	if (mdb_vread(wsp->walk_data, sizeof (_sd_cctl_t), wsp->walk_addr)
				== -1) {
		mdb_warn("sdbc_dchain_winit failed to read centry at %p",
			wsp->walk_addr);
		return (WALK_ERR);
	}

	return (WALK_NEXT);
}

static int
sdbc_dchain_wstep(mdb_walk_state_t *wsp)
{
	_sd_cctl_t centry;
	int status;

	if (wsp->walk_addr == NULL)
		return (WALK_DONE);

	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
						wsp->walk_cbdata);


	if (mdb_vread(&centry, sizeof (_sd_cctl_t), wsp->walk_addr)
				== -1) {
		mdb_warn("sdbc_dchain_wstep failed to read centry at %p",
			wsp->walk_addr);
		return (WALK_ERR);
	}

	wsp->walk_addr =
		(uintptr_t)(centry.cc_dirty_next);

	/* end of dirty_next chain?  start on subsequent dirty_link */
	if (wsp->walk_addr == NULL) {
		wsp->walk_addr =
		(uintptr_t)(((_sd_cctl_t *)(wsp->walk_data))->cc_dirty_link);

		/* update dirty link */
		/* walk data stores the first and subsequent cc_dirty_link */
		if (wsp->walk_addr) {
			if (mdb_vread(wsp->walk_data, sizeof (_sd_cctl_t),
					wsp->walk_addr) == -1) {

				mdb_warn(
				"sdbc_dchain_wstep failed to read centry at %p",
					wsp->walk_addr);

				return (WALK_ERR);
			}
		}
	}

	return (status);
}

static void
sdbc_dchain_wfini(mdb_walk_state_t *wsp)
{
	mdb_free(wsp->walk_data, sizeof (_sd_cctl_t));
}

/* for stepping thru the dynmem chain */
#define	GET_HEAD_DM 0x1
#define	GET_NEXT_DM 0x2

/*
 * walk the dm chain of a cctl
 * start with current address, then cc_head_dm, then the cc_next_dm chain
 */
static int
sdbc_dmchain_winit(mdb_walk_state_t *wsp)
{
	if (wsp->walk_addr == NULL)
		return (WALK_ERR);

	wsp->walk_data = (void *)GET_HEAD_DM;

	return (WALK_NEXT);
}

static int
sdbc_dmchain_wstep(mdb_walk_state_t *wsp)
{
	_sd_cctl_t centry;
	int status;

	if (wsp->walk_addr == NULL)
		return (WALK_DONE);

	if (mdb_vread(&centry, sizeof (_sd_cctl_t), wsp->walk_addr)
				== -1) {
		mdb_warn("sdbc_dmchain_wstep failed to read centry at %p",
			wsp->walk_addr);
		return (WALK_ERR);
	}

	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
						wsp->walk_cbdata);

	if (wsp->walk_data == (void *)GET_HEAD_DM) {
		wsp->walk_addr = (uintptr_t)centry.cc_head_dm;
		wsp->walk_data = (void *)GET_NEXT_DM;
	} else
		wsp->walk_addr = (uintptr_t)centry.cc_next_dm;

	return (status);
}

/*ARGSUSED*/
static void
sdbc_dmchain_wfini(mdb_walk_state_t *wsp)
{
}

/*
 * walk a hash chain
 * requires an address
 */
/*ARGSUSED*/
static int
sdbc_hashchain_winit(mdb_walk_state_t *wsp)
{

	if (wsp->walk_addr == NULL)
		return (WALK_ERR);


	return (WALK_NEXT);
}

static int
sdbc_hashchain_wstep(mdb_walk_state_t *wsp)
{
	int status;
	_sd_hash_hd_t hash_entry;


	if (wsp->walk_addr == NULL)
		return (WALK_DONE);

	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
						wsp->walk_cbdata);

	if (mdb_vread(&hash_entry, sizeof (_sd_hash_hd_t),
					wsp->walk_addr) == -1) {
		mdb_warn(
			"sdbc_hashchain_wstep failed to read hash_entry at %p",
			wsp->walk_addr);
		return (WALK_ERR); /* will upper layer continue ? */
	}

	wsp->walk_addr = (uintptr_t)hash_entry.hh_next;

	return (status);
}

/*ARGSUSED*/
static void
sdbc_hashchain_wfini(mdb_walk_state_t *wsp)
{
}

/*
 * walk the sdbc lru list
 */
static int
sdbc_lru_winit(mdb_walk_state_t *wsp)
{
	struct walk_info *winfo;
	GElf_Sym sym;

	winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP);

	/* if called without an address, start at the head of the queue */
	if (wsp->walk_addr == NULL) {

		if (mdb_lookup_by_obj("sdbc", "_sd_lru_q", &sym) == -1) {
			mdb_warn("failed to lookup _sd_lru_q symbol");
			return (WALK_ERR);
		}

		/* &(_sd_lru_q.sq_qhead) */
		wsp->walk_addr = (uintptr_t)(sym.st_value);
	}

	winfo->w_start = 0;
	winfo->w_end = wsp->walk_addr;
	wsp->walk_data = winfo;

	return (WALK_NEXT);
}

static int
sdbc_lru_wstep(mdb_walk_state_t *wsp)
{
	struct walk_info *winfo = wsp->walk_data;
	_sd_cctl_t centry;
	int status;

	if (wsp->walk_addr == NULL) /* should not happen */
		return (WALK_DONE);

	/*
	 * w_start is 0 on the first iteration so the test
	 * will fail, allowing the first centry to be processed
	 */
	if (wsp->walk_addr == winfo->w_start)
		return (WALK_DONE);

	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
						wsp->walk_cbdata);

	if (mdb_vread(&centry, sizeof (_sd_cctl_t), wsp->walk_addr) == -1) {
		mdb_warn("failed to read centry at %p", wsp->walk_addr);
		return (WALK_ERR);
	}
	wsp->walk_addr = (uintptr_t)(centry.cc_next);

	/* set termination condition. only needs to be done once */
	winfo->w_start = winfo->w_end;

	return (status);
}

static void
sdbc_lru_wfini(mdb_walk_state_t *wsp)
{
	mdb_free(wsp->walk_data, sizeof (struct walk_info));
}


#ifdef SAFESTORE
/*
 * walk the array of allocated write control structures
 */

static int
sdbc_wctl_winit(mdb_walk_state_t *wsp)
{
	_sd_net_t  _sd_net_config;
	_sd_writeq_t wrq;
	struct walk_info *winfo;
	int blk_shft;
	int count;


	winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP);

	/* need to calculate the end of the array */
	if (mdb_readvar(&_sd_net_config, "_sd_net_config") == -1) {
		mdb_warn("failed to read _sd_net_config structure");
		return (WALK_ERR);
	}

	if (wsp->walk_addr == NULL)
		wsp->walk_addr = (uintptr_t)(_sd_net_config.sn_wr_cctl);

	/*
	 * this module assumes 8k block size so this code can
	 * be commented out if necessary.
	 */
	if (mdb_readvar(&blk_shft, "_sd_cblock_shift") == -1) {
		mdb_warn("failed to read _sd_cblock_shift."
			"assuming 8k cache block size");
		blk_shft = 13;
	}

	count = (_sd_net_config.sn_wpages * _sd_net_config.sn_psize) /
						    (1 << blk_shft);

	winfo->w_end = (uintptr_t)(_sd_net_config.sn_wr_cctl + count);
	wsp->walk_data = winfo;

	return (WALK_NEXT);
}

static int
sdbc_wctl_wstep(mdb_walk_state_t *wsp)
{
	struct walk_info *winfo = wsp->walk_data;
	int status;

	if (wsp->walk_addr == NULL)
		return (WALK_DONE);

	if (wsp->walk_addr >= winfo->w_end)
		return (WALK_DONE);

	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
						wsp->walk_cbdata);

	wsp->walk_addr += sizeof (_sd_wr_cctl_t);

	return (status);

}

static void
sdbc_wctl_wfini(mdb_walk_state_t *wsp)
{
	mdb_free(wsp->walk_data, sizeof (struct walk_info));
}

/*
 * walk the queue (free list) of write control structures
 */

static int
sdbc_wrq_winit(mdb_walk_state_t *wsp)
{
	_sd_net_t  _sd_net_config;
	_sd_writeq_t wrq;

	/* if called without an address, start at the head of the queue */
	if (wsp->walk_addr == NULL) {

		if (mdb_readvar(&_sd_net_config, "_sd_net_config") == -1) {
			mdb_warn("failed to read _sd_net_config structure");
			return (WALK_ERR);
		}

		wsp->walk_addr = (uintptr_t)
					(_sd_net_config.sn_wr_queue.wq_qtop);
	}

	return (WALK_NEXT);
}

static int
sdbc_wrq_wstep(mdb_walk_state_t *wsp)
{
	_sd_wr_cctl_t wctl;
	int status;

	if (wsp->walk_addr == NULL)
		return (WALK_DONE);

	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
						wsp->walk_cbdata);

	if (mdb_vread(&wctl, sizeof (_sd_wr_cctl_t), wsp->walk_addr)
				== -1) {
		mdb_warn("sdbc_cchain_wstep failed to read wctl at %p",
			wsp->walk_addr);
		return (WALK_ERR);
	}

	/* special case -- mini-DSP fake wr_cctl */
	if (wsp->walk_addr == (uintptr_t)wctl.wc_next)
		return (WALK_DONE);

	wsp->walk_addr = (uintptr_t)(wctl.wc_next);

	return (WALK_NEXT);
}

static void
sdbc_wrq_wfini(mdb_walk_state_t *wsp)
{
}
#endif /* SAFESTORE */
/*
 * walk the _sd_cache_files array of cd_info structures
 */
static int
sdbc_cdinfo_winit(mdb_walk_state_t *wsp)
{
	struct walk_info *winfo;
	_sd_cd_info_t	*_sd_cache_files_addr;
	int maxdevs;

	winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP);


	/* get the address of the cdinfo table */
	if (mdb_readvar(&_sd_cache_files_addr, "_sd_cache_files") == -1) {
		mdb_warn("failed to read _sd_cache_files address\n");
		return (WALK_ERR);
	}

	/* if called without an address, start at the head of the queue */
	if (wsp->walk_addr == NULL) {
		/* address of first _sd_cd_info_t */
		wsp->walk_addr = (uintptr_t)(_sd_cache_files_addr);
	}

	/* get the number of volumes */
	if (mdb_readvar(&maxdevs, "sdbc_max_devs") == -1) {
		mdb_warn("failed to read  sdbc_max_devs");
		return (WALK_ERR);
	}

	winfo->w_end = (uintptr_t)(_sd_cache_files_addr + maxdevs);
	wsp->walk_data = winfo;

	return (WALK_NEXT);
}

static int
sdbc_cdinfo_wstep(mdb_walk_state_t *wsp)
{
	struct walk_info *winfo = wsp->walk_data;
	int status;

	if (wsp->walk_addr >= winfo->w_end)
		return (WALK_DONE);

	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
						wsp->walk_cbdata);

	wsp->walk_addr += sizeof (_sd_cd_info_t);

	return (status);
}

static void
sdbc_cdinfo_wfini(mdb_walk_state_t *wsp)
{
	mdb_free(wsp->walk_data, sizeof (struct walk_info));
}

#ifdef SAFESTORE
/*
 * walk the array of allocated fault tolerant control structures
 */
static int
sdbc_ftctl_winit(mdb_walk_state_t *wsp)
{
	_sd_net_t  _sd_net_config;
	struct walk_info *winfo;
	int blk_shft = 13; /* 8k default */
	int count;


	winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP);

	/* need to calculate the end of the array */
	if (mdb_readvar(&_sd_net_config, "_sd_net_config") == -1) {
		mdb_warn("failed to read _sd_net_config structure");
		return (WALK_ERR);
	}

	if (wsp->walk_addr == NULL)
		wsp->walk_addr = (uintptr_t)(_sd_net_config.sn_ft_cctl);

	/*
	 * this module assumes 8k block size so this code can
	 * be commented out if necessary.
	 */
	if (mdb_readvar(&blk_shft, "_sd_cblock_shift") == -1) {
		mdb_warn("failed to read _sd_cblock_shift."
			"assuming 8k cache block size");
		blk_shft = 13;
	}

	count = (_sd_net_config.sn_wpages * _sd_net_config.sn_psize) /
						    (1 << blk_shft);

	winfo->w_end = (uintptr_t)(_sd_net_config.sn_ft_cctl + count);
	wsp->walk_data = winfo;

	return (WALK_NEXT);
}

static int
sdbc_ftctl_wstep(mdb_walk_state_t *wsp)
{
	struct walk_info *winfo = wsp->walk_data;
	int status;

	if (wsp->walk_addr == NULL)
		return (WALK_DONE);

	if (wsp->walk_addr >= winfo->w_end)
		return (WALK_DONE);

	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
						wsp->walk_cbdata);

	wsp->walk_addr += sizeof (_sd_ft_cctl_t);

	return (status);
}

static void
sdbc_ftctl_wfini(mdb_walk_state_t *wsp)
{
	mdb_free(wsp->walk_data, sizeof (struct walk_info));
}
#endif /* SAFESTORE */

/*
 * walk the handle list
 */
static int
sdbc_handle_winit(mdb_walk_state_t *wsp)
{
	_sd_buf_hlist_t hl;
	struct walk_info *winfo;
	GElf_Sym sym;

	if (mdb_readvar(&hl, "_sd_handle_list") == -1) {
		mdb_warn("failed to read _sd_handle_list structure");
		return (WALK_ERR);
	}

	if (mdb_lookup_by_obj("sdbc", "_sd_handle_list", &sym) == -1) {
		mdb_warn("failed to lookup _sd_handle_list symbol");
		return (WALK_ERR);
	}

	/* if called without an address, start at first element in list */
	if (wsp->walk_addr == NULL)
		wsp->walk_addr = (uintptr_t)(hl.hl_top.bh_next);

	winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP);

	winfo->w_end = (uintptr_t)(sym.st_value); /* &_sd_handle_list.hl_top */
	wsp->walk_data = winfo;

	return (WALK_NEXT);
}

static int
sdbc_handle_wstep(mdb_walk_state_t *wsp)
{
	struct walk_info *winfo = wsp->walk_data;
	_sd_buf_handle_t handle;
	int status;

	if (wsp->walk_addr == NULL)
		return (WALK_DONE);

	if (wsp->walk_addr == winfo->w_end)
		return (WALK_DONE);

	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
						wsp->walk_cbdata);

	if (mdb_vread(&handle, sizeof (_sd_buf_handle_t), wsp->walk_addr)
								== -1) {
		mdb_warn("failed to read handle at %p", wsp->walk_addr);
		return (WALK_ERR);
	}

	wsp->walk_addr = (uintptr_t)(handle.bh_next);

	return (status);
}

static void
sdbc_handle_wfini(mdb_walk_state_t *wsp)
{
	mdb_free(wsp->walk_data, sizeof (struct walk_info));
}

/*
 * walk the global info array (dirty bits)
 */

static int
sdbc_glcinfo_winit(mdb_walk_state_t *wsp)
{
	ss_centry_info_t *gl_centry_info;
	size_t gl_centry_info_size;
	struct walk_info *winfo;


	winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP);

	/* get start of the cache entry metadata */
	if (mdb_readvar(&gl_centry_info, "_sdbc_gl_centry_info") == -1) {
		mdb_warn("failed to read  _sdbc_gl_centry_info");
		return (WALK_ERR);
	}

	/* need to calculate the end of the array */
	if (mdb_readvar(&gl_centry_info_size,
				"_sdbc_gl_centry_info_size") == -1) {
		mdb_warn("failed to read  _sdbc_gl_centry_info_size");
		return (WALK_ERR);
	}

	if (wsp->walk_addr == NULL)
		wsp->walk_addr = (uintptr_t)(gl_centry_info);



	winfo->w_end = ((uintptr_t)(gl_centry_info)) + gl_centry_info_size;
	wsp->walk_data = winfo;

	return (WALK_NEXT);
}

static int
sdbc_glcinfo_wstep(mdb_walk_state_t *wsp)
{
	struct walk_info *winfo = wsp->walk_data;
	int status;

	if (wsp->walk_addr == NULL)
		return (WALK_DONE);

	if (wsp->walk_addr >= winfo->w_end)
		return (WALK_DONE);
	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
						wsp->walk_cbdata);

	wsp->walk_addr += sizeof (ss_centry_info_t);

	return (status);
}

static void
sdbc_glcinfo_wfini(mdb_walk_state_t *wsp)
{
	mdb_free(wsp->walk_data, sizeof (struct walk_info));
}

/*
 * walk the global file info array
 */
static int
sdbc_glfinfo_winit(mdb_walk_state_t *wsp)
{
	ss_voldata_t *gl_file_info;
	struct walk_info *winfo;
	int maxdevs;


	winfo = mdb_zalloc(sizeof (struct walk_info), UM_SLEEP);

	/* get start of the cache entry metadata */
	if (mdb_readvar(&gl_file_info, "_sdbc_gl_file_info") == -1) {
		mdb_warn("failed to read  _sdbc_gl_file_info");
		return (WALK_ERR);
	}


	if (wsp->walk_addr == NULL)
		wsp->walk_addr = (uintptr_t)(gl_file_info);

	/* get the number of volumes */
	if (mdb_readvar(&maxdevs, "sdbc_max_devs") == -1) {
		mdb_warn("failed to read  sdbc_max_devs");
		return (WALK_ERR);
	}

	/* end of the array */
	winfo->w_end = (uintptr_t)((gl_file_info) + maxdevs);

	wsp->walk_data = winfo;

	return (WALK_NEXT);
}

static int
sdbc_glfinfo_wstep(mdb_walk_state_t *wsp)
{
	struct walk_info *winfo = wsp->walk_data;
	int status;

	if (wsp->walk_addr == NULL)
		return (WALK_DONE);

	if (wsp->walk_addr >= winfo->w_end)
		return (WALK_DONE);

	status = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
						wsp->walk_cbdata);

	wsp->walk_addr += sizeof (ss_voldata_t);

	return (status);

}

static void
sdbc_glfinfo_wfini(mdb_walk_state_t *wsp)
{
	mdb_free(wsp->walk_data, sizeof (struct walk_info));
}

/* end of WALKERS section */


const mdb_bitmask_t cc_flag_bits[] = {
	{"PEND_DIRTY", CC_PEND_DIRTY, CC_PEND_DIRTY},
	{"PINNED", CC_PINNED, CC_PINNED},
	{"PINNABLE", CC_PINNABLE, CC_PINNABLE},
	{"QHEAD", CC_QHEAD, CC_QHEAD},
	{NULL, 0, 0}
};

const mdb_bitmask_t io_status_bits[] = {
	{"IO_NONE", 0xff, _SD_IO_NONE},
	{"IO_INITIATE", 0xff, _SD_IO_INITIATE},
	{"IO_DONE", 0xff, _SD_IO_DONE},
	{"IO_FAILED", 0xff, _SD_IO_FAILED},
	{"IO_DISCARDED", 0xff, _SD_IO_DISCARDED},
	{NULL, 0, 0}
};

const mdb_bitmask_t cc_aging_bits[] = {
	{"FOUND_IN_HASH", FOUND_IN_HASH_DM, FOUND_IN_HASH_DM},
	{"FOUND_HOLD_OVER", FOUND_HOLD_OVER_DM, FOUND_HOLD_OVER_DM},
	{"HOST_ENTRY", HOST_ENTRY_DM, HOST_ENTRY_DM},
	{"PARASITIC_ENTRY", PARASITIC_ENTRY_DM, PARASITIC_ENTRY_DM},
	{"STICKY_METADATA", STICKY_METADATA_DM, STICKY_METADATA_DM},
	{"ELIGIBLE_ENTRY", ELIGIBLE_ENTRY_DM, ELIGIBLE_ENTRY_DM},
	{"HASH_ENTRY", HASH_ENTRY_DM, HASH_ENTRY_DM},
	{"HOLD_ENTRY", HOLD_ENTRY_DM, HOLD_ENTRY_DM},
	{"AVAIL_ENTRY", AVAIL_ENTRY_DM, AVAIL_ENTRY_DM},
	{"BAD_CHAIN", BAD_CHAIN_DM, BAD_CHAIN_DM},
	{"BAD_ENTRY", BAD_ENTRY_DM, BAD_ENTRY_DM},
	{"PREFETCH_I", PREFETCH_BUF_I, PREFETCH_BUF_I},
	{"PREFETCH_E", PREFETCH_BUF_E, PREFETCH_BUF_E},
	{NULL, 0, 0}
};


/* DCMDS that use walkers */

/*
 * dcmd to display cache entry control structures
 */
static int
sdbc_cctl(uintptr_t addr, uint_t flags, int argc,
					const mdb_arg_t *argv)
{
	uint_t opt_a = FALSE;
	uintptr_t opt_c = MDB_CD;    /* cd */
	uintptr_t opt_b = MDB_BLKNUM;    /* block num */
	uint_t opt_B = FALSE;    /* BAD CHAIN or ENTRY */
	uint_t opt_d = FALSE;    /* dirty */
	uint_t opt_H = FALSE;    /* HOST */
	uint_t opt_h = FALSE;    /* hashed */
	uint_t opt_i = FALSE;    /* inuse */
	uint_t opt_p = FALSE;    /* pageio */
	uint_t opt_P = FALSE;    /* PARASITE */
	uint_t opt_R = FALSE;    /* explicit read-ahead (prefetch) */
	uint_t opt_r = FALSE;    /* implicit read-ahead (prefetch) */
	uint_t opt_o = FALSE;    /* io in progress */
	uint_t opt_m = FALSE;	 /* has memory allocated */
	uint_t opt_V = FALSE;    /* valid bits */
	uint_t opt_v = FALSE;    /* verbose */
	uint_t nofilter = FALSE; /* true if b, d, h, i, o, p, V are all false */
	_sd_cctl_t centry;
	_sd_cctl_sync_t cc_sync;

	/*
	 * possible enhancements -- option to filter on flag bits
	 * option that toggles other options.
	 */
	if (mdb_getopts(argc, argv,
			'a', MDB_OPT_SETBITS, TRUE, &opt_a,
			'B', MDB_OPT_SETBITS, TRUE, &opt_B,
			'b', MDB_OPT_UINTPTR, &opt_b,
			'c', MDB_OPT_UINTPTR, &opt_c,
			'd', MDB_OPT_SETBITS, TRUE, &opt_d,
			'H', MDB_OPT_SETBITS, TRUE, &opt_H,
			'h', MDB_OPT_SETBITS, TRUE, &opt_h,
			'i', MDB_OPT_SETBITS, TRUE, &opt_i,
			'o', MDB_OPT_SETBITS, TRUE, &opt_o,
			'm', MDB_OPT_SETBITS, TRUE, &opt_m,
			'P', MDB_OPT_SETBITS, TRUE, &opt_P,
			'p', MDB_OPT_SETBITS, TRUE, &opt_p,
			'R', MDB_OPT_SETBITS, TRUE, &opt_R,
			'r', MDB_OPT_SETBITS, TRUE, &opt_r,
			'V', MDB_OPT_SETBITS, TRUE, &opt_V,
			'v', MDB_OPT_SETBITS, TRUE, &opt_v) != argc)
		return (DCMD_USAGE);


	nofilter = (!OPT_B_SELECTED && !opt_d && !opt_h && !opt_i &&
			!opt_o && !opt_m && !opt_p && !opt_V && !opt_B &&
			!opt_P && !opt_H && !opt_R && !opt_r); /* no options */

	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_walk_dcmd("sdbc`sdbc_cctl", "sdbc`sdbc_cctl",
					argc, argv) == -1) {
			mdb_warn("failed to walk 'cctl' list");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("sdbc cache ctl structures:\n");
	}


	if (mdb_vread(&centry, sizeof (_sd_cctl_t), addr) == -1) {
		mdb_warn("dcmd failed to read centry at %p", addr);
		return (DCMD_ERR);
	}

	/* filter exclusively on a cd number if specified */
	if (OPT_C_SELECTED && (centry.cc_head.hh_cd != opt_c))
		return (DCMD_OK);

	/* all other filters are inclusive */
	if ((nofilter) ||
		(OPT_B_SELECTED && (centry.cc_head.hh_blk_num == opt_b)) ||
		(opt_B && (centry.cc_aging_dm &
			(BAD_ENTRY_DM | BAD_CHAIN_DM))) ||
		(opt_d && (centry.cc_dirty)) ||
		(opt_H && (centry.cc_aging_dm & HOST_ENTRY_DM)) ||
		(opt_h && (centry.cc_head.hh_hashed)) ||
		(opt_i && (centry.cc_inuse)) ||
		(opt_p && (centry.cc_pageio)) ||
		(opt_P && (centry.cc_aging_dm & PARASITIC_ENTRY_DM)) ||
		(opt_R && (centry.cc_aging_dm & PREFETCH_BUF_E)) ||
		(opt_r && (centry.cc_aging_dm & PREFETCH_BUF_I)) ||
		(opt_V && (centry.cc_valid)) ||
		(opt_m && (centry.cc_alloc_size_dm)) ||
		(opt_o && (centry.cc_iostatus != _SD_IO_NONE)))
		/*EMPTY*/;
	else
		return (DCMD_OK);

	mdb_inc_indent(4);
	mdb_printf(
	"%-?p cd %3-d blk_num %10-d valid %04hx dirty %04hx flag %02x\n",
			addr, centry.cc_head.hh_cd,
			centry.cc_head.hh_blk_num, centry.cc_valid,
			centry.cc_dirty, centry.cc_flag);
	mdb_dec_indent(4);

	if (!opt_v)
		return (DCMD_OK);

	/* verbose */
	mdb_inc_indent(4);
	mdb_printf(
	"hashed %d seq %4-d toflush %04hx %8Tawait_use %4-d await_page %4-d\n",
		centry.cc_head.hh_hashed, centry.cc_seq,
		centry.cc_toflush, centry.cc_await_use,
		centry.cc_await_page);

	mdb_printf("inuse %d pageio %d cc_flag <%b>\n",
		centry.cc_inuse, centry.cc_pageio,
		centry.cc_flag, cc_flag_bits);

	mdb_printf("iocount %2d iostatus <%b>\n",
		    centry.cc_iocount, centry.cc_iostatus, io_status_bits);

	if (mdb_vread(&cc_sync, sizeof (struct _sd_cctl_sync),
					(uintptr_t)centry.cc_sync)
		== -1)
		mdb_warn("failed to read cc_sync"); /* not catastophic */

	else
		mdb_printf("cc_sync blkcv: %h-x %8Tlock: 0x%p (owner)\n",
				cc_sync._cc_blkcv._opaque,
				cc_sync._cc_lock._opaque[0]);

	mdb_printf("dynamic memory allocation:\n");
	mdb_inc_indent(4);
	mdb_printf("aging_dm age %3d %4Tage flags: <%b> 0x%x\n",
			centry.cc_aging_dm & 0xff,
			centry.cc_aging_dm, cc_aging_bits, centry.cc_aging_dm);

	mdb_printf("alloc_size_dm %10-d head_dm %?-p\n",
		centry.cc_alloc_size_dm, centry.cc_head_dm);
	mdb_printf("next_dm %?-p link_list_dm %?-p\n",
		centry.cc_next_dm, centry.cc_link_list_dm);

	mdb_printf("alloc_ct_dm %10-d dealloc_ct_dm %10-d\n",
		centry.cc_alloc_ct_dm, centry.cc_dealloc_ct_dm);

	mdb_dec_indent(4);
	/* pointers */
	mdb_printf("cctl pointers:\n");
	mdb_inc_indent(4);

	mdb_printf("next %?-p prev %?-p chain %?-p\n",
		centry.cc_next, centry.cc_prev, centry.cc_chain);
	mdb_printf("dirty_next %?-p dirty_link %?-p\n",
		centry.cc_dirty_next, centry.cc_dirty_link);
	mdb_printf("data %?-p write ctl %?-p\n",
		centry.cc_data, centry.cc_write);

	mdb_dec_indent(4);

	/* dynmem chain */
	mdb_printf("cctl dmqueue index cc_blocks %4-d\n", centry.cc_cblocks);

	mdb_printf("anon_addr %?-p anon_len %8-d\n",
			centry.cc_anon_addr.sa_virt, centry.cc_anon_len);

	/* stats */
	mdb_printf("cctl stats:	");
	mdb_inc_indent(4);
	mdb_printf("hits %8-d creat time %?-p\n", centry.cc_hits,
			centry.cc_creat);
	mdb_dec_indent(4);

	mdb_printf("\n");

	mdb_dec_indent(4);

	return (DCMD_OK);
}


/*
 * convenience dcmd to display the _sd_cctl cc_chain list (alloc list)
 * Must be called with an address of a cache entry (_sd_cctl_t)
 * same options as sdbc_cctl().
 * alternatively the user can call the sdbc_cchain walker
 * and pipe the addresses to sdbc_cctl dcmd.
 */
static int
sdbc_cchain(uintptr_t addr, uint_t flags, int argc,
					const mdb_arg_t *argv)
{

	if (!(flags & DCMD_ADDRSPEC))
		return (DCMD_USAGE);

	if (mdb_pwalk_dcmd("sdbc`sdbc_cchain", "sdbc`sdbc_cctl",
						argc, argv, addr)
			== -1) {
		mdb_warn("failed to walk cc_chain at addr %p", addr);
		return (DCMD_ERR);
	}

	return (DCMD_OK);
}


/*
 * convenience dcmd to cdisplay the _sd_cctl dirty chain
 * (which is really a 2d chain).
 * Must be called with an address of a cache entry (_sd_cctl_t)
 * same options as sdbc_cctl().
 * alternatively the user can call the sdbc_dchain walker
 * and pipe the addresses to sdbc_cctl dcmd.
 */
static int
sdbc_dchain(uintptr_t addr, uint_t flags, int argc,
					const mdb_arg_t *argv)
{

	if (!(flags & DCMD_ADDRSPEC))
		return (DCMD_USAGE);

	if (mdb_pwalk_dcmd("sdbc`sdbc_dchain", "sdbc`sdbc_cctl",
						argc, argv, addr)
			== -1) {
		mdb_warn("failed to walk dirty chain at addr %p", addr);
		return (DCMD_ERR);
	}

	return (DCMD_OK);
}

/*
 * convenience dcmd to display the _sd_cctl dm chain list
 * Must be called with an address of a cache entry (_sd_cctl_t)
 * same options as sdbc_cctl().
 * alternatively the user can call the sdbc_dmchain walker
 * and pipe the addresses to sdbc_cctl dcmd.
 */
static int
sdbc_dmchain(uintptr_t addr, uint_t flags, int argc,
					const mdb_arg_t *argv)
{

	if (!(flags & DCMD_ADDRSPEC))
		return (DCMD_USAGE);

	if (mdb_pwalk_dcmd("sdbc`sdbc_dmchain", "sdbc`sdbc_cctl",
						argc, argv, addr)
			== -1) {
		mdb_warn("failed to walk dm chain at addr %p", addr);
		return (DCMD_ERR);
	}

	return (DCMD_OK);
}

/*
 * dcmd to walk a hash chain
 * requires an address. same options as sdbc_cctl dcmd
 */
static int
sdbc_hashchain(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	if (!(flags & DCMD_ADDRSPEC))
		return (DCMD_USAGE);

	if (mdb_pwalk_dcmd("sdbc`sdbc_hashchain", "sdbc`sdbc_cctl",
					argc, argv, addr) == -1) {
		mdb_warn("failed to walk hashchain at %p", addr);
		return (DCMD_ERR);
	}

	return (DCMD_OK);
}


static void
display_hash_table(_sd_hash_table_t *addr, _sd_hash_table_t *ht)
{
	mdb_printf("hash table (%p):\n", addr);
	mdb_inc_indent(4);
	mdb_printf("size %7-d bits %2-d mask %8-x nmask %8-x buckets %p\n",
		ht->ht_size, ht->ht_bits, ht->ht_mask,
		ht->ht_nmask, ht->ht_buckets);
	mdb_dec_indent(4);
}

static void
display_hash_bucket(_sd_hash_bucket_t *addr, _sd_hash_bucket_t *hb)
{
	kmutex_t lock;
	int rc;

	if ((rc = mdb_vread(&lock, sizeof (kmutex_t),
				(uintptr_t)hb->hb_lock)) == -1)
		mdb_warn("failed to read bucket lock at %p", hb->hb_lock);

	mdb_printf("hash bucket (%p):\n", addr);
	mdb_inc_indent(4);
	mdb_printf("head %?-p tail %?-p lock %?-p %s\n",
		hb->hb_head, hb->hb_tail,
		(rc == -1) ? hb->hb_lock : lock._opaque[0],
		(rc == -1) ? "" : "(owner)");
	mdb_printf("inlist %d seq %d\n", hb->hb_inlist, hb->hb_seq);
	mdb_dec_indent(4);
}

/*
 * dcmd to walk the hash table
 * defaults to _sd_htable the cache hash table,
 * but wil accept an address which is probably only useful
 * in the event that other hash tables are implemented in
 * the cache.
 *
 * calls sdbc_hashchain dcmd.  same options as sdbc_cctl dcmd.
 */
static int
sdbc_hashtable(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	_sd_hash_table_t *sd_htable_addr;
	_sd_hash_table_t _sd_htable;
	_sd_hash_bucket_t hash_bucket;
	int i;



	if (!(flags & DCMD_ADDRSPEC)) {
		/* get the address of the standard cache hash table */
		if (mdb_readvar(&sd_htable_addr, "_sd_htable") == -1) {
			mdb_warn("failed to read _sd_htable address\n");
			return (DCMD_ERR);
		}
	} else
		sd_htable_addr = (_sd_hash_table_t *)addr;

	/* read in the hash table structure */
	if (mdb_vread(&_sd_htable, sizeof (_sd_hash_table_t),
		(uintptr_t)sd_htable_addr) == -1) {
		mdb_warn("failed to read _sd_htable structure at %p\n",
						    sd_htable_addr);
		return (DCMD_ERR);
	}

	display_hash_table(sd_htable_addr, &_sd_htable);

	/*
	 * read in the hash buckets
	 * and display chains if there are any
	 */
	for (i = 0; i < _sd_htable.ht_size; ++i) {
		if (mdb_vread(&hash_bucket, sizeof (_sd_hash_bucket_t),
			    (uintptr_t)(_sd_htable.ht_buckets + i)) == -1) {
			mdb_warn("failed to read ht_buckets at %p\n",
					    _sd_htable.ht_buckets + i);
			return (DCMD_ERR);
		}

		if (hash_bucket.hb_head != NULL) {
			display_hash_bucket(_sd_htable.ht_buckets + i,
							&hash_bucket);
			/*
			 * if this walk fails, continue trying
			 * to read hash buckets
			 */
			if (mdb_call_dcmd("sdbc`sdbc_hashchain",
					(uintptr_t)hash_bucket.hb_head,
					flags|DCMD_ADDRSPEC, argc, argv)
								    == -1)
				    mdb_warn(
					    "failed to walk hash chain at %p",
					hash_bucket.hb_head);
			    mdb_printf("\n");
		    }
	}

	return (DCMD_OK);
}
/*
 * dcmd to display the sdbc lru queue
 * same options as sdbc_cctl().
 * alternatively the user can call the sdbc_lru walker
 * and pipe the addresses to sdbc_cctl dcmd.
 */
static int
sdbc_lru(uintptr_t addr, uint_t flags, int argc,
					const mdb_arg_t *argv)
{
	_sd_queue_t _sd_lru_q;
	GElf_Sym sym;

	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_lookup_by_obj("sdbc", "_sd_lru_q", &sym) == -1) {
			mdb_warn("failed to lookup _sd_lru_q symbol");
			return (DCMD_ERR);
		}

		if (mdb_vread(&_sd_lru_q, sizeof (_sd_queue_t),
						sym.st_value) == -1) {
			mdb_warn("failed to read _sd_lru_q structure");
			return (DCMD_ERR);
		}

		mdb_printf("Cache LRU Queue\n");
		mdb_inc_indent(4);
		mdb_printf(
		"qlock: 0x%-p (owner) await %d seq %d inq %d req %d noreq %d\n",
			_sd_lru_q.sq_qlock._opaque[0],
			_sd_lru_q.sq_await,
			_sd_lru_q.sq_seq,
			_sd_lru_q.sq_inq,
			_sd_lru_q.sq_req_stat,
			_sd_lru_q.sq_noreq_stat);

		addr = (uintptr_t)(sym.st_value);
	}

	if (mdb_pwalk_dcmd("sdbc`sdbc_lru", "sdbc`sdbc_cctl",
					argc, argv, addr) == -1) {
		mdb_warn("failed to walk lru at addr %p", addr);
		return (DCMD_ERR);
	}

	return (DCMD_OK);
}

#ifdef SAFESTORE
static void
print_wrq(_sd_writeq_t *wrq, uint_t verbose)
{
	int i;

	mdb_printf("Cache Write Ctl Queue:\n");
	mdb_inc_indent(4);
	mdb_printf("qtop %-p qlock: %-p (owner) inq %d\n",
		wrq->wq_qtop,
		wrq->wq_qlock._opaque[0],
		wrq->wq_inq);

	mdb_printf("slp_top %3-d slp_index %3-d slp_inq %3-d\n",
		wrq->wq_slp_top,
		wrq->wq_slp_index,
		wrq->wq_slp_inq);

	for (i = 0; verbose && i < SD_WR_SLP_Q_MAX; i += 2) {
		mdb_printf("%3d: cv %h-x wq_need %3-d wq_held %3-d%4T",
			i,
			wrq->wq_slp[i].slp_wqcv._opaque,
			wrq->wq_slp[i].slp_wqneed,
			wrq->wq_slp[i].slp_wqheld);
		if (SD_WR_SLP_Q_MAX > (i + 1)) {
			mdb_printf(
			"%3d: cv %h-x wq_need %3-d wq_held %3-d%\n",
			    i+1,
			    wrq->wq_slp[i+1].slp_wqcv._opaque,
			    wrq->wq_slp[i+1].slp_wqneed,
			    wrq->wq_slp[i+1].slp_wqheld);
		}
	}
	mdb_dec_indent(4);
}

/*
 * dcmd to display write control structures
 */

static int
sdbc_wctl(uintptr_t addr, uint_t flags, int argc,
					const mdb_arg_t *argv)
{
	_sd_wr_cctl_t wctl;
	ss_centry_info_t gl_info;
	ss_centry_info_t nv_gl_info;
	uintptr_t opt_c = MDB_CD;
	uint_t opt_d = FALSE;
	uint_t opt_v = FALSE;


	/* TODO option for fba pos */
	if (mdb_getopts(argc, argv,
			'd', MDB_OPT_SETBITS, TRUE, &opt_d,
			'c', MDB_OPT_UINTPTR, &opt_c,
			'v', MDB_OPT_SETBITS, TRUE, &opt_v) != argc)
		return (DCMD_USAGE);


	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_walk_dcmd("sdbc`sdbc_wctl", "sdbc`sdbc_wctl",
					argc, argv) == -1) {
			mdb_warn("failed to walk write ctl array");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("write control block structures:\n");
	}

	if (mdb_vread(&wctl, sizeof (_sd_wr_cctl_t), addr) == -1) {
		mdb_warn("failed to read wctl at 0x%p", addr);
		return (DCMD_ERR);
	}


	/*
	 * print "all" is the default.
	 * filter conditions can only be checked by reading in wc_gl_info
	 */
	if (opt_c || opt_d || opt_v)
	    if (mdb_vread(&gl_info, sizeof (ss_centry_info_t),
				(uintptr_t)wctl.wc_gl_info) == -1) {
		    mdb_warn("failed to read at wc_gl_info 0x%p", addr);
		return (DCMD_ERR);
	}


	if (OPT_C_SELECTED && (gl_info.gl_cd != opt_c))
		return (DCMD_OK);

	if (opt_d && !(gl_info.gl_dirty))
		return (DCMD_OK);

	mdb_inc_indent(4);
	mdb_printf("%-p data %-p gl_info %-p Ngl_info %-p flg %02x\n",
		addr,
		wctl.wc_data,
		wctl.wc_gl_info,
		wctl.wc_nvmem_gl_info,
		wctl.wc_flag);
	mdb_dec_indent(4);

	/* verbose */
	if (!opt_v)
		return (DCMD_OK);

	mdb_inc_indent(4);
	mdb_printf("next %?-p prev %?-p\n", wctl.wc_next, wctl.wc_prev);
	mdb_printf("      gl_info: ");
	mdb_printf("cd %3-d fpos %10-d dirty %04x flag <%b>\n",
		gl_info.gl_cd, gl_info.gl_fpos, gl_info.gl_dirty & 0xffff,
		gl_info.gl_flag, cc_flag_bits);

	if (wctl.wc_nvmem_gl_info) {
	    if (mdb_vread(&nv_gl_info, sizeof (ss_centry_info_t),
				(uintptr_t)wctl.wc_nvmem_gl_info) == -1) {
		    mdb_warn("failed to read at wc_nvmem_gl_info 0x%p",
		    wctl.wc_nvmem_gl_info);  /* not catastophic, continue */
	    } else {

		    /* consistency check */
			if (memcmp(&gl_info, &nv_gl_info,
					sizeof (ss_centry_info_t) != 0)) {
			mdb_warn("nvram and host memory are NOT identical!");
			mdb_printf("nvmem_gl_info: ");
			mdb_printf("cd %3-d fpos %10-d dirty %04x flag <%b>\n",
			nv_gl_info.gl_cd, nv_gl_info.gl_fpos,
			nv_gl_info.gl_dirty & 0xffff,
			nv_gl_info.gl_flag, cc_flag_bits);
		    }

	    }
	}

	mdb_dec_indent(4);
	mdb_printf("\n");
	return (DCMD_OK);
}

/*
 * dcmd to display write control structures in the free list
 * same options as sdbc_wctl
 */

static int
sdbc_wrq(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	_sd_net_t _sd_net_config;
	uintptr_t opt_c = MDB_CD;
	uint_t opt_d = FALSE;
	uint_t opt_v = FALSE;


	/* look for verbose option */
	if (mdb_getopts(argc, argv,
			'd', MDB_OPT_SETBITS, TRUE, &opt_d,
			'c', MDB_OPT_UINTPTR, &opt_c,
			'v', MDB_OPT_SETBITS, TRUE, &opt_v) != argc)
		return (DCMD_USAGE);

	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_readvar(&_sd_net_config, "_sd_net_config") == -1) {
			mdb_warn("failed to read _sd_net_config structure");
			return (DCMD_ERR);
		}

		print_wrq(&(_sd_net_config.sn_wr_queue), opt_v);

		addr = (uintptr_t)(_sd_net_config.sn_wr_queue.wq_qtop);
	}

	if (mdb_pwalk_dcmd("sdbc`sdbc_wrq", "sdbc`sdbc_wctl",
					argc, argv, addr) == -1) {
		mdb_warn("failed to walk write ctl queue at addr %p", addr);
		return (DCMD_ERR);
	}
	return (DCMD_OK);
}
#endif

/*
 * dcmd to display the dm queues
 * use sdbc_lru walker to walk each queue.
 */
/*ARGSUSED*/
static int
sdbc_dmqueues(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	_sd_queue_t *sdbc_dm_queues; /* kernel address of dm queues */
	int max_dm_queues;
	_sd_queue_t *queues = NULL; /* local copy */
	int i;


	if (argc != 0)
		return (DCMD_USAGE);

	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_readvar(&sdbc_dm_queues, "sdbc_dm_queues") == -1) {
			mdb_warn("failed to read sdbc_dm_queues address\n");
			return (DCMD_ERR);
		}

		if (mdb_readvar(&max_dm_queues, "max_dm_queues") == -1) {
			mdb_warn("failed to read max_dm_queues variable\n");
			return (DCMD_ERR);
		}

		queues = mdb_zalloc(max_dm_queues * sizeof (_sd_queue_t),
					UM_SLEEP);
mdb_printf("max_dm_queues %d sdbc_dm_queues %p queues %p\n",
		max_dm_queues, sdbc_dm_queues, queues);

		if (mdb_vread(queues, max_dm_queues * sizeof (_sd_queue_t),
					(uintptr_t)sdbc_dm_queues) == -1) {
			mdb_warn("failed to read sdbc_dm_queues");
			return (DCMD_ERR);
		}

		for (i = 0;  i < max_dm_queues; ++i) {
			mdb_printf("Cache DM Queue %d %p\n",
					queues[i].sq_dmchain_cblocks,
					sdbc_dm_queues +i);
			mdb_inc_indent(4);
			mdb_printf("qlock: 0x%-p (owner) await %d "
					"seq %d inq %d req %d noreq %d\n",
					queues[i].sq_qlock._opaque[0],
					queues[i].sq_await,
					queues[i].sq_seq,
					queues[i].sq_inq,
					queues[i].sq_req_stat,
					queues[i].sq_noreq_stat);

			mdb_dec_indent(4);
		}
	}

	return (DCMD_OK);
}


mdb_bitmask_t cd_writer_bits[] = {
	{ "NONE   ", (u_longlong_t)~0, _SD_WRITER_NONE },
	{ "CREATE ", (u_longlong_t)~0, _SD_WRITER_CREATE },
	{ "RUNNING", (u_longlong_t)~0, _SD_WRITER_RUNNING },
	{ NULL, 0, 0 }
};

mdb_bitmask_t sh_failed_status[] = {
	{ "STATUS OK", (u_longlong_t)~0, 0 },
	{ "I/O ERROR", (u_longlong_t)~0, 1 },
	{ "OPEN FAIL", (u_longlong_t)~0, 2 },
	{ NULL, 0, 0 }
};

mdb_bitmask_t sh_flag_bits[] = {
	{ "ATTACHED", CD_ATTACHED, CD_ATTACHED },
	{ NULL, 0, 0 }
};

mdb_bitmask_t sh_alloc_bits[] = {
	{ "ALLOC_IN_PROGRESS", CD_ALLOC_IN_PROGRESS, CD_ALLOC_IN_PROGRESS },
	{ "ALLOCATED", CD_ALLOCATED, CD_ALLOCATED },
	{ "CLOSE_IN_PROGRESS", CD_CLOSE_IN_PROGRESS, CD_CLOSE_IN_PROGRESS },
	{ NULL, 0, 0 }
};

/*
 * dcmd to display cd information
 */
static int
sdbc_cdinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	_sd_shared_t sd_shared;
	_sd_cd_info_t cdi;
	ss_voldata_t gl_file;
	char *fn = "nopath"; /* filename if sd_shared info cannot be read */
	uchar_t sh_alloc = 0; /* assume not alloc'd if sd_shared info unavail */
	uintptr_t opt_c = MDB_CD;
	uint_t opt_a = FALSE;
	uint_t opt_v = FALSE;
	int dev_t_chars;

	dev_t_chars = sizeof (dev_t) * 2;	/* # chars to display dev_t */


	if (mdb_getopts(argc, argv,
			'a', MDB_OPT_SETBITS, TRUE, &opt_a,
			'c', MDB_OPT_UINTPTR, &opt_c,
			'v', MDB_OPT_SETBITS, TRUE, &opt_v) != argc)
		return (DCMD_USAGE);

	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_walk_dcmd("sdbc`sdbc_cdinfo", "sdbc`sdbc_cdinfo",
					argc, argv) == -1) {
			mdb_warn("failed to walk cd info array");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("cd info structures:\n");
	}

	if (mdb_vread(&cdi, sizeof (_sd_cd_info_t), addr) == -1) {
		mdb_warn("failed to read cd info at 0x%p", addr);
		return (DCMD_ERR);
	}

	/*
	 * need to do this read even for non-verbose option to
	 * get the filename and the sh_alloc field
	 */
	if (cdi.cd_info) {
	    if (mdb_vread(&sd_shared, sizeof (_sd_shared_t),
				    (uintptr_t)cdi.cd_info) == -1) {
		    mdb_warn("failed to read shared cd info at 0x%p",
						    cdi.cd_info);
		    /* not catastrophic, keep truckin' */
	    } else {
		    fn = sd_shared.sh_filename;
		    sh_alloc = sd_shared.sh_alloc;
	    }
	}

	if (!opt_a && (sh_alloc == 0))
		return (DCMD_OK);

	if (OPT_C_SELECTED && (opt_c != cdi.cd_desc))
		return (DCMD_OK);

	mdb_inc_indent(4);
	mdb_printf("%p cd %3-d filename %s\n",
		addr, cdi.cd_desc, fn);
	mdb_printf("alloc <%b> hint <%b>\n",
		sh_alloc, sh_alloc_bits,
		cdi.cd_hint, cache_hints);
	mdb_dec_indent(4);

	if (!opt_v)
		return (DCMD_OK);

	/* verbose */
	mdb_inc_indent(4);
	mdb_printf("rawfd %?-p crdev %0*lx iodev %?-p\n",
		cdi.cd_rawfd,
		dev_t_chars,
		cdi.cd_crdev,
		cdi.cd_iodev);
	mdb_printf("flag %x %8Tlock %?-p writer <%b>\n",
		cdi.cd_flag,
		cdi.cd_lock._opaque[0],
		cdi.cd_writer, cd_writer_bits);
	mdb_printf("global %?-p dirty_head %?-p\n",
		cdi.cd_global, cdi.cd_dirty_head);
	mdb_printf("last_ent %?-p lastchain_ptr %?-p lastchain %d\n",
		cdi.cd_last_ent, cdi.cd_lastchain_ptr,
		cdi.cd_lastchain);
	mdb_printf("io_head %?-p io_tail %?-p fail_head %?-p\n",
		cdi.cd_io_head, cdi.cd_io_tail, cdi.cd_fail_head);
	mdb_printf(
	    "cd_info %?-p failover %d recovering %d write_inprogress %d\n",
		cdi.cd_info, cdi.cd_failover,
		cdi.cd_recovering,
		cdi.cd_write_inprogress);

	if (cdi.cd_global != NULL) {
		if (mdb_vread(&gl_file, sizeof (ss_voldata_t),
					(uintptr_t)cdi.cd_global) == -1)
			mdb_warn("failed to read cd_global at %p",
						    cdi.cd_global);
		else {
			mdb_printf("cd_global: %s\n", gl_file.sv_volname);
			mdb_printf("pinned %2-d attached %2-d devidsz %3-d\n",
				gl_file.sv_pinned, gl_file.sv_attached,
				gl_file.sv_devidsz);
			mdb_printf("devid %s\n", gl_file.sv_devid);
			mdb_printf("vol %?p\n", gl_file.sv_vol);
		}
		/* TODO do a consistency check here against the nvram copy */
	}

	if (cdi.cd_info == NULL) {
		mdb_printf("no shared info\n");
	} else {
		mdb_printf("shared:\n");
		mdb_printf("failed <%b> cd %3-d",
		    sd_shared.sh_failed, sh_failed_status,
		    sd_shared.sh_cd);
		mdb_printf("cache_read %10-d cache_write %10-d\n",
		    sd_shared.sh_cache_read, sd_shared.sh_cache_write);
		mdb_printf("disk_read %10-d disk_write %10-d filesize %10-d\n",
		    sd_shared.sh_disk_read, sd_shared.sh_disk_write,
		    sd_shared.sh_filesize);
		mdb_printf("numdirty %8-d numio %8-d numfail %8-d\n",
		    sd_shared.sh_numdirty,
		    sd_shared.sh_numio,
		    sd_shared.sh_numfail);
		mdb_printf("flushloop %2-d sh_flag <%b>\n",
		    sd_shared.sh_flushloop, sd_shared.sh_flag, sh_flag_bits);

		/* this can be really verbose */
		if (cdi.cd_dirty_head) {
			mdb_printf("Dirty Chain (cd_dirty_head):");
			/* TODO reconstruct argv without opt_a */
			if (!opt_a)
				mdb_call_dcmd("sdbc_dchain",
					(uintptr_t)cdi.cd_dirty_head,
					flags, argc, argv);
			else /* print with no options */
				mdb_call_dcmd("sdbc_dchain",
					(uintptr_t)cdi.cd_dirty_head,
					flags, 0, NULL);
		}

		if (cdi.cd_io_head) {
			mdb_printf("I/O Pending Chain (cd_io_head):");
			/* TODO reconstruct argv without opt_a */
			if (!opt_a)
				mdb_call_dcmd("sdbc_dchain",
					(uintptr_t)cdi.cd_io_head,
					flags, argc, argv);
			else /* print with no options */
				mdb_call_dcmd("sdbc_dchain",
					(uintptr_t)cdi.cd_dirty_head,
					flags, 0, NULL);
		}

		if (cdi.cd_fail_head) {
			mdb_printf("Failed Chain (cd_fail_head):");
			/* TODO reconstruct argv without opt_a */
			if (!opt_a)
				mdb_call_dcmd("sdbc_dchain",
					(uintptr_t)cdi.cd_fail_head,
					flags, argc, argv);
			else /* print with no options */
				mdb_call_dcmd("sdbc_dchain",
					(uintptr_t)cdi.cd_dirty_head,
					flags, 0, NULL);
		}
	}

	mdb_dec_indent(4);

	mdb_printf("\n");

	return (DCMD_OK);
}

#ifdef SAFESTORE
/*
 * dcmd to display fault tolerant control structures
 */
static int
sdbc_ftctl(uintptr_t addr, uint_t flags, int argc,
					const mdb_arg_t *argv)
{
	_sd_ft_cctl_t ft_cent;
	ss_centry_info_t gl_info;
	ss_centry_info_t nv_gl_info;
	uintptr_t opt_c = MDB_CD;
	uint_t opt_d = FALSE;
	uint_t opt_v = FALSE;


	/* TODO option to select on fpos */
	if (mdb_getopts(argc, argv,
			'd', MDB_OPT_SETBITS, TRUE, &opt_d,
			'c', MDB_OPT_UINTPTR, &opt_c,
			'v', MDB_OPT_SETBITS, TRUE, &opt_v) != argc)
		return (DCMD_USAGE);


	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_walk_dcmd("sdbc`sdbc_ftctl", "sdbc`sdbc_ftctl",
					argc, argv) == -1) {
			mdb_warn("failed to walk write ctl array");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("Ft control block structures:\n");
	}

	if (mdb_vread(&ft_cent, sizeof (_sd_ft_cctl_t), addr) == -1) {
		mdb_warn("failed to read ft_cent at 0x%p", addr);
		return (DCMD_ERR);
	}


	/*
	 * print "all" is the default.
	 * filter conditions can only be checked by reading in wc_gl_info
	 */
	if (opt_c || opt_d || opt_v)
	    if (mdb_vread(&gl_info, sizeof (ss_centry_info_t),
				(uintptr_t)ft_cent.ft_gl_info) == -1) {
		mdb_warn("failed to read at wc_gl_info 0x%p", addr);
		return (DCMD_ERR);
	}


	if (OPT_C_SELECTED && (gl_info.gl_cd != opt_c))
		return (DCMD_OK);

	if (opt_d && !(gl_info.gl_dirty))
		return (DCMD_OK);

	mdb_inc_indent(4);
	mdb_printf("%-p data %?-p qnext %?-p\n",
		addr,
		ft_cent.ft_qnext,
		ft_cent.ft_data);
	mdb_printf("gl_info %?-p nvmem_gl_info %?-p\n",
		ft_cent.ft_gl_info,
		ft_cent.ft_nvmem_gl_info);
	mdb_dec_indent(4);

	/* verbose */
	if (!opt_v) {
		mdb_printf("\n");
		return (DCMD_OK);
	}

	mdb_inc_indent(4);
	mdb_printf("      gl_info: ");
	mdb_printf("cd %3-d fpos %10-d dirty %04x flag <%b>\n",
		gl_info.gl_cd, gl_info.gl_fpos, gl_info.gl_dirty & 0xffff,
		gl_info.gl_flag, cc_flag_bits);

	if (ft_cent.ft_nvmem_gl_info) {
	    if (mdb_vread(&nv_gl_info, sizeof (ss_centry_info_t),
				(uintptr_t)ft_cent.ft_nvmem_gl_info) == -1) {
		    mdb_warn("failed to read at ft_nvmem_gl_info 0x%p",
		    ft_cent.ft_nvmem_gl_info);  /* not catastophic, continue */
	    } else {
		    mdb_printf("nvmem_gl_info: ");
		    mdb_printf("cd %3-d fpos %10-d dirty %04x flag <%b>\n",
		    nv_gl_info.gl_cd, nv_gl_info.gl_fpos,
		    nv_gl_info.gl_dirty & 0xffff,
		    nv_gl_info.gl_flag, cc_flag_bits);

		    /* consistency check */
		    if (memcmp(&gl_info, &nv_gl_info, sizeof (ss_centry_info_t))
								!= 0) {
			mdb_warn("nvram and host memory are NOT identical!");
		    }

	    }
	}

	mdb_dec_indent(4);
	mdb_printf("\n");
	return (DCMD_OK);
}
#endif /* SAFESTORE */


/* dcmd to display buffer handles */
static int
sdbc_handles(uintptr_t addr, uint_t flags, int argc,
					const mdb_arg_t *argv)
{
	uint_t opt_a = FALSE;
	uintptr_t opt_c = MDB_CD;
	uint_t opt_v = FALSE;
	uint_t opt_C = FALSE;
	_sd_buf_hlist_t hl;
	_sd_buf_handle_t bh;


	if (mdb_getopts(argc, argv,
			'a', MDB_OPT_SETBITS, TRUE, &opt_a,
			'c', MDB_OPT_UINTPTR, &opt_c,
			'C', MDB_OPT_SETBITS, TRUE, &opt_C,
			'v', MDB_OPT_SETBITS, TRUE, &opt_v) != argc)
		return (DCMD_USAGE);


	if (mdb_readvar(&hl, "_sd_handle_list") == -1) {
		mdb_warn("failed to read _sd_handle_list structure");
		return (DCMD_ERR);
	}


	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_walk_dcmd("sdbc`sdbc_handles", "sdbc`sdbc_handles",
					argc, argv) == -1) {
			mdb_warn("failed to walk 'sdbc_handle_list'");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("Handle List Info:\n");

		mdb_inc_indent(4);
		mdb_printf("hl_top.bh_next: 0x%p\n", hl.hl_top.bh_next);
		mdb_printf("hl_lock: 0x%p (owner)\n", hl.hl_lock._opaque[0]);
		mdb_printf("hl_count: %hd\n", hl.hl_count);
		mdb_dec_indent(4);
		mdb_printf("buf handles:\n");
	}

	if (mdb_vread(&bh, sizeof (bh), addr) == -1) {
		mdb_warn("failed to read buf handle at 0x%p", addr);
		return (DCMD_ERR);
	}

	if (!opt_a && !(bh.bh_flag & (NSC_HALLOCATED | NSC_HACTIVE)))
		return (DCMD_OK);

	/*
	 * may get false matches on cd option --
	 * a cleared bh_cd field will match if user specified cd 0
	 */
	if (OPT_C_SELECTED && (bh.bh_cd != opt_c))
		return (DCMD_OK);

	mdb_inc_indent(4);
	mdb_printf("%p %8T cd %3-d %4T<%b> %x\n", addr, bh.bh_cd,
					bh.bh_flag, nsc_buf_bits, bh.bh_flag);

	/* check for verbose, avoid printing twice */
	if (!opt_v && opt_C) {
		mdb_printf("cc_chain: ");
		if (bh.bh_centry)
			mdb_call_dcmd("sdbc`sdbc_cchain",
			    (uintptr_t)bh.bh_centry, DCMD_ADDRSPEC, 0, NULL);
	}

	mdb_dec_indent(4);

	if (!opt_v)
		return (DCMD_OK);

	/* verbose */
	mdb_inc_indent(4);

	mdb_printf("callbacks: %-20a%-20a%-20a\n",
	    bh.bh_disconnect_cb, bh.bh_read_cb, bh.bh_write_cb);

	mdb_printf("centry %?p %8T next %?p\n",
				bh.bh_centry, bh.bh_next);
	mdb_printf("buffer:\n");

	mdb_inc_indent(4);
	mdb_printf("fd 0x%p pos %10d len %6d flag 0x%x\n",
		    bh.bh_buf.sb_fd, bh.bh_fba_pos, bh.bh_fba_len, bh.bh_flag);

	mdb_printf("alloc_thread %p busy_thread %p\n", bh.bh_alloc_thread,
			bh.bh_busy_thread);

	mdb_printf("err %4d %8T bh_vec 0x%p\n", bh.bh_error, bh.bh_vec);
	mdb_dec_indent(4);

	mdb_printf("bufvec (scatter gather list): %-?s %8T%-s\n",
						"ADDR", "LEN");
	{
		_sd_bufvec_t *bv, *endvec;


		/* todo check for (bh_vec != bh_bufvec) => readahead? */

		bv = bh.bh_bufvec;
		endvec = bv + _SD_MAX_BLKS;
		mdb_inc_indent(30);
		while (bv->bufaddr) {
			mdb_printf("%p    %8T%d\n", bv->bufaddr, bv->buflen);
			++bv;
			if (bv > endvec) {
				mdb_warn("END of bh_bufvec ARRAY");
				break;
			}
		}
		mdb_dec_indent(30);
	}

	if (opt_C) {
		mdb_printf("cc_chain: ");
		if (bh.bh_centry)
			mdb_call_dcmd("sdbc`sdbc_cchain",
			    (uintptr_t)bh.bh_centry, DCMD_ADDRSPEC, 0, NULL);
	}

	mdb_dec_indent(4);
	mdb_printf("\n");

	return (DCMD_OK);
}
/*
 * dcmd to display ss_centry_info_t structures and
 * do optional consistency check with the nvram copy
 * if configured for nvram safe storage.
 */

static int
sdbc_glcinfo(uintptr_t addr, uint_t flags, int argc,
					const mdb_arg_t *argv)
{
	ss_centry_info_t gl_centry_info;
	/* for doing consistency check */

	ss_centry_info_t *gl_centry_info_start;
	ss_centry_info_t *nv_gl_centry_info_start;
	uintptr_t nv_addr;
	ss_centry_info_t nv_gl_centry_info;

	/* options */
	uint_t opt_a = FALSE;
	uintptr_t opt_b = MDB_BLKNUM;	/* fba pos match */
	uintptr_t opt_c = MDB_CD;
	uintptr_t opt_C = FALSE; /* consistency check */
	uint_t opt_d = FALSE;



	if (mdb_getopts(argc, argv,
			'a', MDB_OPT_SETBITS, TRUE, &opt_a,
			'b', MDB_OPT_UINTPTR, &opt_b,
			'c', MDB_OPT_UINTPTR, &opt_c,
			'C', MDB_OPT_SETBITS, TRUE, &opt_C,
			'd', MDB_OPT_SETBITS, TRUE, &opt_d) != argc)
		return (DCMD_USAGE);


	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_walk_dcmd("sdbc`sdbc_glcinfo", "sdbc`sdbc_glcinfo",
					argc, argv) == -1) {
			mdb_warn("failed to walk global centry info array");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("global cache entry info:\n");
	}

	if (mdb_vread(&gl_centry_info, sizeof (ss_centry_info_t), addr) == -1) {
		mdb_warn("failed to read gl_centry_info at 0x%p", addr);
		return (DCMD_ERR);
	}


	/*
	 * default is to print entries initialized with a cd.  return if
	 * no options are selected and cd is invalid.
	 */
	if (!opt_a && (!OPT_B_SELECTED) && (!OPT_C_SELECTED) && !opt_d &&
		(gl_centry_info.sc_cd == -1))
		return (DCMD_OK);


	/*
	 * opt_c is exclusive filter. if opt_c is selected and there
	 * is no match on the cd then return
	 */
	if (!opt_a &&
		(OPT_C_SELECTED && (gl_centry_info.sc_cd != opt_c)))
		return (DCMD_OK);

	/*
	 * opt_d and opt_b are inclusive. print if either one is chosen
	 * and the selection condition is true.
	 */
	if (opt_a ||
	    (!opt_d && (!OPT_B_SELECTED)) || /* no options chosen */
	    (opt_d && gl_centry_info.sc_dirty) ||
	    (OPT_B_SELECTED && (gl_centry_info.sc_fpos == opt_b)))
		/*EMPTY*/;
	else
		return (DCMD_OK);

	mdb_inc_indent(4);
	mdb_printf("%?-p cd %3-d fpos %10-d dirty %04x flag <%b>\n",
		addr,
		gl_centry_info.sc_cd,
		gl_centry_info.sc_fpos,
		gl_centry_info.sc_dirty & 0xffff,
		gl_centry_info.sc_flag, cc_flag_bits);

	if (opt_C) {
		/* get start of the cache entry metadata */
		if (mdb_readvar(&gl_centry_info_start,
				"_sdbc_gl_centry_info") == -1) {
			mdb_warn("failed to read  _sdbc_gl_centry_info");
			/* not catastrophic */
			goto end;
		}

		/* get start of the nvram copy cache entry metadata */
		if (mdb_readvar(&nv_gl_centry_info_start,
				"_sdbc_gl_centry_info_nvmem") == -1) {
			mdb_warn("failed to read  _sdbc_gl_centry_info_nvmem");
			/* not catastrophic */
			goto end;
		}

		nv_addr = (addr - (uintptr_t)gl_centry_info_start) +
				(uintptr_t)nv_gl_centry_info_start;

		if (mdb_vread(&nv_gl_centry_info, sizeof (ss_centry_info_t),
						    nv_addr) == -1) {
			mdb_warn("failed to read at nvmem_gl_info 0x%p",
					nv_addr);
		    /* not catastophic, continue */
	    } else {

			/* consistency check */
			mdb_inc_indent(4);
			if (memcmp(&gl_centry_info, &nv_gl_centry_info,
					sizeof (ss_centry_info_t) != 0)) {
				mdb_warn(
				"nvram and host memory are NOT identical!");
				mdb_printf("nvmem_gl_centry_info: ");
				mdb_printf(
			    "%?-p cd %3-d fpos %10-d dirty %04x flag <%b>\n",
				nv_addr,
				nv_gl_centry_info.sc_cd,
				nv_gl_centry_info.sc_fpos,
				nv_gl_centry_info.sc_dirty & 0xffff,
				nv_gl_centry_info.sc_flag, cc_flag_bits);
				mdb_printf("\n");
		    } else
				mdb_printf("NVRAM ok\n");

		    mdb_dec_indent(4);

	    }
	}

	end:
	mdb_dec_indent(4);
	return (DCMD_OK);
}

/*
 * dcmd to display ss_voldata_t structures and
 * do optional consistency check with the nvram copy
 * if configured for nvram safe storage.
 */

static int
sdbc_glfinfo(uintptr_t addr, uint_t flags, int argc,
					const mdb_arg_t *argv)
{
	ss_voldata_t gl_file_info;
	/* for doing consistency check */

	ss_voldata_t *gl_file_info_start;
	ss_voldata_t *nv_gl_file_info_start;
	uintptr_t nv_addr;
	ss_voldata_t nv_gl_file_info;

	/* options  default: valid filename */
	uint_t opt_a = FALSE; /* all */
	uint_t opt_p = FALSE; /* PINNED */
	uint_t opt_t = FALSE; /* attached */
	uint_t opt_C = FALSE; /* consistency check */



	/*
	 * possible enhancement -- match on filename,
	 * or filename part (e.g. controller number)
	 */
	if (mdb_getopts(argc, argv,
			'a', MDB_OPT_SETBITS, TRUE, &opt_a,
			'C', MDB_OPT_SETBITS, TRUE, &opt_C,
			'p', MDB_OPT_SETBITS, TRUE, &opt_p,
			't', MDB_OPT_SETBITS, TRUE, &opt_t) != argc)
		return (DCMD_USAGE);


	if (!(flags & DCMD_ADDRSPEC)) {
		if (mdb_walk_dcmd("sdbc`sdbc_glfinfo", "sdbc`sdbc_glfinfo",
					argc, argv) == -1) {
			mdb_warn("failed to walk global file info array");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("global file entry info:\n");
	}

	if (mdb_vread(&gl_file_info, sizeof (ss_voldata_t), addr) == -1) {
		mdb_warn("failed to read gl_file_info at 0x%p", addr);
		return (DCMD_ERR);
	}


	/*
	 * default is to print entries initialized with non-null filename.
	 * return if no options are selected and filename is invalid.
	 */
	if (!opt_a && !opt_p && !opt_t &&
		(strlen(gl_file_info.sv_volname) == 0))
		return (DCMD_OK);


	if (opt_a ||
		(!opt_p && !opt_t) || /* no options chosen */
		(opt_p && (gl_file_info.sv_pinned != _SD_NO_HOST)) ||
		(opt_t && (gl_file_info.sv_attached != _SD_NO_HOST)))
		/*EMPTY*/;
	else
		return (DCMD_OK);

	mdb_inc_indent(4);
	mdb_printf("%?-p %s\n", addr, gl_file_info.sv_volname);
	mdb_printf("pinned %2-d attached %2-d devidsz %3-d\n",
		gl_file_info.sv_pinned,
		gl_file_info.sv_attached,
		gl_file_info.sv_devidsz);
	mdb_printf("devid %s\n", gl_file_info.sv_devid);

	if (opt_C) {
		/* get start of the cache entry metadata */
		if (mdb_readvar(&gl_file_info_start,
				"_sdbc_gl_file_info") == -1) {
			mdb_warn("failed to read  _sdbc_gl_file_info");
			/* not catastrophic */
			goto end;
		}

		/* get start of the nvram copy cache entry metadata */
		if (mdb_readvar(&nv_gl_file_info_start,
				"_sdbc_gl_file_info_nvmem") == -1) {
			mdb_warn("failed to read  _sdbc_gl_file_info_nvmem");
			/* not catastrophic */
			goto end;
		}

		nv_addr = (addr - (uintptr_t)gl_file_info_start) +
				(uintptr_t)nv_gl_file_info_start;

		if (mdb_vread(&nv_gl_file_info, sizeof (ss_voldata_t),
						    nv_addr) == -1) {
			mdb_warn("failed to read nvmem_gl_info at 0x%p",
					nv_addr);
		    /* not catastophic, continue */
	    } else {

		    /* consistency check */
		    mdb_inc_indent(4);
		    if (memcmp(&gl_file_info, &nv_gl_file_info,
				sizeof (ss_centry_info_t) != 0)) {
			mdb_warn("nvram and host memory are NOT identical!");
			mdb_printf("nvmem_gl_file_info: ");
			mdb_printf("%?-p %s\n", nv_addr,
					nv_gl_file_info.sv_volname);
			mdb_printf("pinned %2-d attached %2-d devidsz %3-d\n",
				nv_gl_file_info.sv_pinned,
				nv_gl_file_info.sv_attached,
				nv_gl_file_info.sv_devidsz);
			mdb_printf("devid %s\n", nv_gl_file_info.sv_devid);
		    } else
			mdb_printf("NVRAM ok\n");

		    mdb_dec_indent(4);

	    }
	}

	end:
	mdb_dec_indent(4);
	mdb_printf("\n");
	return (DCMD_OK);
}


/*
 * MDB module linkage information:
 *
 * We declare a list of structures describing our dcmds, and a function
 * named _mdb_init to return a pointer to our module information.
 */

static const mdb_dcmd_t dcmds[] = {
	/* general dcmds */
	{ "sdbc_config", NULL,
		"display sdbc configuration information",
		sdbc_config },
	{ "sdbc_stats", NULL,
		"display sdbc stats information",
		sdbc_stats },
	{ "sdbc_vars", NULL,
		"display some sdbc variables, counters and addresses",
		sdbc_vars },

	/* cctl dcmds */
	{"sdbc_cctl", "?[-vdhioV][-c cd][-b blknum]",
		"display sdbc cache ctl structures",
		sdbc_cctl, cctl_help },
	{"sdbc_cchain", ":[-vdhioV][-c cd][-b blknum]",
		"display cache ctl structure cc_chain",
		sdbc_cchain, cchain_help },
	{"sdbc_dchain", ":[-vdhioV][-c cd][-b blknum]",
		"display cache ctl structure dirty chain",
		sdbc_dchain, dchain_help },
	{"sdbc_dmchain", ":[-vdhioV][-c cd][-b blknum]",
		"display dynamic memory cache ctl chain",
		sdbc_dmchain, dmchain_help },
	{"sdbc_hashchain", ":[-vdhioV][-c cd][-b blknum]",
		"display a hash chain", sdbc_hashchain, hashchain_help },
	{"sdbc_hashtable", "?[-vdhioV][-c cd][-b blknum]",
		"display hash table", sdbc_hashtable, hashtable_help },
	{"sdbc_lru", "?[-vdhioV][-c cd][-b blknum]",
		"display the cache lru queue",
		sdbc_lru, lru_help },
#ifdef SAFESTORE
	/* wctl dcmds */
	{"sdbc_wctl", "?[-vd][-c cd]",
		"display the write control structures",
		sdbc_wctl, wctl_help },
	{"sdbc_wrq", "?[-vd][-c cd]",
		"display the write control queue",
		sdbc_wrq, wrq_help },
#endif /* SAFESTORE */

	/* others */
	{"sdbc_cdinfo", "?[-av][-c cd]",
		"display cache descriptor information",
		sdbc_cdinfo, cdinfo_help },
#ifdef SAFESTORE
	{"sdbc_ftctl", "?[-vd][-c cd]",
		"display the fault tolerant control structures",
		sdbc_ftctl, ftctl_help },
#endif /* SAFESTORE */
	{"sdbc_handles", "?[-avC][-c cd]",
		"display sdbc buffer handle information",
		sdbc_handles, handle_help },

	{ "sdbc_dmqueues", NULL,
		"display sdbc dynamic memory buffer queues information",
		sdbc_dmqueues },

	/* "global" metadata dcmds */
	{"sdbc_glcinfo", "?[-adC][-c cd][-b fbapos]",
		"display the global cache entry info structures",
		sdbc_glcinfo, glcinfo_help },
	{"sdbc_glfinfo", "?[-aptC]",
		"display the global file info structures",
		sdbc_glfinfo, glfinfo_help },
	{ NULL }
};

static const mdb_walker_t walkers[] = {
	/* walkers of cctl list and arrays */
	{ "sdbc_cchain", "walk the cc_chain (alloc chain) of a cache ctl",
		sdbc_cchain_winit, sdbc_cchain_wstep, sdbc_cchain_wfini },
	{ "sdbc_cctl", "walk the cache ctl structure list",
		sdbc_cctl_winit, sdbc_cctl_wstep, sdbc_cctl_wfini },
	{ "sdbc_dchain", "walk the dirty chain of a cache ctl",
		sdbc_dchain_winit, sdbc_dchain_wstep, sdbc_dchain_wfini },
	{ "sdbc_dmchain", "walk the dynamic memory chain of a cache cctl",
		sdbc_dmchain_winit, sdbc_dmchain_wstep, sdbc_dmchain_wfini },
	{ "sdbc_hashchain", "walk a hash chain",
		sdbc_hashchain_winit, sdbc_hashchain_wstep,
					sdbc_hashchain_wfini },
	{ "sdbc_lru", "walk the cache lru queue",
		sdbc_lru_winit, sdbc_lru_wstep, sdbc_lru_wfini },

#ifdef SAFESTORE
	/* walkers of wctl lists and arrays */
	{ "sdbc_wctl", "walk the allocated write ctl array",
		sdbc_wctl_winit, sdbc_wctl_wstep, sdbc_wctl_wfini },
	{ "sdbc_wrq", "walk the write ctl queue (free list)",
		sdbc_wrq_winit, sdbc_wrq_wstep, sdbc_wrq_wfini },
#endif /* SAFESTORE */
	/* others */
	{ "sdbc_cdinfo",
	    "walk the _sd_cache_files array of cache descriptor information",
		sdbc_cdinfo_winit, sdbc_cdinfo_wstep, sdbc_cdinfo_wfini },
#ifdef SAFESTORE
	{ "sdbc_ftctl",
	    "walk the allocated array of fault tolerant structures",
		sdbc_ftctl_winit, sdbc_ftctl_wstep, sdbc_ftctl_wfini },
#endif /* SAFESTORE */
	{ "sdbc_handles", "walk array of _sd_buf_handle_t structures",
		sdbc_handle_winit, sdbc_handle_wstep, sdbc_handle_wfini },

	/* walkers for metadata arrays */
	{ "sdbc_glcinfo", "walk the allocated global cache entry info array",
		sdbc_glcinfo_winit, sdbc_glcinfo_wstep, sdbc_glcinfo_wfini },
	{ "sdbc_glfinfo", "walk the allocated global file info array",
		sdbc_glfinfo_winit, sdbc_glfinfo_wstep, sdbc_glfinfo_wfini },
	{ NULL }
};

static const mdb_modinfo_t modinfo = {
	MDB_API_VERSION, dcmds, walkers
};

const mdb_modinfo_t *
_mdb_init(void)
{
	return (&modinfo);
}