xref: /onnv-gate/usr/src/cmd/mdb/common/modules/rdc/rdc.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/types.h>
#include <sys/mdb_modapi.h>

#include <sys/nsctl/nsctl.h>
#include <sys/unistat/spcs_s.h>
#include <sys/unistat/spcs_s_k.h>

#include <rpc/auth.h>
#include <rpc/auth_unix.h>
#include <rpc/auth_des.h>
#include <rpc/svc.h>
#include <rpc/xdr.h>
#include <rpc/svc_soc.h>

/* HACK HACK  so we can bring in rdc_io.h and friends */
#define	nstset_t	char

#include <sys/nsctl/rdc.h>
#include <sys/nsctl/rdc_prot.h>
#include <sys/nsctl/rdc_ioctl.h>
#include <sys/nsctl/rdc_io.h>
#include <sys/nsctl/rdc_bitmap.h>

#include <sys/nsctl/nsvers.h>


/*
 * Walker for an array of rdc_k_info_t structures.
 * A global walk is assumed to start at rdc_k_info.
 */

struct rdc_kinfo_winfo {
	uintptr_t start;
	uintptr_t end;
};

char bitstr[33] = { '0' };

static int
rdc_k_info_winit(mdb_walk_state_t *wsp)
{
	struct rdc_kinfo_winfo *winfo;
	rdc_k_info_t *rdc_k_info;
	int rdc_max_sets;

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

	if (mdb_readvar(&rdc_k_info, "rdc_k_info") == -1) {
		mdb_warn("failed to read 'rdc_k_info'");
		mdb_free(winfo,  sizeof (struct rdc_kinfo_winfo));
		return (WALK_ERR);
	}

	if (mdb_readvar(&rdc_max_sets, "rdc_max_sets") == -1) {
		mdb_warn("failed to read 'rdc_max_sets'");
		mdb_free(winfo, sizeof (struct rdc_kinfo_winfo));
		return (WALK_ERR);
	}

	winfo->start = (uintptr_t)rdc_k_info;
	winfo->end = (uintptr_t)(rdc_k_info + rdc_max_sets);

	if (wsp->walk_addr == NULL)
		wsp->walk_addr = winfo->start;

	wsp->walk_data = winfo;
	return (WALK_NEXT);
}


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

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

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

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

	wsp->walk_addr += sizeof (rdc_k_info_t);
	return (status);
}


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

/*
 * Walker for an array of rdc_u_info_t structures.
 * A global walk is assumed to start at rdc_u_info.
 */

struct rdc_uinfo_winfo {
	uintptr_t start;
	uintptr_t end;
};


static int
rdc_u_info_winit(mdb_walk_state_t *wsp)
{
	struct rdc_uinfo_winfo *winfo;
	rdc_u_info_t *rdc_u_info;
	int rdc_max_sets;

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

	if (mdb_readvar(&rdc_u_info, "rdc_u_info") == -1) {
		mdb_warn("failed to read 'rdc_u_info'");
		mdb_free(winfo,  sizeof (struct rdc_uinfo_winfo));
		return (WALK_ERR);
	}

	if (mdb_readvar(&rdc_max_sets, "rdc_max_sets") == -1) {
		mdb_warn("failed to read 'rdc_max_sets'");
		mdb_free(winfo, sizeof (struct rdc_uinfo_winfo));
		return (WALK_ERR);
	}

	winfo->start = (uintptr_t)rdc_u_info;
	winfo->end = (uintptr_t)(rdc_u_info + rdc_max_sets);

	if (wsp->walk_addr == NULL)
		wsp->walk_addr = winfo->start;

	wsp->walk_data = winfo;
	return (WALK_NEXT);
}


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

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

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

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

	wsp->walk_addr += sizeof (rdc_u_info_t);
	return (status);
}


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

/*
 * Walker for the rdc_if chain.
 * A global walk is assumed to start at rdc_if_top.
 */

static int
rdc_if_winit(mdb_walk_state_t *wsp)
{
	if (wsp->walk_addr == NULL &&
	    mdb_readvar(&wsp->walk_addr, "rdc_if_top") == -1) {
		mdb_warn("unable to read 'rdc_if_top'");
		return (WALK_ERR);
	}

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

	return (WALK_NEXT);
}


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

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

	if (mdb_vread(wsp->walk_data,
	    sizeof (rdc_if_t), wsp->walk_addr) == -1) {
		mdb_warn("failed to read rdc_if at %p", wsp->walk_addr);
		return (WALK_DONE);
	}

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

	wsp->walk_addr = (uintptr_t)(((rdc_if_t *)wsp->walk_data)->next);
	return (status);
}


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

/*
 * Displays the asynchronous sleep q on the server.
 */
/*ARGSUSED*/
static int
rdc_sleepq(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	rdc_sleepq_t sq;

	if (!(flags & DCMD_ADDRSPEC))
		return (DCMD_USAGE);
	while (addr) {
		if (mdb_vread(&sq, sizeof (sq), addr) != sizeof (sq)) {
			mdb_warn("failed to read rdc_sleepq at %p", addr);
			return (DCMD_ERR);
		}
		mdb_printf("sequence number %u  qpos %d \n", sq.seq, sq.qpos);
		addr = (uintptr_t)sq.next;
	}
	return (DCMD_OK);
}

/*
 * display the header info for the pending diskq requests
 */
/*ARGSUSED*/
static int
rdc_iohdr(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	io_hdr hdr;

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

	while (addr) {
		if (mdb_vread(&hdr, sizeof (io_hdr), addr) != sizeof (io_hdr)) {
			mdb_warn("failed to read io_hdr at %p", addr);
			return (DCMD_ERR);
		}
		mdb_printf("iohdr: type %d pos %d qpos %d len %d flag 0x%x"
		" iostatus %x setid %d next %p\n", hdr.dat.type, hdr.dat.pos,
		hdr.dat.qpos, hdr.dat.len, hdr.dat.flag, hdr.dat.iostatus,
		hdr.dat.setid, hdr.dat.next);

		addr = (uintptr_t)hdr.dat.next;
	}
	return (DCMD_OK);
}

/*
 * Display a krdc->group.
 * Requires an address.
 */
/*ARGSUSED*/
static int
rdc_group(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	struct rdc_group *group;
	disk_queue	*dq;

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


	group = mdb_zalloc(sizeof (*group), UM_GC);

	if (mdb_vread(group, sizeof (*group), addr) != sizeof (*group)) {
		mdb_warn("failed to read rdc_group at %p", addr);
		return (DCMD_ERR);
	}
#ifdef XXXJET
	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("%-?s  %8T%-8s  %8T%s\n", "ADDR", "MAJOR", "INUSE");
	}
