xref: /onnv-gate/usr/src/cmd/mdb/common/modules/nsctl/nsctl.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/ksynch.h>
#include <sys/kmem.h>
#include <sys/errno.h>
#include <sys/ddi.h>

#include <sys/mdb_modapi.h>

#define	__NSC_GEN__
#include <sys/nsc_thread.h>
#include <sys/nsctl/nsc_dev.h>
#include <sys/nsctl/nsc_gen.h>
#include <sys/nsctl/nsc_mem.h>
#include <sys/nsctl/nsctl.h>
#include <sys/nsctl/nsc_disk.h>


/*
 * Data struct for the complex walks.
 */

struct complex_args {
	int		argc;
	mdb_arg_t	*argv;
};


/*
 * Bit definitions
 */

#define	NSC_RW_BITS	\
	{ "NSC_READ", NSC_READ, NSC_READ },	\
	{ "NSC_WRITE", NSC_WRITE, NSC_WRITE }


static const mdb_bitmask_t nsc_bhflag_bits[] = {
	NSC_RW_BITS,
	{ "NSC_PINNABLE", NSC_PINNABLE, NSC_PINNABLE },
	{ "NSC_NOBLOCK", NSC_NOBLOCK, NSC_NOBLOCK },
	{ "NSC_HALLOCATED", NSC_HALLOCATED, NSC_HALLOCATED },
	{ "NSC_HACTIVE", NSC_HACTIVE, NSC_HACTIVE },
	{ "NSC_BCOPY", NSC_BCOPY, NSC_BCOPY },
	{ "NSC_PAGEIO", NSC_PAGEIO, NSC_PAGEIO },
	{ "NSC_ABUF", NSC_ABUF, NSC_ABUF },
	{ "NSC_MIXED", NSC_MIXED, NSC_MIXED },
	{ "NSC_WRTHRU", NSC_WRTHRU, NSC_WRTHRU },
	{ "NSC_FORCED_WRTHRU", NSC_FORCED_WRTHRU, NSC_FORCED_WRTHRU },
	{ "NSC_NOCACHE", NSC_NOCACHE, NSC_NOCACHE },
	{ "NSC_QUEUE", NSC_QUEUE, NSC_QUEUE },
	{ "NSC_RDAHEAD", NSC_RDAHEAD, NSC_RDAHEAD },
	{ "NSC_NO_FORCED_WRTHRU", NSC_NO_FORCED_WRTHRU, NSC_NO_FORCED_WRTHRU },
	{ "NSC_METADATA", NSC_METADATA, NSC_METADATA },
	{ "NSC_SEQ_IO", NSC_SEQ_IO, NSC_SEQ_IO },
	{ NULL, 0, 0 }
};


static const mdb_bitmask_t nsc_fdflag_bits[] = {
	NSC_RW_BITS,
	{ NULL, 0, 0 }
};


static const mdb_bitmask_t nsc_fdmode_bits[] = {
	{ "NSC_MULTI", NSC_MULTI, NSC_MULTI },
	{ NULL, 0, 0 }
};


static const mdb_bitmask_t nsc_type_bits[] = {
	/* types */
	{ "NSC_NULL", NSC_NULL, NSC_NULL },
	{ "NSC_DEVICE", NSC_DEVICE, NSC_DEVICE },
	{ "NSC_FILE", NSC_FILE, NSC_FILE },
	{ "NSC_CACHE", NSC_CACHE, NSC_CACHE },
	{ "NSC_VCHR", NSC_VCHR, NSC_VCHR },
	{ "NSC_NCALL", NSC_NCALL, NSC_NCALL },

	/* type flags */
	{ "NSC_ANON", NSC_ANON, NSC_ANON },

	/* ids */
	{ "NSC_RAW_ID", NSC_RAW_ID, NSC_RAW_ID },
	{ "NSC_FILE_ID", NSC_FILE_ID, NSC_FILE_ID },
	{ "NSC_FREEZE_ID", NSC_FREEZE_ID, NSC_FREEZE_ID },
	{ "NSC_VCHR_ID", NSC_VCHR_ID, NSC_VCHR_ID },
	{ "NSC_NCALL_ID", NSC_NCALL_ID, NSC_NCALL_ID },
	{ "NSC_SDBC_ID", NSC_SDBC_ID, NSC_SDBC_ID },
	{ "NSC_RDCLR_ID", NSC_RDCLR_ID, NSC_RDCLR_ID },
	{ "NSC_RDCL_ID", NSC_RDCL_ID, NSC_RDCL_ID },
	{ "NSC_IIR_ID", NSC_IIR_ID, NSC_IIR_ID },
	{ "NSC_II_ID", NSC_II_ID, NSC_II_ID },
	{ "NSC_RDCHR_ID", NSC_RDCHR_ID, NSC_RDCHR_ID },
	{ "NSC_RDCH_ID", NSC_RDCH_ID, NSC_RDCH_ID },
	{ NULL, 0, 0 }
};


static const mdb_bitmask_t nsc_availpend_bits[] = {
	NSC_RW_BITS,
	{ "_NSC_OPEN", _NSC_OPEN, _NSC_OPEN },
	{ "_NSC_CLOSE", _NSC_CLOSE, _NSC_CLOSE },
	{ "_NSC_PINNED", _NSC_PINNED, _NSC_PINNED },
	{ "_NSC_ATTACH", _NSC_ATTACH, _NSC_ATTACH },
	{ "_NSC_DETACH", _NSC_DETACH, _NSC_DETACH },
	{ "_NSC_OWNER", _NSC_OWNER, _NSC_OWNER },
	{ NULL, 0, 0 }
};


static const mdb_bitmask_t nsc_ioflag_bits[] = {
	{ "NSC_REFCNT", NSC_REFCNT, NSC_REFCNT },
	{ "NSC_FILTER", NSC_FILTER, NSC_FILTER },
	{ NULL, 0, 0 }
};


static const mdb_bitmask_t nstset_flag_bits[] = {
	{ "NST_SF_KILL", NST_SF_KILL, NST_SF_KILL },
	{ NULL, 0, 0 }
};


static const mdb_bitmask_t nst_flag_bits[] = {
	{ "NST_TF_INUSE", NST_TF_INUSE, NST_TF_INUSE },
	{ "NST_TF_ACTIVE", NST_TF_ACTIVE, NST_TF_ACTIVE },
	{ "NST_TF_PENDING", NST_TF_PENDING, NST_TF_PENDING },
	{ "NST_TF_DESTROY", NST_TF_DESTROY, NST_TF_DESTROY },
	{ "NST_TF_KILL", NST_TF_KILL, NST_TF_KILL },
	{ NULL, 0, 0 }
};


/*
 * Global data.
 */

static nsc_mem_t type_mem[20];
static int complex_walk;
static int complex_hdr;


/* ---------------------------------------------------------------------- */

/*
 * Walker for an nsc_io chain.
 * A global walk is assumed to start at _nsc_io_top.
 */

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

	return (WALK_NEXT);
}


