/*
* 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);
}