#endif
	mdb_printf("count: %d  %8Twriter: %d  %8T flags: %d\n",
	    group->count, group->rdc_writer, group->flags);
	mdb_printf("thread num %d\n", group->rdc_thrnum);

	dq = &group->diskq;
	if (RDC_IS_MEMQ(group)) {
		mdb_printf("queue type: Memory based\n");
	} else if (RDC_IS_DISKQ(group)) {
		mdb_printf("queue type: Disk based  %8Tqstate 0x%x\n",
		    QSTATE(dq));
	}
	mdb_printf("ra_queue head: 0x%p  %8Ttail 0x%p\n",
	    group->ra_queue.net_qhead, group->ra_queue.net_qtail);
	mdb_printf("ra_queue blocks: %d  %8Titems %d\n",
	    group->ra_queue.blocks, group->ra_queue.nitems);
	mdb_printf("ra_queue blockhwm: %d itemhwm: %d\n",
	    group->ra_queue.blocks_hwm, group->ra_queue.nitems_hwm);
	mdb_printf("ra_queue hwmhit: %d qfillsleep: %d\n",
	    group->ra_queue.hwmhit, group->ra_queue.qfill_sleeping);
	mdb_printf("ra_queue throttle: %ld\n",
	    group->ra_queue.throttle_delay);

	if (RDC_IS_DISKQ(group)) {
		mdb_printf("head: %d %8Tnxtio: %d  %8Ttail %d %8Tlastail: %d\n",
		    QHEAD(dq), QNXTIO(dq), QTAIL(dq), LASTQTAIL(dq));
		mdb_printf("coalbounds: %d %8Tqwrap: %d\n", QCOALBOUNDS(dq),
		    QWRAP(dq));
		mdb_printf("blocks: %d  %8Titems %d qfflags 0x%x \n",
		    QBLOCKS(dq), QNITEMS(dq), group->ra_queue.qfflags);
		mdb_printf("diskq throttle: %ld %8Tflags: %x\n",
		    dq->throttle_delay, group->flags);
		mdb_printf("disk queue nitems_hwm: %d %8Tblocks_hwm: %d\n",
		    dq->nitems_hwm, dq->blocks_hwm);
		mdb_printf("diskqfd:   0x%p %8Tdisqrsrv: %d lastio: 0x%p\n",
		    group->diskqfd, group->diskqrsrv, dq->lastio);
		mdb_printf("outstanding req %d iohdrs 0x%p iohdrs_last 0x%p\n",
		    dq->hdrcnt, dq->iohdrs, dq->hdr_last);
	}
	mdb_printf("seq: %u\n", group->seq);
	mdb_printf("seqack: %u\n", group->seqack);
	mdb_printf("sleepq: 0x%p\n", group->sleepq);
	mdb_printf("asyncstall %d\n", group->asyncstall);
	mdb_printf("asyncdis %d\n", group->asyncdis);

	mdb_inc_indent(4);
	if (group->sleepq) {
		rdc_sleepq((uintptr_t)group->sleepq, DCMD_ADDRSPEC,
		    0, 0);
	}
	mdb_dec_indent(4);

	return (DCMD_OK);
}


/*
 * Display a krdc->lsrv.
 * Requires an address.
 */
/*ARGSUSED*/
static int
rdc_srv(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	rdc_srv_t *lsrv;
	char name[MAX_RDC_HOST_SIZE];

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


	lsrv = mdb_zalloc(sizeof (*lsrv), UM_GC);

	if (mdb_vread(lsrv, sizeof (*lsrv), addr) != sizeof (*lsrv)) {
		mdb_warn("failed to read rdc_srv at %p", addr);
		return (DCMD_ERR);
	}

	if (mdb_readstr(name, sizeof (name),
		(uintptr_t)lsrv->ri_hostname) == -1) {
		mdb_warn("failed to read ri_hostname name at %p", addr);
		return (DCMD_ERR);
	}

	mdb_printf("host: %s  %16Tri_knconf 0x%p\n", name, lsrv->ri_knconf);

	mdb_printf("ri_addr: 0x%p  %8Tsecdata 0x%p\n",
	    addr + OFFSETOF(rdc_srv_t, ri_addr), lsrv->ri_secdata);

	return (DCMD_OK);
}

/*
 * Display a rdc_if_t.
 * Requires an address.
 */
static int
rdc_if(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	rdc_if_t *ifp;

	if (!(flags & DCMD_ADDRSPEC)) {
		/*
		 * paranoid mode on: qualify walker name with module name
		 * using '`' syntax.
		 */
		if (mdb_walk_dcmd("rdc`rdc_if",
			"rdc`rdc_if", argc, argv) == -1) {
			mdb_warn("failed to walk 'rdc_if'");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}

	ifp = mdb_zalloc(sizeof (*ifp), UM_GC);

	if (mdb_vread(ifp, sizeof (*ifp), addr) != sizeof (*ifp)) {
		mdb_warn("failed to read rdc_srv at %p", addr);
		return (DCMD_ERR);
	}

	mdb_printf("next: 0x%p  %8Tsrv 0x%p\n", ifp->next, ifp->srv);
	mdb_printf("if_addr: 0x%p  %8Tr_ifaddr 0x%p\n",
	    addr + OFFSETOF(rdc_if_t, ifaddr),
	    addr + OFFSETOF(rdc_if_t, r_ifaddr));
	mdb_printf("if_down: %d  %8Tprimary %d  %8Tsecondary  %d\n",
		ifp->if_down, ifp->isprimary, ifp->issecondary);
	mdb_printf("version %d  %8Tnoping  %d\n", ifp->rpc_version,
		ifp->no_ping);
	mdb_printf("\n");

	return (DCMD_OK);
}


/*
 * Display a rdc_buf_t
 * Requires an address.
 */
/*ARGSUSED*/
static int
rdc_buf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	rdc_buf_t *buf;

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


	buf = mdb_zalloc(sizeof (*buf), UM_GC);

	if (mdb_vread(buf, sizeof (*buf), addr) != sizeof (*buf)) {
		mdb_warn("failed to read rdc_buf at %p", addr);
		return (DCMD_ERR);
	}

	mdb_printf("nsc_buf fd: 0x%p  %8Tvec 0x%p\n",
	    buf->rdc_bufh.sb_fd, buf->rdc_bufh.sb_vec);

	mdb_printf("nsc_buf pos: %d  %8Tlen %d\n",
	    buf->rdc_bufh.sb_pos, buf->rdc_bufh.sb_len);

	mdb_printf("nsc_buf flag: 0x%x  %8Terror %d\n",
	    buf->rdc_bufh.sb_flag, buf->rdc_bufh.sb_error);

	mdb_printf("anon_buf : 0x%p  %8Tfd 0x%p  %8Tbufp  0x%p\n",
	    buf->rdc_anon, buf->rdc_fd, buf->rdc_bufp);

	mdb_printf("vsize: %d  %8Tflags 0x%x\n",
	    buf->rdc_vsize, buf->rdc_flags);

	return (DCMD_OK);
}