static int
nsc_io_wstep(mdb_walk_state_t *wsp)
{
	uintptr_t next;
	int status;

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

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

	next = wsp->walk_addr + OFFSETOF(nsc_io_t, next);

	if (mdb_vread(&wsp->walk_addr, sizeof (uintptr_t), next) == -1) {
		mdb_warn("failed to read nsc_io_t.next at %p", next);
		return (WALK_DONE);
	}

	return (status);
}


/* ---------------------------------------------------------------------- */

/*
 * Walker for an nsc_dev chain.
 * A global walk is assumed to start at _nsc_dev_top.
 */

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

	return (WALK_NEXT);
}


static int
nsc_dev_wstep(mdb_walk_state_t *wsp)
{
	uintptr_t next;
	int status;

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

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

	next = wsp->walk_addr + OFFSETOF(nsc_dev_t, nsc_next);

	if (mdb_vread(&wsp->walk_addr, sizeof (uintptr_t), next) == -1) {
		mdb_warn("failed to read nsc_dev_t.nsc_next at %p", next);
		return (WALK_DONE);
	}

	return (status);
}


/* ARGSUSED */

static void
nsc_dev_wfini(mdb_walk_state_t *wsp)
{
	complex_walk = 0;
}


/* ---------------------------------------------------------------------- */

/*
 * Walker for a chain of nsc_devval_t structures.
 * Global walks start from _nsc_devval_top;
 */

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

	return (WALK_NEXT);
}


static int
nsc_devval_wstep(mdb_walk_state_t *wsp)
{
	uintptr_t devval = wsp->walk_addr;
	int status;

	if (!devval)
		return (WALK_DONE);

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

	/* move on to next devval */

	if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
	    devval + OFFSETOF(nsc_devval_t, dv_next)) == -1) {
		mdb_warn("failed to read nsc_devval_t.dv_next");
		return (WALK_ERR);
	}

	return (status);
}


/* ---------------------------------------------------------------------- */

/*
 * Walker for a chain of nsc_fd_t structures.
 * No global walks.
 */

static int
nsc_fd_winit(mdb_walk_state_t *wsp)
{
	if (wsp->walk_addr == NULL) {
		mdb_warn("nsc_fd doesn't support global walks");
		return (WALK_ERR);
	}

	return (WALK_NEXT);
}


static int
nsc_fd_wstep(mdb_walk_state_t *wsp)
{
	uintptr_t fd = wsp->walk_addr;
	int status;

	if (!fd)
		return (WALK_DONE);

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

	/* move on to next fd */

	if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
	    fd + OFFSETOF(nsc_fd_t, sf_next)) == -1) {
		mdb_warn("failed to read nsc_fd_t.sf_next");
		return (WALK_ERR);
	}

	return (status);
}


/* ---------------------------------------------------------------------- */

/*
 * Walker for a chain of nsc_iodev_t structures.
 * No global walks.
 */

static int
nsc_iodev_winit(mdb_walk_state_t *wsp)
{
	if (wsp->walk_addr == NULL) {
		mdb_warn("nsc_iodev doesn't support global walks");
		return (WALK_ERR);
	}

	return (WALK_NEXT);
}


static int
nsc_iodev_wstep(mdb_walk_state_t *wsp)
{
	uintptr_t iodev = wsp->walk_addr;
	int status;

	if (!iodev)
		return (WALK_DONE);

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

	if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
	    iodev + OFFSETOF(nsc_iodev_t, si_next)) == -1) {
		mdb_warn("failed to read nsc_iodev_t.si_next");
		return (WALK_ERR);
	}

	return (status);
}


/* ---------------------------------------------------------------------- */

/*
 * Walker for a chain of nsc_service_t structures.
 * Global walks start at _nsc_services.
 */

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

	return (WALK_NEXT);
}


static int
nsc_service_wstep(mdb_walk_state_t *wsp)
{
	uintptr_t service = wsp->walk_addr;
	int status;

	if (!service)
		return (WALK_DONE);

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

	/* move on to next service */

	if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
	    service + OFFSETOF(nsc_service_t, s_next)) == -1) {
		mdb_warn("failed to read nsc_service_t.s_next");
		return (WALK_ERR);
	}

	return (status);
}


/* ---------------------------------------------------------------------- */

/*
 * Walker for a chain of nsc_svc_t structures.
 * No global walks.
 */

static int
nsc_svc_winit(mdb_walk_state_t *wsp)
{
	if (wsp->walk_addr == NULL) {
		mdb_warn("nsc_svc does not support global walks");
		return (WALK_ERR);
	}

	return (WALK_NEXT);
}


static int
nsc_svc_wstep(mdb_walk_state_t *wsp)
{
	uintptr_t svc = wsp->walk_addr;
	int status;

	if (!svc)
		return (WALK_DONE);

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

	/* move on to next svc */

	if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
	    svc + OFFSETOF(nsc_svc_t, svc_next)) == -1) {
		mdb_warn("failed to read nsc_svc_t.svc_next");
		return (WALK_ERR);
	}

	return (status);
}


/* ---------------------------------------------------------------------- */

/*
 * Walker for a chain of nsc_val_t structures.
 * No global walks.
 */

static int
nsc_val_winit(mdb_walk_state_t *wsp)
{
	if (wsp->walk_addr == NULL) {
		mdb_warn("nsc_val doesn't support global walks");
		return (WALK_ERR);
	}

	return (WALK_NEXT);
}


static int
nsc_val_wstep(mdb_walk_state_t *wsp)
{
	uintptr_t val = wsp->walk_addr;
	int status;

	if (!val)
		return (WALK_DONE);

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

	/* move on to next val */

	if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
	    val + OFFSETOF(nsc_val_t, sv_next)) == -1) {
		mdb_warn("failed to read nsc_val_t.sv_next");
		return (WALK_ERR);
	}

	return (status);
}


/* ---------------------------------------------------------------------- */

/*
 * Walker for a chain of nstset_t structures.
 * Global walks start at _nst_sets.
 */

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

	return (WALK_NEXT);
}


static int
nstset_wstep(mdb_walk_state_t *wsp)
{
	uintptr_t set = wsp->walk_addr;
	int status;

	if (!set)
		return (WALK_DONE);

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

	/* move on to next set */

	if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
	    set + OFFSETOF(nstset_t, set_next)) == -1) {
		mdb_warn("failed to read nstset_t.set_next");
		return (WALK_ERR);
	}

	return (status);
}


/* ---------------------------------------------------------------------- */

/*
 * Walker for a chain of nsthread_t structures.
 * No global walks.
 */

static int
nsthread_winit(mdb_walk_state_t *wsp)
{
	if (wsp->walk_addr == NULL) {
		mdb_warn("nsthread does not support global walks");
		return (WALK_ERR);
	}

	return (WALK_NEXT);
}


static int
nsthread_wstep(mdb_walk_state_t *wsp)
{
	uintptr_t thread = wsp->walk_addr;
	int status;

	if (!thread)
		return (WALK_DONE);

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

	/* move on to next iodev */

	if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
	    thread + OFFSETOF(nsthread_t, tp_chain)) == -1) {
		mdb_warn("failed to read nsthread_t.tp_chain");
		return (WALK_ERR);
	}

	return (status);
}


