--- old/usr/src/cmd/mdb/common/modules/sdbc/sdbc.c	Fri Jul 27 15:35:38 2018
+++ /dev/null	Fri Jul 27 15:07:21 2018
@@ -1,3158 +0,0 @@
-/*
- * 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);
-}