/*ARGSUSED*/
static int
rdc_aio(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	rdc_aio_t *aio;

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

	aio = mdb_zalloc(sizeof (*aio), UM_GC);

	if (mdb_vread(aio, sizeof (*aio), addr) != sizeof (*aio)) {
		mdb_warn("failed to read rdc_aio at %p", addr);
		return (DCMD_ERR);
	}
	mdb_printf("rdc_aio next: %p %8T nsc_buf: %p %8T nsc_qbuf %p\n",
	    aio->next, aio->handle, aio->qhandle);
	mdb_printf("pos: %d len: %d qpos: %d flag: %x iostatus: %d index: %d"
	    " seq: %d\n", aio->pos, aio->len, aio->qpos, aio->flag,
	    aio->iostatus, aio->index, aio->seq);
	return (DCMD_OK);
}

/*ARGSUSED*/
static int
rdc_dset(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	rdc_net_dataset_t *dset;

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

	dset = mdb_zalloc(sizeof (*dset), UM_GC);

	if (mdb_vread(dset, sizeof (*dset), addr) != sizeof (*dset)) {
		mdb_warn("failed to read dset at %p", addr);
		return (DCMD_ERR);
	}
	mdb_printf("dset id: %d %8T dset inuse: %d %8T dset delpend: %d\n",
	    dset->id, dset->inuse, dset->delpend);
	mdb_printf("dset items: %d %8T dset head %p %8T dset tail %p \n",
	    dset->nitems, dset->head, dset->tail);
	mdb_printf("dset pos %d %8T dset len %d\n", dset->pos, dset->fbalen);

	return (DCMD_OK);
}
/*
 * Display a single rdc_k_info structure.
 * If called with no address, performs a global walk of all rdc_k_info.
 * -a : all (i.e. display all devices, even if disabled
 * -v : verbose
 */

const mdb_bitmask_t sv_flag_bits[] = {
	{ "NSC_DEVICE", NSC_DEVICE, NSC_DEVICE },
	{ "NSC_CACHE", NSC_CACHE, NSC_CACHE },
	{ NULL, 0, 0 }
};

static int
rdc_kinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	rdc_k_info_t *krdc;
	rdc_u_info_t *rdc_u_info, *urdc;
	int a_opt, v_opt;
	int dev_t_chars;

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

	if (mdb_getopts(argc, argv,
	    'a', MDB_OPT_SETBITS, TRUE, &a_opt,
	    'v', MDB_OPT_SETBITS, TRUE, &v_opt) != argc)
		return (DCMD_USAGE);

	krdc = mdb_zalloc(sizeof (*krdc), UM_GC);
	urdc = mdb_zalloc(sizeof (*urdc), UM_GC);

	if (!(flags & DCMD_ADDRSPEC)) {
		/*
		 * paranoid mode on: qualify walker name with module name
		 * using '`' syntax.
		 */
		if (mdb_walk_dcmd("rdc`rdc_kinfo",
			"rdc`rdc_kinfo", argc, argv) == -1) {
			mdb_warn("failed to walk 'rdc_kinfo'");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}
	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("%-?s  %8T%-*s  %8T%s\n", "ADDR",
		    dev_t_chars, "TFLAG", "STATE");
	}

	if (mdb_vread(krdc, sizeof (*krdc), addr) != sizeof (*krdc)) {
		mdb_warn("failed to read rdc_k_info at %p", addr);
		return (DCMD_ERR);
	}

	if (mdb_readvar(&rdc_u_info, "rdc_u_info") == -1) {
		mdb_warn("failed to read 'rdc_u_info'");
		return (DCMD_ERR);
	}

	urdc = &rdc_u_info[krdc->index];

	if (!a_opt && ((krdc->type_flag & RDC_CONFIGURED) == 0))
		return (DCMD_OK);

	mdb_printf("%?p  %8T%0*lx  %8T", addr, dev_t_chars, krdc->type_flag);


	if (krdc->type_flag & RDC_DISABLEPEND)
		mdb_printf(" disable pending");
	if (krdc->type_flag &  RDC_ASYNCMODE)
		mdb_printf(" async");
	if (krdc->type_flag & RDC_RESUMEPEND)
		mdb_printf(" resume pending");
	if (krdc->type_flag & RDC_BUSYWAIT)
		mdb_printf(" busywait");
#ifdef RDC_SMALLIO
	if (krdc->type_flag & RDC_SMALLIO)
		mdb_printf(" smallio");
#endif

	mdb_printf("\n");

	if (!v_opt)
		return (DCMD_OK);

	/*
	 * verbose - print the rest of the structure as well.
	 */

	mdb_inc_indent(4);

	mdb_printf("index: %d  %8Trindex: %d  %8Tbusyc: %d  %8Tmaxfbas:  %d\n",
	    krdc->index, krdc->remote_index, krdc->busy_count, krdc->maxfbas);

	mdb_printf("info_dev:  0x%p %8Tiodev: 0x%p  %8T %8T vers %d\n",
	krdc->devices, krdc->iodev, krdc->rpc_version);

	mdb_printf("iokstats:  0x%p\n", krdc->io_kstats);
	mdb_printf("group:  0x%p %8Tgroup_next:  0x%p\n",
		krdc->group, krdc->group_next);
	mdb_printf("group lock: 0x%p aux_state: %d\n",
	    &krdc->group->lock, krdc->aux_state);

	mdb_inc_indent(4);
	if (krdc->type_flag & RDC_ASYNCMODE) {
		rdc_group((uintptr_t)krdc->group, DCMD_ADDRSPEC, 0, 0);
	}
	mdb_dec_indent(4);

	mdb_printf("servinfo:  0x%p %8Tintf:  0x%p\nbitmap: 0x%p  %8T"
	    "bitmap_ref:  0x%p\n",
	    krdc->lsrv, krdc->intf, krdc->dcio_bitmap, krdc->bitmap_ref);

	mdb_printf("bmap_size:  %d %8Tbmaprsrv: %d%8T bmap_write:  %d\n",
	    krdc->bitmap_size, krdc->bmaprsrv, krdc->bitmap_write);

	mdb_printf("bitmapfd:  0x%p %8Tremote_fd: 0x%p  %8T\n", krdc->bitmapfd,
	    krdc->remote_fd);

	mdb_printf("net_dataset:  0x%p %8Tdisk_status: %d  %8T\n",
	    krdc->net_dataset, krdc->disk_status);

	mdb_printf("many:  0x%p %8Tmulti: 0x%p  %8T\n", krdc->many_next,
	    krdc->multi_next);

	mdb_printf("rdc_uinfo: 0x%p\n\n", urdc);
	mdb_dec_indent(4);
	return (DCMD_OK);
}