/* ---------------------------------------------------------------------- */

/*
 * Walker for nsthread_t free/reuse chain.
 * No global walks.
 */

static int
nst_free_winit(mdb_walk_state_t *wsp)
{
	if (wsp->walk_addr == NULL) {
		mdb_warn("nst_free does not support global walks");
		return (WALK_ERR);
	}

	/* store starting address */

	wsp->walk_data = (void *)wsp->walk_addr;

	/* move on to next thread */

	if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
	    wsp->walk_addr + OFFSETOF(nsthread_t, tp_link.q_forw)) == -1) {
		mdb_warn("failed to read nsthread_t.tp_link.q_forw");
		return (WALK_ERR);
	}

	return (WALK_NEXT);
}


static int
nst_free_wstep(mdb_walk_state_t *wsp)
{
	uintptr_t thread = wsp->walk_addr;
	int status;

	if (!thread)
		return (WALK_DONE);

	if (thread == (uintptr_t)wsp->walk_data)
		return (WALK_DONE);

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

	/* move on to next thread */

	if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
	    thread + OFFSETOF(nsthread_t, tp_link.q_forw)) == -1) {
		mdb_warn("failed to read nsthread_t.tp_link.q_forw");
		return (WALK_ERR);
	}

	return (status);
}


/* ---------------------------------------------------------------------- */

/*
 * Walker for a chain of nsc_mem_t structures.
 * Global walks start at _nsc_mem_top.
 */

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

	return (WALK_NEXT);
}


static int
nsc_mem_wstep(mdb_walk_state_t *wsp)
{
	uintptr_t mem = wsp->walk_addr;
	int status;

	if (!mem)
		return (WALK_DONE);

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

	/* move on to next mem */

	if (mdb_vread(&wsp->walk_addr, sizeof (wsp->walk_addr),
	    mem + OFFSETOF(nsc_mem_t, next)) == -1) {
		mdb_warn("failed to read nsc_mem_t.next");
		return (WALK_ERR);
	}

	return (status);
}


/* ---------------------------------------------------------------------- */

struct {
	char	*name;
	int	id;
} io_ids[] = {
	{ "NSC_RAW_ID", NSC_RAW_ID },
	{ "NSC_FILE_ID", NSC_FILE_ID },
	{ "NSC_FREEZE_ID", NSC_FREEZE_ID },
	{ "NSC_SDBC_ID", NSC_SDBC_ID },
	{ "NSC_RDCLR_ID", NSC_RDCLR_ID },
	{ "NSC_RDCL_ID", NSC_RDCL_ID },
	{ "NSC_IIR_ID", NSC_IIR_ID },
	{ "NSC_II_ID", NSC_II_ID },
	{ "NSC_RDCHR_ID", NSC_RDCHR_ID },
	{ "NSC_RDCH_ID", NSC_RDCH_ID },
	{ NULL, 0 }
};


static char *
nsc_io_id(const int id)
{
	int i;

	for (i = 0; io_ids[i].name != NULL; i++) {
		if (io_ids[i].id == id) {
			return (io_ids[i].name);
		}
	}

	return ("unknown");
}


/*
 * Display a single nsc_io_t structure.
 * If called with no address, performs a global walk of all nsc_ios.
 */
static int
nsc_io(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	char io_name[128];
	nsc_io_t *io;
	int v_opt;

	v_opt = 0;

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

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

		return (DCMD_OK);
	}

	io = mdb_zalloc(sizeof (*io), UM_SLEEP | UM_GC);
	memset(io_name, 0, sizeof (io_name));

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

	if (io->name) {
		if (mdb_readstr(io_name, sizeof (io_name),
		    (uintptr_t)io->name) == -1) {
			mdb_warn("failed to read nsc_io_t.name");
			return (DCMD_ERR);
		}
	}

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("%-?s  %8Tid       fl  ref abuf name\n", "io");
	}

	mdb_printf("%0?p  %8T%08x %2x %4d %4d %s\n",
	    addr, io->id, io->flag, io->refcnt, io->abufcnt, io_name);

	if (!v_opt)
		return (DCMD_OK);

	mdb_inc_indent(4);

	mdb_printf("id: %08x <%s>\n", io->id, nsc_io_id(io->id));

	mdb_printf("provide: %08x <%b>\n", io->provide,
	    io->provide, nsc_type_bits);

	mdb_printf("flag: %08x <%b>\n", io->flag, io->flag, nsc_ioflag_bits);

	mdb_printf("pend: %d\n", io->pend);

	mdb_dec_indent(4);

	return (DCMD_OK);
}


/* ---------------------------------------------------------------------- */

/*
 * Display a single nsc_dev_t structure.
 * If called with no address, performs a global walk of all nsc_devs.
 */
static int
nsc_dev(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	char path[NSC_MAXPATH+1];
	nsc_devval_t *dv;
	nsc_dev_t *dev;
	uintptr_t dev_pend;
	int a_opt, v_opt;

	a_opt = v_opt = 0;

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

	if (!(flags & DCMD_ADDRSPEC)) {
		mdb_printf("Active device structures:\n");

		if (mdb_walk_dcmd("nsctl`nsc_dev",
		    "nsctl`nsc_dev", argc, argv) == -1) {
			mdb_warn("failed to walk 'nsc_dev'");
			return (DCMD_ERR);
		}

		if (a_opt) {
			if (mdb_readvar(&dev_pend, "_nsc_dev_pend") == -1) {
				mdb_warn("failed to read _nsc_dev_pend");
				return (DCMD_ERR);
			}

			mdb_printf("\nPending device structures:");

			if (dev_pend) {
				mdb_printf("\n");

				if (mdb_pwalk_dcmd("nsctl`nsc_dev",
				    "nsctl`nsc_dev", argc, argv,
				    dev_pend) == -1) {
					mdb_warn("failed to walk "
					    "pending dev structs");
					return (DCMD_ERR);
				}
			} else {
				mdb_printf(" none\n");
			}
		}

		return (DCMD_OK);
	}

	memset(path, 0, sizeof (path));
	dev = mdb_zalloc(sizeof (*dev), UM_SLEEP | UM_GC);

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

	if (mdb_readstr(path, sizeof (path), (uintptr_t)dev->nsc_path) == -1) {
		mdb_warn("failed to read nsc_path at %p", dev->nsc_path);
		return (DCMD_ERR);
	}

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("%-?s  %8Tref pend rpnd wait path\n", "dev");
	}

	mdb_printf("%0?p  %8T%3d %4d %4d %4d %s\n",
	    addr, dev->nsc_refcnt, dev->nsc_pend, dev->nsc_rpend,
	    dev->nsc_wait, path);

	if (!v_opt)
		return (DCMD_OK);

	mdb_inc_indent(4);

	mdb_printf("next: %0?p  %8Tclose: %0?p\n",
	    dev->nsc_next, dev->nsc_close);

	mdb_printf("list: %0?p  %8Tlock: %0?p\n",
	    dev->nsc_list, addr + OFFSETOF(nsc_dev_t, nsc_lock));

	mdb_printf("cv: %0?p  %8Tpath: %0?p  %8Tphash: %016llx\n",
	    addr + OFFSETOF(nsc_dev_t, nsc_cv),
	    dev->nsc_path, dev->nsc_phash);

	mdb_printf("drop: %d  %8Treopen: %d\n",
	    dev->nsc_drop, dev->nsc_reopen);

	if (dev->nsc_values) {
		dv = mdb_zalloc(sizeof (*dv), UM_SLEEP | UM_GC);
		if (mdb_vread(dv, sizeof (*dv), (uintptr_t)dev->nsc_values) !=
		    sizeof (*dv)) {
			mdb_warn("unable to read nsc_dev_t.nsc_values");
			mdb_dec_indent(4);
			return (DCMD_ERR);
		}

		if (dv->dv_values) {
			mdb_printf("device/values: (nsc_devval: %0?p)\n",
			    dev->nsc_values);

			mdb_inc_indent(4);

			if (mdb_pwalk_dcmd("nsctl`nsc_val", "nsctl`nsc_val",
			    0, NULL, (uintptr_t)dv->dv_values) == -1) {
				mdb_dec_indent(8);
				return (DCMD_ERR);
			}

			mdb_dec_indent(4);
		}
	}

	mdb_dec_indent(4);

	return (DCMD_OK);
}


/* ---------------------------------------------------------------------- */

/*
 * Display a single nsc_devval_t structure.
 * If called with no address, performs a global walk of all nsc_devs.
 */
static int
nsc_devval(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	nsc_devval_t *dv;
	int a_opt;

	a_opt = 0;

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

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

		return (DCMD_OK);
	}

	dv = mdb_zalloc(sizeof (*dv), UM_SLEEP | UM_GC);

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

	if (!a_opt && !dv->dv_values) {
		return (DCMD_OK);
	}

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("%-?s  %8T%?-s  %8Tpath\n", "devval", "phash");
	}

	mdb_printf("%0?p  %8T%016llx  %8T%s\n", addr,
	    dv->dv_phash, dv->dv_path);

	mdb_inc_indent(4);

	if (dv->dv_values) {
		if (mdb_pwalk_dcmd("nsctl`nsc_val", "nsctl`nsc_val",
		    0, NULL, (uintptr_t)dv->dv_values) == -1) {
			return (DCMD_ERR);
		}
	} else {
		mdb_printf("No values\n");
	}

	mdb_dec_indent(4);

	return (DCMD_OK);
}


/* ---------------------------------------------------------------------- */

/*
 * Part 2 callback for the all devices and fds walk.  Called per iodev.
 */
/* ARGSUSED */
static int
nsc_fd_iodev(uintptr_t addr, const void *data, void *cbdata)
{
	struct complex_args *fdall = cbdata;
	struct nsc_fd_t *fd;

	if (mdb_vread(&fd, sizeof (fd),
	    addr + OFFSETOF(nsc_iodev_t, si_open)) == -1) {
		mdb_warn("unable to read nsc_iodev_t.si_open");
		return (WALK_ERR);
	}

	if (fd != NULL) {
		if (mdb_pwalk_dcmd("nsctl`nsc_fd", "nsctl`nsc_fd",
		    fdall->argc, fdall->argv, (uintptr_t)fd) == -1)
			return (WALK_ERR);
	}

	return (WALK_NEXT);
}


/*
 * Part 1 callback for the all devices and fds walk.  Called per device.
 */
/* ARGSUSED */
static int
nsc_fd_dev(uintptr_t addr, const void *data, void *cbdata)
{
	struct complex_args *fdall = cbdata;
	nsc_iodev_t *iodev;
	nsc_fd_t *fd;

	if (mdb_vread(&iodev, sizeof (iodev),
	    addr + OFFSETOF(nsc_dev_t, nsc_list)) == -1) {
		mdb_warn("unable to read nsc_dev_t.nsc_list at %p", addr);
		return (WALK_ERR);
	}

	/* walk iodev chains */

	if (iodev != NULL) {
		if (mdb_pwalk("nsctl`nsc_iodev",
		    nsc_fd_iodev, fdall, (uintptr_t)iodev) == -1)
			return (WALK_ERR);
	}

	/* walk nsc_close (closing fds) chains */

	if (mdb_vread(&fd, sizeof (fd),
	    addr + OFFSETOF(nsc_dev_t, nsc_close)) == -1) {
		mdb_warn("unable to read nsc_dev_t.nsc_close at %p", addr);
		return (WALK_ERR);
	}

	if (fd != NULL) {
		if (mdb_pwalk_dcmd("nsctl`nsc_fd", "nsctl`nsc_fd",
		    fdall->argc, fdall->argv, (uintptr_t)fd) == -1)
			return (WALK_ERR);
	}

	return (WALK_NEXT);
}


/*
 * Walk all devices and fds in the system.
 */
static int
nsc_fd_all(int argc, const mdb_arg_t *argv)
{
	struct complex_args fdall;

	fdall.argc = argc;
	fdall.argv = (mdb_arg_t *)argv;

	complex_walk = 1;
	complex_hdr = 0;

	if (mdb_walk("nsctl`nsc_dev", nsc_fd_dev, &fdall) == -1) {
		return (DCMD_ERR);
	}

	return (DCMD_OK);
}



/*
 * Display an nsd_fd_t structure, or walk all devices and fds in the system.
 */