static int
rdc_uinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	rdc_u_info_t *urdc;
	rdc_k_info_t *rdc_k_info, *krdc, krdc1;
	rdc_group_t grp;
	disk_queue *dqp = NULL;
	int a_opt, v_opt;
	int dev_t_chars;
	int rdcflags;

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

	if (mdb_getopts(argc, argv,
	    'a', MDB_OPT_SETBITS, TRUE, &a_opt,
	    'v', MDB_OPT_SETBITS, TRUE, &v_opt) != argc)
		return (DCMD_USAGE);

	urdc = mdb_zalloc(sizeof (*urdc), UM_GC);
	krdc = mdb_zalloc(sizeof (*krdc), UM_GC);

	if (!(flags & DCMD_ADDRSPEC)) {
		/*
		 * paranoid mode on: qualify walker name with module name
		 * using '`' syntax.
		 */
		if (mdb_walk_dcmd("rdc`rdc_uinfo",
			"rdc`rdc_uinfo", argc, argv) == -1) {
			mdb_warn("failed to walk 'rdc_uinfo'");
			return (DCMD_ERR);
		}
		return (DCMD_OK);
	}
	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("%-?s  %8T%-*s  %8T%s\n", "ADDR",
		    dev_t_chars, "FLAG", "STATE");
	}

	if (mdb_vread(urdc, sizeof (*urdc), addr) != sizeof (*urdc)) {
		mdb_warn("failed to read rdc_u_info at %p", addr);
		return (DCMD_ERR);
	}

	if (mdb_readvar(&rdc_k_info, "rdc_k_info") == -1) {
		mdb_warn("failed to read 'rdc_k_info'");
		return (DCMD_ERR);
	}

	krdc = &rdc_k_info[urdc->index];

	if (!a_opt && ((urdc->flags & RDC_ENABLED) == 0))
		return (DCMD_OK);


	if (mdb_vread(&krdc1, sizeof (krdc1),
	    (uintptr_t)krdc) != sizeof (krdc1)) {
		mdb_warn("failed to read 'rdc_k_info1'");
		return (DCMD_ERR);
	}

	if (krdc1.group) {
		if (mdb_vread(&grp, sizeof (grp),
		    (uintptr_t)krdc1.group) != sizeof (grp)) {
			mdb_warn("failed to read group info ");
			return (DCMD_ERR);
		}
		dqp = &grp.diskq;
	}

	rdcflags = (urdc->flags | urdc->sync_flags | urdc->bmap_flags);
	mdb_printf("%?p  %8T%0*lx  %8T", addr, dev_t_chars, rdcflags);


	if (rdcflags & RDC_PRIMARY)
		mdb_printf(" primary");
	if (rdcflags &  RDC_SLAVE)
		mdb_printf(" slave");
	if (rdcflags &  RDC_SYNCING)
		mdb_printf(" syncing");
	if (rdcflags &  RDC_SYNC_NEEDED)
		mdb_printf(" sync_need");
	if (rdcflags &  RDC_RSYNC_NEEDED)
		mdb_printf(" rsync_need");
	if (rdcflags & RDC_LOGGING)
		mdb_printf(" logging");
	if (rdcflags & RDC_QUEUING)
		mdb_printf(" queuing");
	if (rdcflags & RDC_DISKQ_FAILED)
		mdb_printf(" diskq failed");
	if (rdcflags & RDC_VOL_FAILED)
		mdb_printf(" vol failed");
	if (rdcflags & RDC_BMP_FAILED)
		mdb_printf(" bmp failed");
	if (rdcflags & RDC_ASYNC)
		mdb_printf(" async");
	if (rdcflags & RDC_CLR_AFTERSYNC)
		mdb_printf(" clr_bitmap_aftersync");
	if (dqp) {
		if (IS_QSTATE(dqp, RDC_QNOBLOCK))
			mdb_printf(" noblock");
	}
#ifdef RDC_SMALLIO
	if (rdcflags & RDC_SMALLIO)
		mdb_printf(" smallio");
#endif

	mdb_printf("\n");

	if (!v_opt)
		return (DCMD_OK);

	/*
	 * verbose - print the rest of the structure as well.
	 */

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

	mdb_printf("primary: %s  %8Tfile: %s  \nbitmap: %s  ",
	    urdc->primary.intf, urdc->primary.file, urdc->primary.bitmap);
	mdb_printf("netbuf: 0x%p\n", addr + OFFSETOF(rdc_set_t, primary));
	mdb_printf("secondary: %s  %8Tfile: %s  \nbitmap: %s  ",
	    urdc->secondary.intf, urdc->secondary.file, urdc->secondary.bitmap);
	mdb_printf("netbuf: 0x%p\n", addr + OFFSETOF(rdc_set_t, secondary));

	mdb_printf("sflags:  %d %8Tbflags: %d%8T mflags:  %d\n",
		urdc->sync_flags, urdc->bmap_flags, urdc->mflags);
	mdb_printf("index:  %d %8Tsync_pos: %d%8T vsize:  %d\n",
		urdc->index, urdc->sync_pos, urdc->volume_size);
	mdb_printf("setid:  %d %8Tbits set:  %d %8Tautosync: %d\n",
		urdc->setid, urdc->bits_set, urdc->autosync);
	mdb_printf("maxqfbas:  %d %8Tmaxqitems: %d\n",
		urdc->maxqfbas, urdc->maxqitems);
	mdb_printf("netconfig:  %p\n", urdc->netconfig);
	mdb_printf("group:  %s %8TdirectIO: %s\n",
		urdc->group_name, urdc->direct_file);
	mdb_printf("diskqueue: %s ", urdc->disk_queue);
	if (dqp) {
		mdb_printf("diskqsize: %d\n", QSIZE(dqp));
	} else {
		mdb_printf("\n");
	}
	mdb_printf("rdc_k_info: 0x%p\n", krdc);
	mdb_printf("\n");
	mdb_dec_indent(4);

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