static int
nsc_fd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	char io_name[128], *io_namep;
	char path[NSC_MAXPATH+1];
	uintptr_t pathp;
	nsc_fd_t *fd;
	nsc_io_t *io;
	int v_opt;
	int hdr;

	v_opt = 0;

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

	if (!(flags & DCMD_ADDRSPEC)) {
		return (nsc_fd_all(argc, argv));
	}

	memset(path, 0, sizeof (path));
	fd = mdb_zalloc(sizeof (*fd), UM_SLEEP | UM_GC);
	memset(io_name, 0, sizeof (io_name));

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

	if (mdb_vread(&pathp, sizeof (pathp),
	    (uintptr_t)fd->sf_dev + OFFSETOF(nsc_dev_t, nsc_path)) !=
	    sizeof (pathp)) {
		mdb_warn("failed to read nsc_dev.nsc_path");
		return (DCMD_ERR);
	}

	if (mdb_readstr(path, sizeof (path), pathp) == -1) {
		mdb_warn("failed to read nsc_path");
		return (DCMD_ERR);
	}

	if (fd->sf_iodev) {
		if (mdb_vread(&io, sizeof (io),
		    (uintptr_t)fd->sf_iodev + OFFSETOF(nsc_iodev_t, si_io)) !=
		    sizeof (io)) {
			mdb_warn("failed to read nsc_iodev.si_io");
			return (DCMD_ERR);
		}

		if (mdb_vread(&io_namep, sizeof (io_namep),
		    (uintptr_t)io + OFFSETOF(nsc_io_t, name)) !=
		    sizeof (io_namep)) {
			mdb_warn("failed to read nsc_io_t.name");
			return (DCMD_ERR);
		}

		if (mdb_readstr(io_name, sizeof (io_name),
		    (uintptr_t)io_namep) == -1) {
			mdb_warn("failed to read nsc_io_t.name string");
			return (DCMD_ERR);
		}
	}

	hdr = 0;
	if (complex_walk) {
		if (!complex_hdr) {
			complex_hdr = 1;
			hdr = 1;
		}
	} else if (DCMD_HDRSPEC(flags)) {
		hdr = 1;
	}

	if (hdr) {
		mdb_printf("%-?s  %8T%-?s  %8T%-8s  %-?s\n",
		    "fd", "dev", "io", "cd");
		mdb_printf("    %-?s  %8Trv pend av path\n", "arg");
	}

	mdb_printf("%0?p  %8T%0?p  %8T%-8s  %p\n",
	    addr, fd->sf_dev, io_name, fd->sf_cd);
	mdb_printf("    %0?p  %8T%2d %4x %2x %s\n",
	    fd->sf_arg, fd->sf_reserve, fd->sf_pend,
	    fd->sf_avail, path);

	if (!v_opt)
		return (DCMD_OK);

	mdb_inc_indent(4);

	mdb_printf("open type: %08x <%b>\n", fd->sf_type,
	    fd->sf_type, nsc_type_bits);

	mdb_printf("avail: %08x <%b>\n", fd->sf_avail,
	    fd->sf_avail, nsc_availpend_bits);

	mdb_printf("flag: %08x <%b>\n", fd->sf_flag,
	    fd->sf_flag, nsc_fdflag_bits);

	mdb_printf("rsrv mode: %08x <%b>\n", fd->sf_mode,
	    fd->sf_mode, nsc_fdmode_bits);

	mdb_printf("open lbolt: %?x  %8Treopen: %d\n", fd->sf_lbolt,
	    fd->sf_reopen);

	mdb_dec_indent(4);

	return (DCMD_OK);
}


/* ---------------------------------------------------------------------- */

/*
 * Callback for the all devices and iodevs walk.  Called per device.
 */
/* ARGSUSED */
static int
nsc_iodev_dev(uintptr_t addr, const void *data, void *cbdata)
{
	struct complex_args *iodevall = cbdata;
	uintptr_t iodev;

	if (mdb_vread(&iodev, sizeof (iodev),
	    addr + OFFSETOF(nsc_dev_t, nsc_list)) == -1) {
		mdb_warn("unable to read nsc_dev_t.nsc_list at %p", addr);
		return (WALK_ERR);
	}

	/* walk iodev chains */

	if (iodev != NULL) {
		if (mdb_pwalk_dcmd("nsctl`nsc_iodev", "nsctl`nsc_iodev",
		    iodevall->argc, iodevall->argv, iodev) == -1)
			return (WALK_ERR);
	}

	return (WALK_NEXT);
}


/*
 * Walk all devices and iodevs in the system.
 */
static int
nsc_iodev_all(int argc, const mdb_arg_t *argv)
{
	struct complex_args iodevall;

	iodevall.argc = argc;
	iodevall.argv = (mdb_arg_t *)argv;

	complex_walk = 1;
	complex_hdr = 0;

	if (mdb_walk("nsctl`nsc_dev", nsc_iodev_dev, &iodevall) == -1) {
		return (DCMD_ERR);
	}

	return (DCMD_OK);
}


/*
 * Display an nsc_iodev_t structure, or walk all devices and
 * iodevs in the system.
 */
static int
nsc_iodev(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	char io_name[128], *io_namep;
	char path[NSC_MAXPATH+1];
	nsc_iodev_t *iodev;
	uintptr_t pathp;
	int v_opt;
	int hdr;

	v_opt = 0;

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

	if (!(flags & DCMD_ADDRSPEC)) {
		return (nsc_iodev_all(argc, argv));
	}

	memset(path, 0, sizeof (path));
	iodev = mdb_zalloc(sizeof (*iodev), UM_SLEEP | UM_GC);
	memset(io_name, 0, sizeof (io_name));

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

	if (mdb_vread(&pathp, sizeof (pathp),
	    (uintptr_t)iodev->si_dev + OFFSETOF(nsc_dev_t, nsc_path)) !=
	    sizeof (pathp)) {
		mdb_warn("failed to read nsc_dev.nsc_path");
		return (DCMD_ERR);
	}

	if (mdb_readstr(path, sizeof (path), pathp) == -1) {
		mdb_warn("failed to read nsc_path");
		return (DCMD_ERR);
	}

	if (mdb_vread(&io_namep, sizeof (io_namep),
	    (uintptr_t)iodev->si_io + OFFSETOF(nsc_io_t, name)) !=
	    sizeof (io_namep)) {
		mdb_warn("failed to read nsc_io_t.name");
		return (DCMD_ERR);
	}

	if (mdb_readstr(io_name, sizeof (io_name),
	    (uintptr_t)io_namep) == -1) {
		mdb_warn("failed to read nsc_io_t.name string");
		return (DCMD_ERR);
	}

	hdr = 0;
	if (complex_walk) {
		if (!complex_hdr) {
			complex_hdr = 1;
			hdr = 1;
		}
	} else if (DCMD_HDRSPEC(flags)) {
		hdr = 1;
	}

	if (hdr) {
		mdb_printf("%-?s  %8T%-?s  ref %-8s path\n",
		    "iodev", "dev", "io");
	}

	mdb_printf("%0?p  %8T%0?p  %3d %-8s %s\n",
	    addr, iodev->si_dev, iodev->si_refcnt, io_name, path);

	if (!v_opt)
		return (DCMD_OK);

	mdb_inc_indent(4);

	mdb_printf("open fds: %?p  %8Tactive ios: %?p\n",
	    iodev->si_open, iodev->si_active);

	mdb_printf("busy: %d  %8Trsrv pend: %d\n",
	    iodev->si_busy, iodev->si_rpend);

	mdb_printf("pend: %08x <%b>\n", iodev->si_pend,
	    iodev->si_pend, nsc_availpend_bits);

	mdb_printf("avail: %08x <%b>\n", iodev->si_avail,
	    iodev->si_avail, nsc_availpend_bits);

	mdb_dec_indent(4);

	return (DCMD_OK);
}


/* ---------------------------------------------------------------------- */

/*
 * Display an nsc_service_t structure, or walk all services.
 */
static int
nsc_service(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	nsc_service_t *service;
	char s_name[32];
	int v_opt;

	v_opt = 0;

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

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

		return (DCMD_OK);
	}

	service = mdb_zalloc(sizeof (*service), UM_SLEEP | UM_GC);

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

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("%-?s  %8Tname\n", "service");
	}

	memset(s_name, 0, sizeof (s_name));
	if (service->s_name) {
		if (mdb_readstr(s_name, sizeof (s_name),
		    (uintptr_t)service->s_name) == -1) {
			mdb_warn("failed to read nsc_io_t.name");
			return (DCMD_ERR);
		}
	}

	mdb_printf("%0?p  %8T%s\n", addr, s_name);

	if (!v_opt)
		return (DCMD_OK);

	mdb_inc_indent(4);

	mdb_printf("servers:\n");
	if (service->s_servers == NULL) {
		mdb_printf("<none>\n");
	} else {
		mdb_inc_indent(4);
		if (mdb_pwalk_dcmd("nsctl`nsc_svc", "nsctl`nsc_svc",
		    argc, argv, (uintptr_t)service->s_servers) == -1) {
			mdb_dec_indent(8);
			return (DCMD_ERR);
		}
		mdb_dec_indent(4);
	}

	mdb_printf("clients:\n");
	if (service->s_clients == NULL) {
		mdb_printf("<none>\n");
	} else {
		mdb_inc_indent(4);
		if (mdb_pwalk_dcmd("nsctl`nsc_svc", "nsctl`nsc_svc",
		    argc, argv, (uintptr_t)service->s_clients) == -1) {
			mdb_dec_indent(8);
			return (DCMD_ERR);
		}
		mdb_dec_indent(4);
	}

	mdb_dec_indent(4);

	return (DCMD_OK);
}


/* ---------------------------------------------------------------------- */

/*
 * Display an nsc_svc_t structure.
 */
/*ARGSUSED*/
static int
nsc_svc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	nsc_svc_t *svc;

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

	svc = mdb_zalloc(sizeof (*svc), UM_SLEEP | UM_GC);

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

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("%-?s  %8T%-?s  %8Tfunc\n", "svc", "service");
	}

	mdb_printf("%0?p  %8T%0?p  %8T%a\n", addr, svc->svc_svc, svc->svc_fn);
	return (DCMD_OK);
}


/* ---------------------------------------------------------------------- */

/*
 * Display a single nsc_val_t structure.
 * If called with no address, performs a global walk of all nsc_devs.
 */
/* ARGSUSED3 */
static int
nsc_val(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	nsc_val_t *vp;

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

	if (!(flags & DCMD_ADDRSPEC)) {
		mdb_warn("nsc_val requires an address");
		return (DCMD_ERR);
	}

	vp = mdb_zalloc(sizeof (*vp), UM_SLEEP | UM_GC);

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

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("%-?s  %8T%8-s  %8Tname\n", "val", "value");
	}

	mdb_printf("%0?p  %8T%08x  %8T%s\n", addr, vp->sv_value, vp->sv_name);

	return (DCMD_OK);
}


/* ---------------------------------------------------------------------- */

/*
 * Display an nstset_t structure, or walk all sets.
 */

static int
nstset(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	nstset_t *set;
	int f_opt, r_opt, t_opt, v_opt;

	f_opt = r_opt = t_opt = v_opt = 0;

	if (mdb_getopts(argc, argv,
	    'f', MDB_OPT_SETBITS, TRUE, &f_opt,		/* free list */
	    'r', MDB_OPT_SETBITS, TRUE, &r_opt,		/* reuse list */
	    't', MDB_OPT_SETBITS, TRUE, &t_opt,		/* all threads */
	    'v', MDB_OPT_SETBITS, TRUE, &v_opt) != argc)
		return (DCMD_USAGE);

	/* displaying threads implies verbose */
	if (f_opt || r_opt || t_opt)
		v_opt = 1;

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

		return (DCMD_OK);
	}

	set = mdb_zalloc(sizeof (*set), UM_SLEEP | UM_GC);

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

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("%-?s  %8T  live   nthr flag name\n", "set");
	}

	mdb_printf("%0?p  %8T%6d %6d %4x %s\n", addr,
	    set->set_nlive, set->set_nthread, set->set_flag, set->set_name);

	if (!v_opt)
		return (DCMD_OK);

	mdb_inc_indent(4);

	mdb_printf("chain: %0?p  %8Tpending: %4d  res_cnt: %4d\n",
	    set->set_chain, set->set_pending, set->set_res_cnt);

	if (set->set_reuse.q_forw == set->set_reuse.q_back &&
	    (uintptr_t)set->set_reuse.q_forw ==
	    (addr + OFFSETOF(nstset_t, set_reuse))) {
		mdb_printf("reuse.forw: %-?s  %8Treuse.back: %s\n",
		    "empty", "empty");
	} else {
		mdb_printf("reuse.forw: %0?p  %8Treuse.back: %0?p\n",
		    set->set_reuse.q_forw, set->set_reuse.q_back);

		/* display all threads in reuse list */
		if (r_opt &&
		    mdb_pwalk_dcmd("nsctl`nst_free", "nsctl`nsthread",
		    0, (const mdb_arg_t *)NULL,
		    (addr + OFFSETOF(nstset_t, set_reuse))) == -1) {
			mdb_dec_indent(4);
			return (DCMD_ERR);
		}
	}

	if (set->set_free.q_forw == set->set_free.q_back &&
	    (uintptr_t)set->set_free.q_forw ==
	    (addr + OFFSETOF(nstset_t, set_free))) {
		mdb_printf("free.forw:  %-?s  %8Tfree.back:  %s\n",
		    "empty", "empty");
	} else {
		mdb_printf("free.forw:  %0?p  %8Tfree.back:  %0?p\n",
		    set->set_free.q_forw, set->set_free.q_back);

		/* display all threads in free list */
		if (f_opt &&
		    mdb_pwalk_dcmd("nsctl`nst_free", "nsctl`nsthread",
		    0, (const mdb_arg_t *)NULL,
		    (addr + OFFSETOF(nstset_t, set_free))) == -1) {
			mdb_dec_indent(4);
			return (DCMD_ERR);
		}
	}

	mdb_printf("flag: %08x <%b>\n",
	    set->set_flag, set->set_flag, nstset_flag_bits);

	/* display all threads in set */
	if (t_opt) {
		mdb_printf("all threads in set:\n");
		if (mdb_pwalk_dcmd("nsctl`nsthread", "nsctl`nsthread",
		    0, (const mdb_arg_t *)NULL,
		    (uintptr_t)set->set_chain) == -1) {
			mdb_dec_indent(4);
			return (DCMD_ERR);
		}
	}

	mdb_dec_indent(4);

	return (DCMD_OK);
}


/* ---------------------------------------------------------------------- */

/*
 * Callback for the all nstsets and threads walk.  Called per set.
 */
/* ARGSUSED */
static int
nst_thr_set(uintptr_t addr, const void *data, void *cbdata)
{
	struct complex_args *thrall = cbdata;
	char set_name[48];
	uintptr_t tp;

	if (mdb_vread(&tp, sizeof (tp),
	    addr + OFFSETOF(nstset_t, set_chain)) == -1) {
		mdb_warn("unable to read nstset_t.set_chain at %p", addr);
		return (WALK_ERR);
	}

	memset(set_name, 0, sizeof (set_name));

	if (mdb_readstr(set_name, sizeof (set_name),
	    addr + OFFSETOF(nstset_t, set_name)) == -1) {
		mdb_warn("unable to read nstset_t.set_name at %p", addr);
	}

	mdb_printf("nstset: %0?p (%s)\n", addr, set_name);

	/* walk thread chains */

	if (tp != NULL) {
		if (mdb_pwalk_dcmd("nsctl`nsthread", "nsctl`nsthread",
		    thrall->argc, thrall->argv, tp) == -1)
			return (WALK_ERR);
	} else
		mdb_printf("    no threads\n");

	mdb_printf("\n");

	return (WALK_NEXT);
}