/*ARGSUSED*/
static int
rdc_infodev(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	rdc_info_dev_t *infodev;
	_rdc_info_dev_t *infp;

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

	infodev = mdb_zalloc(sizeof (*infodev), UM_GC);
	infp = mdb_zalloc(sizeof (*infp), UM_GC);

	if (mdb_vread(infodev, sizeof (*infodev), addr) != sizeof (*infodev)) {
		mdb_warn("failed to read rdc_infodev at 0x%p\n", addr);
		return (DCMD_ERR);
	}

	infp = &infodev->id_cache_dev;
	mdb_inc_indent(4);

	mdb_printf("id_next: 0x%p\n", infodev->id_next);
	mdb_printf("id_cache_dev:\n");

	mdb_inc_indent(4);
	mdb_printf("bi_fd: 0x%p %8Tbi_iodev: 0x%p %8Tbi_krdc 0x%p\n",
	    infp->bi_fd, infp->bi_iodev, infp->bi_krdc);
	mdb_printf("bi_rsrv: %d %8Tbi_orsrv: %d %8Tbi_failed: %d %8T\n"
	    "bi_ofailed: %d %8Tbi_flag: %d\n", infp->bi_rsrv, infp->bi_orsrv,
	    infp->bi_failed, infp->bi_ofailed, infp->bi_flag);

	infp = &infodev->id_raw_dev;

	mdb_dec_indent(4);
	mdb_printf("id_cache_dev:\n");
	mdb_inc_indent(4);

	mdb_printf("bi_fd: 0x%p %8Tbi_iodev: 0x%p %8Tbi_krdc 0x%p\n",
	    infp->bi_fd, infp->bi_iodev, infp->bi_krdc);
	mdb_printf("bi_rsrv: %d %8Tbi_orsrv: %d %8Tbi_failed: %d %8T\n"
	    "bi_ofailed: %d %8Tbi_flag: %d\n", infp->bi_rsrv, infp->bi_orsrv,
	    infp->bi_failed, infp->bi_ofailed, infp->bi_flag);

	mdb_dec_indent(4);

	mdb_printf("id_sets: %d %8Tid_release: %d %8Tid_flag %d",
	    infodev->id_sets, infodev->id_release, infodev->id_flag);

	if (infodev->id_flag & RDC_ID_CLOSING) {
		mdb_printf("closing");
	}
	mdb_printf("\n");

	mdb_dec_indent(4);
	return (DCMD_OK);
}

/*
 * Display general sv module information.
 */

#define	rdc_get_print(kvar, str, fmt, val)		\
	if (mdb_readvar(&(val), #kvar) == -1) {		\
		mdb_dec_indent(4);			\
		mdb_warn("unable to read '" #kvar "'");	\
		return (DCMD_ERR);			\
	}						\
	mdb_printf("%-20s" fmt "\n", str ":", val)

/*ARGSUSED*/
static int
rdc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	int maj, min, mic, baseline, i;

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

	if (mdb_readvar(&maj, "sndr_major_rev") == -1) {
		mdb_warn("unable to read 'sndr_major_rev'");
		return (DCMD_ERR);
	}

	if (mdb_readvar(&min, "sndr_minor_rev") == -1) {
		mdb_warn("unable to read 'sndr_minor_rev'");
		return (DCMD_ERR);
	}

	if (mdb_readvar(&mic, "sndr_micro_rev") == -1) {
		mdb_warn("unable to read 'sndr_micro_rev'");
		return (DCMD_ERR);
	}

	if (mdb_readvar(&baseline, "sndr_baseline_rev") == -1) {
		mdb_warn("unable to read 'sndr_baseline_rev'");
		return (DCMD_ERR);
	}

	mdb_printf("Remote Mirror module version: kernel %d.%d.%d.%d; "
		    "mdb %d.%d.%d.%d\n", maj, min, mic, baseline,
	    ISS_VERSION_MAJ, ISS_VERSION_MIN, ISS_VERSION_MIC, ISS_VERSION_NUM);
	mdb_inc_indent(4);

	rdc_get_print(rdc_debug, "debug", "%d", i);
	rdc_get_print(rdc_bitmap_mode, "bitmap mode", "%d", i);
	rdc_get_print(rdc_max_sets, "max sndr devices", "%d", i);
	rdc_get_print(rdc_rpc_tmout, "client RPC timeout", "%d", i);
	rdc_get_print(rdc_health_thres, "health threshold", "%d", i);
	rdc_get_print(MAX_RDC_FBAS, "max trans fba", "%d", i);

	mdb_dec_indent(4);
	return (DCMD_OK);
}

static int
rdc_k2u(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	rdc_k_info_t *krdc;
	rdc_u_info_t *rdc_u_info, *urdc;
	int rc;

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

	krdc = mdb_zalloc(sizeof (*krdc), UM_GC);
	urdc = mdb_zalloc(sizeof (*urdc), UM_GC);

	if (mdb_vread(krdc, sizeof (*krdc), addr) != sizeof (*krdc)) {
		mdb_warn("failed to read krdc at %p", addr);
		return (DCMD_ERR);
	}

	if (mdb_readvar(&rdc_u_info, "rdc_u_info") == -1) {
		mdb_warn("failed to read 'rdc_u_info'");
		return (DCMD_ERR);
	}

	urdc = &rdc_u_info[krdc->index];

	rc = rdc_uinfo((uintptr_t)urdc, DCMD_ADDRSPEC, argc, argv);
	return (rc);
}

static int
rdc_u2k(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	rdc_u_info_t *urdc;
	rdc_k_info_t *rdc_k_info, *krdc;
	int rc;

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

	urdc = mdb_zalloc(sizeof (*urdc), UM_GC);
	krdc = mdb_zalloc(sizeof (*krdc), UM_GC);

	if (mdb_vread(urdc, sizeof (*urdc), addr) != sizeof (*urdc)) {
		mdb_warn("failed to read urdc at %p\n", addr);
		return (DCMD_ERR);
	}

	if (mdb_readvar(&rdc_k_info, "rdc_k_info") == -1) {
		mdb_warn("failed to read 'rdc_k_info'");
		return (DCMD_ERR);
	}

	krdc = &rdc_k_info[urdc->index];

	rc = rdc_kinfo((uintptr_t)krdc, DCMD_ADDRSPEC, argc, argv);
	return (rc);
}

#ifdef DEBUG
/*
 * This routine is used to set the seq field in the rdc_kinfo->group
 * structure. Used to test that the queue code handles the integer
 * overflow correctly.
 * Takes two arguments index and value.
 * The index is the index into the kinfo structure array and
 * the value is the new value to set into the seq field.
 */
/*ARGSUSED*/
static int
rdc_setseq(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	rdc_k_info_t *rdc_k_info;
	rdc_group_t *group;
	int index;
	uint_t val;
	uintptr_t pokeaddr;

	if (argc != 2) {
		mdb_warn("must have two arguments, index and value\n");
		return (DCMD_ERR);
	}

	index = (int)mdb_strtoull(argv[0].a_un.a_str);
	val = (uint_t)mdb_strtoull(argv[1].a_un.a_str);

	/*
	 * Find out where in memory the seq field.
	 * The structure offset first.
	 */

	if (mdb_readvar(&rdc_k_info, "rdc_k_info") == -1) {
		mdb_warn("failed to read 'rdc_k_info'");
		return (DCMD_ERR);
	}
	pokeaddr = (uintptr_t)&rdc_k_info[index].group;
	if (mdb_vread(&group, sizeof (rdc_group_t *), pokeaddr) !=
	    sizeof (rdc_group_t *)) {
		mdb_warn("failed to fetch the group structure for set %d\n",
		    index);
		return (DCMD_ERR);
	}
	pokeaddr = (uintptr_t)(&group->seq);
	if (mdb_vwrite(&val, sizeof (val), pokeaddr) != sizeof (val)) {
		mdb_warn("failed to write seq at %p\n", pokeaddr);
		return (DCMD_ERR);
	}

	return (DCMD_OK);
}


/*
 * This routine is used to set the seqack field in the rdc_kinfo->group
 * structure. Used to test that the queue code handles the integer
 * overflow correctly.
 * Takes two arguments index and value.
 * The index is the index into the kinfo structure array and
 * the value is the new value to set into the seqack field.
 */
/*ARGSUSED*/
static int
rdc_setseqack(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	rdc_k_info_t *rdc_k_info;
	rdc_group_t *group;
	int index;
	uint_t val;
	uintptr_t pokeaddr;

	if (argc != 2) {
		mdb_warn("must have two arguments, index and value\n");
		return (DCMD_ERR);
	}

	index = (int)mdb_strtoull(argv[0].a_un.a_str);
	val = (uint_t)mdb_strtoull(argv[1].a_un.a_str);

	/*
	 * Find out where in memory the seqack field.
	 * The structure offset first.
	 */

	if (mdb_readvar(&rdc_k_info, "rdc_k_info") == -1) {
		mdb_warn("failed to read 'rdc_k_info'");
		return (DCMD_ERR);
	}
	pokeaddr = (uintptr_t)&rdc_k_info[index].group;
	if (mdb_vread(&group, sizeof (rdc_group_t *), pokeaddr) !=
	    sizeof (rdc_group_t *)) {
		mdb_warn("failed to fetch the group structure for set %d\n",
		    index);
		return (DCMD_ERR);
	}
	pokeaddr = (uintptr_t)(&group->seqack);
	if (mdb_vwrite(&val, sizeof (val), pokeaddr) != sizeof (val)) {
		mdb_warn("failed to write seqack at %p\n", pokeaddr);
		return (DCMD_ERR);
	}

	return (DCMD_OK);
}

/*
 * random define printing stuff, just does the define, and print the result
 */
/*ARGSUSED*/
static int
fba_to_log_num(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	int num;
	if (argc < 1) {
		mdb_warn("must have an argument\n");
		return (DCMD_ERR);
	}
	num = (int)mdb_strtoull(argv[0].a_un.a_str);
	num = FBA_TO_LOG_NUM(num);
	mdb_printf("LOG NUM: %d (0x%x)", num, num);

	return (DCMD_OK);
}

/*ARGSUSED*/
static int
log_to_fba_num(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	int num;
	if (argc < 1) {
		mdb_warn("must have an argument\n");
		return (DCMD_ERR);
	}
	num = (int)mdb_strtoull(argv[0].a_un.a_str);
	num = LOG_TO_FBA_NUM(num);
	mdb_printf("LOG NUM: %d (0x%x)", num, num);

	return (DCMD_OK);
}

static int
bmap_bit_isset(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	int st;
	int i, num;
	rdc_k_info_t *krdc;
	unsigned char *bmap;
	unsigned char *bmaddr;
	int bmsize;

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

	if (argc < 1) {
		mdb_warn("must have an argument\n");
		return (DCMD_ERR);
	}
	krdc = mdb_zalloc(sizeof (*krdc), UM_GC);

	if (mdb_vread(krdc, sizeof (*krdc), addr) != sizeof (*krdc)) {
		mdb_warn("failed to read rdc_k_info at %p", addr);
		return (DCMD_ERR);
	}

	bmaddr = krdc->dcio_bitmap;
	bmsize = krdc->bitmap_size;
	bmap = mdb_zalloc(bmsize, UM_GC);
	if (mdb_vread(bmap, bmsize, (uintptr_t)bmaddr) != bmsize) {
		mdb_warn("failed to read bitmap");
		return (DCMD_ERR);
	}

	num = (int)mdb_strtoull(argv[0].a_un.a_str);
	st = FBA_TO_LOG_NUM(num);
	i = BMAP_BIT_ISSET(bmap, st);
	mdb_printf(" BIT (%d) for %x %s set (%02x)", st, num, i?"IS":"IS NOT",
	    bmap[IND_BYTE(st)] & 0xff);

	return (DCMD_OK);
}

static int
bmap_bitref_isset(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	int num, st, i;
	rdc_k_info_t *krdc;
	unsigned char *brefbyte;
	unsigned int *brefint;
	void *bradder;
	int brsize;
	size_t refcntsize = sizeof (unsigned char);
	struct bm_ref_ops *refops;

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

	if (argc < 1) {
		mdb_warn("must have an argument\n");
		return (DCMD_ERR);
	}

	krdc = mdb_zalloc(sizeof (*krdc), UM_GC);

	if (mdb_vread(krdc, sizeof (*krdc), addr) != sizeof (*krdc)) {
		mdb_warn("failed to read rdc_k_info at %p", addr);
		return (DCMD_ERR);
	}

	bradder = krdc->bitmap_ref;
	refops = mdb_zalloc(sizeof (*refops), UM_GC);
	if (mdb_vread(refops, sizeof (*refops), (uintptr_t)krdc->bm_refs) !=
	    sizeof (*refops)) {
		mdb_warn("failed to read bm_refops at %p", krdc->bm_refs);
		return (DCMD_ERR);
	}
	refcntsize = refops->bmap_ref_size;
	brsize = krdc->bitmap_size * BITS_IN_BYTE * refcntsize;
	if (refcntsize == sizeof (unsigned char)) {
		brefbyte = mdb_zalloc(brsize, UM_GC);
		if (mdb_vread(brefbyte, brsize, (uintptr_t)bradder) != brsize) {
			mdb_warn("failed to read bitmap");
			return (DCMD_ERR);
		}
	} else {
		brefint = mdb_zalloc(brsize, UM_GC);
		if (mdb_vread(brefint, brsize, (uintptr_t)bradder) != brsize) {
			mdb_warn("failed to read bitmap");
			return (DCMD_ERR);
		}
	}

	num = (int)mdb_strtoull(argv[0].a_un.a_str);
	st = FBA_TO_LOG_NUM(num);
	if (refcntsize == sizeof (unsigned char))
		i = brefbyte[st];
	else
		i = brefint[st];

	mdb_printf("BITREF (%d) for %x %s set (%02x)", st, num, i?"IS":"IS NOT",
	    i);

	return (DCMD_OK);
}

/*ARGSUSED*/
static int
ind_byte(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	int num;

	if (argc < 1) {
		mdb_warn("must have an argument\n");
		return (DCMD_ERR);
	}
	num = FBA_TO_LOG_NUM((int)mdb_strtoull(argv[0].a_un.a_str));
	mdb_printf("IND_BYTE: %d", IND_BYTE(num));

	return (DCMD_OK);
}

/*ARGSUSED*/
static int
ind_bit(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	int num;

	if (argc < 1) {
		mdb_warn("must have an argument\n");
		return (DCMD_ERR);
	}
	num = FBA_TO_LOG_NUM((int)mdb_strtoull(argv[0].a_un.a_str));
	mdb_printf("IND_BIT: %d 0x%x", IND_BIT(num), IND_BIT(num));

	return (DCMD_OK);
}

static char *
print_bit(uint_t bitmask)
{
	int bitval = 1;
	int i;

	bitstr[32] = '\0';

	for (i = 31; i >= 0; i--) {
		if (bitmask & bitval) {
			bitstr[i] = '1';
		} else {
			bitstr[i] = '0';
		}
		bitval *= 2;
	}
	return (bitstr);
}

/*ARGSUSED*/
static int
rdc_bitmask(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	uint_t bitmask = 0;
	int first, st, en, pos, len;

	if (argc < 2) {
		mdb_warn("must have 2 args (pos, len)\n");
		return (DCMD_ERR);
	}
	pos = (int)mdb_strtoull(argv[0].a_un.a_str);
	len = (int)mdb_strtoull(argv[1].a_un.a_str);

	if (len <= 0) {
		mdb_printf("non positive len specified");
		return (DCMD_ERR);
	}

	if ((len - pos) > 2048) {
		mdb_printf("len out of range, 32 bit bitmask");
		return (DCMD_ERR);
	}

	first = st = FBA_TO_LOG_NUM(pos);
	en = FBA_TO_LOG_NUM(pos + len - 1);
	while (st <= en) {
		BMAP_BIT_SET((uchar_t *)&bitmask, st - first);
		st++;
	}

	mdb_printf("bitmask for POS: %d LEN: %d : 0x%08x (%s)", pos, len,
	    bitmask & 0xffffffff, print_bit(bitmask));
	return (DCMD_OK);

}

/*
 * Dump the bitmap of the krdc structure indicated by the index
 * argument. Used by the ZatoIchi tests.
 */
/*ARGSUSED*/
static int
rdc_bmapdump(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	rdc_k_info_t *rdc_k_info;
	int index;
	uintptr_t bmapaddr;
	uintptr_t bmapdata;
	unsigned char *data;
	int bmapsize;
	int i;
	int st = 0;
	int en = 0;

	if (argc < 1) {
		mdb_warn("must have index argument\n");
		return (DCMD_ERR);
	}

	i = argc;
	if (i == 3) {
		en = (int)mdb_strtoull(argv[2].a_un.a_str);
		en = FBA_TO_LOG_NUM(en);
		i--;
	}
	if (i == 2) {
		st = (int)mdb_strtoull(argv[1].a_un.a_str);
		st = FBA_TO_LOG_NUM(st);
	}

	index = (int)mdb_strtoull(argv[0].a_un.a_str);
	/*
	 * Find out where in memory the rdc_k_kinfo array starts
	 */
	if (mdb_readvar(&rdc_k_info, "rdc_k_info") == -1) {
		mdb_warn("failed to read 'rdc_k_info'");
		return (DCMD_ERR);
	}
	bmapaddr = (uintptr_t)(&rdc_k_info[index].bitmap_size);
	if (mdb_vread(&bmapsize, sizeof (bmapsize), bmapaddr)
	    != sizeof (bmapsize)) {
		mdb_warn("failed to read dcio_bitmap at %p\n", bmapaddr);
		return (DCMD_ERR);
	}

	bmapaddr = (uintptr_t)(&rdc_k_info[index].dcio_bitmap);
	if (mdb_vread(&bmapdata, sizeof (bmapdata), bmapaddr)
	    != sizeof (bmapdata)) {
		mdb_warn("failed to read dcio_bitmap at %p\n", bmapaddr);
		return (DCMD_ERR);
	}
	data = mdb_zalloc(bmapsize, UM_SLEEP);

	if (mdb_vread(data, bmapsize, bmapdata) != bmapsize) {
		mdb_warn("failed to read the bitmap data\n");
		mdb_free(data, bmapsize);
		return (DCMD_ERR);
	}
	mdb_printf("bitmap data address 0x%p bitmap size %d\n"
	    "kinfo 0x%p\n", bmapdata, bmapsize, &rdc_k_info[index]);

	if ((st < 0) || ((st/8) > bmapsize) || (en < 0)) {
		mdb_warn("offset is out of range st %d bms %d en %d",
		    st, bmapsize, en);
		return (DCMD_ERR);
	}
	if (((en/8) > bmapsize) || (en == 0))
		en = bmapsize * 8;

	mdb_printf("bit start pos: %d bit end pos: %d\n\n", st, en);
	st /= 8;
	en /= 8;
	for (i = st; i < en; i++) {
		mdb_printf("%02x ", data[i] & 0xff);
		if ((i % 16) == 15) {
			int s = LOG_TO_FBA_NUM((i-15)*8);
			int e = LOG_TO_FBA_NUM(((i+1)*8)) - 1;
			mdb_printf(" fbas: %x - %x\n", s, e);
		}
	}
	mdb_printf("\n");
	mdb_free(data, bmapsize);
	return (DCMD_OK);
}

/*
 * dump the bitmap reference count
 */
/*ARGSUSED*/
static int
rdc_brefdump(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	rdc_k_info_t *rdc_k_info;
	int index;
	uintptr_t bmapaddr;
	uintptr_t bmapdata;
	unsigned char *data;
	int bmapsize;
	int i;
	int st = 0;
	int en = 0;

	if (argc < 1) {
		mdb_warn("must have index argument\n");
		return (DCMD_ERR);
	}
	index = (int)mdb_strtoull(argv[0].a_un.a_str);

	i = argc;
	if (i == 3) {
		en = (int)mdb_strtoull(argv[2].a_un.a_str);
		en = FBA_TO_LOG_NUM(en);
		i--;

	}
	if (i == 2) {
		st = (int)mdb_strtoull(argv[1].a_un.a_str);
		st = FBA_TO_LOG_NUM(st);
	}

	/*
	 * Find out where in memory the rdc_k_kinfo array starts
	 */
	if (mdb_readvar(&rdc_k_info, "rdc_k_info") == -1) {
		mdb_warn("failed to read 'rdc_k_info'");
		return (DCMD_ERR);
	}
	bmapaddr = (uintptr_t)(&rdc_k_info[index].bitmap_size);

	if (mdb_vread(&bmapsize, sizeof (bmapsize), bmapaddr)
	    != sizeof (bmapsize)) {
		mdb_warn("failed to read dcio_bitmap at %p\n", bmapaddr);
		return (DCMD_ERR);
	}

	bmapsize *= 8;
	bmapaddr = (uintptr_t)(&rdc_k_info[index].bitmap_ref);

	if (mdb_vread(&bmapdata, sizeof (bmapdata), bmapaddr)
	    != sizeof (bmapdata)) {
		mdb_warn("failed to read dcio_bitmap at %p\n", bmapaddr);
		return (DCMD_ERR);
	}
	data = mdb_zalloc(bmapsize, UM_SLEEP);

	if (mdb_vread(data, bmapsize, bmapdata) != bmapsize) {
		mdb_warn("failed to read the bitmap data\n");
		mdb_free(data, bmapsize);
		return (DCMD_ERR);
	}
	mdb_printf("bitmap data address 0x%p bitmap size %d\n"
	    "kinfo 0x%p\n", bmapdata, bmapsize, &rdc_k_info[index]);

	if ((st < 0) || (st > bmapsize) || (en < 0)) {
		mdb_warn("offset is out of range");
	}
	if ((en > bmapsize) || (en == 0))
		en = bmapsize;

	mdb_printf("bit start pos: %d bit end pos: %d\n\n", st, en);

	for (i = st; i < en; i++) {
		mdb_printf("%02x ", data[i] & 0xff);
		if ((i % 16) == 15) {
			int s = LOG_TO_FBA_NUM(i-15);
			int e = LOG_TO_FBA_NUM(i+1) - 1;
			mdb_printf(" fbas: 0x%x - 0x%x \n", s, e);
		}
	}
	mdb_printf("\n");
	mdb_free(data, bmapsize);
	return (DCMD_OK);
}

static int
rdc_bmapnref(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	mdb_printf("\nRDC bitmap info\n");
	rdc_bmapdump(addr, flags, argc, argv);
	mdb_printf("RDC bitmap reference count info\n");
	rdc_brefdump(addr, flags, argc, argv);
	return (DCMD_OK);
}

#endif
/*
 * MDB module linkage information:
 */

static const mdb_dcmd_t dcmds[] = {
	{ "rdc", NULL, "display sndr module info", rdc },
	{ "rdc_buf", "?[-v]", "rdc_buf structure", rdc_buf },
	{ "rdc_kinfo", "?[-av]", "rdc_k_info structure", rdc_kinfo },
	{ "rdc_uinfo", "?[-av]", "rdc_u_info structure", rdc_uinfo },
	{ "rdc_group", "?", "rdc group structure", rdc_group },
	{ "rdc_srv", "?", "rdc_srv structure", rdc_srv },
	{ "rdc_if", "?", "rdc_if structure", rdc_if },
	{ "rdc_infodev", "?", "rdc_info_dev structure", rdc_infodev },
	{ "rdc_k2u", "?", "rdc_kinfo to rdc_uinfo", rdc_k2u },
	{ "rdc_u2k", "?", "rdc_uinfo to rdc_kinfo", rdc_u2k },
	{ "rdc_aio", "?", "rdc_aio structure", rdc_aio},
	{ "rdc_iohdr", "?", "rdc_iohdr structure", rdc_iohdr},
#ifdef DEBUG
	{ "rdc_setseq", "?", "Write seq field in group", rdc_setseq },
	{ "rdc_setseqack", "?", "Write seqack field in group", rdc_setseqack },
	{ "rdc_dset", "?", "Dump dset info", rdc_dset },
	{ "rdc_bmapdump", "?", "Dump bitmap", rdc_bmapdump },
	{ "rdc_brefdump", "?", "Dump bitmap reference count", rdc_brefdump },
	{ "rdc_bmapnref", "?", "Dump bitmap and ref count", rdc_bmapnref },
	{ "rdc_fba2log", "?", "fba to log num", fba_to_log_num },
	{ "rdc_log2fba", "?", "log to fba num", log_to_fba_num },
	{ "rdc_bitisset", "?", "check bit set", bmap_bit_isset },
	{ "rdc_brefisset", "?", "check bit ref set", bmap_bitref_isset },
	{ "rdc_indbyte", "?", "print indbyte", ind_byte },
	{ "rdc_indbit", "?", "print indbit", ind_bit },
	{ "rdc_bitmask", "?", "print bitmask for pos->len", rdc_bitmask },
#endif
	{ NULL }
};


static const mdb_walker_t walkers[] = {
	{ "rdc_kinfo", "walk the rdc_k_info array",
	    rdc_k_info_winit, rdc_k_info_wstep, rdc_k_info_wfini },
	{ "rdc_uinfo", "walk the rdc_u_info array",
	    rdc_u_info_winit, rdc_u_info_wstep, rdc_u_info_wfini },
	{ "rdc_if", "walk rdc_if chain",
	    rdc_if_winit, rdc_if_wstep, rdc_if_wfini },
	{ NULL }
};


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


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