/*
 * Walk all nstsets and threads in the system.
 */
static int
nst_thr_all(int argc, const mdb_arg_t *argv)
{
	struct complex_args thrall;

	thrall.argc = argc;
	thrall.argv = (mdb_arg_t *)argv;

	if (mdb_walk("nsctl`nstset", nst_thr_set, &thrall) == -1)
		return (DCMD_ERR);

	return (DCMD_OK);
}


/*
 * Display an nsthread_t structure, or walk all threads.
 */

static int
nsthread(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	uintptr_t thrpend;
	nsthread_t *tp;
	int a_opt, v_opt;
	int rc;

	a_opt = v_opt = 0;

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

	if (!(flags & DCMD_ADDRSPEC)) {
		if ((rc = nst_thr_all(argc, argv)) != DCMD_OK)
			return (rc);

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

			if (thrpend) {
				mdb_printf("\nPending threads:\n");

				if (mdb_pwalk_dcmd("nsctl`nsthread",
				    "nsctl`nsthread", argc, argv,
				    thrpend) == -1) {
					mdb_warn("failed to walk 'nsthread'");
					return (DCMD_ERR);
				}
			}
		}

		return (DCMD_OK);
	}

	tp = mdb_zalloc(sizeof (*tp), UM_SLEEP | UM_GC);

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

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("%-?s  %8Tflag %-?s  %8Tfunc\n", "thread", "arg");
	}

	mdb_printf("%0?p  %8T%4x %0?p  %8T%a\n",
	    addr, tp->tp_flag, tp->tp_arg, tp->tp_func);

	if (!v_opt)
		return (DCMD_OK);

	mdb_inc_indent(4);

	mdb_printf("set: %0?p  %8Tchain: %0?p\n",
	    tp->tp_set, tp->tp_chain);

	mdb_printf("link.forw: %0?p  %8Tlink.back: %0?p\n",
	    tp->tp_link.q_forw, tp->tp_link.q_back);

	mdb_printf("flag: %08x <%b>\n",
	    tp->tp_flag, tp->tp_flag, nst_flag_bits);

	mdb_dec_indent(4);

	return (DCMD_OK);
}


/* ---------------------------------------------------------------------- */

static void
nsc_rmap(char *name)
{
	nsc_rmmap_t slot;
	uintptr_t addr;
	int nslot;
	char *cp;

	if (mdb_readvar(&addr, name) == -1) {
		mdb_warn("unable to read rmap '%s'", name);
		return;
	}

	if (mdb_vread(&slot, sizeof (slot), addr) != sizeof (slot)) {
		mdb_warn("unable to read rmap '%s' slot 0", name);
		return;
	}

	mdb_printf("\nmap name		offset      size    nslot\n");
	mdb_printf("%16s     %9d %9d    %5d\n",
	    slot.name, slot.offset, slot.size, slot.inuse);

	nslot = slot.inuse;
	mdb_printf("\nslot name	       offset      size    inuse\n");

	while (--nslot) {
		addr += sizeof (slot);

		if (mdb_vread(&slot, sizeof (slot), addr) != sizeof (slot)) {
			mdb_warn("unable to read rmap '%s' slot @ %p",
			    name, addr);
			return;
		}

		if (!slot.inuse || !slot.size)
			continue;

		for (cp = slot.name; *cp; cp++)
			if (*cp == ':')
				*cp = ' ';

		mdb_printf("%16s     %9d %9d %08x\n",
		    slot.name, slot.offset, slot.size, slot.inuse);
	}
}


static void
nsc_rmhdr(void)
{
	nsc_rmhdr_t *rmhdr = mdb_zalloc(sizeof (*rmhdr), UM_SLEEP | UM_GC);
	uintptr_t addr;

	if (mdb_readvar(&addr, "_nsc_rmhdr_ptr") == -1) {
		mdb_warn("unable to read _nsc_rmhdr_ptr");
		return;
	}

	if (!addr) {
		mdb_printf("\n\nGlobal header not initialised\n");
		return;
	}

	if (mdb_vread(rmhdr, sizeof (*rmhdr), addr) != sizeof (*rmhdr)) {
		mdb_warn("unable to read global header at %p", addr);
		return;
	}

	mdb_printf("\n\nglobal header    (magic %08x, version %d, size %d)\n",
	    rmhdr->magic, rmhdr->ver, rmhdr->size);

	nsc_rmap("_nsc_global_map");
}


static nsc_mem_t *
memptr(int type, int flag)
{
	int i;

	type &= NSC_MEM_GLOBAL;

	if (type)
		flag = 0;

	if (!type && !flag)
		return (&type_mem[0]);

	for (i = 1; i < (sizeof (type_mem) / sizeof (nsc_mem_t)); i++) {
		if (!type_mem[i].flag && !type_mem[i].type) {
			type_mem[i].flag = flag;
			type_mem[i].type = type;
			return (&type_mem[i]);
		}

		if (type_mem[i].flag == flag && type_mem[i].type == type)
			return (&type_mem[i]);
	}

	return (&type_mem[i]);
}


#define	typename(t)	\
		(((t) & NSC_MEM_GLOBAL) ? "gbl" : " - ")

#define	memname(t)	\
		(((t) & NSC_MEM_GLOBAL) ? "nsc_global" : "system kmem")

static void
nsc_mem_type(const int first, nsc_mem_t *mp)
{
	char *type, *name;

	if (first) {
		mdb_printf("\nregion	   typ  f      ");
		mdb_printf("used       hwm    pgs  alloc  free\n");
	}

	type = typename(mp->type);
	name = memname(mp->type);

	mdb_printf("%16s %s %2x %9d %9d %6d  %5d %5d\n",
	    name, type, mp->flag, mp->used, mp->hwm, mp->pagehwm,
	    mp->nalloc, mp->nfree);
}


static int
nsc_mem_all(int argc, const mdb_arg_t *argv, int v_opt)
{
	int first;
	int i;

	memset(type_mem, 0, sizeof (type_mem));

	if (mdb_walk_dcmd("nsctl`nsc_mem",
	    "nsctl`nsc_mem", argc, argv) == -1) {
		mdb_warn("unable to walk 'nsc_mem'");
		return (DCMD_ERR);
	}

	for (first = 1, i = 0;
	    i < (sizeof (type_mem) / sizeof (nsc_mem_t)); first = 0, i++) {
		if (type_mem[i].nalloc || type_mem[i].hwm) {
			nsc_mem_type(first, &type_mem[i]);
		}
	}

	if (v_opt)
		nsc_rmhdr();

	return (DCMD_OK);
}


static int
nsc_mem(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	char name[16], *type, *cp;
	nsc_mem_t mem, *mp;
	int v_opt;

	v_opt = 0;

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

	if (!(flags & DCMD_ADDRSPEC)) {
		return (nsc_mem_all(argc, argv, v_opt));
	}

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

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

	if (!mem.nalloc && !mem.hwm && !v_opt)
		return (DCMD_OK);

	if (DCMD_HDRSPEC(flags)) {
		mdb_printf("name	     typ  f      ");
		mdb_printf("used       hwm   pgs alloc  free     base\n");
	}

	type = typename(mem.type);
	mp = memptr(mem.type, mem.flag);

	for (cp = name; *cp; cp++)
		if (*cp == ':')
			*cp = ' ';

	mdb_printf("%-16s %s %2x %9d %9d %5d %5d %5d %0?p\n",
	    name, type, mem.flag, mem.used, mem.hwm, mem.pagehwm,
	    mem.nalloc, mem.nfree, mem.base);

	mp->used += mem.used;
	mp->hwm += mem.hwm;
	mp->pagehwm += mem.pagehwm;
	mp->nalloc += mem.nalloc;
	mp->nfree += mem.nfree;

	return (DCMD_OK);
}

/*ARGSUSED*/
static int
nsc_vec(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	nsc_vec_t *vec;

	vec = mdb_zalloc(sizeof (*vec), UM_SLEEP | UM_GC);
	if (mdb_vread(vec, sizeof (*vec), addr) != sizeof (*vec)) {
		mdb_warn("failed to read nsc_vec at %p", addr);
		return (DCMD_ERR);
	}
	mdb_printf("nsc_vec_t @ 0x%p = {\n", addr);
	mdb_inc_indent(4);
	mdb_printf("sv_addr: %p\n", vec->sv_addr);
	mdb_printf("sv_vme:  %lu\n", vec->sv_vme);
	mdb_printf("sv_len:  %d\n", vec->sv_len);
	mdb_dec_indent(4);
	mdb_printf("};\n");
	if (vec->sv_addr)
		return (DCMD_OK);
	else
		return (DCMD_ERR);
}

/* ---------------------------------------------------------------------- */
/*
 * Display an nsc_buf_t structure.
 */

#ifdef NSC_MULTI_TERABYTE
#define	STRCONV	"ll"
#else
#define	STRCONV	""
#endif

/* ARGSUSED */
static int
nsc_buf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	nsc_buf_t *bh;
	nsc_vec_t *v;

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

	bh = mdb_zalloc(sizeof (*bh), UM_SLEEP | UM_GC);

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

	mdb_printf("nsc_buf_t @ 0x%p = {\n", addr);
	mdb_inc_indent(4);
	mdb_printf("sb_fd:    0x%p\n", bh->sb_fd);
	mdb_printf("sb_pos:   0x%" STRCONV "x\n", bh->sb_pos);
	mdb_printf("sb_len:   0x%" STRCONV "x\n", bh->sb_len);
	mdb_printf("sb_flag:  0x%08x <%b>\n", bh->sb_flag,
	    bh->sb_flag, nsc_bhflag_bits);
	mdb_printf("sb_error: %d\n", bh->sb_error);
#ifdef NSC_MULTI_TERABYTE
	mdb_printf("sb_user:  0x%p\n", bh->sb_user);
#else
	mdb_printf("sb_user:  0x%x\n", bh->sb_user);
#endif
	mdb_printf("sb_vec:   0x%p\n", bh->sb_vec);
	v = bh->sb_vec++;
	while (nsc_vec((uintptr_t)v, flags, argc, argv) == DCMD_OK)
		v++;

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

	return (DCMD_OK);
}

/* ---------------------------------------------------------------------- */

/* ARGSUSED */
static int
nsc_dbuf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
{
	nsc_dbuf_t *bh;

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

	bh = mdb_zalloc(sizeof (*bh), UM_SLEEP | UM_GC);

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

	mdb_printf("nsc_dbuf_t @ 0x%p = {\n", addr);
	mdb_inc_indent(4);
	mdb_printf("db_disc:    0x%p\n", bh->db_disc);
	mdb_printf("db_addr:    0x%p\n", bh->db_addr);
	mdb_printf("db_next:    0x%p\n", bh->db_next);
	mdb_printf("db_maxfbas: 0x%d\n", bh->db_maxfbas);


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

	return (DCMD_OK);
}
/* ---------------------------------------------------------------------- */

/*
 * MDB module linkage information:
 */

static const mdb_dcmd_t dcmds[] = {
#if 0
	{ "nsctl", NULL, "display nsctl module info", nsctl },
#endif
	{ "nsc_buf", ":", "list nsc_buf structure", nsc_buf },
	{ "nsc_dbuf", ":", "list nsc_dbuf structure", nsc_dbuf },
	{ "nsc_dev", "?[-av]", "list nsc_dev structure", nsc_dev },
	{ "nsc_devval", "?[-a]", "list nsc_devval structure", nsc_devval },
	{ "nsc_fd", "?[-v]", "list nsc_fd structure", nsc_fd },
	{ "nsc_iodev", "?[-v]", "list nsc_iodev structure", nsc_iodev },
	{ "nsc_io", "?[-v]", "list nsc_io structure", nsc_io },
	{ "nsc_mem", "?[-v]", "list nsc_mem structure", nsc_mem },
	{ "nsc_svc", ":", "list nsc_svc structure", nsc_svc },
	{ "nsc_service", "?[-v]", "list nsc_service structure", nsc_service },
	{ "nsc_val", ":", "list nsc_val structure", nsc_val },
	{ "nstset", "?[-frtv]", "list nstset structure", nstset },
	{ "nsthread", "?[-av]", "list nsthread structure", nsthread },
	{ NULL }
};


static const mdb_walker_t walkers[] = {
	{ "nsc_dev", "walk nsc_dev chain",
	    nsc_dev_winit, nsc_dev_wstep, nsc_dev_wfini, NULL },
	{ "nsc_devval", "walk nsc_devval chain",
	    nsc_devval_winit, nsc_devval_wstep, NULL, NULL },
	{ "nsc_fd", "walk nsc_fd chain",
	    nsc_fd_winit, nsc_fd_wstep, NULL, NULL },
	{ "nsc_io", "walk nsc_io chain",
	    nsc_io_winit, nsc_io_wstep, NULL, NULL },
	{ "nsc_iodev", "walk nsc_iodev chain",
	    nsc_iodev_winit, nsc_iodev_wstep, NULL, NULL },
	{ "nsc_mem", "walk nsc_mem chain",
	    nsc_mem_winit, nsc_mem_wstep, NULL, NULL },
	{ "nsc_service", "walk nsc_service chain",
	    nsc_service_winit, nsc_service_wstep, NULL, NULL },
	{ "nsc_svc", "walk nsc_svc chain",
	    nsc_svc_winit, nsc_svc_wstep, NULL, NULL },
	{ "nsc_val", "walk nsc_val chain",
	    nsc_val_winit, nsc_val_wstep, NULL, NULL },
	{ "nstset", "walk nstset chain",
	    nstset_winit, nstset_wstep, NULL, NULL },
	{ "nsthread", "walk nsthread chain",
	    nsthread_winit, nsthread_wstep, NULL, NULL },
	{ "nst_free", "walk nsthread free/reuse list",
	    nst_free_winit, nst_free_wstep, NULL, NULL },
	{ NULL }
};


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


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