xref: /illumos-gate/usr/src/cmd/mdb/common/modules/genunix/genunix.c (revision 4c06356b0f0fffb4fc1b6eccc8e5d8e2254a84d6)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
5154eb83fSjwadams  * Common Development and Distribution License (the "License").
6154eb83fSjwadams  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
217c478bd9Sstevel@tonic-gate /*
225febcb4aSScott Carter, SD IOSW  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
237c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
247c478bd9Sstevel@tonic-gate  */
257c478bd9Sstevel@tonic-gate 
267c478bd9Sstevel@tonic-gate #include <mdb/mdb_param.h>
277c478bd9Sstevel@tonic-gate #include <mdb/mdb_modapi.h>
287c478bd9Sstevel@tonic-gate #include <mdb/mdb_ks.h>
297c478bd9Sstevel@tonic-gate #include <mdb/mdb_ctf.h>
307c478bd9Sstevel@tonic-gate 
317c478bd9Sstevel@tonic-gate #include <sys/types.h>
327c478bd9Sstevel@tonic-gate #include <sys/thread.h>
337c478bd9Sstevel@tonic-gate #include <sys/session.h>
347c478bd9Sstevel@tonic-gate #include <sys/user.h>
357c478bd9Sstevel@tonic-gate #include <sys/proc.h>
367c478bd9Sstevel@tonic-gate #include <sys/var.h>
377c478bd9Sstevel@tonic-gate #include <sys/t_lock.h>
3887a18d3fSMadhavan Venkataraman #include <sys/systm.h>
397c478bd9Sstevel@tonic-gate #include <sys/callo.h>
407c478bd9Sstevel@tonic-gate #include <sys/priocntl.h>
417c478bd9Sstevel@tonic-gate #include <sys/class.h>
427c478bd9Sstevel@tonic-gate #include <sys/regset.h>
437c478bd9Sstevel@tonic-gate #include <sys/stack.h>
447c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h>
457c478bd9Sstevel@tonic-gate #include <sys/vnode.h>
467c478bd9Sstevel@tonic-gate #include <sys/vfs.h>
477c478bd9Sstevel@tonic-gate #include <sys/flock_impl.h>
487c478bd9Sstevel@tonic-gate #include <sys/kmem_impl.h>
497c478bd9Sstevel@tonic-gate #include <sys/vmem_impl.h>
507c478bd9Sstevel@tonic-gate #include <sys/kstat.h>
517c478bd9Sstevel@tonic-gate #include <vm/seg_vn.h>
527c478bd9Sstevel@tonic-gate #include <vm/anon.h>
537c478bd9Sstevel@tonic-gate #include <vm/as.h>
547c478bd9Sstevel@tonic-gate #include <vm/seg_map.h>
557c478bd9Sstevel@tonic-gate #include <sys/dditypes.h>
567c478bd9Sstevel@tonic-gate #include <sys/ddi_impldefs.h>
577c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
587c478bd9Sstevel@tonic-gate #include <sys/sysconf.h>
597c478bd9Sstevel@tonic-gate #include <sys/task.h>
607c478bd9Sstevel@tonic-gate #include <sys/project.h>
617c478bd9Sstevel@tonic-gate #include <sys/taskq.h>
627c478bd9Sstevel@tonic-gate #include <sys/taskq_impl.h>
637c478bd9Sstevel@tonic-gate #include <sys/errorq_impl.h>
647c478bd9Sstevel@tonic-gate #include <sys/cred_impl.h>
657c478bd9Sstevel@tonic-gate #include <sys/zone.h>
667c478bd9Sstevel@tonic-gate #include <sys/panic.h>
677c478bd9Sstevel@tonic-gate #include <regex.h>
687c478bd9Sstevel@tonic-gate #include <sys/port_impl.h>
697c478bd9Sstevel@tonic-gate 
70fa9e4066Sahrens #include "avl.h"
71*4c06356bSdh #include "bio.h"
72*4c06356bSdh #include "bitset.h"
73b5fca8f8Stomee #include "combined.h"
747c478bd9Sstevel@tonic-gate #include "contract.h"
757c478bd9Sstevel@tonic-gate #include "cpupart_mdb.h"
76*4c06356bSdh #include "ctxop.h"
77*4c06356bSdh #include "cyclic.h"
78*4c06356bSdh #include "damap.h"
797c478bd9Sstevel@tonic-gate #include "devinfo.h"
80*4c06356bSdh #include "findstack.h"
81*4c06356bSdh #include "fm.h"
82*4c06356bSdh #include "group.h"
835febcb4aSScott Carter, SD IOSW #include "irm.h"
84*4c06356bSdh #include "kgrep.h"
85*4c06356bSdh #include "kmem.h"
86*4c06356bSdh #include "ldi.h"
877c478bd9Sstevel@tonic-gate #include "leaky.h"
887c478bd9Sstevel@tonic-gate #include "lgrp.h"
897c478bd9Sstevel@tonic-gate #include "list.h"
907c478bd9Sstevel@tonic-gate #include "log.h"
91*4c06356bSdh #include "mdi.h"
92*4c06356bSdh #include "memory.h"
937c478bd9Sstevel@tonic-gate #include "mmd.h"
94*4c06356bSdh #include "modhash.h"
95*4c06356bSdh #include "ndievents.h"
967c478bd9Sstevel@tonic-gate #include "net.h"
97f4b3ec61Sdh #include "netstack.h"
987c478bd9Sstevel@tonic-gate #include "nvpair.h"
99*4c06356bSdh #include "pg.h"
100*4c06356bSdh #include "rctl.h"
1017c478bd9Sstevel@tonic-gate #include "sobj.h"
102*4c06356bSdh #include "streams.h"
1037c478bd9Sstevel@tonic-gate #include "sysevent.h"
104*4c06356bSdh #include "thread.h"
105*4c06356bSdh #include "tsd.h"
10645916cd2Sjpk #include "tsol.h"
1077c478bd9Sstevel@tonic-gate #include "typegraph.h"
1087c478bd9Sstevel@tonic-gate #include "vfs.h"
1097c478bd9Sstevel@tonic-gate #include "zone.h"
1107c478bd9Sstevel@tonic-gate 
1117c478bd9Sstevel@tonic-gate /*
1127c478bd9Sstevel@tonic-gate  * Surely this is defined somewhere...
1137c478bd9Sstevel@tonic-gate  */
1147c478bd9Sstevel@tonic-gate #define	NINTR		16
1157c478bd9Sstevel@tonic-gate 
116bb8b5132Sek #define	KILOS		10
117bb8b5132Sek #define	MEGS		20
118bb8b5132Sek #define	GIGS		30
119bb8b5132Sek 
1207c478bd9Sstevel@tonic-gate #ifndef STACK_BIAS
1217c478bd9Sstevel@tonic-gate #define	STACK_BIAS	0
1227c478bd9Sstevel@tonic-gate #endif
1237c478bd9Sstevel@tonic-gate 
1247c478bd9Sstevel@tonic-gate static char
1257c478bd9Sstevel@tonic-gate pstat2ch(uchar_t state)
1267c478bd9Sstevel@tonic-gate {
1277c478bd9Sstevel@tonic-gate 	switch (state) {
1287c478bd9Sstevel@tonic-gate 		case SSLEEP: return ('S');
1297c478bd9Sstevel@tonic-gate 		case SRUN: return ('R');
1307c478bd9Sstevel@tonic-gate 		case SZOMB: return ('Z');
1317c478bd9Sstevel@tonic-gate 		case SIDL: return ('I');
1327c478bd9Sstevel@tonic-gate 		case SONPROC: return ('O');
1337c478bd9Sstevel@tonic-gate 		case SSTOP: return ('T');
134c97ad5cdSakolb 		case SWAIT: return ('W');
1357c478bd9Sstevel@tonic-gate 		default: return ('?');
1367c478bd9Sstevel@tonic-gate 	}
1377c478bd9Sstevel@tonic-gate }
1387c478bd9Sstevel@tonic-gate 
1397c478bd9Sstevel@tonic-gate #define	PS_PRTTHREADS	0x1
1407c478bd9Sstevel@tonic-gate #define	PS_PRTLWPS	0x2
1417c478bd9Sstevel@tonic-gate #define	PS_PSARGS	0x4
1427c478bd9Sstevel@tonic-gate #define	PS_TASKS	0x8
1437c478bd9Sstevel@tonic-gate #define	PS_PROJECTS	0x10
1447c478bd9Sstevel@tonic-gate #define	PS_ZONES	0x20
1457c478bd9Sstevel@tonic-gate 
1467c478bd9Sstevel@tonic-gate static int
1477c478bd9Sstevel@tonic-gate ps_threadprint(uintptr_t addr, const void *data, void *private)
1487c478bd9Sstevel@tonic-gate {
1497c478bd9Sstevel@tonic-gate 	const kthread_t *t = (const kthread_t *)data;
1507c478bd9Sstevel@tonic-gate 	uint_t prt_flags = *((uint_t *)private);
1517c478bd9Sstevel@tonic-gate 
1527c478bd9Sstevel@tonic-gate 	static const mdb_bitmask_t t_state_bits[] = {
1537c478bd9Sstevel@tonic-gate 		{ "TS_FREE",	UINT_MAX,	TS_FREE		},
1547c478bd9Sstevel@tonic-gate 		{ "TS_SLEEP",	TS_SLEEP,	TS_SLEEP	},
1557c478bd9Sstevel@tonic-gate 		{ "TS_RUN",	TS_RUN,		TS_RUN		},
1567c478bd9Sstevel@tonic-gate 		{ "TS_ONPROC",	TS_ONPROC,	TS_ONPROC	},
1577c478bd9Sstevel@tonic-gate 		{ "TS_ZOMB",	TS_ZOMB,	TS_ZOMB		},
1587c478bd9Sstevel@tonic-gate 		{ "TS_STOPPED",	TS_STOPPED,	TS_STOPPED	},
159c97ad5cdSakolb 		{ "TS_WAIT",	TS_WAIT,	TS_WAIT		},
1607c478bd9Sstevel@tonic-gate 		{ NULL,		0,		0		}
1617c478bd9Sstevel@tonic-gate 	};
1627c478bd9Sstevel@tonic-gate 
1637c478bd9Sstevel@tonic-gate 	if (prt_flags & PS_PRTTHREADS)
1647c478bd9Sstevel@tonic-gate 		mdb_printf("\tT  %?a <%b>\n", addr, t->t_state, t_state_bits);
1657c478bd9Sstevel@tonic-gate 
1667c478bd9Sstevel@tonic-gate 	if (prt_flags & PS_PRTLWPS)
1677c478bd9Sstevel@tonic-gate 		mdb_printf("\tL  %?a ID: %u\n", t->t_lwp, t->t_tid);
1687c478bd9Sstevel@tonic-gate 
1697c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
1707c478bd9Sstevel@tonic-gate }
1717c478bd9Sstevel@tonic-gate 
1727c478bd9Sstevel@tonic-gate int
1737c478bd9Sstevel@tonic-gate ps(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1747c478bd9Sstevel@tonic-gate {
1757c478bd9Sstevel@tonic-gate 	uint_t prt_flags = 0;
1767c478bd9Sstevel@tonic-gate 	proc_t pr;
1777c478bd9Sstevel@tonic-gate 	struct pid pid, pgid, sid;
1787c478bd9Sstevel@tonic-gate 	sess_t session;
1797c478bd9Sstevel@tonic-gate 	cred_t cred;
1807c478bd9Sstevel@tonic-gate 	task_t tk;
1817c478bd9Sstevel@tonic-gate 	kproject_t pj;
1827c478bd9Sstevel@tonic-gate 	zone_t zn;
1837c478bd9Sstevel@tonic-gate 
1847c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC)) {
1857c478bd9Sstevel@tonic-gate 		if (mdb_walk_dcmd("proc", "ps", argc, argv) == -1) {
1867c478bd9Sstevel@tonic-gate 			mdb_warn("can't walk 'proc'");
1877c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
1887c478bd9Sstevel@tonic-gate 		}
1897c478bd9Sstevel@tonic-gate 		return (DCMD_OK);
1907c478bd9Sstevel@tonic-gate 	}
1917c478bd9Sstevel@tonic-gate 
1927c478bd9Sstevel@tonic-gate 	if (mdb_getopts(argc, argv,
1937c478bd9Sstevel@tonic-gate 	    'f', MDB_OPT_SETBITS, PS_PSARGS, &prt_flags,
1947c478bd9Sstevel@tonic-gate 	    'l', MDB_OPT_SETBITS, PS_PRTLWPS, &prt_flags,
1957c478bd9Sstevel@tonic-gate 	    'T', MDB_OPT_SETBITS, PS_TASKS, &prt_flags,
1967c478bd9Sstevel@tonic-gate 	    'P', MDB_OPT_SETBITS, PS_PROJECTS, &prt_flags,
1977c478bd9Sstevel@tonic-gate 	    'z', MDB_OPT_SETBITS, PS_ZONES, &prt_flags,
1987c478bd9Sstevel@tonic-gate 	    't', MDB_OPT_SETBITS, PS_PRTTHREADS, &prt_flags, NULL) != argc)
1997c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
2007c478bd9Sstevel@tonic-gate 
2017c478bd9Sstevel@tonic-gate 	if (DCMD_HDRSPEC(flags)) {
2027c478bd9Sstevel@tonic-gate 		mdb_printf("%<u>%1s %6s %6s %6s %6s ",
2037c478bd9Sstevel@tonic-gate 		    "S", "PID", "PPID", "PGID", "SID");
2047c478bd9Sstevel@tonic-gate 		if (prt_flags & PS_TASKS)
2057c478bd9Sstevel@tonic-gate 			mdb_printf("%5s ", "TASK");
2067c478bd9Sstevel@tonic-gate 		if (prt_flags & PS_PROJECTS)
2077c478bd9Sstevel@tonic-gate 			mdb_printf("%5s ", "PROJ");
2087c478bd9Sstevel@tonic-gate 		if (prt_flags & PS_ZONES)
2097c478bd9Sstevel@tonic-gate 			mdb_printf("%5s ", "ZONE");
2107c478bd9Sstevel@tonic-gate 		mdb_printf("%6s %10s %?s %s%</u>\n",
2117c478bd9Sstevel@tonic-gate 		    "UID", "FLAGS", "ADDR", "NAME");
2127c478bd9Sstevel@tonic-gate 	}
2137c478bd9Sstevel@tonic-gate 
2147c478bd9Sstevel@tonic-gate 	mdb_vread(&pr, sizeof (pr), addr);
2157c478bd9Sstevel@tonic-gate 	mdb_vread(&pid, sizeof (pid), (uintptr_t)pr.p_pidp);
2167c478bd9Sstevel@tonic-gate 	mdb_vread(&pgid, sizeof (pgid), (uintptr_t)pr.p_pgidp);
2177c478bd9Sstevel@tonic-gate 	mdb_vread(&cred, sizeof (cred), (uintptr_t)pr.p_cred);
2187c478bd9Sstevel@tonic-gate 	mdb_vread(&session, sizeof (session), (uintptr_t)pr.p_sessp);
2197c478bd9Sstevel@tonic-gate 	mdb_vread(&sid, sizeof (sid), (uintptr_t)session.s_sidp);
2207c478bd9Sstevel@tonic-gate 	if (prt_flags & (PS_TASKS | PS_PROJECTS))
2217c478bd9Sstevel@tonic-gate 		mdb_vread(&tk, sizeof (tk), (uintptr_t)pr.p_task);
2227c478bd9Sstevel@tonic-gate 	if (prt_flags & PS_PROJECTS)
2237c478bd9Sstevel@tonic-gate 		mdb_vread(&pj, sizeof (pj), (uintptr_t)tk.tk_proj);
2247c478bd9Sstevel@tonic-gate 	if (prt_flags & PS_ZONES)
2257c478bd9Sstevel@tonic-gate 		mdb_vread(&zn, sizeof (zone_t), (uintptr_t)pr.p_zone);
2267c478bd9Sstevel@tonic-gate 
2277c478bd9Sstevel@tonic-gate 	mdb_printf("%c %6d %6d %6d %6d ",
2287c478bd9Sstevel@tonic-gate 	    pstat2ch(pr.p_stat), pid.pid_id, pr.p_ppid, pgid.pid_id,
2297c478bd9Sstevel@tonic-gate 	    sid.pid_id);
2307c478bd9Sstevel@tonic-gate 	if (prt_flags & PS_TASKS)
2317c478bd9Sstevel@tonic-gate 		mdb_printf("%5d ", tk.tk_tkid);
2327c478bd9Sstevel@tonic-gate 	if (prt_flags & PS_PROJECTS)
2337c478bd9Sstevel@tonic-gate 		mdb_printf("%5d ", pj.kpj_id);
2347c478bd9Sstevel@tonic-gate 	if (prt_flags & PS_ZONES)
2357c478bd9Sstevel@tonic-gate 		mdb_printf("%5d ", zn.zone_id);
2367c478bd9Sstevel@tonic-gate 	mdb_printf("%6d 0x%08x %0?p %s\n",
2377c478bd9Sstevel@tonic-gate 	    cred.cr_uid, pr.p_flag, addr,
2387c478bd9Sstevel@tonic-gate 	    (prt_flags & PS_PSARGS) ? pr.p_user.u_psargs : pr.p_user.u_comm);
2397c478bd9Sstevel@tonic-gate 
2407c478bd9Sstevel@tonic-gate 	if (prt_flags & ~PS_PSARGS)
2417c478bd9Sstevel@tonic-gate 		(void) mdb_pwalk("thread", ps_threadprint, &prt_flags, addr);
2427c478bd9Sstevel@tonic-gate 
2437c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
2447c478bd9Sstevel@tonic-gate }
2457c478bd9Sstevel@tonic-gate 
2467c478bd9Sstevel@tonic-gate #define	PG_NEWEST	0x0001
2477c478bd9Sstevel@tonic-gate #define	PG_OLDEST	0x0002
2487c478bd9Sstevel@tonic-gate #define	PG_PIPE_OUT	0x0004
249adb664e2Svb #define	PG_EXACT_MATCH	0x0008
2507c478bd9Sstevel@tonic-gate 
2517c478bd9Sstevel@tonic-gate typedef struct pgrep_data {
2527c478bd9Sstevel@tonic-gate 	uint_t pg_flags;
2537c478bd9Sstevel@tonic-gate 	uint_t pg_psflags;
2547c478bd9Sstevel@tonic-gate 	uintptr_t pg_xaddr;
2557c478bd9Sstevel@tonic-gate 	hrtime_t pg_xstart;
2567c478bd9Sstevel@tonic-gate 	const char *pg_pat;
2577c478bd9Sstevel@tonic-gate #ifndef _KMDB
2587c478bd9Sstevel@tonic-gate 	regex_t pg_reg;
2597c478bd9Sstevel@tonic-gate #endif
2607c478bd9Sstevel@tonic-gate } pgrep_data_t;
2617c478bd9Sstevel@tonic-gate 
2627c478bd9Sstevel@tonic-gate /*ARGSUSED*/
2637c478bd9Sstevel@tonic-gate static int
2647c478bd9Sstevel@tonic-gate pgrep_cb(uintptr_t addr, const void *pdata, void *data)
2657c478bd9Sstevel@tonic-gate {
2667c478bd9Sstevel@tonic-gate 	const proc_t *prp = pdata;
2677c478bd9Sstevel@tonic-gate 	pgrep_data_t *pgp = data;
2687c478bd9Sstevel@tonic-gate #ifndef _KMDB
2697c478bd9Sstevel@tonic-gate 	regmatch_t pmatch;
2707c478bd9Sstevel@tonic-gate #endif
2717c478bd9Sstevel@tonic-gate 
2727c478bd9Sstevel@tonic-gate 	/*
2737c478bd9Sstevel@tonic-gate 	 * kmdb doesn't have access to the reg* functions, so we fall back
274adb664e2Svb 	 * to strstr/strcmp.
2757c478bd9Sstevel@tonic-gate 	 */
2767c478bd9Sstevel@tonic-gate #ifdef _KMDB
277adb664e2Svb 	if ((pgp->pg_flags & PG_EXACT_MATCH) ?
278adb664e2Svb 	    (strcmp(prp->p_user.u_comm, pgp->pg_pat) != 0) :
279adb664e2Svb 	    (strstr(prp->p_user.u_comm, pgp->pg_pat) == NULL))
2807c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
2817c478bd9Sstevel@tonic-gate #else
2827c478bd9Sstevel@tonic-gate 	if (regexec(&pgp->pg_reg, prp->p_user.u_comm, 1, &pmatch, 0) != 0)
2837c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
284adb664e2Svb 
285adb664e2Svb 	if ((pgp->pg_flags & PG_EXACT_MATCH) &&
286adb664e2Svb 	    (pmatch.rm_so != 0 || prp->p_user.u_comm[pmatch.rm_eo] != '\0'))
287adb664e2Svb 		return (WALK_NEXT);
2887c478bd9Sstevel@tonic-gate #endif
2897c478bd9Sstevel@tonic-gate 
2907c478bd9Sstevel@tonic-gate 	if (pgp->pg_flags & (PG_NEWEST | PG_OLDEST)) {
2917c478bd9Sstevel@tonic-gate 		hrtime_t start;
2927c478bd9Sstevel@tonic-gate 
2937c478bd9Sstevel@tonic-gate 		start = (hrtime_t)prp->p_user.u_start.tv_sec * NANOSEC +
2947c478bd9Sstevel@tonic-gate 		    prp->p_user.u_start.tv_nsec;
2957c478bd9Sstevel@tonic-gate 
2967c478bd9Sstevel@tonic-gate 		if (pgp->pg_flags & PG_NEWEST) {
2977c478bd9Sstevel@tonic-gate 			if (pgp->pg_xaddr == NULL || start > pgp->pg_xstart) {
2987c478bd9Sstevel@tonic-gate 				pgp->pg_xaddr = addr;
2997c478bd9Sstevel@tonic-gate 				pgp->pg_xstart = start;
3007c478bd9Sstevel@tonic-gate 			}
3017c478bd9Sstevel@tonic-gate 		} else {
3027c478bd9Sstevel@tonic-gate 			if (pgp->pg_xaddr == NULL || start < pgp->pg_xstart) {
3037c478bd9Sstevel@tonic-gate 				pgp->pg_xaddr = addr;
3047c478bd9Sstevel@tonic-gate 				pgp->pg_xstart = start;
3057c478bd9Sstevel@tonic-gate 			}
3067c478bd9Sstevel@tonic-gate 		}
3077c478bd9Sstevel@tonic-gate 
3087c478bd9Sstevel@tonic-gate 	} else if (pgp->pg_flags & PG_PIPE_OUT) {
3097c478bd9Sstevel@tonic-gate 		mdb_printf("%p\n", addr);
3107c478bd9Sstevel@tonic-gate 
3117c478bd9Sstevel@tonic-gate 	} else {
3127c478bd9Sstevel@tonic-gate 		if (mdb_call_dcmd("ps", addr, pgp->pg_psflags, 0, NULL) != 0) {
3137c478bd9Sstevel@tonic-gate 			mdb_warn("can't invoke 'ps'");
3147c478bd9Sstevel@tonic-gate 			return (WALK_DONE);
3157c478bd9Sstevel@tonic-gate 		}
3167c478bd9Sstevel@tonic-gate 		pgp->pg_psflags &= ~DCMD_LOOPFIRST;
3177c478bd9Sstevel@tonic-gate 	}
3187c478bd9Sstevel@tonic-gate 
3197c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
3207c478bd9Sstevel@tonic-gate }
3217c478bd9Sstevel@tonic-gate 
3227c478bd9Sstevel@tonic-gate /*ARGSUSED*/
3237c478bd9Sstevel@tonic-gate int
3247c478bd9Sstevel@tonic-gate pgrep(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3257c478bd9Sstevel@tonic-gate {
3267c478bd9Sstevel@tonic-gate 	pgrep_data_t pg;
3277c478bd9Sstevel@tonic-gate 	int i;
3287c478bd9Sstevel@tonic-gate #ifndef _KMDB
3297c478bd9Sstevel@tonic-gate 	int err;
3307c478bd9Sstevel@tonic-gate #endif
3317c478bd9Sstevel@tonic-gate 
3327c478bd9Sstevel@tonic-gate 	if (flags & DCMD_ADDRSPEC)
3337c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
3347c478bd9Sstevel@tonic-gate 
3357c478bd9Sstevel@tonic-gate 	pg.pg_flags = 0;
3367c478bd9Sstevel@tonic-gate 	pg.pg_xaddr = 0;
3377c478bd9Sstevel@tonic-gate 
3387c478bd9Sstevel@tonic-gate 	i = mdb_getopts(argc, argv,
3397c478bd9Sstevel@tonic-gate 	    'n', MDB_OPT_SETBITS, PG_NEWEST, &pg.pg_flags,
3407c478bd9Sstevel@tonic-gate 	    'o', MDB_OPT_SETBITS, PG_OLDEST, &pg.pg_flags,
341adb664e2Svb 	    'x', MDB_OPT_SETBITS, PG_EXACT_MATCH, &pg.pg_flags,
3427c478bd9Sstevel@tonic-gate 	    NULL);
3437c478bd9Sstevel@tonic-gate 
3447c478bd9Sstevel@tonic-gate 	argc -= i;
3457c478bd9Sstevel@tonic-gate 	argv += i;
3467c478bd9Sstevel@tonic-gate 
3477c478bd9Sstevel@tonic-gate 	if (argc != 1)
3487c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
3497c478bd9Sstevel@tonic-gate 
3507c478bd9Sstevel@tonic-gate 	/*
3517c478bd9Sstevel@tonic-gate 	 * -n and -o are mutually exclusive.
3527c478bd9Sstevel@tonic-gate 	 */
3537c478bd9Sstevel@tonic-gate 	if ((pg.pg_flags & PG_NEWEST) && (pg.pg_flags & PG_OLDEST))
3547c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
3557c478bd9Sstevel@tonic-gate 
3567c478bd9Sstevel@tonic-gate 	if (argv->a_type != MDB_TYPE_STRING)
3577c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
3587c478bd9Sstevel@tonic-gate 
3597c478bd9Sstevel@tonic-gate 	if (flags & DCMD_PIPE_OUT)
3607c478bd9Sstevel@tonic-gate 		pg.pg_flags |= PG_PIPE_OUT;
3617c478bd9Sstevel@tonic-gate 
3627c478bd9Sstevel@tonic-gate 	pg.pg_pat = argv->a_un.a_str;
3637c478bd9Sstevel@tonic-gate 	if (DCMD_HDRSPEC(flags))
3647c478bd9Sstevel@tonic-gate 		pg.pg_psflags = DCMD_ADDRSPEC | DCMD_LOOP | DCMD_LOOPFIRST;
3657c478bd9Sstevel@tonic-gate 	else
3667c478bd9Sstevel@tonic-gate 		pg.pg_psflags = DCMD_ADDRSPEC | DCMD_LOOP;
3677c478bd9Sstevel@tonic-gate 
3687c478bd9Sstevel@tonic-gate #ifndef _KMDB
3697c478bd9Sstevel@tonic-gate 	if ((err = regcomp(&pg.pg_reg, pg.pg_pat, REG_EXTENDED)) != 0) {
3707c478bd9Sstevel@tonic-gate 		size_t nbytes;
3717c478bd9Sstevel@tonic-gate 		char *buf;
3727c478bd9Sstevel@tonic-gate 
3737c478bd9Sstevel@tonic-gate 		nbytes = regerror(err, &pg.pg_reg, NULL, 0);
3747c478bd9Sstevel@tonic-gate 		buf = mdb_alloc(nbytes + 1, UM_SLEEP | UM_GC);
3757c478bd9Sstevel@tonic-gate 		(void) regerror(err, &pg.pg_reg, buf, nbytes);
3767c478bd9Sstevel@tonic-gate 		mdb_warn("%s\n", buf);
3777c478bd9Sstevel@tonic-gate 
3787c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
3797c478bd9Sstevel@tonic-gate 	}
3807c478bd9Sstevel@tonic-gate #endif
3817c478bd9Sstevel@tonic-gate 
3827c478bd9Sstevel@tonic-gate 	if (mdb_walk("proc", pgrep_cb, &pg) != 0) {
3837c478bd9Sstevel@tonic-gate 		mdb_warn("can't walk 'proc'");
3847c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
3857c478bd9Sstevel@tonic-gate 	}
3867c478bd9Sstevel@tonic-gate 
3877c478bd9Sstevel@tonic-gate 	if (pg.pg_xaddr != 0 && (pg.pg_flags & (PG_NEWEST | PG_OLDEST))) {
3887c478bd9Sstevel@tonic-gate 		if (pg.pg_flags & PG_PIPE_OUT) {
3897c478bd9Sstevel@tonic-gate 			mdb_printf("%p\n", pg.pg_xaddr);
3907c478bd9Sstevel@tonic-gate 		} else {
3917c478bd9Sstevel@tonic-gate 			if (mdb_call_dcmd("ps", pg.pg_xaddr, pg.pg_psflags,
3927c478bd9Sstevel@tonic-gate 			    0, NULL) != 0) {
3937c478bd9Sstevel@tonic-gate 				mdb_warn("can't invoke 'ps'");
3947c478bd9Sstevel@tonic-gate 				return (DCMD_ERR);
3957c478bd9Sstevel@tonic-gate 			}
3967c478bd9Sstevel@tonic-gate 		}
3977c478bd9Sstevel@tonic-gate 	}
3987c478bd9Sstevel@tonic-gate 
3997c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
4007c478bd9Sstevel@tonic-gate }
4017c478bd9Sstevel@tonic-gate 
4027c478bd9Sstevel@tonic-gate int
4037c478bd9Sstevel@tonic-gate task(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
4047c478bd9Sstevel@tonic-gate {
4057c478bd9Sstevel@tonic-gate 	task_t tk;
4067c478bd9Sstevel@tonic-gate 	kproject_t pj;
4077c478bd9Sstevel@tonic-gate 
4087c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC)) {
4097c478bd9Sstevel@tonic-gate 		if (mdb_walk_dcmd("task_cache", "task", argc, argv) == -1) {
4107c478bd9Sstevel@tonic-gate 			mdb_warn("can't walk task_cache");
4117c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
4127c478bd9Sstevel@tonic-gate 		}
4137c478bd9Sstevel@tonic-gate 		return (DCMD_OK);
4147c478bd9Sstevel@tonic-gate 	}
4157c478bd9Sstevel@tonic-gate 	if (DCMD_HDRSPEC(flags)) {
4167c478bd9Sstevel@tonic-gate 		mdb_printf("%<u>%?s %6s %6s %6s %6s %10s%</u>\n",
4177c478bd9Sstevel@tonic-gate 		    "ADDR", "TASKID", "PROJID", "ZONEID", "REFCNT", "FLAGS");
4187c478bd9Sstevel@tonic-gate 	}
4197c478bd9Sstevel@tonic-gate 	if (mdb_vread(&tk, sizeof (task_t), addr) == -1) {
4207c478bd9Sstevel@tonic-gate 		mdb_warn("can't read task_t structure at %p", addr);
4217c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
4227c478bd9Sstevel@tonic-gate 	}
4237c478bd9Sstevel@tonic-gate 	if (mdb_vread(&pj, sizeof (kproject_t), (uintptr_t)tk.tk_proj) == -1) {
4247c478bd9Sstevel@tonic-gate 		mdb_warn("can't read project_t structure at %p", addr);
4257c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
4267c478bd9Sstevel@tonic-gate 	}
4277c478bd9Sstevel@tonic-gate 	mdb_printf("%0?p %6d %6d %6d %6u 0x%08x\n",
4287c478bd9Sstevel@tonic-gate 	    addr, tk.tk_tkid, pj.kpj_id, pj.kpj_zoneid, tk.tk_hold_count,
4297c478bd9Sstevel@tonic-gate 	    tk.tk_flags);
4307c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
4317c478bd9Sstevel@tonic-gate }
4327c478bd9Sstevel@tonic-gate 
4337c478bd9Sstevel@tonic-gate int
4347c478bd9Sstevel@tonic-gate project(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
4357c478bd9Sstevel@tonic-gate {
4367c478bd9Sstevel@tonic-gate 	kproject_t pj;
4377c478bd9Sstevel@tonic-gate 
4387c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC)) {
4397c478bd9Sstevel@tonic-gate 		if (mdb_walk_dcmd("projects", "project", argc, argv) == -1) {
4407c478bd9Sstevel@tonic-gate 			mdb_warn("can't walk projects");
4417c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
4427c478bd9Sstevel@tonic-gate 		}
4437c478bd9Sstevel@tonic-gate 		return (DCMD_OK);
4447c478bd9Sstevel@tonic-gate 	}
4457c478bd9Sstevel@tonic-gate 	if (DCMD_HDRSPEC(flags)) {
4467c478bd9Sstevel@tonic-gate 		mdb_printf("%<u>%?s %6s %6s %6s%</u>\n",
4477c478bd9Sstevel@tonic-gate 		    "ADDR", "PROJID", "ZONEID", "REFCNT");
4487c478bd9Sstevel@tonic-gate 	}
4497c478bd9Sstevel@tonic-gate 	if (mdb_vread(&pj, sizeof (kproject_t), addr) == -1) {
4507c478bd9Sstevel@tonic-gate 		mdb_warn("can't read kproject_t structure at %p", addr);
4517c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
4527c478bd9Sstevel@tonic-gate 	}
4537c478bd9Sstevel@tonic-gate 	mdb_printf("%0?p %6d %6d %6u\n", addr, pj.kpj_id, pj.kpj_zoneid,
4547c478bd9Sstevel@tonic-gate 	    pj.kpj_count);
4557c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
4567c478bd9Sstevel@tonic-gate }
4577c478bd9Sstevel@tonic-gate 
45887a18d3fSMadhavan Venkataraman /* walk callouts themselves, either by list or id hash. */
4597c478bd9Sstevel@tonic-gate int
46087a18d3fSMadhavan Venkataraman callout_walk_init(mdb_walk_state_t *wsp)
4617c478bd9Sstevel@tonic-gate {
46287a18d3fSMadhavan Venkataraman 	if (wsp->walk_addr == NULL) {
46387a18d3fSMadhavan Venkataraman 		mdb_warn("callout doesn't support global walk");
46487a18d3fSMadhavan Venkataraman 		return (WALK_ERR);
46587a18d3fSMadhavan Venkataraman 	}
46687a18d3fSMadhavan Venkataraman 	wsp->walk_data = mdb_alloc(sizeof (callout_t), UM_SLEEP);
46787a18d3fSMadhavan Venkataraman 	return (WALK_NEXT);
46887a18d3fSMadhavan Venkataraman }
4697c478bd9Sstevel@tonic-gate 
47087a18d3fSMadhavan Venkataraman #define	CALLOUT_WALK_BYLIST	0
47187a18d3fSMadhavan Venkataraman #define	CALLOUT_WALK_BYID	1
47287a18d3fSMadhavan Venkataraman 
47387a18d3fSMadhavan Venkataraman /* the walker arg switches between walking by list (0) and walking by id (1). */
47487a18d3fSMadhavan Venkataraman int
47587a18d3fSMadhavan Venkataraman callout_walk_step(mdb_walk_state_t *wsp)
47687a18d3fSMadhavan Venkataraman {
47787a18d3fSMadhavan Venkataraman 	int retval;
4787c478bd9Sstevel@tonic-gate 
47987a18d3fSMadhavan Venkataraman 	if (wsp->walk_addr == NULL) {
48087a18d3fSMadhavan Venkataraman 		return (WALK_DONE);
48187a18d3fSMadhavan Venkataraman 	}
48287a18d3fSMadhavan Venkataraman 	if (mdb_vread(wsp->walk_data, sizeof (callout_t),
48387a18d3fSMadhavan Venkataraman 	    wsp->walk_addr) == -1) {
48487a18d3fSMadhavan Venkataraman 		mdb_warn("failed to read callout at %p", wsp->walk_addr);
48587a18d3fSMadhavan Venkataraman 		return (WALK_DONE);
48687a18d3fSMadhavan Venkataraman 	}
48787a18d3fSMadhavan Venkataraman 	retval = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
48887a18d3fSMadhavan Venkataraman 	    wsp->walk_cbdata);
48987a18d3fSMadhavan Venkataraman 
49087a18d3fSMadhavan Venkataraman 	if ((ulong_t)wsp->walk_arg == CALLOUT_WALK_BYID) {
49187a18d3fSMadhavan Venkataraman 		wsp->walk_addr =
49287a18d3fSMadhavan Venkataraman 		    (uintptr_t)(((callout_t *)wsp->walk_data)->c_idnext);
493843e1988Sjohnlev 	} else {
49487a18d3fSMadhavan Venkataraman 		wsp->walk_addr =
49587a18d3fSMadhavan Venkataraman 		    (uintptr_t)(((callout_t *)wsp->walk_data)->c_clnext);
496843e1988Sjohnlev 	}
4977c478bd9Sstevel@tonic-gate 
49887a18d3fSMadhavan Venkataraman 	return (retval);
49987a18d3fSMadhavan Venkataraman }
50087a18d3fSMadhavan Venkataraman 
50187a18d3fSMadhavan Venkataraman void
50287a18d3fSMadhavan Venkataraman callout_walk_fini(mdb_walk_state_t *wsp)
50387a18d3fSMadhavan Venkataraman {
50487a18d3fSMadhavan Venkataraman 	mdb_free(wsp->walk_data, sizeof (callout_t));
50587a18d3fSMadhavan Venkataraman }
50687a18d3fSMadhavan Venkataraman 
50787a18d3fSMadhavan Venkataraman /*
50887a18d3fSMadhavan Venkataraman  * walker for callout lists. This is different from hashes and callouts.
50987a18d3fSMadhavan Venkataraman  * Thankfully, it's also simpler.
51087a18d3fSMadhavan Venkataraman  */
51187a18d3fSMadhavan Venkataraman int
51287a18d3fSMadhavan Venkataraman callout_list_walk_init(mdb_walk_state_t *wsp)
51387a18d3fSMadhavan Venkataraman {
51487a18d3fSMadhavan Venkataraman 	if (wsp->walk_addr == NULL) {
51587a18d3fSMadhavan Venkataraman 		mdb_warn("callout list doesn't support global walk");
51687a18d3fSMadhavan Venkataraman 		return (WALK_ERR);
5177c478bd9Sstevel@tonic-gate 	}
51887a18d3fSMadhavan Venkataraman 	wsp->walk_data = mdb_alloc(sizeof (callout_list_t), UM_SLEEP);
51987a18d3fSMadhavan Venkataraman 	return (WALK_NEXT);
52087a18d3fSMadhavan Venkataraman }
5217c478bd9Sstevel@tonic-gate 
52287a18d3fSMadhavan Venkataraman int
52387a18d3fSMadhavan Venkataraman callout_list_walk_step(mdb_walk_state_t *wsp)
52487a18d3fSMadhavan Venkataraman {
52587a18d3fSMadhavan Venkataraman 	int retval;
52687a18d3fSMadhavan Venkataraman 
52787a18d3fSMadhavan Venkataraman 	if (wsp->walk_addr == NULL) {
52887a18d3fSMadhavan Venkataraman 		return (WALK_DONE);
5297c478bd9Sstevel@tonic-gate 	}
53087a18d3fSMadhavan Venkataraman 	if (mdb_vread(wsp->walk_data, sizeof (callout_list_t),
53187a18d3fSMadhavan Venkataraman 	    wsp->walk_addr) != sizeof (callout_list_t)) {
53287a18d3fSMadhavan Venkataraman 		mdb_warn("failed to read callout_list at %p", wsp->walk_addr);
53387a18d3fSMadhavan Venkataraman 		return (WALK_ERR);
53487a18d3fSMadhavan Venkataraman 	}
53587a18d3fSMadhavan Venkataraman 	retval = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
53687a18d3fSMadhavan Venkataraman 	    wsp->walk_cbdata);
5377c478bd9Sstevel@tonic-gate 
53887a18d3fSMadhavan Venkataraman 	wsp->walk_addr = (uintptr_t)
53987a18d3fSMadhavan Venkataraman 	    (((callout_list_t *)wsp->walk_data)->cl_next);
54087a18d3fSMadhavan Venkataraman 
54187a18d3fSMadhavan Venkataraman 	return (retval);
54287a18d3fSMadhavan Venkataraman }
54387a18d3fSMadhavan Venkataraman 
54487a18d3fSMadhavan Venkataraman void
54587a18d3fSMadhavan Venkataraman callout_list_walk_fini(mdb_walk_state_t *wsp)
54687a18d3fSMadhavan Venkataraman {
54787a18d3fSMadhavan Venkataraman 	mdb_free(wsp->walk_data, sizeof (callout_list_t));
54887a18d3fSMadhavan Venkataraman }
54987a18d3fSMadhavan Venkataraman 
55087a18d3fSMadhavan Venkataraman /* routines/structs to walk callout table(s) */
55187a18d3fSMadhavan Venkataraman typedef struct cot_data {
55287a18d3fSMadhavan Venkataraman 	callout_table_t *ct0;
55387a18d3fSMadhavan Venkataraman 	callout_table_t ct;
55487a18d3fSMadhavan Venkataraman 	callout_hash_t cot_idhash[CALLOUT_BUCKETS];
55587a18d3fSMadhavan Venkataraman 	callout_hash_t cot_clhash[CALLOUT_BUCKETS];
55687a18d3fSMadhavan Venkataraman 	kstat_named_t ct_kstat_data[CALLOUT_NUM_STATS];
55787a18d3fSMadhavan Venkataraman 	int cotndx;
55887a18d3fSMadhavan Venkataraman 	int cotsize;
55987a18d3fSMadhavan Venkataraman } cot_data_t;
56087a18d3fSMadhavan Venkataraman 
56187a18d3fSMadhavan Venkataraman int
56287a18d3fSMadhavan Venkataraman callout_table_walk_init(mdb_walk_state_t *wsp)
56387a18d3fSMadhavan Venkataraman {
56487a18d3fSMadhavan Venkataraman 	int max_ncpus;
56587a18d3fSMadhavan Venkataraman 	cot_data_t *cot_walk_data;
56687a18d3fSMadhavan Venkataraman 
56787a18d3fSMadhavan Venkataraman 	cot_walk_data = mdb_alloc(sizeof (cot_data_t), UM_SLEEP);
56887a18d3fSMadhavan Venkataraman 
56987a18d3fSMadhavan Venkataraman 	if (wsp->walk_addr == NULL) {
57087a18d3fSMadhavan Venkataraman 		if (mdb_readvar(&cot_walk_data->ct0, "callout_table") == -1) {
57187a18d3fSMadhavan Venkataraman 			mdb_warn("failed to read 'callout_table'");
57287a18d3fSMadhavan Venkataraman 			return (WALK_ERR);
57387a18d3fSMadhavan Venkataraman 		}
57487a18d3fSMadhavan Venkataraman 		if (mdb_readvar(&max_ncpus, "max_ncpus") == -1) {
57587a18d3fSMadhavan Venkataraman 			mdb_warn("failed to get callout_table array size");
57687a18d3fSMadhavan Venkataraman 			return (WALK_ERR);
57787a18d3fSMadhavan Venkataraman 		}
57887a18d3fSMadhavan Venkataraman 		cot_walk_data->cotsize = CALLOUT_NTYPES * max_ncpus;
57987a18d3fSMadhavan Venkataraman 		wsp->walk_addr = (uintptr_t)cot_walk_data->ct0;
58087a18d3fSMadhavan Venkataraman 	} else {
58187a18d3fSMadhavan Venkataraman 		/* not a global walk */
58287a18d3fSMadhavan Venkataraman 		cot_walk_data->cotsize = 1;
5837c478bd9Sstevel@tonic-gate 	}
5847c478bd9Sstevel@tonic-gate 
58587a18d3fSMadhavan Venkataraman 	cot_walk_data->cotndx = 0;
58687a18d3fSMadhavan Venkataraman 	wsp->walk_data = cot_walk_data;
5877c478bd9Sstevel@tonic-gate 
58887a18d3fSMadhavan Venkataraman 	return (WALK_NEXT);
58987a18d3fSMadhavan Venkataraman }
5907c478bd9Sstevel@tonic-gate 
59187a18d3fSMadhavan Venkataraman int
59287a18d3fSMadhavan Venkataraman callout_table_walk_step(mdb_walk_state_t *wsp)
59387a18d3fSMadhavan Venkataraman {
59487a18d3fSMadhavan Venkataraman 	int retval;
59587a18d3fSMadhavan Venkataraman 	cot_data_t *cotwd = (cot_data_t *)wsp->walk_data;
59687a18d3fSMadhavan Venkataraman 	size_t size;
5977c478bd9Sstevel@tonic-gate 
59887a18d3fSMadhavan Venkataraman 	if (cotwd->cotndx >= cotwd->cotsize) {
59987a18d3fSMadhavan Venkataraman 		return (WALK_DONE);
60087a18d3fSMadhavan Venkataraman 	}
60187a18d3fSMadhavan Venkataraman 	if (mdb_vread(&(cotwd->ct), sizeof (callout_table_t),
60287a18d3fSMadhavan Venkataraman 	    wsp->walk_addr) != sizeof (callout_table_t)) {
60387a18d3fSMadhavan Venkataraman 		mdb_warn("failed to read callout_table at %p", wsp->walk_addr);
60487a18d3fSMadhavan Venkataraman 		return (WALK_ERR);
60587a18d3fSMadhavan Venkataraman 	}
60687a18d3fSMadhavan Venkataraman 
60787a18d3fSMadhavan Venkataraman 	size = sizeof (callout_hash_t) * CALLOUT_BUCKETS;
60887a18d3fSMadhavan Venkataraman 	if (cotwd->ct.ct_idhash != NULL) {
60987a18d3fSMadhavan Venkataraman 		if (mdb_vread(cotwd->cot_idhash, size,
61087a18d3fSMadhavan Venkataraman 		    (uintptr_t)(cotwd->ct.ct_idhash)) != size) {
61187a18d3fSMadhavan Venkataraman 			mdb_warn("failed to read id_hash at %p",
61287a18d3fSMadhavan Venkataraman 			    cotwd->ct.ct_idhash);
61387a18d3fSMadhavan Venkataraman 			return (WALK_ERR);
61487a18d3fSMadhavan Venkataraman 		}
61587a18d3fSMadhavan Venkataraman 	}
61687a18d3fSMadhavan Venkataraman 	if (cotwd->ct.ct_clhash != NULL) {
61787a18d3fSMadhavan Venkataraman 		if (mdb_vread(&(cotwd->cot_clhash), size,
61887a18d3fSMadhavan Venkataraman 		    (uintptr_t)cotwd->ct.ct_clhash) == -1) {
61987a18d3fSMadhavan Venkataraman 			mdb_warn("failed to read cl_hash at %p",
62087a18d3fSMadhavan Venkataraman 			    cotwd->ct.ct_clhash);
62187a18d3fSMadhavan Venkataraman 			return (WALK_ERR);
62287a18d3fSMadhavan Venkataraman 		}
62387a18d3fSMadhavan Venkataraman 	}
62487a18d3fSMadhavan Venkataraman 	size = sizeof (kstat_named_t) * CALLOUT_NUM_STATS;
62587a18d3fSMadhavan Venkataraman 	if (cotwd->ct.ct_kstat_data != NULL) {
62687a18d3fSMadhavan Venkataraman 		if (mdb_vread(&(cotwd->ct_kstat_data), size,
62787a18d3fSMadhavan Venkataraman 		    (uintptr_t)cotwd->ct.ct_kstat_data) == -1) {
62887a18d3fSMadhavan Venkataraman 			mdb_warn("failed to read kstats at %p",
62987a18d3fSMadhavan Venkataraman 			    cotwd->ct.ct_kstat_data);
63087a18d3fSMadhavan Venkataraman 			return (WALK_ERR);
63187a18d3fSMadhavan Venkataraman 		}
63287a18d3fSMadhavan Venkataraman 	}
63387a18d3fSMadhavan Venkataraman 	retval = wsp->walk_callback(wsp->walk_addr, (void *)cotwd,
63487a18d3fSMadhavan Venkataraman 	    wsp->walk_cbdata);
63587a18d3fSMadhavan Venkataraman 
63687a18d3fSMadhavan Venkataraman 	cotwd->cotndx++;
63787a18d3fSMadhavan Venkataraman 	if (cotwd->cotndx >= cotwd->cotsize) {
63887a18d3fSMadhavan Venkataraman 		return (WALK_DONE);
63987a18d3fSMadhavan Venkataraman 	}
64087a18d3fSMadhavan Venkataraman 	wsp->walk_addr = (uintptr_t)((char *)wsp->walk_addr +
64187a18d3fSMadhavan Venkataraman 	    sizeof (callout_table_t));
64287a18d3fSMadhavan Venkataraman 
64387a18d3fSMadhavan Venkataraman 	return (retval);
64487a18d3fSMadhavan Venkataraman }
64587a18d3fSMadhavan Venkataraman 
64687a18d3fSMadhavan Venkataraman void
64787a18d3fSMadhavan Venkataraman callout_table_walk_fini(mdb_walk_state_t *wsp)
64887a18d3fSMadhavan Venkataraman {
64987a18d3fSMadhavan Venkataraman 	mdb_free(wsp->walk_data, sizeof (cot_data_t));
65087a18d3fSMadhavan Venkataraman }
65187a18d3fSMadhavan Venkataraman 
65287a18d3fSMadhavan Venkataraman static const char *co_typenames[] = { "R", "N" };
65387a18d3fSMadhavan Venkataraman 
65407247649SMadhavan Venkataraman #define	CO_PLAIN_ID(xid)	((xid) & CALLOUT_ID_MASK)
65587a18d3fSMadhavan Venkataraman 
65687a18d3fSMadhavan Venkataraman #define	TABLE_TO_SEQID(x)	((x) >> CALLOUT_TYPE_BITS)
65787a18d3fSMadhavan Venkataraman 
65887a18d3fSMadhavan Venkataraman /* callout flags, in no particular order */
65987a18d3fSMadhavan Venkataraman #define	COF_REAL	0x0000001
66087a18d3fSMadhavan Venkataraman #define	COF_NORM	0x0000002
66187a18d3fSMadhavan Venkataraman #define	COF_LONG	0x0000004
66287a18d3fSMadhavan Venkataraman #define	COF_SHORT	0x0000008
66387a18d3fSMadhavan Venkataraman #define	COF_EMPTY	0x0000010
66487a18d3fSMadhavan Venkataraman #define	COF_TIME	0x0000020
66587a18d3fSMadhavan Venkataraman #define	COF_BEFORE	0x0000040
66687a18d3fSMadhavan Venkataraman #define	COF_AFTER	0x0000080
66787a18d3fSMadhavan Venkataraman #define	COF_SEQID	0x0000100
66887a18d3fSMadhavan Venkataraman #define	COF_FUNC	0x0000200
66987a18d3fSMadhavan Venkataraman #define	COF_ADDR	0x0000400
67087a18d3fSMadhavan Venkataraman #define	COF_EXEC	0x0000800
67187a18d3fSMadhavan Venkataraman #define	COF_HIRES	0x0001000
67207247649SMadhavan Venkataraman #define	COF_ABS		0x0002000
67387a18d3fSMadhavan Venkataraman #define	COF_TABLE	0x0004000
67487a18d3fSMadhavan Venkataraman #define	COF_BYIDH	0x0008000
67587a18d3fSMadhavan Venkataraman #define	COF_FREE	0x0010000
67687a18d3fSMadhavan Venkataraman #define	COF_LIST	0x0020000
67787a18d3fSMadhavan Venkataraman #define	COF_EXPREL	0x0040000
67887a18d3fSMadhavan Venkataraman #define	COF_HDR		0x0080000
67987a18d3fSMadhavan Venkataraman #define	COF_VERBOSE	0x0100000
68087a18d3fSMadhavan Venkataraman #define	COF_LONGLIST	0x0200000
68187a18d3fSMadhavan Venkataraman #define	COF_THDR	0x0400000
68287a18d3fSMadhavan Venkataraman #define	COF_LHDR	0x0800000
68387a18d3fSMadhavan Venkataraman #define	COF_CHDR	0x1000000
68487a18d3fSMadhavan Venkataraman #define	COF_PARAM	0x2000000
68587a18d3fSMadhavan Venkataraman #define	COF_DECODE	0x4000000
68687a18d3fSMadhavan Venkataraman 
68787a18d3fSMadhavan Venkataraman /* show real and normal, short and long, expired and unexpired. */
68887a18d3fSMadhavan Venkataraman #define	COF_DEFAULT	(COF_REAL | COF_NORM | COF_LONG | COF_SHORT)
68987a18d3fSMadhavan Venkataraman 
69051b32bddSMadhavan Venkataraman #define	COF_LIST_FLAGS	\
69151b32bddSMadhavan Venkataraman 	(CALLOUT_LIST_FLAG_HRESTIME | CALLOUT_LIST_FLAG_ABSOLUTE)
69251b32bddSMadhavan Venkataraman 
69387a18d3fSMadhavan Venkataraman /* private callout data for callback functions */
69487a18d3fSMadhavan Venkataraman typedef struct callout_data {
69587a18d3fSMadhavan Venkataraman 	uint_t flags;		/* COF_* */
69687a18d3fSMadhavan Venkataraman 	cpu_t *cpu;		/* cpu pointer if given */
69787a18d3fSMadhavan Venkataraman 	int seqid;		/* cpu seqid, or -1 */
69887a18d3fSMadhavan Venkataraman 	hrtime_t time;		/* expiration time value */
69987a18d3fSMadhavan Venkataraman 	hrtime_t atime;		/* expiration before value */
70087a18d3fSMadhavan Venkataraman 	hrtime_t btime;		/* expiration after value */
70187a18d3fSMadhavan Venkataraman 	uintptr_t funcaddr;	/* function address or NULL */
70287a18d3fSMadhavan Venkataraman 	uintptr_t param;	/* parameter to function or NULL */
70387a18d3fSMadhavan Venkataraman 	hrtime_t now;		/* current system time */
70487a18d3fSMadhavan Venkataraman 	int nsec_per_tick;	/* for conversions */
70587a18d3fSMadhavan Venkataraman 	ulong_t ctbits;		/* for decoding xid */
70687a18d3fSMadhavan Venkataraman 	callout_table_t *co_table;	/* top of callout table array */
70787a18d3fSMadhavan Venkataraman 	int ndx;		/* table index. */
70887a18d3fSMadhavan Venkataraman 	int bucket;		/* which list/id bucket are we in */
70987a18d3fSMadhavan Venkataraman 	hrtime_t exp;		/* expire time */
71007247649SMadhavan Venkataraman 	int list_flags;		/* copy of cl_flags */
71187a18d3fSMadhavan Venkataraman } callout_data_t;
71287a18d3fSMadhavan Venkataraman 
71387a18d3fSMadhavan Venkataraman /* this callback does the actual callback itself (finally). */
71487a18d3fSMadhavan Venkataraman /*ARGSUSED*/
71587a18d3fSMadhavan Venkataraman static int
71687a18d3fSMadhavan Venkataraman callouts_cb(uintptr_t addr, const void *data, void *priv)
71787a18d3fSMadhavan Venkataraman {
71887a18d3fSMadhavan Venkataraman 	callout_data_t *coargs = (callout_data_t *)priv;
71987a18d3fSMadhavan Venkataraman 	callout_t *co = (callout_t *)data;
72051b32bddSMadhavan Venkataraman 	int tableid, list_flags;
72187a18d3fSMadhavan Venkataraman 	callout_id_t coid;
72287a18d3fSMadhavan Venkataraman 
72387a18d3fSMadhavan Venkataraman 	if ((coargs == NULL) || (co == NULL)) {
72487a18d3fSMadhavan Venkataraman 		return (WALK_ERR);
72587a18d3fSMadhavan Venkataraman 	}
72687a18d3fSMadhavan Venkataraman 
72751b32bddSMadhavan Venkataraman 	if ((coargs->flags & COF_FREE) && !(co->c_xid & CALLOUT_FREE)) {
72851b32bddSMadhavan Venkataraman 		/*
72951b32bddSMadhavan Venkataraman 		 * The callout must have been reallocated. No point in
73051b32bddSMadhavan Venkataraman 		 * walking any more.
73151b32bddSMadhavan Venkataraman 		 */
73251b32bddSMadhavan Venkataraman 		return (WALK_DONE);
73351b32bddSMadhavan Venkataraman 	}
73451b32bddSMadhavan Venkataraman 	if (!(coargs->flags & COF_FREE) && (co->c_xid & CALLOUT_FREE)) {
73551b32bddSMadhavan Venkataraman 		/*
73651b32bddSMadhavan Venkataraman 		 * The callout must have been freed. No point in
73751b32bddSMadhavan Venkataraman 		 * walking any more.
73851b32bddSMadhavan Venkataraman 		 */
73951b32bddSMadhavan Venkataraman 		return (WALK_DONE);
74051b32bddSMadhavan Venkataraman 	}
74187a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_FUNC) &&
74287a18d3fSMadhavan Venkataraman 	    (coargs->funcaddr != (uintptr_t)co->c_func)) {
74387a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
74487a18d3fSMadhavan Venkataraman 	}
74587a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_PARAM) &&
74687a18d3fSMadhavan Venkataraman 	    (coargs->param != (uintptr_t)co->c_arg)) {
74787a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
74887a18d3fSMadhavan Venkataraman 	}
74987a18d3fSMadhavan Venkataraman 	if (!(coargs->flags & COF_LONG) && (co->c_xid & CALLOUT_LONGTERM)) {
75087a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
75187a18d3fSMadhavan Venkataraman 	}
75287a18d3fSMadhavan Venkataraman 	if (!(coargs->flags & COF_SHORT) && !(co->c_xid & CALLOUT_LONGTERM)) {
75387a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
75487a18d3fSMadhavan Venkataraman 	}
75587a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_EXEC) && !(co->c_xid & CALLOUT_EXECUTING)) {
75687a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
75787a18d3fSMadhavan Venkataraman 	}
75851b32bddSMadhavan Venkataraman 	/* it is possible we don't have the exp time or flags */
75987a18d3fSMadhavan Venkataraman 	if (coargs->flags & COF_BYIDH) {
76087a18d3fSMadhavan Venkataraman 		if (!(coargs->flags & COF_FREE)) {
76187a18d3fSMadhavan Venkataraman 			/* we have to fetch the expire time ourselves. */
76287a18d3fSMadhavan Venkataraman 			if (mdb_vread(&coargs->exp, sizeof (hrtime_t),
76387a18d3fSMadhavan Venkataraman 			    (uintptr_t)co->c_list + offsetof(callout_list_t,
76487a18d3fSMadhavan Venkataraman 			    cl_expiration)) == -1) {
76587a18d3fSMadhavan Venkataraman 				mdb_warn("failed to read expiration "
76687a18d3fSMadhavan Venkataraman 				    "time from %p", co->c_list);
76787a18d3fSMadhavan Venkataraman 				coargs->exp = 0;
7687c478bd9Sstevel@tonic-gate 			}
76907247649SMadhavan Venkataraman 			/* and flags. */
77007247649SMadhavan Venkataraman 			if (mdb_vread(&coargs->list_flags, sizeof (int),
77107247649SMadhavan Venkataraman 			    (uintptr_t)co->c_list + offsetof(callout_list_t,
77207247649SMadhavan Venkataraman 			    cl_flags)) == -1) {
77307247649SMadhavan Venkataraman 				mdb_warn("failed to read list flags"
77407247649SMadhavan Venkataraman 				    "from %p", co->c_list);
77507247649SMadhavan Venkataraman 				coargs->list_flags = 0;
77607247649SMadhavan Venkataraman 			}
77787a18d3fSMadhavan Venkataraman 		} else {
77887a18d3fSMadhavan Venkataraman 			/* free callouts can't use list pointer. */
77987a18d3fSMadhavan Venkataraman 			coargs->exp = 0;
78007247649SMadhavan Venkataraman 			coargs->list_flags = 0;
78107247649SMadhavan Venkataraman 		}
78207247649SMadhavan Venkataraman 		if (coargs->exp != 0) {
78307247649SMadhavan Venkataraman 			if ((coargs->flags & COF_TIME) &&
78407247649SMadhavan Venkataraman 			    (coargs->exp != coargs->time)) {
78507247649SMadhavan Venkataraman 				return (WALK_NEXT);
78607247649SMadhavan Venkataraman 			}
78707247649SMadhavan Venkataraman 			if ((coargs->flags & COF_BEFORE) &&
78807247649SMadhavan Venkataraman 			    (coargs->exp > coargs->btime)) {
78907247649SMadhavan Venkataraman 				return (WALK_NEXT);
79007247649SMadhavan Venkataraman 			}
79107247649SMadhavan Venkataraman 			if ((coargs->flags & COF_AFTER) &&
79207247649SMadhavan Venkataraman 			    (coargs->exp < coargs->atime)) {
79307247649SMadhavan Venkataraman 				return (WALK_NEXT);
79407247649SMadhavan Venkataraman 			}
79507247649SMadhavan Venkataraman 		}
79607247649SMadhavan Venkataraman 		/* tricky part, since both HIRES and ABS can be set */
79751b32bddSMadhavan Venkataraman 		list_flags = coargs->list_flags;
79807247649SMadhavan Venkataraman 		if ((coargs->flags & COF_HIRES) && (coargs->flags & COF_ABS)) {
79907247649SMadhavan Venkataraman 			/* both flags are set, only skip "regular" ones */
80051b32bddSMadhavan Venkataraman 			if (! (list_flags & COF_LIST_FLAGS)) {
80107247649SMadhavan Venkataraman 				return (WALK_NEXT);
80207247649SMadhavan Venkataraman 			}
80307247649SMadhavan Venkataraman 		} else {
80407247649SMadhavan Venkataraman 			/* individual flags, or no flags */
80507247649SMadhavan Venkataraman 			if ((coargs->flags & COF_HIRES) &&
80651b32bddSMadhavan Venkataraman 			    !(list_flags & CALLOUT_LIST_FLAG_HRESTIME)) {
80707247649SMadhavan Venkataraman 				return (WALK_NEXT);
80807247649SMadhavan Venkataraman 			}
80907247649SMadhavan Venkataraman 			if ((coargs->flags & COF_ABS) &&
81051b32bddSMadhavan Venkataraman 			    !(list_flags & CALLOUT_LIST_FLAG_ABSOLUTE)) {
81107247649SMadhavan Venkataraman 				return (WALK_NEXT);
81207247649SMadhavan Venkataraman 			}
81387a18d3fSMadhavan Venkataraman 		}
81487a18d3fSMadhavan Venkataraman 	}
81587a18d3fSMadhavan Venkataraman 
81687a18d3fSMadhavan Venkataraman #define	callout_table_mask	((1 << coargs->ctbits) - 1)
81787a18d3fSMadhavan Venkataraman 	tableid = CALLOUT_ID_TO_TABLE(co->c_xid);
81887a18d3fSMadhavan Venkataraman #undef	callout_table_mask
81987a18d3fSMadhavan Venkataraman 	coid = CO_PLAIN_ID(co->c_xid);
82087a18d3fSMadhavan Venkataraman 
82187a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_CHDR) && !(coargs->flags & COF_ADDR)) {
82287a18d3fSMadhavan Venkataraman 		/*
82387a18d3fSMadhavan Venkataraman 		 * We need to print the headers. If walking by id, then
82487a18d3fSMadhavan Venkataraman 		 * the list header isn't printed, so we must include
82587a18d3fSMadhavan Venkataraman 		 * that info here.
82687a18d3fSMadhavan Venkataraman 		 */
82787a18d3fSMadhavan Venkataraman 		if (!(coargs->flags & COF_VERBOSE)) {
82887a18d3fSMadhavan Venkataraman 			mdb_printf("%<u>%3s %-1s %-14s %</u>",
82987a18d3fSMadhavan Venkataraman 			    "SEQ", "T", "EXP");
83087a18d3fSMadhavan Venkataraman 		} else if (coargs->flags & COF_BYIDH) {
83187a18d3fSMadhavan Venkataraman 			mdb_printf("%<u>%-14s %</u>", "EXP");
83287a18d3fSMadhavan Venkataraman 		}
83307247649SMadhavan Venkataraman 		mdb_printf("%<u>%-4s %-?s %-20s%</u>",
83407247649SMadhavan Venkataraman 		    "XHAL", "XID", "FUNC(ARG)");
83587a18d3fSMadhavan Venkataraman 		if (coargs->flags & COF_LONGLIST) {
83687a18d3fSMadhavan Venkataraman 			mdb_printf("%<u> %-?s %-?s %-?s %-?s%</u>",
83787a18d3fSMadhavan Venkataraman 			    "PREVID", "NEXTID", "PREVL", "NEXTL");
83807247649SMadhavan Venkataraman 			mdb_printf("%<u> %-?s %-4s %-?s%</u>",
83907247649SMadhavan Venkataraman 			    "DONE", "UTOS", "THREAD");
84087a18d3fSMadhavan Venkataraman 		}
84187a18d3fSMadhavan Venkataraman 		mdb_printf("\n");
84287a18d3fSMadhavan Venkataraman 		coargs->flags &= ~COF_CHDR;
84387a18d3fSMadhavan Venkataraman 		coargs->flags |= (COF_THDR | COF_LHDR);
84487a18d3fSMadhavan Venkataraman 	}
84587a18d3fSMadhavan Venkataraman 
84687a18d3fSMadhavan Venkataraman 	if (!(coargs->flags & COF_ADDR)) {
84787a18d3fSMadhavan Venkataraman 		if (!(coargs->flags & COF_VERBOSE)) {
84887a18d3fSMadhavan Venkataraman 			mdb_printf("%-3d %1s %-14llx ",
84987a18d3fSMadhavan Venkataraman 			    TABLE_TO_SEQID(tableid),
85087a18d3fSMadhavan Venkataraman 			    co_typenames[tableid & CALLOUT_TYPE_MASK],
85187a18d3fSMadhavan Venkataraman 			    (coargs->flags & COF_EXPREL) ?
85287a18d3fSMadhavan Venkataraman 			    coargs->exp - coargs->now : coargs->exp);
85387a18d3fSMadhavan Venkataraman 		} else if (coargs->flags & COF_BYIDH) {
85487a18d3fSMadhavan Venkataraman 			mdb_printf("%-14x ",
85587a18d3fSMadhavan Venkataraman 			    (coargs->flags & COF_EXPREL) ?
85687a18d3fSMadhavan Venkataraman 			    coargs->exp - coargs->now : coargs->exp);
85787a18d3fSMadhavan Venkataraman 		}
85851b32bddSMadhavan Venkataraman 		list_flags = coargs->list_flags;
85907247649SMadhavan Venkataraman 		mdb_printf("%1s%1s%1s%1s %-?llx %a(%p)",
86087a18d3fSMadhavan Venkataraman 		    (co->c_xid & CALLOUT_EXECUTING) ? "X" : " ",
86151b32bddSMadhavan Venkataraman 		    (list_flags & CALLOUT_LIST_FLAG_HRESTIME) ? "H" : " ",
86251b32bddSMadhavan Venkataraman 		    (list_flags & CALLOUT_LIST_FLAG_ABSOLUTE) ? "A" : " ",
86387a18d3fSMadhavan Venkataraman 		    (co->c_xid & CALLOUT_LONGTERM) ? "L" : " ",
86487a18d3fSMadhavan Venkataraman 		    (long long)coid, co->c_func, co->c_arg);
86587a18d3fSMadhavan Venkataraman 		if (coargs->flags & COF_LONGLIST) {
86687a18d3fSMadhavan Venkataraman 			mdb_printf(" %-?p %-?p %-?p %-?p",
86787a18d3fSMadhavan Venkataraman 			    co->c_idprev, co->c_idnext, co->c_clprev,
86887a18d3fSMadhavan Venkataraman 			    co->c_clnext);
86907247649SMadhavan Venkataraman 			mdb_printf(" %-?p %-4d %-0?p",
87007247649SMadhavan Venkataraman 			    co->c_done, co->c_waiting, co->c_executor);
87187a18d3fSMadhavan Venkataraman 		}
87287a18d3fSMadhavan Venkataraman 	} else {
87387a18d3fSMadhavan Venkataraman 		/* address only */
87487a18d3fSMadhavan Venkataraman 		mdb_printf("%-0p", addr);
87587a18d3fSMadhavan Venkataraman 	}
87687a18d3fSMadhavan Venkataraman 	mdb_printf("\n");
87787a18d3fSMadhavan Venkataraman 	return (WALK_NEXT);
87887a18d3fSMadhavan Venkataraman }
87987a18d3fSMadhavan Venkataraman 
88087a18d3fSMadhavan Venkataraman /* this callback is for callout list handling. idhash is done by callout_t_cb */
88187a18d3fSMadhavan Venkataraman /*ARGSUSED*/
88287a18d3fSMadhavan Venkataraman static int
88387a18d3fSMadhavan Venkataraman callout_list_cb(uintptr_t addr, const void *data, void *priv)
88487a18d3fSMadhavan Venkataraman {
88587a18d3fSMadhavan Venkataraman 	callout_data_t *coargs = (callout_data_t *)priv;
88687a18d3fSMadhavan Venkataraman 	callout_list_t *cl = (callout_list_t *)data;
88787a18d3fSMadhavan Venkataraman 	callout_t *coptr;
88851b32bddSMadhavan Venkataraman 	int list_flags;
88987a18d3fSMadhavan Venkataraman 
89087a18d3fSMadhavan Venkataraman 	if ((coargs == NULL) || (cl == NULL)) {
89187a18d3fSMadhavan Venkataraman 		return (WALK_ERR);
89287a18d3fSMadhavan Venkataraman 	}
89387a18d3fSMadhavan Venkataraman 
89487a18d3fSMadhavan Venkataraman 	coargs->exp = cl->cl_expiration;
89507247649SMadhavan Venkataraman 	coargs->list_flags = cl->cl_flags;
89651b32bddSMadhavan Venkataraman 	if ((coargs->flags & COF_FREE) &&
89751b32bddSMadhavan Venkataraman 	    !(cl->cl_flags & CALLOUT_LIST_FLAG_FREE)) {
89851b32bddSMadhavan Venkataraman 		/*
89951b32bddSMadhavan Venkataraman 		 * The callout list must have been reallocated. No point in
90051b32bddSMadhavan Venkataraman 		 * walking any more.
90151b32bddSMadhavan Venkataraman 		 */
90251b32bddSMadhavan Venkataraman 		return (WALK_DONE);
90351b32bddSMadhavan Venkataraman 	}
90451b32bddSMadhavan Venkataraman 	if (!(coargs->flags & COF_FREE) &&
90551b32bddSMadhavan Venkataraman 	    (cl->cl_flags & CALLOUT_LIST_FLAG_FREE)) {
90651b32bddSMadhavan Venkataraman 		/*
90751b32bddSMadhavan Venkataraman 		 * The callout list must have been freed. No point in
90851b32bddSMadhavan Venkataraman 		 * walking any more.
90951b32bddSMadhavan Venkataraman 		 */
91051b32bddSMadhavan Venkataraman 		return (WALK_DONE);
91151b32bddSMadhavan Venkataraman 	}
91287a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_TIME) &&
91387a18d3fSMadhavan Venkataraman 	    (cl->cl_expiration != coargs->time)) {
91487a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
91587a18d3fSMadhavan Venkataraman 	}
91687a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_BEFORE) &&
91787a18d3fSMadhavan Venkataraman 	    (cl->cl_expiration > coargs->btime)) {
91887a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
91987a18d3fSMadhavan Venkataraman 	}
92087a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_AFTER) &&
92187a18d3fSMadhavan Venkataraman 	    (cl->cl_expiration < coargs->atime)) {
92287a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
92387a18d3fSMadhavan Venkataraman 	}
92487a18d3fSMadhavan Venkataraman 	if (!(coargs->flags & COF_EMPTY) &&
92587a18d3fSMadhavan Venkataraman 	    (cl->cl_callouts.ch_head == NULL)) {
92687a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
92787a18d3fSMadhavan Venkataraman 	}
92807247649SMadhavan Venkataraman 	/* FOUR cases, each different, !A!B, !AB, A!B, AB */
92907247649SMadhavan Venkataraman 	if ((coargs->flags & COF_HIRES) && (coargs->flags & COF_ABS)) {
93007247649SMadhavan Venkataraman 		/* both flags are set, only skip "regular" ones */
93151b32bddSMadhavan Venkataraman 		if (! (cl->cl_flags & COF_LIST_FLAGS)) {
93207247649SMadhavan Venkataraman 			return (WALK_NEXT);
93307247649SMadhavan Venkataraman 		}
93407247649SMadhavan Venkataraman 	} else {
93507247649SMadhavan Venkataraman 		if ((coargs->flags & COF_HIRES) &&
93651b32bddSMadhavan Venkataraman 		    !(cl->cl_flags & CALLOUT_LIST_FLAG_HRESTIME)) {
93707247649SMadhavan Venkataraman 			return (WALK_NEXT);
93807247649SMadhavan Venkataraman 		}
93907247649SMadhavan Venkataraman 		if ((coargs->flags & COF_ABS) &&
94051b32bddSMadhavan Venkataraman 		    !(cl->cl_flags & CALLOUT_LIST_FLAG_ABSOLUTE)) {
94107247649SMadhavan Venkataraman 			return (WALK_NEXT);
94207247649SMadhavan Venkataraman 		}
94307247649SMadhavan Venkataraman 	}
94487a18d3fSMadhavan Venkataraman 
94587a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_LHDR) && !(coargs->flags & COF_ADDR) &&
94687a18d3fSMadhavan Venkataraman 	    (coargs->flags & (COF_LIST | COF_VERBOSE))) {
94787a18d3fSMadhavan Venkataraman 		if (!(coargs->flags & COF_VERBOSE)) {
94887a18d3fSMadhavan Venkataraman 			/* don't be redundant again */
94987a18d3fSMadhavan Venkataraman 			mdb_printf("%<u>SEQ T %</u>");
95087a18d3fSMadhavan Venkataraman 		}
95107247649SMadhavan Venkataraman 		mdb_printf("%<u>EXP            HA BUCKET "
95207247649SMadhavan Venkataraman 		    "CALLOUTS         %</u>");
95387a18d3fSMadhavan Venkataraman 
95487a18d3fSMadhavan Venkataraman 		if (coargs->flags & COF_LONGLIST) {
95507247649SMadhavan Venkataraman 			mdb_printf("%<u> %-?s %-?s%</u>",
95607247649SMadhavan Venkataraman 			    "PREV", "NEXT");
95787a18d3fSMadhavan Venkataraman 		}
95887a18d3fSMadhavan Venkataraman 		mdb_printf("\n");
95987a18d3fSMadhavan Venkataraman 		coargs->flags &= ~COF_LHDR;
96087a18d3fSMadhavan Venkataraman 		coargs->flags |= (COF_THDR | COF_CHDR);
96187a18d3fSMadhavan Venkataraman 	}
96287a18d3fSMadhavan Venkataraman 	if (coargs->flags & (COF_LIST | COF_VERBOSE)) {
96387a18d3fSMadhavan Venkataraman 		if (!(coargs->flags & COF_ADDR)) {
96487a18d3fSMadhavan Venkataraman 			if (!(coargs->flags & COF_VERBOSE)) {
96587a18d3fSMadhavan Venkataraman 				mdb_printf("%3d %1s ",
96687a18d3fSMadhavan Venkataraman 				    TABLE_TO_SEQID(coargs->ndx),
96787a18d3fSMadhavan Venkataraman 				    co_typenames[coargs->ndx &
96887a18d3fSMadhavan Venkataraman 				    CALLOUT_TYPE_MASK]);
96987a18d3fSMadhavan Venkataraman 			}
97087a18d3fSMadhavan Venkataraman 
97151b32bddSMadhavan Venkataraman 			list_flags = coargs->list_flags;
97207247649SMadhavan Venkataraman 			mdb_printf("%-14llx %1s%1s %-6d %-0?p ",
97387a18d3fSMadhavan Venkataraman 			    (coargs->flags & COF_EXPREL) ?
97487a18d3fSMadhavan Venkataraman 			    coargs->exp - coargs->now : coargs->exp,
97551b32bddSMadhavan Venkataraman 			    (list_flags & CALLOUT_LIST_FLAG_HRESTIME) ?
97607247649SMadhavan Venkataraman 			    "H" : " ",
97751b32bddSMadhavan Venkataraman 			    (list_flags & CALLOUT_LIST_FLAG_ABSOLUTE) ?
97807247649SMadhavan Venkataraman 			    "A" : " ",
97907247649SMadhavan Venkataraman 			    coargs->bucket, cl->cl_callouts.ch_head);
98087a18d3fSMadhavan Venkataraman 
98187a18d3fSMadhavan Venkataraman 			if (coargs->flags & COF_LONGLIST) {
98207247649SMadhavan Venkataraman 				mdb_printf(" %-?p %-?p",
98307247649SMadhavan Venkataraman 				    cl->cl_prev, cl->cl_next);
98487a18d3fSMadhavan Venkataraman 			}
98587a18d3fSMadhavan Venkataraman 		} else {
98687a18d3fSMadhavan Venkataraman 			/* address only */
98787a18d3fSMadhavan Venkataraman 			mdb_printf("%-0p", addr);
98887a18d3fSMadhavan Venkataraman 		}
98987a18d3fSMadhavan Venkataraman 		mdb_printf("\n");
99087a18d3fSMadhavan Venkataraman 		if (coargs->flags & COF_LIST) {
99187a18d3fSMadhavan Venkataraman 			return (WALK_NEXT);
99287a18d3fSMadhavan Venkataraman 		}
99387a18d3fSMadhavan Venkataraman 	}
99487a18d3fSMadhavan Venkataraman 	/* yet another layer as we walk the actual callouts via list. */
99587a18d3fSMadhavan Venkataraman 	if (cl->cl_callouts.ch_head == NULL) {
99687a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
99787a18d3fSMadhavan Venkataraman 	}
99887a18d3fSMadhavan Venkataraman 	/* free list structures do not have valid callouts off of them. */
99987a18d3fSMadhavan Venkataraman 	if (coargs->flags & COF_FREE) {
100087a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
100187a18d3fSMadhavan Venkataraman 	}
100287a18d3fSMadhavan Venkataraman 	coptr = (callout_t *)cl->cl_callouts.ch_head;
100387a18d3fSMadhavan Venkataraman 
100487a18d3fSMadhavan Venkataraman 	if (coargs->flags & COF_VERBOSE) {
100587a18d3fSMadhavan Venkataraman 		mdb_inc_indent(4);
100687a18d3fSMadhavan Venkataraman 	}
100787a18d3fSMadhavan Venkataraman 	/*
100887a18d3fSMadhavan Venkataraman 	 * walk callouts using yet another callback routine.
100987a18d3fSMadhavan Venkataraman 	 * we use callouts_bytime because id hash is handled via
101087a18d3fSMadhavan Venkataraman 	 * the callout_t_cb callback.
101187a18d3fSMadhavan Venkataraman 	 */
101287a18d3fSMadhavan Venkataraman 	if (mdb_pwalk("callouts_bytime", callouts_cb, coargs,
101387a18d3fSMadhavan Venkataraman 	    (uintptr_t)coptr) == -1) {
101487a18d3fSMadhavan Venkataraman 		mdb_warn("cannot walk callouts at %p", coptr);
101587a18d3fSMadhavan Venkataraman 		return (WALK_ERR);
101687a18d3fSMadhavan Venkataraman 	}
101787a18d3fSMadhavan Venkataraman 	if (coargs->flags & COF_VERBOSE) {
101887a18d3fSMadhavan Venkataraman 		mdb_dec_indent(4);
101987a18d3fSMadhavan Venkataraman 	}
102087a18d3fSMadhavan Venkataraman 
102187a18d3fSMadhavan Venkataraman 	return (WALK_NEXT);
102287a18d3fSMadhavan Venkataraman }
102387a18d3fSMadhavan Venkataraman 
102487a18d3fSMadhavan Venkataraman /* this callback handles the details of callout table walking. */
102587a18d3fSMadhavan Venkataraman static int
102687a18d3fSMadhavan Venkataraman callout_t_cb(uintptr_t addr, const void *data, void *priv)
102787a18d3fSMadhavan Venkataraman {
102887a18d3fSMadhavan Venkataraman 	callout_data_t *coargs = (callout_data_t *)priv;
102987a18d3fSMadhavan Venkataraman 	cot_data_t *cotwd = (cot_data_t *)data;
103087a18d3fSMadhavan Venkataraman 	callout_table_t *ct = &(cotwd->ct);
103187a18d3fSMadhavan Venkataraman 	int index, seqid, cotype;
103287a18d3fSMadhavan Venkataraman 	int i;
103387a18d3fSMadhavan Venkataraman 	callout_list_t *clptr;
103487a18d3fSMadhavan Venkataraman 	callout_t *coptr;
103587a18d3fSMadhavan Venkataraman 
103687a18d3fSMadhavan Venkataraman 	if ((coargs == NULL) || (ct == NULL) || (coargs->co_table == NULL)) {
103787a18d3fSMadhavan Venkataraman 		return (WALK_ERR);
103887a18d3fSMadhavan Venkataraman 	}
103987a18d3fSMadhavan Venkataraman 
104087a18d3fSMadhavan Venkataraman 	index =  ((char *)addr - (char *)coargs->co_table) /
104187a18d3fSMadhavan Venkataraman 	    sizeof (callout_table_t);
104287a18d3fSMadhavan Venkataraman 	cotype = index & CALLOUT_TYPE_MASK;
104387a18d3fSMadhavan Venkataraman 	seqid = TABLE_TO_SEQID(index);
10447c478bd9Sstevel@tonic-gate 
104587a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_SEQID) && (coargs->seqid != seqid)) {
104687a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
104787a18d3fSMadhavan Venkataraman 	}
10487c478bd9Sstevel@tonic-gate 
104987a18d3fSMadhavan Venkataraman 	if (!(coargs->flags & COF_REAL) && (cotype == CALLOUT_REALTIME)) {
105087a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
105187a18d3fSMadhavan Venkataraman 	}
10527c478bd9Sstevel@tonic-gate 
105387a18d3fSMadhavan Venkataraman 	if (!(coargs->flags & COF_NORM) && (cotype == CALLOUT_NORMAL)) {
105487a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
105587a18d3fSMadhavan Venkataraman 	}
10567c478bd9Sstevel@tonic-gate 
105787a18d3fSMadhavan Venkataraman 	if (!(coargs->flags & COF_EMPTY) && (
105887a18d3fSMadhavan Venkataraman 	    (ct->ct_heap == NULL) || (ct->ct_cyclic == NULL))) {
105987a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
106087a18d3fSMadhavan Venkataraman 	}
106187a18d3fSMadhavan Venkataraman 
106287a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_THDR) && !(coargs->flags & COF_ADDR) &&
106387a18d3fSMadhavan Venkataraman 	    (coargs->flags & (COF_TABLE | COF_VERBOSE))) {
106487a18d3fSMadhavan Venkataraman 		/* print table hdr */
106587a18d3fSMadhavan Venkataraman 		mdb_printf("%<u>%-3s %-1s %-?s %-?s %-?s %-?s%</u>",
106687a18d3fSMadhavan Venkataraman 		    "SEQ", "T", "FREE", "LFREE", "CYCLIC", "HEAP");
106787a18d3fSMadhavan Venkataraman 		coargs->flags &= ~COF_THDR;
106887a18d3fSMadhavan Venkataraman 		coargs->flags |= (COF_LHDR | COF_CHDR);
106987a18d3fSMadhavan Venkataraman 		if (coargs->flags & COF_LONGLIST) {
107087a18d3fSMadhavan Venkataraman 			/* more info! */
107187a18d3fSMadhavan Venkataraman 			mdb_printf("%<u> %-T%-7s %-7s %-?s %-?s"
107287a18d3fSMadhavan Venkataraman 			    " %-?s %-?s %-?s%</u>",
107387a18d3fSMadhavan Venkataraman 			    "HEAPNUM", "HEAPMAX", "TASKQ", "EXPQ",
107487a18d3fSMadhavan Venkataraman 			    "PEND", "FREE", "LOCK");
107587a18d3fSMadhavan Venkataraman 		}
107687a18d3fSMadhavan Venkataraman 		mdb_printf("\n");
107787a18d3fSMadhavan Venkataraman 	}
107887a18d3fSMadhavan Venkataraman 	if (coargs->flags & (COF_TABLE | COF_VERBOSE)) {
107987a18d3fSMadhavan Venkataraman 		if (!(coargs->flags & COF_ADDR)) {
108087a18d3fSMadhavan Venkataraman 			mdb_printf("%-3d %-1s %-0?p %-0?p %-0?p %-?p",
108187a18d3fSMadhavan Venkataraman 			    seqid, co_typenames[cotype],
108287a18d3fSMadhavan Venkataraman 			    ct->ct_free, ct->ct_lfree, ct->ct_cyclic,
108387a18d3fSMadhavan Venkataraman 			    ct->ct_heap);
108487a18d3fSMadhavan Venkataraman 			if (coargs->flags & COF_LONGLIST)  {
108587a18d3fSMadhavan Venkataraman 				/* more info! */
108687a18d3fSMadhavan Venkataraman 				mdb_printf(" %-7d %-7d %-?p %-?p"
108787a18d3fSMadhavan Venkataraman 				    " %-?lld %-?lld %-?p",
108887a18d3fSMadhavan Venkataraman 				    ct->ct_heap_num,  ct->ct_heap_max,
108987a18d3fSMadhavan Venkataraman 				    ct->ct_taskq, ct->ct_expired.ch_head,
109087a18d3fSMadhavan Venkataraman 				    cotwd->ct_timeouts_pending,
109187a18d3fSMadhavan Venkataraman 				    cotwd->ct_allocations -
109287a18d3fSMadhavan Venkataraman 				    cotwd->ct_timeouts_pending,
109387a18d3fSMadhavan Venkataraman 				    ct->ct_mutex);
109487a18d3fSMadhavan Venkataraman 			}
109587a18d3fSMadhavan Venkataraman 		} else {
109687a18d3fSMadhavan Venkataraman 			/* address only */
109787a18d3fSMadhavan Venkataraman 			mdb_printf("%-0?p", addr);
109887a18d3fSMadhavan Venkataraman 		}
109987a18d3fSMadhavan Venkataraman 		mdb_printf("\n");
110087a18d3fSMadhavan Venkataraman 		if (coargs->flags & COF_TABLE) {
110187a18d3fSMadhavan Venkataraman 			return (WALK_NEXT);
110287a18d3fSMadhavan Venkataraman 		}
110387a18d3fSMadhavan Venkataraman 	}
110487a18d3fSMadhavan Venkataraman 
110587a18d3fSMadhavan Venkataraman 	coargs->ndx = index;
110687a18d3fSMadhavan Venkataraman 	if (coargs->flags & COF_VERBOSE) {
110787a18d3fSMadhavan Venkataraman 		mdb_inc_indent(4);
110887a18d3fSMadhavan Venkataraman 	}
110987a18d3fSMadhavan Venkataraman 	/* keep digging. */
111087a18d3fSMadhavan Venkataraman 	if (!(coargs->flags & COF_BYIDH)) {
111187a18d3fSMadhavan Venkataraman 		/* walk the list hash table */
111287a18d3fSMadhavan Venkataraman 		if (coargs->flags & COF_FREE) {
111387a18d3fSMadhavan Venkataraman 			clptr = ct->ct_lfree;
111487a18d3fSMadhavan Venkataraman 			coargs->bucket = 0;
111587a18d3fSMadhavan Venkataraman 			if (clptr == NULL) {
111687a18d3fSMadhavan Venkataraman 				return (WALK_NEXT);
111787a18d3fSMadhavan Venkataraman 			}
111887a18d3fSMadhavan Venkataraman 			if (mdb_pwalk("callout_list", callout_list_cb, coargs,
111987a18d3fSMadhavan Venkataraman 			    (uintptr_t)clptr) == -1) {
112087a18d3fSMadhavan Venkataraman 				mdb_warn("cannot walk callout free list at %p",
112187a18d3fSMadhavan Venkataraman 				    clptr);
112287a18d3fSMadhavan Venkataraman 				return (WALK_ERR);
112387a18d3fSMadhavan Venkataraman 			}
112487a18d3fSMadhavan Venkataraman 		} else {
112587a18d3fSMadhavan Venkataraman 			/* first print the expired list. */
112687a18d3fSMadhavan Venkataraman 			clptr = (callout_list_t *)ct->ct_expired.ch_head;
112787a18d3fSMadhavan Venkataraman 			if (clptr != NULL) {
112887a18d3fSMadhavan Venkataraman 				coargs->bucket = -1;
112987a18d3fSMadhavan Venkataraman 				if (mdb_pwalk("callout_list", callout_list_cb,
113087a18d3fSMadhavan Venkataraman 				    coargs, (uintptr_t)clptr) == -1) {
113187a18d3fSMadhavan Venkataraman 					mdb_warn("cannot walk callout_list"
113287a18d3fSMadhavan Venkataraman 					    " at %p", clptr);
113387a18d3fSMadhavan Venkataraman 					return (WALK_ERR);
113487a18d3fSMadhavan Venkataraman 				}
113587a18d3fSMadhavan Venkataraman 			}
113687a18d3fSMadhavan Venkataraman 			for (i = 0; i < CALLOUT_BUCKETS; i++) {
113787a18d3fSMadhavan Venkataraman 				if (ct->ct_clhash == NULL) {
113887a18d3fSMadhavan Venkataraman 					/* nothing to do */
113987a18d3fSMadhavan Venkataraman 					break;
114087a18d3fSMadhavan Venkataraman 				}
114187a18d3fSMadhavan Venkataraman 				if (cotwd->cot_clhash[i].ch_head == NULL) {
114287a18d3fSMadhavan Venkataraman 					continue;
11437c478bd9Sstevel@tonic-gate 				}
114487a18d3fSMadhavan Venkataraman 				clptr = (callout_list_t *)
114587a18d3fSMadhavan Venkataraman 				    cotwd->cot_clhash[i].ch_head;
114687a18d3fSMadhavan Venkataraman 				coargs->bucket = i;
114787a18d3fSMadhavan Venkataraman 				/* walk list with callback routine. */
114887a18d3fSMadhavan Venkataraman 				if (mdb_pwalk("callout_list", callout_list_cb,
114987a18d3fSMadhavan Venkataraman 				    coargs, (uintptr_t)clptr) == -1) {
115087a18d3fSMadhavan Venkataraman 					mdb_warn("cannot walk callout_list"
115187a18d3fSMadhavan Venkataraman 					    " at %p", clptr);
115287a18d3fSMadhavan Venkataraman 					return (WALK_ERR);
115387a18d3fSMadhavan Venkataraman 				}
115487a18d3fSMadhavan Venkataraman 			}
115587a18d3fSMadhavan Venkataraman 		}
115687a18d3fSMadhavan Venkataraman 	} else {
115787a18d3fSMadhavan Venkataraman 		/* walk the id hash table. */
115887a18d3fSMadhavan Venkataraman 		if (coargs->flags & COF_FREE) {
115987a18d3fSMadhavan Venkataraman 			coptr = ct->ct_free;
116087a18d3fSMadhavan Venkataraman 			coargs->bucket = 0;
116187a18d3fSMadhavan Venkataraman 			if (coptr == NULL) {
116287a18d3fSMadhavan Venkataraman 				return (WALK_NEXT);
11637c478bd9Sstevel@tonic-gate 			}
116487a18d3fSMadhavan Venkataraman 			if (mdb_pwalk("callouts_byid", callouts_cb, coargs,
116587a18d3fSMadhavan Venkataraman 			    (uintptr_t)coptr) == -1) {
116687a18d3fSMadhavan Venkataraman 				mdb_warn("cannot walk callout id free list"
116787a18d3fSMadhavan Venkataraman 				    " at %p", coptr);
116887a18d3fSMadhavan Venkataraman 				return (WALK_ERR);
116987a18d3fSMadhavan Venkataraman 			}
117087a18d3fSMadhavan Venkataraman 		} else {
117187a18d3fSMadhavan Venkataraman 			for (i = 0; i < CALLOUT_BUCKETS; i++) {
117287a18d3fSMadhavan Venkataraman 				if (ct->ct_idhash == NULL) {
117387a18d3fSMadhavan Venkataraman 					break;
117487a18d3fSMadhavan Venkataraman 				}
117587a18d3fSMadhavan Venkataraman 				coptr = (callout_t *)
117687a18d3fSMadhavan Venkataraman 				    cotwd->cot_idhash[i].ch_head;
117787a18d3fSMadhavan Venkataraman 				if (coptr == NULL) {
117887a18d3fSMadhavan Venkataraman 					continue;
117987a18d3fSMadhavan Venkataraman 				}
118087a18d3fSMadhavan Venkataraman 				coargs->bucket = i;
118187a18d3fSMadhavan Venkataraman 
118287a18d3fSMadhavan Venkataraman 				/*
118387a18d3fSMadhavan Venkataraman 				 * walk callouts directly by id. For id
118487a18d3fSMadhavan Venkataraman 				 * chain, the callout list is just a header,
118587a18d3fSMadhavan Venkataraman 				 * so there's no need to walk it.
118687a18d3fSMadhavan Venkataraman 				 */
118787a18d3fSMadhavan Venkataraman 				if (mdb_pwalk("callouts_byid", callouts_cb,
118887a18d3fSMadhavan Venkataraman 				    coargs, (uintptr_t)coptr) == -1) {
118987a18d3fSMadhavan Venkataraman 					mdb_warn("cannot walk callouts at %p",
119087a18d3fSMadhavan Venkataraman 					    coptr);
119187a18d3fSMadhavan Venkataraman 					return (WALK_ERR);
119287a18d3fSMadhavan Venkataraman 				}
119387a18d3fSMadhavan Venkataraman 			}
119487a18d3fSMadhavan Venkataraman 		}
119587a18d3fSMadhavan Venkataraman 	}
119687a18d3fSMadhavan Venkataraman 	if (coargs->flags & COF_VERBOSE) {
119787a18d3fSMadhavan Venkataraman 		mdb_dec_indent(4);
119887a18d3fSMadhavan Venkataraman 	}
119987a18d3fSMadhavan Venkataraman 	return (WALK_NEXT);
120087a18d3fSMadhavan Venkataraman }
120187a18d3fSMadhavan Venkataraman 
120287a18d3fSMadhavan Venkataraman /*
120387a18d3fSMadhavan Venkataraman  * initialize some common info for both callout dcmds.
120487a18d3fSMadhavan Venkataraman  */
120587a18d3fSMadhavan Venkataraman int
120687a18d3fSMadhavan Venkataraman callout_common_init(callout_data_t *coargs)
120787a18d3fSMadhavan Venkataraman {
120887a18d3fSMadhavan Venkataraman 	/* we need a couple of things */
120987a18d3fSMadhavan Venkataraman 	if (mdb_readvar(&(coargs->co_table), "callout_table") == -1) {
121087a18d3fSMadhavan Venkataraman 		mdb_warn("failed to read 'callout_table'");
121187a18d3fSMadhavan Venkataraman 		return (DCMD_ERR);
121287a18d3fSMadhavan Venkataraman 	}
121387a18d3fSMadhavan Venkataraman 	/* need to get now in nsecs. Approximate with hrtime vars */
121487a18d3fSMadhavan Venkataraman 	if (mdb_readsym(&(coargs->now), sizeof (hrtime_t), "hrtime_last") !=
121587a18d3fSMadhavan Venkataraman 	    sizeof (hrtime_t)) {
121687a18d3fSMadhavan Venkataraman 		if (mdb_readsym(&(coargs->now), sizeof (hrtime_t),
121787a18d3fSMadhavan Venkataraman 		    "hrtime_base") != sizeof (hrtime_t)) {
121887a18d3fSMadhavan Venkataraman 			mdb_warn("Could not determine current system time");
121987a18d3fSMadhavan Venkataraman 			return (DCMD_ERR);
122087a18d3fSMadhavan Venkataraman 		}
122187a18d3fSMadhavan Venkataraman 	}
122287a18d3fSMadhavan Venkataraman 
122387a18d3fSMadhavan Venkataraman 	if (mdb_readvar(&(coargs->ctbits), "callout_table_bits") == -1) {
122487a18d3fSMadhavan Venkataraman 		mdb_warn("failed to read 'callout_table_bits'");
122587a18d3fSMadhavan Venkataraman 		return (DCMD_ERR);
122687a18d3fSMadhavan Venkataraman 	}
122787a18d3fSMadhavan Venkataraman 	if (mdb_readvar(&(coargs->nsec_per_tick), "nsec_per_tick") == -1) {
122887a18d3fSMadhavan Venkataraman 		mdb_warn("failed to read 'nsec_per_tick'");
122987a18d3fSMadhavan Venkataraman 		return (DCMD_ERR);
123087a18d3fSMadhavan Venkataraman 	}
123187a18d3fSMadhavan Venkataraman 	return (DCMD_OK);
123287a18d3fSMadhavan Venkataraman }
123387a18d3fSMadhavan Venkataraman 
123487a18d3fSMadhavan Venkataraman /*
123587a18d3fSMadhavan Venkataraman  * dcmd to print callouts.  Optional addr limits to specific table.
123687a18d3fSMadhavan Venkataraman  * Parses lots of options that get passed to callbacks for walkers.
123787a18d3fSMadhavan Venkataraman  * Has it's own help function.
123887a18d3fSMadhavan Venkataraman  */
123987a18d3fSMadhavan Venkataraman /*ARGSUSED*/
124087a18d3fSMadhavan Venkataraman int
124187a18d3fSMadhavan Venkataraman callout(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
124287a18d3fSMadhavan Venkataraman {
124387a18d3fSMadhavan Venkataraman 	callout_data_t coargs;
124487a18d3fSMadhavan Venkataraman 	/* getopts doesn't help much with stuff like this */
124587a18d3fSMadhavan Venkataraman 	boolean_t Sflag, Cflag, tflag, aflag, bflag, dflag, kflag;
124687a18d3fSMadhavan Venkataraman 	char *funcname = NULL;
124787a18d3fSMadhavan Venkataraman 	char *paramstr = NULL;
124887a18d3fSMadhavan Venkataraman 	uintptr_t Stmp, Ctmp;	/* for getopt. */
124987a18d3fSMadhavan Venkataraman 	int retval;
125087a18d3fSMadhavan Venkataraman 
125187a18d3fSMadhavan Venkataraman 	coargs.flags = COF_DEFAULT;
125287a18d3fSMadhavan Venkataraman 	Sflag = Cflag = tflag = bflag = aflag = dflag = kflag = FALSE;
125387a18d3fSMadhavan Venkataraman 	coargs.seqid = -1;
125487a18d3fSMadhavan Venkataraman 
125587a18d3fSMadhavan Venkataraman 	if (mdb_getopts(argc, argv,
125687a18d3fSMadhavan Venkataraman 	    'r', MDB_OPT_CLRBITS, COF_NORM, &coargs.flags,
125787a18d3fSMadhavan Venkataraman 	    'n', MDB_OPT_CLRBITS, COF_REAL, &coargs.flags,
125887a18d3fSMadhavan Venkataraman 	    'l', MDB_OPT_CLRBITS, COF_SHORT, &coargs.flags,
125987a18d3fSMadhavan Venkataraman 	    's', MDB_OPT_CLRBITS, COF_LONG, &coargs.flags,
126087a18d3fSMadhavan Venkataraman 	    'x', MDB_OPT_SETBITS, COF_EXEC, &coargs.flags,
126187a18d3fSMadhavan Venkataraman 	    'h', MDB_OPT_SETBITS, COF_HIRES, &coargs.flags,
126207247649SMadhavan Venkataraman 	    'B', MDB_OPT_SETBITS, COF_ABS, &coargs.flags,
126387a18d3fSMadhavan Venkataraman 	    'E', MDB_OPT_SETBITS, COF_EMPTY, &coargs.flags,
126487a18d3fSMadhavan Venkataraman 	    'd', MDB_OPT_SETBITS, 1, &dflag,
126587a18d3fSMadhavan Venkataraman 	    'C', MDB_OPT_UINTPTR_SET, &Cflag, &Ctmp,
126687a18d3fSMadhavan Venkataraman 	    'S', MDB_OPT_UINTPTR_SET, &Sflag, &Stmp,
126787a18d3fSMadhavan Venkataraman 	    't', MDB_OPT_UINTPTR_SET, &tflag, (uintptr_t *)&coargs.time,
126887a18d3fSMadhavan Venkataraman 	    'a', MDB_OPT_UINTPTR_SET, &aflag, (uintptr_t *)&coargs.atime,
126987a18d3fSMadhavan Venkataraman 	    'b', MDB_OPT_UINTPTR_SET, &bflag, (uintptr_t *)&coargs.btime,
127087a18d3fSMadhavan Venkataraman 	    'k', MDB_OPT_SETBITS, 1, &kflag,
127187a18d3fSMadhavan Venkataraman 	    'f', MDB_OPT_STR, &funcname,
127287a18d3fSMadhavan Venkataraman 	    'p', MDB_OPT_STR, &paramstr,
127387a18d3fSMadhavan Venkataraman 	    'T', MDB_OPT_SETBITS, COF_TABLE, &coargs.flags,
127487a18d3fSMadhavan Venkataraman 	    'D', MDB_OPT_SETBITS, COF_EXPREL, &coargs.flags,
127587a18d3fSMadhavan Venkataraman 	    'L', MDB_OPT_SETBITS, COF_LIST, &coargs.flags,
127687a18d3fSMadhavan Venkataraman 	    'V', MDB_OPT_SETBITS, COF_VERBOSE, &coargs.flags,
127787a18d3fSMadhavan Venkataraman 	    'v', MDB_OPT_SETBITS, COF_LONGLIST, &coargs.flags,
127887a18d3fSMadhavan Venkataraman 	    'i', MDB_OPT_SETBITS, COF_BYIDH, &coargs.flags,
127987a18d3fSMadhavan Venkataraman 	    'F', MDB_OPT_SETBITS, COF_FREE, &coargs.flags,
128087a18d3fSMadhavan Venkataraman 	    'A', MDB_OPT_SETBITS, COF_ADDR, &coargs.flags,
128187a18d3fSMadhavan Venkataraman 	    NULL) != argc) {
128287a18d3fSMadhavan Venkataraman 		return (DCMD_USAGE);
128387a18d3fSMadhavan Venkataraman 	}
128487a18d3fSMadhavan Venkataraman 
128587a18d3fSMadhavan Venkataraman 	/* initialize from kernel variables */
128687a18d3fSMadhavan Venkataraman 	if ((retval = callout_common_init(&coargs)) != DCMD_OK) {
128787a18d3fSMadhavan Venkataraman 		return (retval);
128887a18d3fSMadhavan Venkataraman 	}
128987a18d3fSMadhavan Venkataraman 
129087a18d3fSMadhavan Venkataraman 	/* do some option post-processing */
129187a18d3fSMadhavan Venkataraman 	if (kflag) {
129287a18d3fSMadhavan Venkataraman 		coargs.time *= coargs.nsec_per_tick;
129387a18d3fSMadhavan Venkataraman 		coargs.atime *= coargs.nsec_per_tick;
129487a18d3fSMadhavan Venkataraman 		coargs.btime *= coargs.nsec_per_tick;
129587a18d3fSMadhavan Venkataraman 	}
129687a18d3fSMadhavan Venkataraman 
129787a18d3fSMadhavan Venkataraman 	if (dflag) {
129887a18d3fSMadhavan Venkataraman 		coargs.time += coargs.now;
129987a18d3fSMadhavan Venkataraman 		coargs.atime += coargs.now;
130087a18d3fSMadhavan Venkataraman 		coargs.btime += coargs.now;
130187a18d3fSMadhavan Venkataraman 	}
130287a18d3fSMadhavan Venkataraman 	if (Sflag) {
130387a18d3fSMadhavan Venkataraman 		if (flags & DCMD_ADDRSPEC) {
130487a18d3fSMadhavan Venkataraman 			mdb_printf("-S option conflicts with explicit"
130587a18d3fSMadhavan Venkataraman 			    " address\n");
130687a18d3fSMadhavan Venkataraman 			return (DCMD_USAGE);
130787a18d3fSMadhavan Venkataraman 		}
130887a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_SEQID;
130987a18d3fSMadhavan Venkataraman 		coargs.seqid = (int)Stmp;
131087a18d3fSMadhavan Venkataraman 	}
131187a18d3fSMadhavan Venkataraman 	if (Cflag) {
131287a18d3fSMadhavan Venkataraman 		if (flags & DCMD_ADDRSPEC) {
131387a18d3fSMadhavan Venkataraman 			mdb_printf("-C option conflicts with explicit"
131487a18d3fSMadhavan Venkataraman 			    " address\n");
131587a18d3fSMadhavan Venkataraman 			return (DCMD_USAGE);
131687a18d3fSMadhavan Venkataraman 		}
131787a18d3fSMadhavan Venkataraman 		if (coargs.flags & COF_SEQID) {
131887a18d3fSMadhavan Venkataraman 			mdb_printf("-C and -S are mutually exclusive\n");
131987a18d3fSMadhavan Venkataraman 			return (DCMD_USAGE);
132087a18d3fSMadhavan Venkataraman 		}
132187a18d3fSMadhavan Venkataraman 		coargs.cpu = (cpu_t *)Ctmp;
132287a18d3fSMadhavan Venkataraman 		if (mdb_vread(&coargs.seqid, sizeof (processorid_t),
132387a18d3fSMadhavan Venkataraman 		    (uintptr_t)&(coargs.cpu->cpu_seqid)) == -1) {
132487a18d3fSMadhavan Venkataraman 			mdb_warn("failed to read cpu_t at %p", Ctmp);
132587a18d3fSMadhavan Venkataraman 			return (DCMD_ERR);
132687a18d3fSMadhavan Venkataraman 		}
132787a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_SEQID;
132887a18d3fSMadhavan Venkataraman 	}
132987a18d3fSMadhavan Venkataraman 	/* avoid null outputs. */
133087a18d3fSMadhavan Venkataraman 	if (!(coargs.flags & (COF_REAL | COF_NORM))) {
133187a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_REAL | COF_NORM;
133287a18d3fSMadhavan Venkataraman 	}
133387a18d3fSMadhavan Venkataraman 	if (!(coargs.flags & (COF_LONG | COF_SHORT))) {
133487a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_LONG | COF_SHORT;
133587a18d3fSMadhavan Venkataraman 	}
133687a18d3fSMadhavan Venkataraman 	if (tflag) {
133787a18d3fSMadhavan Venkataraman 		if (aflag || bflag) {
133887a18d3fSMadhavan Venkataraman 			mdb_printf("-t and -a|b are mutually exclusive\n");
133987a18d3fSMadhavan Venkataraman 			return (DCMD_USAGE);
13407c478bd9Sstevel@tonic-gate 		}
134187a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_TIME;
134287a18d3fSMadhavan Venkataraman 	}
134387a18d3fSMadhavan Venkataraman 	if (aflag) {
134487a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_AFTER;
134587a18d3fSMadhavan Venkataraman 	}
134687a18d3fSMadhavan Venkataraman 	if (bflag) {
134787a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_BEFORE;
134887a18d3fSMadhavan Venkataraman 	}
134987a18d3fSMadhavan Venkataraman 	if ((aflag && bflag) && (coargs.btime <= coargs.atime)) {
135087a18d3fSMadhavan Venkataraman 		mdb_printf("value for -a must be earlier than the value"
135187a18d3fSMadhavan Venkataraman 		    " for -b.\n");
135287a18d3fSMadhavan Venkataraman 		return (DCMD_USAGE);
13537c478bd9Sstevel@tonic-gate 	}
13547c478bd9Sstevel@tonic-gate 
135587a18d3fSMadhavan Venkataraman 	if (funcname != NULL) {
135687a18d3fSMadhavan Venkataraman 		GElf_Sym sym;
135787a18d3fSMadhavan Venkataraman 
135887a18d3fSMadhavan Venkataraman 		if (mdb_lookup_by_name(funcname, &sym) != 0) {
135987a18d3fSMadhavan Venkataraman 			coargs.funcaddr = mdb_strtoull(funcname);
136087a18d3fSMadhavan Venkataraman 		} else {
136187a18d3fSMadhavan Venkataraman 			coargs.funcaddr = sym.st_value;
136287a18d3fSMadhavan Venkataraman 		}
136387a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_FUNC;
136487a18d3fSMadhavan Venkataraman 	}
136587a18d3fSMadhavan Venkataraman 
136687a18d3fSMadhavan Venkataraman 	if (paramstr != NULL) {
136787a18d3fSMadhavan Venkataraman 		GElf_Sym sym;
136887a18d3fSMadhavan Venkataraman 
136987a18d3fSMadhavan Venkataraman 		if (mdb_lookup_by_name(paramstr, &sym) != 0) {
137087a18d3fSMadhavan Venkataraman 			coargs.param = mdb_strtoull(paramstr);
137187a18d3fSMadhavan Venkataraman 		} else {
137287a18d3fSMadhavan Venkataraman 			coargs.param = sym.st_value;
137387a18d3fSMadhavan Venkataraman 		}
137487a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_PARAM;
137587a18d3fSMadhavan Venkataraman 	}
137687a18d3fSMadhavan Venkataraman 
137787a18d3fSMadhavan Venkataraman 	if (!(flags & DCMD_ADDRSPEC)) {
137887a18d3fSMadhavan Venkataraman 		/* don't pass "dot" if no addr. */
137987a18d3fSMadhavan Venkataraman 		addr = NULL;
138087a18d3fSMadhavan Venkataraman 	}
138187a18d3fSMadhavan Venkataraman 	if (addr != NULL) {
138287a18d3fSMadhavan Venkataraman 		/*
138387a18d3fSMadhavan Venkataraman 		 * a callout table was specified. Ignore -r|n option
138487a18d3fSMadhavan Venkataraman 		 * to avoid null output.
138587a18d3fSMadhavan Venkataraman 		 */
138687a18d3fSMadhavan Venkataraman 		coargs.flags |= (COF_REAL | COF_NORM);
138787a18d3fSMadhavan Venkataraman 	}
138887a18d3fSMadhavan Venkataraman 
138987a18d3fSMadhavan Venkataraman 	if (DCMD_HDRSPEC(flags) || (coargs.flags & COF_VERBOSE)) {
139087a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_THDR | COF_LHDR | COF_CHDR;
139187a18d3fSMadhavan Venkataraman 	}
139287a18d3fSMadhavan Venkataraman 	if (coargs.flags & COF_FREE) {
139387a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_EMPTY;
139487a18d3fSMadhavan Venkataraman 		/* -F = free callouts, -FL = free lists */
139587a18d3fSMadhavan Venkataraman 		if (!(coargs.flags & COF_LIST)) {
139687a18d3fSMadhavan Venkataraman 			coargs.flags |= COF_BYIDH;
139787a18d3fSMadhavan Venkataraman 		}
139887a18d3fSMadhavan Venkataraman 	}
139987a18d3fSMadhavan Venkataraman 
140087a18d3fSMadhavan Venkataraman 	/* walk table, using specialized callback routine. */
140187a18d3fSMadhavan Venkataraman 	if (mdb_pwalk("callout_table", callout_t_cb, &coargs, addr) == -1) {
140287a18d3fSMadhavan Venkataraman 		mdb_warn("cannot walk callout_table");
140387a18d3fSMadhavan Venkataraman 		return (DCMD_ERR);
140487a18d3fSMadhavan Venkataraman 	}
14057c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
14067c478bd9Sstevel@tonic-gate }
14077c478bd9Sstevel@tonic-gate 
140887a18d3fSMadhavan Venkataraman 
140987a18d3fSMadhavan Venkataraman /*
141087a18d3fSMadhavan Venkataraman  * Given an extended callout id, dump its information.
141187a18d3fSMadhavan Venkataraman  */
141287a18d3fSMadhavan Venkataraman /*ARGSUSED*/
141387a18d3fSMadhavan Venkataraman int
141487a18d3fSMadhavan Venkataraman calloutid(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
141587a18d3fSMadhavan Venkataraman {
141687a18d3fSMadhavan Venkataraman 	callout_data_t coargs;
141787a18d3fSMadhavan Venkataraman 	callout_table_t *ctptr;
141887a18d3fSMadhavan Venkataraman 	callout_table_t ct;
141987a18d3fSMadhavan Venkataraman 	callout_id_t coid;
142087a18d3fSMadhavan Venkataraman 	callout_t *coptr;
142187a18d3fSMadhavan Venkataraman 	int tableid;
142287a18d3fSMadhavan Venkataraman 	callout_id_t xid;
142387a18d3fSMadhavan Venkataraman 	ulong_t idhash;
142487a18d3fSMadhavan Venkataraman 	int i, retval;
142587a18d3fSMadhavan Venkataraman 	const mdb_arg_t *arg;
142687a18d3fSMadhavan Venkataraman 	size_t size;
142787a18d3fSMadhavan Venkataraman 	callout_hash_t cot_idhash[CALLOUT_BUCKETS];
142887a18d3fSMadhavan Venkataraman 
142987a18d3fSMadhavan Venkataraman 	coargs.flags = COF_DEFAULT | COF_BYIDH;
143087a18d3fSMadhavan Venkataraman 	i = mdb_getopts(argc, argv,
143187a18d3fSMadhavan Venkataraman 	    'd', MDB_OPT_SETBITS, COF_DECODE, &coargs.flags,
143287a18d3fSMadhavan Venkataraman 	    'v', MDB_OPT_SETBITS, COF_LONGLIST, &coargs.flags,
143387a18d3fSMadhavan Venkataraman 	    NULL);
143487a18d3fSMadhavan Venkataraman 	argc -= i;
143587a18d3fSMadhavan Venkataraman 	argv += i;
143687a18d3fSMadhavan Venkataraman 
143787a18d3fSMadhavan Venkataraman 	if (argc != 1) {
143887a18d3fSMadhavan Venkataraman 		return (DCMD_USAGE);
143987a18d3fSMadhavan Venkataraman 	}
144087a18d3fSMadhavan Venkataraman 	arg = &argv[0];
144187a18d3fSMadhavan Venkataraman 
144287a18d3fSMadhavan Venkataraman 	if (arg->a_type == MDB_TYPE_IMMEDIATE) {
144387a18d3fSMadhavan Venkataraman 		xid = arg->a_un.a_val;
144487a18d3fSMadhavan Venkataraman 	} else {
144587a18d3fSMadhavan Venkataraman 		xid = (callout_id_t)mdb_strtoull(arg->a_un.a_str);
144687a18d3fSMadhavan Venkataraman 	}
144787a18d3fSMadhavan Venkataraman 
144887a18d3fSMadhavan Venkataraman 	if (DCMD_HDRSPEC(flags)) {
144987a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_CHDR;
145087a18d3fSMadhavan Venkataraman 	}
145187a18d3fSMadhavan Venkataraman 
145287a18d3fSMadhavan Venkataraman 
145387a18d3fSMadhavan Venkataraman 	/* initialize from kernel variables */
145487a18d3fSMadhavan Venkataraman 	if ((retval = callout_common_init(&coargs)) != DCMD_OK) {
145587a18d3fSMadhavan Venkataraman 		return (retval);
145687a18d3fSMadhavan Venkataraman 	}
145787a18d3fSMadhavan Venkataraman 
145887a18d3fSMadhavan Venkataraman 	/* we must massage the environment so that the macros will play nice */
145987a18d3fSMadhavan Venkataraman #define	callout_table_mask	((1 << coargs.ctbits) - 1)
146087a18d3fSMadhavan Venkataraman #define	callout_table_bits	coargs.ctbits
146187a18d3fSMadhavan Venkataraman #define	nsec_per_tick		coargs.nsec_per_tick
146287a18d3fSMadhavan Venkataraman 	tableid = CALLOUT_ID_TO_TABLE(xid);
146387a18d3fSMadhavan Venkataraman 	idhash = CALLOUT_IDHASH(xid);
146487a18d3fSMadhavan Venkataraman #undef	callouts_table_bits
146587a18d3fSMadhavan Venkataraman #undef	callout_table_mask
146687a18d3fSMadhavan Venkataraman #undef	nsec_per_tick
146787a18d3fSMadhavan Venkataraman 	coid = CO_PLAIN_ID(xid);
146887a18d3fSMadhavan Venkataraman 
146987a18d3fSMadhavan Venkataraman 	if (flags & DCMD_ADDRSPEC) {
147087a18d3fSMadhavan Venkataraman 		mdb_printf("calloutid does not accept explicit address.\n");
147187a18d3fSMadhavan Venkataraman 		return (DCMD_USAGE);
147287a18d3fSMadhavan Venkataraman 	}
147387a18d3fSMadhavan Venkataraman 
147487a18d3fSMadhavan Venkataraman 	if (coargs.flags & COF_DECODE) {
147587a18d3fSMadhavan Venkataraman 		if (DCMD_HDRSPEC(flags)) {
147607247649SMadhavan Venkataraman 			mdb_printf("%<u>%3s %1s %2s %-?s %-6s %</u>\n",
147707247649SMadhavan Venkataraman 			    "SEQ", "T", "XL", "XID", "IDHASH");
147887a18d3fSMadhavan Venkataraman 		}
147907247649SMadhavan Venkataraman 		mdb_printf("%-3d %1s %1s%1s %-?llx %-6d\n",
148087a18d3fSMadhavan Venkataraman 		    TABLE_TO_SEQID(tableid),
148187a18d3fSMadhavan Venkataraman 		    co_typenames[tableid & CALLOUT_TYPE_MASK],
148287a18d3fSMadhavan Venkataraman 		    (xid & CALLOUT_EXECUTING) ? "X" : " ",
148387a18d3fSMadhavan Venkataraman 		    (xid & CALLOUT_LONGTERM) ? "L" : " ",
148487a18d3fSMadhavan Venkataraman 		    (long long)coid, idhash);
148587a18d3fSMadhavan Venkataraman 		return (DCMD_OK);
148687a18d3fSMadhavan Venkataraman 	}
148787a18d3fSMadhavan Venkataraman 
148887a18d3fSMadhavan Venkataraman 	/* get our table. Note this relies on the types being correct */
148987a18d3fSMadhavan Venkataraman 	ctptr = coargs.co_table + tableid;
149087a18d3fSMadhavan Venkataraman 	if (mdb_vread(&ct, sizeof (callout_table_t), (uintptr_t)ctptr) == -1) {
149187a18d3fSMadhavan Venkataraman 		mdb_warn("failed to read callout_table at %p", ctptr);
149287a18d3fSMadhavan Venkataraman 		return (DCMD_ERR);
149387a18d3fSMadhavan Venkataraman 	}
149487a18d3fSMadhavan Venkataraman 	size = sizeof (callout_hash_t) * CALLOUT_BUCKETS;
149587a18d3fSMadhavan Venkataraman 	if (ct.ct_idhash != NULL) {
149687a18d3fSMadhavan Venkataraman 		if (mdb_vread(&(cot_idhash), size,
149787a18d3fSMadhavan Venkataraman 		    (uintptr_t)ct.ct_idhash) == -1) {
149887a18d3fSMadhavan Venkataraman 			mdb_warn("failed to read id_hash at %p",
149987a18d3fSMadhavan Venkataraman 			    ct.ct_idhash);
150087a18d3fSMadhavan Venkataraman 			return (WALK_ERR);
150187a18d3fSMadhavan Venkataraman 		}
150287a18d3fSMadhavan Venkataraman 	}
150387a18d3fSMadhavan Venkataraman 
150487a18d3fSMadhavan Venkataraman 	/* callout at beginning of hash chain */
150587a18d3fSMadhavan Venkataraman 	if (ct.ct_idhash == NULL) {
150687a18d3fSMadhavan Venkataraman 		mdb_printf("id hash chain for this xid is empty\n");
150787a18d3fSMadhavan Venkataraman 		return (DCMD_ERR);
150887a18d3fSMadhavan Venkataraman 	}
150987a18d3fSMadhavan Venkataraman 	coptr = (callout_t *)cot_idhash[idhash].ch_head;
151087a18d3fSMadhavan Venkataraman 	if (coptr == NULL) {
151187a18d3fSMadhavan Venkataraman 		mdb_printf("id hash chain for this xid is empty\n");
151287a18d3fSMadhavan Venkataraman 		return (DCMD_ERR);
151387a18d3fSMadhavan Venkataraman 	}
151487a18d3fSMadhavan Venkataraman 
151587a18d3fSMadhavan Venkataraman 	coargs.ndx = tableid;
151687a18d3fSMadhavan Venkataraman 	coargs.bucket = idhash;
151787a18d3fSMadhavan Venkataraman 
151887a18d3fSMadhavan Venkataraman 	/* use the walker, luke */
151987a18d3fSMadhavan Venkataraman 	if (mdb_pwalk("callouts_byid", callouts_cb, &coargs,
152087a18d3fSMadhavan Venkataraman 	    (uintptr_t)coptr) == -1) {
152187a18d3fSMadhavan Venkataraman 		mdb_warn("cannot walk callouts at %p", coptr);
152287a18d3fSMadhavan Venkataraman 		return (WALK_ERR);
152387a18d3fSMadhavan Venkataraman 	}
152487a18d3fSMadhavan Venkataraman 
152587a18d3fSMadhavan Venkataraman 	return (DCMD_OK);
152687a18d3fSMadhavan Venkataraman }
152787a18d3fSMadhavan Venkataraman 
152887a18d3fSMadhavan Venkataraman void
152987a18d3fSMadhavan Venkataraman callout_help(void)
153087a18d3fSMadhavan Venkataraman {
153187a18d3fSMadhavan Venkataraman 	mdb_printf("callout: display callouts.\n"
153287a18d3fSMadhavan Venkataraman 	    "Given a callout table address, display callouts from table.\n"
153387a18d3fSMadhavan Venkataraman 	    "Without an address, display callouts from all tables.\n"
153487a18d3fSMadhavan Venkataraman 	    "options:\n"
153587a18d3fSMadhavan Venkataraman 	    " -r|n : limit display to (r)ealtime or (n)ormal type callouts\n"
153687a18d3fSMadhavan Venkataraman 	    " -s|l : limit display to (s)hort-term ids or (l)ong-term ids\n"
153787a18d3fSMadhavan Venkataraman 	    " -x : limit display to callouts which are executing\n"
153887a18d3fSMadhavan Venkataraman 	    " -h : limit display to callouts based on hrestime\n"
153907247649SMadhavan Venkataraman 	    " -B : limit display to callouts based on absolute time\n"
154087a18d3fSMadhavan Venkataraman 	    " -t|a|b nsec: limit display to callouts that expire a(t) time,"
154187a18d3fSMadhavan Venkataraman 	    " (a)fter time,\n     or (b)efore time. Use -a and -b together "
154287a18d3fSMadhavan Venkataraman 	    " to specify a range.\n     For \"now\", use -d[t|a|b] 0.\n"
154387a18d3fSMadhavan Venkataraman 	    " -d : interpret time option to -t|a|b as delta from current time\n"
154487a18d3fSMadhavan Venkataraman 	    " -k : use ticks instead of nanoseconds as arguments to"
154587a18d3fSMadhavan Venkataraman 	    " -t|a|b. Note that\n     ticks are less accurate and may not"
154687a18d3fSMadhavan Venkataraman 	    " match other tick times (ie: lbolt).\n"
154787a18d3fSMadhavan Venkataraman 	    " -D : display exiration time as delta from current time\n"
154887a18d3fSMadhavan Venkataraman 	    " -S seqid : limit display to callouts for this cpu sequence id\n"
154987a18d3fSMadhavan Venkataraman 	    " -C addr :  limit display to callouts for this cpu pointer\n"
155087a18d3fSMadhavan Venkataraman 	    " -f name|addr : limit display to callouts with this function\n"
155187a18d3fSMadhavan Venkataraman 	    " -p name|addr : limit display to callouts functions with this"
155287a18d3fSMadhavan Venkataraman 	    " parameter\n"
155387a18d3fSMadhavan Venkataraman 	    " -T : display the callout table itself, instead of callouts\n"
155487a18d3fSMadhavan Venkataraman 	    " -L : display callout lists instead of callouts\n"
155587a18d3fSMadhavan Venkataraman 	    " -E : with -T or L, display empty data structures.\n"
155687a18d3fSMadhavan Venkataraman 	    " -i : traverse callouts by id hash instead of list hash\n"
155787a18d3fSMadhavan Venkataraman 	    " -F : walk free callout list (free list with -i) instead\n"
155887a18d3fSMadhavan Venkataraman 	    " -v : display more info for each item\n"
155987a18d3fSMadhavan Venkataraman 	    " -V : show details of each level of info as it is traversed\n"
156087a18d3fSMadhavan Venkataraman 	    " -A : show only addresses. Useful for pipelines.\n");
156187a18d3fSMadhavan Venkataraman }
156287a18d3fSMadhavan Venkataraman 
156387a18d3fSMadhavan Venkataraman void
156487a18d3fSMadhavan Venkataraman calloutid_help(void)
156587a18d3fSMadhavan Venkataraman {
156687a18d3fSMadhavan Venkataraman 	mdb_printf("calloutid: display callout by id.\n"
156787a18d3fSMadhavan Venkataraman 	    "Given an extended callout id, display the callout infomation.\n"
156887a18d3fSMadhavan Venkataraman 	    "options:\n"
156987a18d3fSMadhavan Venkataraman 	    " -d : do not dereference callout, just decode the id.\n"
157087a18d3fSMadhavan Venkataraman 	    " -v : verbose display more info about the callout\n");
157187a18d3fSMadhavan Venkataraman }
157287a18d3fSMadhavan Venkataraman 
15737c478bd9Sstevel@tonic-gate /*ARGSUSED*/
15747c478bd9Sstevel@tonic-gate int
15757c478bd9Sstevel@tonic-gate class(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
15767c478bd9Sstevel@tonic-gate {
15777c478bd9Sstevel@tonic-gate 	long num_classes, i;
15787c478bd9Sstevel@tonic-gate 	sclass_t *class_tbl;
15797c478bd9Sstevel@tonic-gate 	GElf_Sym g_sclass;
15807c478bd9Sstevel@tonic-gate 	char class_name[PC_CLNMSZ];
15817c478bd9Sstevel@tonic-gate 	size_t tbl_size;
15827c478bd9Sstevel@tonic-gate 
15837c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_name("sclass", &g_sclass) == -1) {
15847c478bd9Sstevel@tonic-gate 		mdb_warn("failed to find symbol sclass\n");
15857c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
15867c478bd9Sstevel@tonic-gate 	}
15877c478bd9Sstevel@tonic-gate 
15887c478bd9Sstevel@tonic-gate 	tbl_size = (size_t)g_sclass.st_size;
15897c478bd9Sstevel@tonic-gate 	num_classes = tbl_size / (sizeof (sclass_t));
15907c478bd9Sstevel@tonic-gate 	class_tbl = mdb_alloc(tbl_size, UM_SLEEP | UM_GC);
15917c478bd9Sstevel@tonic-gate 
15927c478bd9Sstevel@tonic-gate 	if (mdb_readsym(class_tbl, tbl_size, "sclass") == -1) {
15937c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read sclass");
15947c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
15957c478bd9Sstevel@tonic-gate 	}
15967c478bd9Sstevel@tonic-gate 
15977c478bd9Sstevel@tonic-gate 	mdb_printf("%<u>%4s %-10s %-24s %-24s%</u>\n", "SLOT", "NAME",
15987c478bd9Sstevel@tonic-gate 	    "INIT FCN", "CLASS FCN");
15997c478bd9Sstevel@tonic-gate 
16007c478bd9Sstevel@tonic-gate 	for (i = 0; i < num_classes; i++) {
16017c478bd9Sstevel@tonic-gate 		if (mdb_vread(class_name, sizeof (class_name),
16027c478bd9Sstevel@tonic-gate 		    (uintptr_t)class_tbl[i].cl_name) == -1)
16037c478bd9Sstevel@tonic-gate 			(void) strcpy(class_name, "???");
16047c478bd9Sstevel@tonic-gate 
16057c478bd9Sstevel@tonic-gate 		mdb_printf("%4ld %-10s %-24a %-24a\n", i, class_name,
16067c478bd9Sstevel@tonic-gate 		    class_tbl[i].cl_init, class_tbl[i].cl_funcs);
16077c478bd9Sstevel@tonic-gate 	}
16087c478bd9Sstevel@tonic-gate 
16097c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
16107c478bd9Sstevel@tonic-gate }
16117c478bd9Sstevel@tonic-gate 
16127c478bd9Sstevel@tonic-gate #define	FSNAMELEN	32	/* Max len of FS name we read from vnodeops */
16137c478bd9Sstevel@tonic-gate 
16147c478bd9Sstevel@tonic-gate int
16157c478bd9Sstevel@tonic-gate vnode2path(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
16167c478bd9Sstevel@tonic-gate {
16177c478bd9Sstevel@tonic-gate 	uintptr_t rootdir;
16187c478bd9Sstevel@tonic-gate 	vnode_t vn;
16197c478bd9Sstevel@tonic-gate 	char buf[MAXPATHLEN];
16207c478bd9Sstevel@tonic-gate 
16217c478bd9Sstevel@tonic-gate 	uint_t opt_F = FALSE;
16227c478bd9Sstevel@tonic-gate 
16237c478bd9Sstevel@tonic-gate 	if (mdb_getopts(argc, argv,
16247c478bd9Sstevel@tonic-gate 	    'F', MDB_OPT_SETBITS, TRUE, &opt_F, NULL) != argc)
16257c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
16267c478bd9Sstevel@tonic-gate 
16277c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC)) {
16287c478bd9Sstevel@tonic-gate 		mdb_warn("expected explicit vnode_t address before ::\n");
16297c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
16307c478bd9Sstevel@tonic-gate 	}
16317c478bd9Sstevel@tonic-gate 
16327c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&rootdir, "rootdir") == -1) {
16337c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read rootdir");
16347c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
16357c478bd9Sstevel@tonic-gate 	}
16367c478bd9Sstevel@tonic-gate 
16377c478bd9Sstevel@tonic-gate 	if (mdb_vnode2path(addr, buf, sizeof (buf)) == -1)
16387c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
16397c478bd9Sstevel@tonic-gate 
16407c478bd9Sstevel@tonic-gate 	if (*buf == '\0') {
16417c478bd9Sstevel@tonic-gate 		mdb_printf("??\n");
16427c478bd9Sstevel@tonic-gate 		return (DCMD_OK);
16437c478bd9Sstevel@tonic-gate 	}
16447c478bd9Sstevel@tonic-gate 
16457c478bd9Sstevel@tonic-gate 	mdb_printf("%s", buf);
16467c478bd9Sstevel@tonic-gate 	if (opt_F && buf[strlen(buf)-1] != '/' &&
16477c478bd9Sstevel@tonic-gate 	    mdb_vread(&vn, sizeof (vn), addr) == sizeof (vn))
16487c478bd9Sstevel@tonic-gate 		mdb_printf("%c", mdb_vtype2chr(vn.v_type, 0));
16497c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
16507c478bd9Sstevel@tonic-gate 
16517c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
16527c478bd9Sstevel@tonic-gate }
16537c478bd9Sstevel@tonic-gate 
16547c478bd9Sstevel@tonic-gate int
16557c478bd9Sstevel@tonic-gate ld_walk_init(mdb_walk_state_t *wsp)
16567c478bd9Sstevel@tonic-gate {
16577c478bd9Sstevel@tonic-gate 	wsp->walk_data = (void *)wsp->walk_addr;
16587c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
16597c478bd9Sstevel@tonic-gate }
16607c478bd9Sstevel@tonic-gate 
16617c478bd9Sstevel@tonic-gate int
16627c478bd9Sstevel@tonic-gate ld_walk_step(mdb_walk_state_t *wsp)
16637c478bd9Sstevel@tonic-gate {
16647c478bd9Sstevel@tonic-gate 	int status;
16657c478bd9Sstevel@tonic-gate 	lock_descriptor_t ld;
16667c478bd9Sstevel@tonic-gate 
16677c478bd9Sstevel@tonic-gate 	if (mdb_vread(&ld, sizeof (lock_descriptor_t), wsp->walk_addr) == -1) {
16687c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't read lock_descriptor_t at %p\n",
16697c478bd9Sstevel@tonic-gate 		    wsp->walk_addr);
16707c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
16717c478bd9Sstevel@tonic-gate 	}
16727c478bd9Sstevel@tonic-gate 
16737c478bd9Sstevel@tonic-gate 	status = wsp->walk_callback(wsp->walk_addr, &ld, wsp->walk_cbdata);
16747c478bd9Sstevel@tonic-gate 	if (status == WALK_ERR)
16757c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
16767c478bd9Sstevel@tonic-gate 
16777c478bd9Sstevel@tonic-gate 	wsp->walk_addr = (uintptr_t)ld.l_next;
16787c478bd9Sstevel@tonic-gate 	if (wsp->walk_addr == (uintptr_t)wsp->walk_data)
16797c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
16807c478bd9Sstevel@tonic-gate 
16817c478bd9Sstevel@tonic-gate 	return (status);
16827c478bd9Sstevel@tonic-gate }
16837c478bd9Sstevel@tonic-gate 
16847c478bd9Sstevel@tonic-gate int
16857c478bd9Sstevel@tonic-gate lg_walk_init(mdb_walk_state_t *wsp)
16867c478bd9Sstevel@tonic-gate {
16877c478bd9Sstevel@tonic-gate 	GElf_Sym sym;
16887c478bd9Sstevel@tonic-gate 
16897c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_name("lock_graph", &sym) == -1) {
16907c478bd9Sstevel@tonic-gate 		mdb_warn("failed to find symbol 'lock_graph'\n");
16917c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
16927c478bd9Sstevel@tonic-gate 	}
16937c478bd9Sstevel@tonic-gate 
16947c478bd9Sstevel@tonic-gate 	wsp->walk_addr = (uintptr_t)sym.st_value;
169589518a1cSdmick 	wsp->walk_data = (void *)(uintptr_t)(sym.st_value + sym.st_size);
16967c478bd9Sstevel@tonic-gate 
16977c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
16987c478bd9Sstevel@tonic-gate }
16997c478bd9Sstevel@tonic-gate 
17007c478bd9Sstevel@tonic-gate typedef struct lg_walk_data {
17017c478bd9Sstevel@tonic-gate 	uintptr_t startaddr;
17027c478bd9Sstevel@tonic-gate 	mdb_walk_cb_t callback;
17037c478bd9Sstevel@tonic-gate 	void *data;
17047c478bd9Sstevel@tonic-gate } lg_walk_data_t;
17057c478bd9Sstevel@tonic-gate 
17067c478bd9Sstevel@tonic-gate /*
17077c478bd9Sstevel@tonic-gate  * We can't use ::walk lock_descriptor directly, because the head of each graph
17087c478bd9Sstevel@tonic-gate  * is really a dummy lock.  Rather than trying to dynamically determine if this
17097c478bd9Sstevel@tonic-gate  * is a dummy node or not, we just filter out the initial element of the
17107c478bd9Sstevel@tonic-gate  * list.
17117c478bd9Sstevel@tonic-gate  */
17127c478bd9Sstevel@tonic-gate static int
17137c478bd9Sstevel@tonic-gate lg_walk_cb(uintptr_t addr, const void *data, void *priv)
17147c478bd9Sstevel@tonic-gate {
17157c478bd9Sstevel@tonic-gate 	lg_walk_data_t *lw = priv;
17167c478bd9Sstevel@tonic-gate 
17177c478bd9Sstevel@tonic-gate 	if (addr != lw->startaddr)
17187c478bd9Sstevel@tonic-gate 		return (lw->callback(addr, data, lw->data));
17197c478bd9Sstevel@tonic-gate 
17207c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
17217c478bd9Sstevel@tonic-gate }
17227c478bd9Sstevel@tonic-gate 
17237c478bd9Sstevel@tonic-gate int
17247c478bd9Sstevel@tonic-gate lg_walk_step(mdb_walk_state_t *wsp)
17257c478bd9Sstevel@tonic-gate {
17267c478bd9Sstevel@tonic-gate 	graph_t *graph;
17277c478bd9Sstevel@tonic-gate 	lg_walk_data_t lw;
17287c478bd9Sstevel@tonic-gate 
17297c478bd9Sstevel@tonic-gate 	if (wsp->walk_addr >= (uintptr_t)wsp->walk_data)
17307c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
17317c478bd9Sstevel@tonic-gate 
17327c478bd9Sstevel@tonic-gate 	if (mdb_vread(&graph, sizeof (graph), wsp->walk_addr) == -1) {
17337c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read graph_t at %p", wsp->walk_addr);
17347c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
17357c478bd9Sstevel@tonic-gate 	}
17367c478bd9Sstevel@tonic-gate 
17377c478bd9Sstevel@tonic-gate 	wsp->walk_addr += sizeof (graph);
17387c478bd9Sstevel@tonic-gate 
17397c478bd9Sstevel@tonic-gate 	if (graph == NULL)
17407c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
17417c478bd9Sstevel@tonic-gate 
17427c478bd9Sstevel@tonic-gate 	lw.callback = wsp->walk_callback;
17437c478bd9Sstevel@tonic-gate 	lw.data = wsp->walk_cbdata;
17447c478bd9Sstevel@tonic-gate 
17457c478bd9Sstevel@tonic-gate 	lw.startaddr = (uintptr_t)&(graph->active_locks);
17467c478bd9Sstevel@tonic-gate 	if (mdb_pwalk("lock_descriptor", lg_walk_cb, &lw, lw.startaddr)) {
17477c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't walk lock_descriptor at %p\n", lw.startaddr);
17487c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
17497c478bd9Sstevel@tonic-gate 	}
17507c478bd9Sstevel@tonic-gate 
17517c478bd9Sstevel@tonic-gate 	lw.startaddr = (uintptr_t)&(graph->sleeping_locks);
17527c478bd9Sstevel@tonic-gate 	if (mdb_pwalk("lock_descriptor", lg_walk_cb, &lw, lw.startaddr)) {
17537c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't walk lock_descriptor at %p\n", lw.startaddr);
17547c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
17557c478bd9Sstevel@tonic-gate 	}
17567c478bd9Sstevel@tonic-gate 
17577c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
17587c478bd9Sstevel@tonic-gate }
17597c478bd9Sstevel@tonic-gate 
17607c478bd9Sstevel@tonic-gate /*
17617c478bd9Sstevel@tonic-gate  * The space available for the path corresponding to the locked vnode depends
17627c478bd9Sstevel@tonic-gate  * on whether we are printing 32- or 64-bit addresses.
17637c478bd9Sstevel@tonic-gate  */
17647c478bd9Sstevel@tonic-gate #ifdef _LP64
17657c478bd9Sstevel@tonic-gate #define	LM_VNPATHLEN	20
17667c478bd9Sstevel@tonic-gate #else
17677c478bd9Sstevel@tonic-gate #define	LM_VNPATHLEN	30
17687c478bd9Sstevel@tonic-gate #endif
17697c478bd9Sstevel@tonic-gate 
17707c478bd9Sstevel@tonic-gate /*ARGSUSED*/
17717c478bd9Sstevel@tonic-gate static int
17727c478bd9Sstevel@tonic-gate lminfo_cb(uintptr_t addr, const void *data, void *priv)
17737c478bd9Sstevel@tonic-gate {
17747c478bd9Sstevel@tonic-gate 	const lock_descriptor_t *ld = data;
17757c478bd9Sstevel@tonic-gate 	char buf[LM_VNPATHLEN];
17767c478bd9Sstevel@tonic-gate 	proc_t p;
17777c478bd9Sstevel@tonic-gate 
17787c478bd9Sstevel@tonic-gate 	mdb_printf("%-?p %2s %04x %6d %-16s %-?p ",
17797c478bd9Sstevel@tonic-gate 	    addr, ld->l_type == F_RDLCK ? "RD" :
17807c478bd9Sstevel@tonic-gate 	    ld->l_type == F_WRLCK ? "WR" : "??",
17817c478bd9Sstevel@tonic-gate 	    ld->l_state, ld->l_flock.l_pid,
17827c478bd9Sstevel@tonic-gate 	    ld->l_flock.l_pid == 0 ? "<kernel>" :
17837c478bd9Sstevel@tonic-gate 	    mdb_pid2proc(ld->l_flock.l_pid, &p) == NULL ?
17847c478bd9Sstevel@tonic-gate 	    "<defunct>" : p.p_user.u_comm,
17857c478bd9Sstevel@tonic-gate 	    ld->l_vnode);
17867c478bd9Sstevel@tonic-gate 
17877c478bd9Sstevel@tonic-gate 	mdb_vnode2path((uintptr_t)ld->l_vnode, buf,
17887c478bd9Sstevel@tonic-gate 	    sizeof (buf));
17897c478bd9Sstevel@tonic-gate 	mdb_printf("%s\n", buf);
17907c478bd9Sstevel@tonic-gate 
17917c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
17927c478bd9Sstevel@tonic-gate }
17937c478bd9Sstevel@tonic-gate 
17947c478bd9Sstevel@tonic-gate /*ARGSUSED*/
17957c478bd9Sstevel@tonic-gate int
17967c478bd9Sstevel@tonic-gate lminfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
17977c478bd9Sstevel@tonic-gate {
17987c478bd9Sstevel@tonic-gate 	if (DCMD_HDRSPEC(flags))
17997c478bd9Sstevel@tonic-gate 		mdb_printf("%<u>%-?s %2s %4s %6s %-16s %-?s %s%</u>\n",
18007c478bd9Sstevel@tonic-gate 		    "ADDR", "TP", "FLAG", "PID", "COMM", "VNODE", "PATH");
18017c478bd9Sstevel@tonic-gate 
18027c478bd9Sstevel@tonic-gate 	return (mdb_pwalk("lock_graph", lminfo_cb, NULL, NULL));
18037c478bd9Sstevel@tonic-gate }
18047c478bd9Sstevel@tonic-gate 
18057c478bd9Sstevel@tonic-gate /*ARGSUSED*/
18067c478bd9Sstevel@tonic-gate int
18077c478bd9Sstevel@tonic-gate seg(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
18087c478bd9Sstevel@tonic-gate {
18097c478bd9Sstevel@tonic-gate 	struct seg s;
18107c478bd9Sstevel@tonic-gate 
18117c478bd9Sstevel@tonic-gate 	if (argc != 0)
18127c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
18137c478bd9Sstevel@tonic-gate 
18147c478bd9Sstevel@tonic-gate 	if ((flags & DCMD_LOOPFIRST) || !(flags & DCMD_LOOP)) {
18157c478bd9Sstevel@tonic-gate 		mdb_printf("%<u>%?s %?s %?s %?s %s%</u>\n",
18167c478bd9Sstevel@tonic-gate 		    "SEG", "BASE", "SIZE", "DATA", "OPS");
18177c478bd9Sstevel@tonic-gate 	}
18187c478bd9Sstevel@tonic-gate 
18197c478bd9Sstevel@tonic-gate 	if (mdb_vread(&s, sizeof (s), addr) == -1) {
18207c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read seg at %p", addr);
18217c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
18227c478bd9Sstevel@tonic-gate 	}
18237c478bd9Sstevel@tonic-gate 
18247c478bd9Sstevel@tonic-gate 	mdb_printf("%?p %?p %?lx %?p %a\n",
18257c478bd9Sstevel@tonic-gate 	    addr, s.s_base, s.s_size, s.s_data, s.s_ops);
18267c478bd9Sstevel@tonic-gate 
18277c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
18287c478bd9Sstevel@tonic-gate }
18297c478bd9Sstevel@tonic-gate 
18307c478bd9Sstevel@tonic-gate /*ARGSUSED*/
18317c478bd9Sstevel@tonic-gate static int
18327c478bd9Sstevel@tonic-gate pmap_walk_anon(uintptr_t addr, const struct anon *anon, int *nres)
18337c478bd9Sstevel@tonic-gate {
18347c478bd9Sstevel@tonic-gate 	uintptr_t pp =
18357c478bd9Sstevel@tonic-gate 	    mdb_vnode2page((uintptr_t)anon->an_vp, (uintptr_t)anon->an_off);
18367c478bd9Sstevel@tonic-gate 
18377c478bd9Sstevel@tonic-gate 	if (pp != NULL)
18387c478bd9Sstevel@tonic-gate 		(*nres)++;
18397c478bd9Sstevel@tonic-gate 
18407c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
18417c478bd9Sstevel@tonic-gate }
18427c478bd9Sstevel@tonic-gate 
18437c478bd9Sstevel@tonic-gate static int
18447c478bd9Sstevel@tonic-gate pmap_walk_seg(uintptr_t addr, const struct seg *seg, uintptr_t segvn)
18457c478bd9Sstevel@tonic-gate {
18467c478bd9Sstevel@tonic-gate 
18477c478bd9Sstevel@tonic-gate 	mdb_printf("%0?p %0?p %7dk", addr, seg->s_base, seg->s_size / 1024);
18487c478bd9Sstevel@tonic-gate 
18497c478bd9Sstevel@tonic-gate 	if (segvn == (uintptr_t)seg->s_ops) {
18507c478bd9Sstevel@tonic-gate 		struct segvn_data svn;
18517c478bd9Sstevel@tonic-gate 		int nres = 0;
18527c478bd9Sstevel@tonic-gate 
18537c478bd9Sstevel@tonic-gate 		(void) mdb_vread(&svn, sizeof (svn), (uintptr_t)seg->s_data);
18547c478bd9Sstevel@tonic-gate 
18557c478bd9Sstevel@tonic-gate 		if (svn.amp == NULL) {
18567c478bd9Sstevel@tonic-gate 			mdb_printf(" %8s", "");
18577c478bd9Sstevel@tonic-gate 			goto drive_on;
18587c478bd9Sstevel@tonic-gate 		}
18597c478bd9Sstevel@tonic-gate 
18607c478bd9Sstevel@tonic-gate 		/*
18617c478bd9Sstevel@tonic-gate 		 * We've got an amp for this segment; walk through
18627c478bd9Sstevel@tonic-gate 		 * the amp, and determine mappings.
18637c478bd9Sstevel@tonic-gate 		 */
18647c478bd9Sstevel@tonic-gate 		if (mdb_pwalk("anon", (mdb_walk_cb_t)pmap_walk_anon,
18657c478bd9Sstevel@tonic-gate 		    &nres, (uintptr_t)svn.amp) == -1)
18667c478bd9Sstevel@tonic-gate 			mdb_warn("failed to walk anon (amp=%p)", svn.amp);
18677c478bd9Sstevel@tonic-gate 
18687c478bd9Sstevel@tonic-gate 		mdb_printf(" %7dk", (nres * PAGESIZE) / 1024);
18697c478bd9Sstevel@tonic-gate drive_on:
18707c478bd9Sstevel@tonic-gate 
18717c478bd9Sstevel@tonic-gate 		if (svn.vp != NULL) {
18727c478bd9Sstevel@tonic-gate 			char buf[29];
18737c478bd9Sstevel@tonic-gate 
18747c478bd9Sstevel@tonic-gate 			mdb_vnode2path((uintptr_t)svn.vp, buf, sizeof (buf));
18757c478bd9Sstevel@tonic-gate 			mdb_printf(" %s", buf);
18767c478bd9Sstevel@tonic-gate 		} else
18777c478bd9Sstevel@tonic-gate 			mdb_printf(" [ anon ]");
18787c478bd9Sstevel@tonic-gate 	}
18797c478bd9Sstevel@tonic-gate 
18807c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
18817c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
18827c478bd9Sstevel@tonic-gate }
18837c478bd9Sstevel@tonic-gate 
18847c478bd9Sstevel@tonic-gate static int
18857c478bd9Sstevel@tonic-gate pmap_walk_seg_quick(uintptr_t addr, const struct seg *seg, uintptr_t segvn)
18867c478bd9Sstevel@tonic-gate {
18877c478bd9Sstevel@tonic-gate 	mdb_printf("%0?p %0?p %7dk", addr, seg->s_base, seg->s_size / 1024);
18887c478bd9Sstevel@tonic-gate 
18897c478bd9Sstevel@tonic-gate 	if (segvn == (uintptr_t)seg->s_ops) {
18907c478bd9Sstevel@tonic-gate 		struct segvn_data svn;
18917c478bd9Sstevel@tonic-gate 
18927c478bd9Sstevel@tonic-gate 		(void) mdb_vread(&svn, sizeof (svn), (uintptr_t)seg->s_data);
18937c478bd9Sstevel@tonic-gate 
18947c478bd9Sstevel@tonic-gate 		if (svn.vp != NULL) {
18957c478bd9Sstevel@tonic-gate 			mdb_printf(" %0?p", svn.vp);
18967c478bd9Sstevel@tonic-gate 		} else {
18977c478bd9Sstevel@tonic-gate 			mdb_printf(" [ anon ]");
18987c478bd9Sstevel@tonic-gate 		}
18997c478bd9Sstevel@tonic-gate 	}
19007c478bd9Sstevel@tonic-gate 
19017c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
19027c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
19037c478bd9Sstevel@tonic-gate }
19047c478bd9Sstevel@tonic-gate 
19057c478bd9Sstevel@tonic-gate /*ARGSUSED*/
19067c478bd9Sstevel@tonic-gate int
19077c478bd9Sstevel@tonic-gate pmap(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
19087c478bd9Sstevel@tonic-gate {
19097c478bd9Sstevel@tonic-gate 	uintptr_t segvn;
19107c478bd9Sstevel@tonic-gate 	proc_t proc;
19117c478bd9Sstevel@tonic-gate 	uint_t quick = FALSE;
19127c478bd9Sstevel@tonic-gate 	mdb_walk_cb_t cb = (mdb_walk_cb_t)pmap_walk_seg;
19137c478bd9Sstevel@tonic-gate 
19147c478bd9Sstevel@tonic-gate 	GElf_Sym sym;
19157c478bd9Sstevel@tonic-gate 
19167c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC))
19177c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
19187c478bd9Sstevel@tonic-gate 
19197c478bd9Sstevel@tonic-gate 	if (mdb_getopts(argc, argv,
19207c478bd9Sstevel@tonic-gate 	    'q', MDB_OPT_SETBITS, TRUE, &quick, NULL) != argc)
19217c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
19227c478bd9Sstevel@tonic-gate 
19237c478bd9Sstevel@tonic-gate 	if (mdb_vread(&proc, sizeof (proc), addr) == -1) {
19247c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read proc at %p", addr);
19257c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
19267c478bd9Sstevel@tonic-gate 	}
19277c478bd9Sstevel@tonic-gate 
19287c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_name("segvn_ops", &sym) == 0)
19297c478bd9Sstevel@tonic-gate 		segvn = (uintptr_t)sym.st_value;
19307c478bd9Sstevel@tonic-gate 	else
19317c478bd9Sstevel@tonic-gate 		segvn = NULL;
19327c478bd9Sstevel@tonic-gate 
19337c478bd9Sstevel@tonic-gate 	mdb_printf("%?s %?s %8s ", "SEG", "BASE", "SIZE");
19347c478bd9Sstevel@tonic-gate 
19357c478bd9Sstevel@tonic-gate 	if (quick) {
19367c478bd9Sstevel@tonic-gate 		mdb_printf("VNODE\n");
19377c478bd9Sstevel@tonic-gate 		cb = (mdb_walk_cb_t)pmap_walk_seg_quick;
19387c478bd9Sstevel@tonic-gate 	} else {
19397c478bd9Sstevel@tonic-gate 		mdb_printf("%8s %s\n", "RES", "PATH");
19407c478bd9Sstevel@tonic-gate 	}
19417c478bd9Sstevel@tonic-gate 
19427c478bd9Sstevel@tonic-gate 	if (mdb_pwalk("seg", cb, (void *)segvn, (uintptr_t)proc.p_as) == -1) {
19437c478bd9Sstevel@tonic-gate 		mdb_warn("failed to walk segments of as %p", proc.p_as);
19447c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
19457c478bd9Sstevel@tonic-gate 	}
19467c478bd9Sstevel@tonic-gate 
19477c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
19487c478bd9Sstevel@tonic-gate }
19497c478bd9Sstevel@tonic-gate 
19507c478bd9Sstevel@tonic-gate typedef struct anon_walk_data {
19517c478bd9Sstevel@tonic-gate 	uintptr_t *aw_levone;
19527c478bd9Sstevel@tonic-gate 	uintptr_t *aw_levtwo;
19537c478bd9Sstevel@tonic-gate 	int aw_nlevone;
19547c478bd9Sstevel@tonic-gate 	int aw_levone_ndx;
19557c478bd9Sstevel@tonic-gate 	int aw_levtwo_ndx;
19567c478bd9Sstevel@tonic-gate 	struct anon_map aw_amp;
19577c478bd9Sstevel@tonic-gate 	struct anon_hdr aw_ahp;
19587c478bd9Sstevel@tonic-gate } anon_walk_data_t;
19597c478bd9Sstevel@tonic-gate 
19607c478bd9Sstevel@tonic-gate int
19617c478bd9Sstevel@tonic-gate anon_walk_init(mdb_walk_state_t *wsp)
19627c478bd9Sstevel@tonic-gate {
19637c478bd9Sstevel@tonic-gate 	anon_walk_data_t *aw;
19647c478bd9Sstevel@tonic-gate 
19657c478bd9Sstevel@tonic-gate 	if (wsp->walk_addr == NULL) {
19667c478bd9Sstevel@tonic-gate 		mdb_warn("anon walk doesn't support global walks\n");
19677c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
19687c478bd9Sstevel@tonic-gate 	}
19697c478bd9Sstevel@tonic-gate 
19707c478bd9Sstevel@tonic-gate 	aw = mdb_alloc(sizeof (anon_walk_data_t), UM_SLEEP);
19717c478bd9Sstevel@tonic-gate 
19727c478bd9Sstevel@tonic-gate 	if (mdb_vread(&aw->aw_amp, sizeof (aw->aw_amp), wsp->walk_addr) == -1) {
19737c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read anon map at %p", wsp->walk_addr);
19747c478bd9Sstevel@tonic-gate 		mdb_free(aw, sizeof (anon_walk_data_t));
19757c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
19767c478bd9Sstevel@tonic-gate 	}
19777c478bd9Sstevel@tonic-gate 
19787c478bd9Sstevel@tonic-gate 	if (mdb_vread(&aw->aw_ahp, sizeof (aw->aw_ahp),
19797c478bd9Sstevel@tonic-gate 	    (uintptr_t)(aw->aw_amp.ahp)) == -1) {
19807c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read anon hdr ptr at %p", aw->aw_amp.ahp);
19817c478bd9Sstevel@tonic-gate 		mdb_free(aw, sizeof (anon_walk_data_t));
19827c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
19837c478bd9Sstevel@tonic-gate 	}
19847c478bd9Sstevel@tonic-gate 
19857c478bd9Sstevel@tonic-gate 	if (aw->aw_ahp.size <= ANON_CHUNK_SIZE ||
19867c478bd9Sstevel@tonic-gate 	    (aw->aw_ahp.flags & ANON_ALLOC_FORCE)) {
19877c478bd9Sstevel@tonic-gate 		aw->aw_nlevone = aw->aw_ahp.size;
19887c478bd9Sstevel@tonic-gate 		aw->aw_levtwo = NULL;
19897c478bd9Sstevel@tonic-gate 	} else {
19907c478bd9Sstevel@tonic-gate 		aw->aw_nlevone =
19917c478bd9Sstevel@tonic-gate 		    (aw->aw_ahp.size + ANON_CHUNK_OFF) >> ANON_CHUNK_SHIFT;
19927c478bd9Sstevel@tonic-gate 		aw->aw_levtwo =
19937c478bd9Sstevel@tonic-gate 		    mdb_zalloc(ANON_CHUNK_SIZE * sizeof (uintptr_t), UM_SLEEP);
19947c478bd9Sstevel@tonic-gate 	}
19957c478bd9Sstevel@tonic-gate 
19967c478bd9Sstevel@tonic-gate 	aw->aw_levone =
19977c478bd9Sstevel@tonic-gate 	    mdb_alloc(aw->aw_nlevone * sizeof (uintptr_t), UM_SLEEP);
19987c478bd9Sstevel@tonic-gate 
19997c478bd9Sstevel@tonic-gate 	aw->aw_levone_ndx = 0;
20007c478bd9Sstevel@tonic-gate 	aw->aw_levtwo_ndx = 0;
20017c478bd9Sstevel@tonic-gate 
20027c478bd9Sstevel@tonic-gate 	mdb_vread(aw->aw_levone, aw->aw_nlevone * sizeof (uintptr_t),
20037c478bd9Sstevel@tonic-gate 	    (uintptr_t)aw->aw_ahp.array_chunk);
20047c478bd9Sstevel@tonic-gate 
20057c478bd9Sstevel@tonic-gate 	if (aw->aw_levtwo != NULL) {
20067c478bd9Sstevel@tonic-gate 		while (aw->aw_levone[aw->aw_levone_ndx] == NULL) {
20077c478bd9Sstevel@tonic-gate 			aw->aw_levone_ndx++;
20087c478bd9Sstevel@tonic-gate 			if (aw->aw_levone_ndx == aw->aw_nlevone) {
20097c478bd9Sstevel@tonic-gate 				mdb_warn("corrupt anon; couldn't"
20107c478bd9Sstevel@tonic-gate 				    "find ptr to lev two map");
20117c478bd9Sstevel@tonic-gate 				goto out;
20127c478bd9Sstevel@tonic-gate 			}
20137c478bd9Sstevel@tonic-gate 		}
20147c478bd9Sstevel@tonic-gate 
20157c478bd9Sstevel@tonic-gate 		mdb_vread(aw->aw_levtwo, ANON_CHUNK_SIZE * sizeof (uintptr_t),
20167c478bd9Sstevel@tonic-gate 		    aw->aw_levone[aw->aw_levone_ndx]);
20177c478bd9Sstevel@tonic-gate 	}
20187c478bd9Sstevel@tonic-gate 
20197c478bd9Sstevel@tonic-gate out:
20207c478bd9Sstevel@tonic-gate 	wsp->walk_data = aw;
20217c478bd9Sstevel@tonic-gate 	return (0);
20227c478bd9Sstevel@tonic-gate }
20237c478bd9Sstevel@tonic-gate 
20247c478bd9Sstevel@tonic-gate int
20257c478bd9Sstevel@tonic-gate anon_walk_step(mdb_walk_state_t *wsp)
20267c478bd9Sstevel@tonic-gate {
20277c478bd9Sstevel@tonic-gate 	int status;
20287c478bd9Sstevel@tonic-gate 	anon_walk_data_t *aw = (anon_walk_data_t *)wsp->walk_data;
20297c478bd9Sstevel@tonic-gate 	struct anon anon;
20307c478bd9Sstevel@tonic-gate 	uintptr_t anonptr;
20317c478bd9Sstevel@tonic-gate 
20327c478bd9Sstevel@tonic-gate again:
20337c478bd9Sstevel@tonic-gate 	/*
20347c478bd9Sstevel@tonic-gate 	 * Once we've walked through level one, we're done.
20357c478bd9Sstevel@tonic-gate 	 */
20367c478bd9Sstevel@tonic-gate 	if (aw->aw_levone_ndx == aw->aw_nlevone)
20377c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
20387c478bd9Sstevel@tonic-gate 
20397c478bd9Sstevel@tonic-gate 	if (aw->aw_levtwo == NULL) {
20407c478bd9Sstevel@tonic-gate 		anonptr = aw->aw_levone[aw->aw_levone_ndx];
20417c478bd9Sstevel@tonic-gate 		aw->aw_levone_ndx++;
20427c478bd9Sstevel@tonic-gate 	} else {
20437c478bd9Sstevel@tonic-gate 		anonptr = aw->aw_levtwo[aw->aw_levtwo_ndx];
20447c478bd9Sstevel@tonic-gate 		aw->aw_levtwo_ndx++;
20457c478bd9Sstevel@tonic-gate 
20467c478bd9Sstevel@tonic-gate 		if (aw->aw_levtwo_ndx == ANON_CHUNK_SIZE) {
20477c478bd9Sstevel@tonic-gate 			aw->aw_levtwo_ndx = 0;
20487c478bd9Sstevel@tonic-gate 
20497c478bd9Sstevel@tonic-gate 			do {
20507c478bd9Sstevel@tonic-gate 				aw->aw_levone_ndx++;
20517c478bd9Sstevel@tonic-gate 
20527c478bd9Sstevel@tonic-gate 				if (aw->aw_levone_ndx == aw->aw_nlevone)
20537c478bd9Sstevel@tonic-gate 					return (WALK_DONE);
20547c478bd9Sstevel@tonic-gate 			} while (aw->aw_levone[aw->aw_levone_ndx] == NULL);
20557c478bd9Sstevel@tonic-gate 
20567c478bd9Sstevel@tonic-gate 			mdb_vread(aw->aw_levtwo, ANON_CHUNK_SIZE *
20577c478bd9Sstevel@tonic-gate 			    sizeof (uintptr_t),
20587c478bd9Sstevel@tonic-gate 			    aw->aw_levone[aw->aw_levone_ndx]);
20597c478bd9Sstevel@tonic-gate 		}
20607c478bd9Sstevel@tonic-gate 	}
20617c478bd9Sstevel@tonic-gate 
20627c478bd9Sstevel@tonic-gate 	if (anonptr != NULL) {
20637c478bd9Sstevel@tonic-gate 		mdb_vread(&anon, sizeof (anon), anonptr);
20647c478bd9Sstevel@tonic-gate 		status = wsp->walk_callback(anonptr, &anon, wsp->walk_cbdata);
20657c478bd9Sstevel@tonic-gate 	} else
20667c478bd9Sstevel@tonic-gate 		goto again;
20677c478bd9Sstevel@tonic-gate 
20687c478bd9Sstevel@tonic-gate 	return (status);
20697c478bd9Sstevel@tonic-gate }
20707c478bd9Sstevel@tonic-gate 
20717c478bd9Sstevel@tonic-gate void
20727c478bd9Sstevel@tonic-gate anon_walk_fini(mdb_walk_state_t *wsp)
20737c478bd9Sstevel@tonic-gate {
20747c478bd9Sstevel@tonic-gate 	anon_walk_data_t *aw = (anon_walk_data_t *)wsp->walk_data;
20757c478bd9Sstevel@tonic-gate 
20767c478bd9Sstevel@tonic-gate 	if (aw->aw_levtwo != NULL)
20777c478bd9Sstevel@tonic-gate 		mdb_free(aw->aw_levtwo, ANON_CHUNK_SIZE * sizeof (uintptr_t));
20787c478bd9Sstevel@tonic-gate 
20797c478bd9Sstevel@tonic-gate 	mdb_free(aw->aw_levone, aw->aw_nlevone * sizeof (uintptr_t));
20807c478bd9Sstevel@tonic-gate 	mdb_free(aw, sizeof (anon_walk_data_t));
20817c478bd9Sstevel@tonic-gate }
20827c478bd9Sstevel@tonic-gate 
20837c478bd9Sstevel@tonic-gate /*ARGSUSED*/
20847c478bd9Sstevel@tonic-gate int
20857c478bd9Sstevel@tonic-gate whereopen_fwalk(uintptr_t addr, struct file *f, uintptr_t *target)
20867c478bd9Sstevel@tonic-gate {
20877c478bd9Sstevel@tonic-gate 	if ((uintptr_t)f->f_vnode == *target) {
20887c478bd9Sstevel@tonic-gate 		mdb_printf("file %p\n", addr);
20897c478bd9Sstevel@tonic-gate 		*target = NULL;
20907c478bd9Sstevel@tonic-gate 	}
20917c478bd9Sstevel@tonic-gate 
20927c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
20937c478bd9Sstevel@tonic-gate }
20947c478bd9Sstevel@tonic-gate 
20957c478bd9Sstevel@tonic-gate /*ARGSUSED*/
20967c478bd9Sstevel@tonic-gate int
20977c478bd9Sstevel@tonic-gate whereopen_pwalk(uintptr_t addr, void *ignored, uintptr_t *target)
20987c478bd9Sstevel@tonic-gate {
20997c478bd9Sstevel@tonic-gate 	uintptr_t t = *target;
21007c478bd9Sstevel@tonic-gate 
21017c478bd9Sstevel@tonic-gate 	if (mdb_pwalk("file", (mdb_walk_cb_t)whereopen_fwalk, &t, addr) == -1) {
21027c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't file walk proc %p", addr);
21037c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
21047c478bd9Sstevel@tonic-gate 	}
21057c478bd9Sstevel@tonic-gate 
21067c478bd9Sstevel@tonic-gate 	if (t == NULL)
21077c478bd9Sstevel@tonic-gate 		mdb_printf("%p\n", addr);
21087c478bd9Sstevel@tonic-gate 
21097c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
21107c478bd9Sstevel@tonic-gate }
21117c478bd9Sstevel@tonic-gate 
21127c478bd9Sstevel@tonic-gate /*ARGSUSED*/
21137c478bd9Sstevel@tonic-gate int
21147c478bd9Sstevel@tonic-gate whereopen(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
21157c478bd9Sstevel@tonic-gate {
21167c478bd9Sstevel@tonic-gate 	uintptr_t target = addr;
21177c478bd9Sstevel@tonic-gate 
21187c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC) || addr == NULL)
21197c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
21207c478bd9Sstevel@tonic-gate 
21217c478bd9Sstevel@tonic-gate 	if (mdb_walk("proc", (mdb_walk_cb_t)whereopen_pwalk, &target) == -1) {
21227c478bd9Sstevel@tonic-gate 		mdb_warn("can't proc walk");
21237c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
21247c478bd9Sstevel@tonic-gate 	}
21257c478bd9Sstevel@tonic-gate 
21267c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
21277c478bd9Sstevel@tonic-gate }
21287c478bd9Sstevel@tonic-gate 
21297c478bd9Sstevel@tonic-gate typedef struct datafmt {
21307c478bd9Sstevel@tonic-gate 	char	*hdr1;
21317c478bd9Sstevel@tonic-gate 	char	*hdr2;
21327c478bd9Sstevel@tonic-gate 	char	*dashes;
21337c478bd9Sstevel@tonic-gate 	char	*fmt;
21347c478bd9Sstevel@tonic-gate } datafmt_t;
21357c478bd9Sstevel@tonic-gate 
21367c478bd9Sstevel@tonic-gate static datafmt_t kmemfmt[] = {
21377c478bd9Sstevel@tonic-gate 	{ "cache                    ", "name                     ",
21387c478bd9Sstevel@tonic-gate 	"-------------------------", "%-25s "				},
21397c478bd9Sstevel@tonic-gate 	{ "   buf",	"  size",	"------",	"%6u "		},
21407c478bd9Sstevel@tonic-gate 	{ "   buf",	"in use",	"------",	"%6u "		},
21417c478bd9Sstevel@tonic-gate 	{ "   buf",	" total",	"------",	"%6u "		},
2142bb8b5132Sek 	{ "   memory",	"   in use",	"----------",	"%9u%c "	},
21437c478bd9Sstevel@tonic-gate 	{ "    alloc",	"  succeed",	"---------",	"%9u "		},
21447c478bd9Sstevel@tonic-gate 	{ "alloc",	" fail",	"-----",	"%5u "		},
21457c478bd9Sstevel@tonic-gate 	{ NULL,		NULL,		NULL,		NULL		}
21467c478bd9Sstevel@tonic-gate };
21477c478bd9Sstevel@tonic-gate 
21487c478bd9Sstevel@tonic-gate static datafmt_t vmemfmt[] = {
21497c478bd9Sstevel@tonic-gate 	{ "vmem                     ", "name                     ",
21507c478bd9Sstevel@tonic-gate 	"-------------------------", "%-*s "				},
2151bb8b5132Sek 	{ "   memory",	"   in use",	"----------",	"%9llu%c "	},
2152bb8b5132Sek 	{ "    memory",	"     total",	"-----------",	"%10llu%c "	},
2153bb8b5132Sek 	{ "   memory",	"   import",	"----------",	"%9llu%c "	},
21547c478bd9Sstevel@tonic-gate 	{ "    alloc",	"  succeed",	"---------",	"%9llu "	},
21557c478bd9Sstevel@tonic-gate 	{ "alloc",	" fail",	"-----",	"%5llu "	},
21567c478bd9Sstevel@tonic-gate 	{ NULL,		NULL,		NULL,		NULL		}
21577c478bd9Sstevel@tonic-gate };
21587c478bd9Sstevel@tonic-gate 
21597c478bd9Sstevel@tonic-gate /*ARGSUSED*/
21607c478bd9Sstevel@tonic-gate static int
21617c478bd9Sstevel@tonic-gate kmastat_cpu_avail(uintptr_t addr, const kmem_cpu_cache_t *ccp, int *avail)
21627c478bd9Sstevel@tonic-gate {
21637c478bd9Sstevel@tonic-gate 	if (ccp->cc_rounds > 0)
21647c478bd9Sstevel@tonic-gate 		*avail += ccp->cc_rounds;
21657c478bd9Sstevel@tonic-gate 	if (ccp->cc_prounds > 0)
21667c478bd9Sstevel@tonic-gate 		*avail += ccp->cc_prounds;
21677c478bd9Sstevel@tonic-gate 
21687c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
21697c478bd9Sstevel@tonic-gate }
21707c478bd9Sstevel@tonic-gate 
21717c478bd9Sstevel@tonic-gate /*ARGSUSED*/
21727c478bd9Sstevel@tonic-gate static int
21737c478bd9Sstevel@tonic-gate kmastat_cpu_alloc(uintptr_t addr, const kmem_cpu_cache_t *ccp, int *alloc)
21747c478bd9Sstevel@tonic-gate {
21757c478bd9Sstevel@tonic-gate 	*alloc += ccp->cc_alloc;
21767c478bd9Sstevel@tonic-gate 
21777c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
21787c478bd9Sstevel@tonic-gate }
21797c478bd9Sstevel@tonic-gate 
21807c478bd9Sstevel@tonic-gate /*ARGSUSED*/
21817c478bd9Sstevel@tonic-gate static int
21827c478bd9Sstevel@tonic-gate kmastat_slab_avail(uintptr_t addr, const kmem_slab_t *sp, int *avail)
21837c478bd9Sstevel@tonic-gate {
21847c478bd9Sstevel@tonic-gate 	*avail += sp->slab_chunks - sp->slab_refcnt;
21857c478bd9Sstevel@tonic-gate 
21867c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
21877c478bd9Sstevel@tonic-gate }
21887c478bd9Sstevel@tonic-gate 
21897c478bd9Sstevel@tonic-gate typedef struct kmastat_vmem {
21907c478bd9Sstevel@tonic-gate 	uintptr_t kv_addr;
21917c478bd9Sstevel@tonic-gate 	struct kmastat_vmem *kv_next;
21927c478bd9Sstevel@tonic-gate 	int kv_meminuse;
21937c478bd9Sstevel@tonic-gate 	int kv_alloc;
21947c478bd9Sstevel@tonic-gate 	int kv_fail;
21957c478bd9Sstevel@tonic-gate } kmastat_vmem_t;
21967c478bd9Sstevel@tonic-gate 
2197c92ff650Sek typedef struct kmastat_args {
2198c92ff650Sek 	kmastat_vmem_t **ka_kvpp;
2199c92ff650Sek 	uint_t ka_shift;
2200c92ff650Sek } kmastat_args_t;
2201c92ff650Sek 
22027c478bd9Sstevel@tonic-gate static int
2203c92ff650Sek kmastat_cache(uintptr_t addr, const kmem_cache_t *cp, kmastat_args_t *kap)
22047c478bd9Sstevel@tonic-gate {
2205c92ff650Sek 	kmastat_vmem_t **kvp = kap->ka_kvpp;
22067c478bd9Sstevel@tonic-gate 	kmastat_vmem_t *kv;
22077c478bd9Sstevel@tonic-gate 	datafmt_t *dfp = kmemfmt;
22087c478bd9Sstevel@tonic-gate 	int magsize;
22097c478bd9Sstevel@tonic-gate 
22107c478bd9Sstevel@tonic-gate 	int avail, alloc, total;
22117c478bd9Sstevel@tonic-gate 	size_t meminuse = (cp->cache_slab_create - cp->cache_slab_destroy) *
22127c478bd9Sstevel@tonic-gate 	    cp->cache_slabsize;
22137c478bd9Sstevel@tonic-gate 
22147c478bd9Sstevel@tonic-gate 	mdb_walk_cb_t cpu_avail = (mdb_walk_cb_t)kmastat_cpu_avail;
22157c478bd9Sstevel@tonic-gate 	mdb_walk_cb_t cpu_alloc = (mdb_walk_cb_t)kmastat_cpu_alloc;
22167c478bd9Sstevel@tonic-gate 	mdb_walk_cb_t slab_avail = (mdb_walk_cb_t)kmastat_slab_avail;
22177c478bd9Sstevel@tonic-gate 
22187c478bd9Sstevel@tonic-gate 	magsize = kmem_get_magsize(cp);
22197c478bd9Sstevel@tonic-gate 
22207c478bd9Sstevel@tonic-gate 	alloc = cp->cache_slab_alloc + cp->cache_full.ml_alloc;
22217c478bd9Sstevel@tonic-gate 	avail = cp->cache_full.ml_total * magsize;
22227c478bd9Sstevel@tonic-gate 	total = cp->cache_buftotal;
22237c478bd9Sstevel@tonic-gate 
22247c478bd9Sstevel@tonic-gate 	(void) mdb_pwalk("kmem_cpu_cache", cpu_alloc, &alloc, addr);
22257c478bd9Sstevel@tonic-gate 	(void) mdb_pwalk("kmem_cpu_cache", cpu_avail, &avail, addr);
22267c478bd9Sstevel@tonic-gate 	(void) mdb_pwalk("kmem_slab_partial", slab_avail, &avail, addr);
22277c478bd9Sstevel@tonic-gate 
22287c478bd9Sstevel@tonic-gate 	for (kv = *kvp; kv != NULL; kv = kv->kv_next) {
22297c478bd9Sstevel@tonic-gate 		if (kv->kv_addr == (uintptr_t)cp->cache_arena)
22307c478bd9Sstevel@tonic-gate 			goto out;
22317c478bd9Sstevel@tonic-gate 	}
22327c478bd9Sstevel@tonic-gate 
22337c478bd9Sstevel@tonic-gate 	kv = mdb_zalloc(sizeof (kmastat_vmem_t), UM_SLEEP | UM_GC);
22347c478bd9Sstevel@tonic-gate 	kv->kv_next = *kvp;
22357c478bd9Sstevel@tonic-gate 	kv->kv_addr = (uintptr_t)cp->cache_arena;
22367c478bd9Sstevel@tonic-gate 	*kvp = kv;
22377c478bd9Sstevel@tonic-gate out:
22387c478bd9Sstevel@tonic-gate 	kv->kv_meminuse += meminuse;
22397c478bd9Sstevel@tonic-gate 	kv->kv_alloc += alloc;
22407c478bd9Sstevel@tonic-gate 	kv->kv_fail += cp->cache_alloc_fail;
22417c478bd9Sstevel@tonic-gate 
22427c478bd9Sstevel@tonic-gate 	mdb_printf((dfp++)->fmt, cp->cache_name);
22437c478bd9Sstevel@tonic-gate 	mdb_printf((dfp++)->fmt, cp->cache_bufsize);
22447c478bd9Sstevel@tonic-gate 	mdb_printf((dfp++)->fmt, total - avail);
22457c478bd9Sstevel@tonic-gate 	mdb_printf((dfp++)->fmt, total);
2246bb8b5132Sek 	mdb_printf((dfp++)->fmt, meminuse >> kap->ka_shift,
2247bb8b5132Sek 	    kap->ka_shift == GIGS ? 'G' : kap->ka_shift == MEGS ? 'M' :
2248bb8b5132Sek 	    kap->ka_shift == KILOS ? 'K' : 'B');
22497c478bd9Sstevel@tonic-gate 	mdb_printf((dfp++)->fmt, alloc);
22507c478bd9Sstevel@tonic-gate 	mdb_printf((dfp++)->fmt, cp->cache_alloc_fail);
22517c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
22527c478bd9Sstevel@tonic-gate 
22537c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
22547c478bd9Sstevel@tonic-gate }
22557c478bd9Sstevel@tonic-gate 
22567c478bd9Sstevel@tonic-gate static int
2257c92ff650Sek kmastat_vmem_totals(uintptr_t addr, const vmem_t *v, kmastat_args_t *kap)
22587c478bd9Sstevel@tonic-gate {
2259c92ff650Sek 	kmastat_vmem_t *kv = *kap->ka_kvpp;
22607c478bd9Sstevel@tonic-gate 	size_t len;
22617c478bd9Sstevel@tonic-gate 
22627c478bd9Sstevel@tonic-gate 	while (kv != NULL && kv->kv_addr != addr)
22637c478bd9Sstevel@tonic-gate 		kv = kv->kv_next;
22647c478bd9Sstevel@tonic-gate 
22657c478bd9Sstevel@tonic-gate 	if (kv == NULL || kv->kv_alloc == 0)
22667c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
22677c478bd9Sstevel@tonic-gate 
22687c478bd9Sstevel@tonic-gate 	len = MIN(17, strlen(v->vm_name));
22697c478bd9Sstevel@tonic-gate 
2270bb8b5132Sek 	mdb_printf("Total [%s]%*s %6s %6s %6s %9u%c %9u %5u\n", v->vm_name,
22717c478bd9Sstevel@tonic-gate 	    17 - len, "", "", "", "",
2272bb8b5132Sek 	    kv->kv_meminuse >> kap->ka_shift,
2273bb8b5132Sek 	    kap->ka_shift == GIGS ? 'G' : kap->ka_shift == MEGS ? 'M' :
2274bb8b5132Sek 	    kap->ka_shift == KILOS ? 'K' : 'B', kv->kv_alloc, kv->kv_fail);
22757c478bd9Sstevel@tonic-gate 
22767c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
22777c478bd9Sstevel@tonic-gate }
22787c478bd9Sstevel@tonic-gate 
22797c478bd9Sstevel@tonic-gate /*ARGSUSED*/
22807c478bd9Sstevel@tonic-gate static int
2281c92ff650Sek kmastat_vmem(uintptr_t addr, const vmem_t *v, const uint_t *shiftp)
22827c478bd9Sstevel@tonic-gate {
22837c478bd9Sstevel@tonic-gate 	datafmt_t *dfp = vmemfmt;
22847c478bd9Sstevel@tonic-gate 	const vmem_kstat_t *vkp = &v->vm_kstat;
22857c478bd9Sstevel@tonic-gate 	uintptr_t paddr;
22867c478bd9Sstevel@tonic-gate 	vmem_t parent;
22877c478bd9Sstevel@tonic-gate 	int ident = 0;
22887c478bd9Sstevel@tonic-gate 
22897c478bd9Sstevel@tonic-gate 	for (paddr = (uintptr_t)v->vm_source; paddr != NULL; ident += 4) {
22907c478bd9Sstevel@tonic-gate 		if (mdb_vread(&parent, sizeof (parent), paddr) == -1) {
22917c478bd9Sstevel@tonic-gate 			mdb_warn("couldn't trace %p's ancestry", addr);
22927c478bd9Sstevel@tonic-gate 			ident = 0;
22937c478bd9Sstevel@tonic-gate 			break;
22947c478bd9Sstevel@tonic-gate 		}
22957c478bd9Sstevel@tonic-gate 		paddr = (uintptr_t)parent.vm_source;
22967c478bd9Sstevel@tonic-gate 	}
22977c478bd9Sstevel@tonic-gate 
22987c478bd9Sstevel@tonic-gate 	mdb_printf("%*s", ident, "");
22997c478bd9Sstevel@tonic-gate 	mdb_printf((dfp++)->fmt, 25 - ident, v->vm_name);
2300bb8b5132Sek 	mdb_printf((dfp++)->fmt, vkp->vk_mem_inuse.value.ui64 >> *shiftp,
2301bb8b5132Sek 	    *shiftp == GIGS ? 'G' : *shiftp == MEGS ? 'M' :
2302bb8b5132Sek 	    *shiftp == KILOS ? 'K' : 'B');
2303bb8b5132Sek 	mdb_printf((dfp++)->fmt, vkp->vk_mem_total.value.ui64 >> *shiftp,
2304bb8b5132Sek 	    *shiftp == GIGS ? 'G' : *shiftp == MEGS ? 'M' :
2305bb8b5132Sek 	    *shiftp == KILOS ? 'K' : 'B');
2306bb8b5132Sek 	mdb_printf((dfp++)->fmt, vkp->vk_mem_import.value.ui64 >> *shiftp,
2307bb8b5132Sek 	    *shiftp == GIGS ? 'G' : *shiftp == MEGS ? 'M' :
2308bb8b5132Sek 	    *shiftp == KILOS ? 'K' : 'B');
23097c478bd9Sstevel@tonic-gate 	mdb_printf((dfp++)->fmt, vkp->vk_alloc.value.ui64);
23107c478bd9Sstevel@tonic-gate 	mdb_printf((dfp++)->fmt, vkp->vk_fail.value.ui64);
23117c478bd9Sstevel@tonic-gate 
23127c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
23137c478bd9Sstevel@tonic-gate 
23147c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
23157c478bd9Sstevel@tonic-gate }
23167c478bd9Sstevel@tonic-gate 
23177c478bd9Sstevel@tonic-gate /*ARGSUSED*/
23187c478bd9Sstevel@tonic-gate int
23197c478bd9Sstevel@tonic-gate kmastat(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
23207c478bd9Sstevel@tonic-gate {
23217c478bd9Sstevel@tonic-gate 	kmastat_vmem_t *kv = NULL;
23227c478bd9Sstevel@tonic-gate 	datafmt_t *dfp;
2323c92ff650Sek 	kmastat_args_t ka;
23247c478bd9Sstevel@tonic-gate 
2325c92ff650Sek 	ka.ka_shift = 0;
2326c92ff650Sek 	if (mdb_getopts(argc, argv,
2327bb8b5132Sek 	    'k', MDB_OPT_SETBITS, KILOS, &ka.ka_shift,
2328bb8b5132Sek 	    'm', MDB_OPT_SETBITS, MEGS, &ka.ka_shift,
2329bb8b5132Sek 	    'g', MDB_OPT_SETBITS, GIGS, &ka.ka_shift, NULL) != argc)
23307c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
23317c478bd9Sstevel@tonic-gate 
23327c478bd9Sstevel@tonic-gate 	for (dfp = kmemfmt; dfp->hdr1 != NULL; dfp++)
23337c478bd9Sstevel@tonic-gate 		mdb_printf("%s ", dfp->hdr1);
23347c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
23357c478bd9Sstevel@tonic-gate 
23367c478bd9Sstevel@tonic-gate 	for (dfp = kmemfmt; dfp->hdr1 != NULL; dfp++)
23377c478bd9Sstevel@tonic-gate 		mdb_printf("%s ", dfp->hdr2);
23387c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
23397c478bd9Sstevel@tonic-gate 
23407c478bd9Sstevel@tonic-gate 	for (dfp = kmemfmt; dfp->hdr1 != NULL; dfp++)
23417c478bd9Sstevel@tonic-gate 		mdb_printf("%s ", dfp->dashes);
23427c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
23437c478bd9Sstevel@tonic-gate 
2344c92ff650Sek 	ka.ka_kvpp = &kv;
2345c92ff650Sek 	if (mdb_walk("kmem_cache", (mdb_walk_cb_t)kmastat_cache, &ka) == -1) {
23467c478bd9Sstevel@tonic-gate 		mdb_warn("can't walk 'kmem_cache'");
23477c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
23487c478bd9Sstevel@tonic-gate 	}
23497c478bd9Sstevel@tonic-gate 
23507c478bd9Sstevel@tonic-gate 	for (dfp = kmemfmt; dfp->hdr1 != NULL; dfp++)
23517c478bd9Sstevel@tonic-gate 		mdb_printf("%s ", dfp->dashes);
23527c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
23537c478bd9Sstevel@tonic-gate 
2354c92ff650Sek 	if (mdb_walk("vmem", (mdb_walk_cb_t)kmastat_vmem_totals, &ka) == -1) {
23557c478bd9Sstevel@tonic-gate 		mdb_warn("can't walk 'vmem'");
23567c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
23577c478bd9Sstevel@tonic-gate 	}
23587c478bd9Sstevel@tonic-gate 
23597c478bd9Sstevel@tonic-gate 	for (dfp = kmemfmt; dfp->hdr1 != NULL; dfp++)
23607c478bd9Sstevel@tonic-gate 		mdb_printf("%s ", dfp->dashes);
23617c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
23627c478bd9Sstevel@tonic-gate 
23637c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
23647c478bd9Sstevel@tonic-gate 
23657c478bd9Sstevel@tonic-gate 	for (dfp = vmemfmt; dfp->hdr1 != NULL; dfp++)
23667c478bd9Sstevel@tonic-gate 		mdb_printf("%s ", dfp->hdr1);
23677c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
23687c478bd9Sstevel@tonic-gate 
23697c478bd9Sstevel@tonic-gate 	for (dfp = vmemfmt; dfp->hdr1 != NULL; dfp++)
23707c478bd9Sstevel@tonic-gate 		mdb_printf("%s ", dfp->hdr2);
23717c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
23727c478bd9Sstevel@tonic-gate 
23737c478bd9Sstevel@tonic-gate 	for (dfp = vmemfmt; dfp->hdr1 != NULL; dfp++)
23747c478bd9Sstevel@tonic-gate 		mdb_printf("%s ", dfp->dashes);
23757c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
23767c478bd9Sstevel@tonic-gate 
2377c92ff650Sek 	if (mdb_walk("vmem", (mdb_walk_cb_t)kmastat_vmem, &ka.ka_shift) == -1) {
23787c478bd9Sstevel@tonic-gate 		mdb_warn("can't walk 'vmem'");
23797c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
23807c478bd9Sstevel@tonic-gate 	}
23817c478bd9Sstevel@tonic-gate 
23827c478bd9Sstevel@tonic-gate 	for (dfp = vmemfmt; dfp->hdr1 != NULL; dfp++)
23837c478bd9Sstevel@tonic-gate 		mdb_printf("%s ", dfp->dashes);
23847c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
23857c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
23867c478bd9Sstevel@tonic-gate }
23877c478bd9Sstevel@tonic-gate 
23887c478bd9Sstevel@tonic-gate /*
23897c478bd9Sstevel@tonic-gate  * Our ::kgrep callback scans the entire kernel VA space (kas).  kas is made
23907c478bd9Sstevel@tonic-gate  * up of a set of 'struct seg's.  We could just scan each seg en masse, but
23917c478bd9Sstevel@tonic-gate  * unfortunately, a few of the segs are both large and sparse, so we could
23927c478bd9Sstevel@tonic-gate  * spend quite a bit of time scanning VAs which have no backing pages.
23937c478bd9Sstevel@tonic-gate  *
23947c478bd9Sstevel@tonic-gate  * So for the few very sparse segs, we skip the segment itself, and scan
23957c478bd9Sstevel@tonic-gate  * the allocated vmem_segs in the vmem arena which manages that part of kas.
23967c478bd9Sstevel@tonic-gate  * Currently, we do this for:
23977c478bd9Sstevel@tonic-gate  *
23987c478bd9Sstevel@tonic-gate  *	SEG		VMEM ARENA
23997c478bd9Sstevel@tonic-gate  *	kvseg		heap_arena
24007c478bd9Sstevel@tonic-gate  *	kvseg32		heap32_arena
24017c478bd9Sstevel@tonic-gate  *	kvseg_core	heap_core_arena
24027c478bd9Sstevel@tonic-gate  *
24037c478bd9Sstevel@tonic-gate  * In addition, we skip the segkpm segment in its entirety, since it is very
24047c478bd9Sstevel@tonic-gate  * sparse, and contains no new kernel data.
24057c478bd9Sstevel@tonic-gate  */
24067c478bd9Sstevel@tonic-gate typedef struct kgrep_walk_data {
24077c478bd9Sstevel@tonic-gate 	kgrep_cb_func *kg_cb;
24087c478bd9Sstevel@tonic-gate 	void *kg_cbdata;
24097c478bd9Sstevel@tonic-gate 	uintptr_t kg_kvseg;
24107c478bd9Sstevel@tonic-gate 	uintptr_t kg_kvseg32;
24117c478bd9Sstevel@tonic-gate 	uintptr_t kg_kvseg_core;
24127c478bd9Sstevel@tonic-gate 	uintptr_t kg_segkpm;
24137bc98a2eSeg 	uintptr_t kg_heap_lp_base;
24147bc98a2eSeg 	uintptr_t kg_heap_lp_end;
24157c478bd9Sstevel@tonic-gate } kgrep_walk_data_t;
24167c478bd9Sstevel@tonic-gate 
24177c478bd9Sstevel@tonic-gate static int
24187c478bd9Sstevel@tonic-gate kgrep_walk_seg(uintptr_t addr, const struct seg *seg, kgrep_walk_data_t *kg)
24197c478bd9Sstevel@tonic-gate {
24207c478bd9Sstevel@tonic-gate 	uintptr_t base = (uintptr_t)seg->s_base;
24217c478bd9Sstevel@tonic-gate 
24227c478bd9Sstevel@tonic-gate 	if (addr == kg->kg_kvseg || addr == kg->kg_kvseg32 ||
24237c478bd9Sstevel@tonic-gate 	    addr == kg->kg_kvseg_core)
24247c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
24257c478bd9Sstevel@tonic-gate 
24267c478bd9Sstevel@tonic-gate 	if ((uintptr_t)seg->s_ops == kg->kg_segkpm)
24277c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
24287c478bd9Sstevel@tonic-gate 
24297c478bd9Sstevel@tonic-gate 	return (kg->kg_cb(base, base + seg->s_size, kg->kg_cbdata));
24307c478bd9Sstevel@tonic-gate }
24317c478bd9Sstevel@tonic-gate 
24327c478bd9Sstevel@tonic-gate /*ARGSUSED*/
24337c478bd9Sstevel@tonic-gate static int
24347c478bd9Sstevel@tonic-gate kgrep_walk_vseg(uintptr_t addr, const vmem_seg_t *seg, kgrep_walk_data_t *kg)
24357bc98a2eSeg {
24367bc98a2eSeg 	/*
24377bc98a2eSeg 	 * skip large page heap address range - it is scanned by walking
24387bc98a2eSeg 	 * allocated vmem_segs in the heap_lp_arena
24397bc98a2eSeg 	 */
24407bc98a2eSeg 	if (seg->vs_start == kg->kg_heap_lp_base &&
24417bc98a2eSeg 	    seg->vs_end == kg->kg_heap_lp_end)
24427bc98a2eSeg 		return (WALK_NEXT);
24437bc98a2eSeg 
24447bc98a2eSeg 	return (kg->kg_cb(seg->vs_start, seg->vs_end, kg->kg_cbdata));
24457bc98a2eSeg }
24467bc98a2eSeg 
24477bc98a2eSeg /*ARGSUSED*/
24487bc98a2eSeg static int
24497bc98a2eSeg kgrep_xwalk_vseg(uintptr_t addr, const vmem_seg_t *seg, kgrep_walk_data_t *kg)
24507c478bd9Sstevel@tonic-gate {
24517c478bd9Sstevel@tonic-gate 	return (kg->kg_cb(seg->vs_start, seg->vs_end, kg->kg_cbdata));
24527c478bd9Sstevel@tonic-gate }
24537c478bd9Sstevel@tonic-gate 
24547c478bd9Sstevel@tonic-gate static int
24557c478bd9Sstevel@tonic-gate kgrep_walk_vmem(uintptr_t addr, const vmem_t *vmem, kgrep_walk_data_t *kg)
24567c478bd9Sstevel@tonic-gate {
24577bc98a2eSeg 	mdb_walk_cb_t walk_vseg = (mdb_walk_cb_t)kgrep_walk_vseg;
24587bc98a2eSeg 
24597c478bd9Sstevel@tonic-gate 	if (strcmp(vmem->vm_name, "heap") != 0 &&
24607c478bd9Sstevel@tonic-gate 	    strcmp(vmem->vm_name, "heap32") != 0 &&
24617bc98a2eSeg 	    strcmp(vmem->vm_name, "heap_core") != 0 &&
24627bc98a2eSeg 	    strcmp(vmem->vm_name, "heap_lp") != 0)
24637c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
24647c478bd9Sstevel@tonic-gate 
24657bc98a2eSeg 	if (strcmp(vmem->vm_name, "heap_lp") == 0)
24667bc98a2eSeg 		walk_vseg = (mdb_walk_cb_t)kgrep_xwalk_vseg;
24677bc98a2eSeg 
24687bc98a2eSeg 	if (mdb_pwalk("vmem_alloc", walk_vseg, kg, addr) == -1) {
24697c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't walk vmem_alloc for vmem %p", addr);
24707c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
24717c478bd9Sstevel@tonic-gate 	}
24727c478bd9Sstevel@tonic-gate 
24737c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
24747c478bd9Sstevel@tonic-gate }
24757c478bd9Sstevel@tonic-gate 
24767c478bd9Sstevel@tonic-gate int
24777c478bd9Sstevel@tonic-gate kgrep_subr(kgrep_cb_func *cb, void *cbdata)
24787c478bd9Sstevel@tonic-gate {
24797c478bd9Sstevel@tonic-gate 	GElf_Sym kas, kvseg, kvseg32, kvseg_core, segkpm;
24807c478bd9Sstevel@tonic-gate 	kgrep_walk_data_t kg;
24817c478bd9Sstevel@tonic-gate 
24827c478bd9Sstevel@tonic-gate 	if (mdb_get_state() == MDB_STATE_RUNNING) {
24837c478bd9Sstevel@tonic-gate 		mdb_warn("kgrep can only be run on a system "
24847c478bd9Sstevel@tonic-gate 		    "dump or under kmdb; see dumpadm(1M)\n");
24857c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
24867c478bd9Sstevel@tonic-gate 	}
24877c478bd9Sstevel@tonic-gate 
24887c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_name("kas", &kas) == -1) {
24897c478bd9Sstevel@tonic-gate 		mdb_warn("failed to locate 'kas' symbol\n");
24907c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
24917c478bd9Sstevel@tonic-gate 	}
24927c478bd9Sstevel@tonic-gate 
24937c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_name("kvseg", &kvseg) == -1) {
24947c478bd9Sstevel@tonic-gate 		mdb_warn("failed to locate 'kvseg' symbol\n");
24957c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
24967c478bd9Sstevel@tonic-gate 	}
24977c478bd9Sstevel@tonic-gate 
24987c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_name("kvseg32", &kvseg32) == -1) {
24997c478bd9Sstevel@tonic-gate 		mdb_warn("failed to locate 'kvseg32' symbol\n");
25007c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
25017c478bd9Sstevel@tonic-gate 	}
25027c478bd9Sstevel@tonic-gate 
25037c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_name("kvseg_core", &kvseg_core) == -1) {
25047c478bd9Sstevel@tonic-gate 		mdb_warn("failed to locate 'kvseg_core' symbol\n");
25057c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
25067c478bd9Sstevel@tonic-gate 	}
25077c478bd9Sstevel@tonic-gate 
25087c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_name("segkpm_ops", &segkpm) == -1) {
25097c478bd9Sstevel@tonic-gate 		mdb_warn("failed to locate 'segkpm_ops' symbol\n");
25107c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
25117c478bd9Sstevel@tonic-gate 	}
25127c478bd9Sstevel@tonic-gate 
25137bc98a2eSeg 	if (mdb_readvar(&kg.kg_heap_lp_base, "heap_lp_base") == -1) {
25147bc98a2eSeg 		mdb_warn("failed to read 'heap_lp_base'\n");
25157bc98a2eSeg 		return (DCMD_ERR);
25167bc98a2eSeg 	}
25177bc98a2eSeg 
25187bc98a2eSeg 	if (mdb_readvar(&kg.kg_heap_lp_end, "heap_lp_end") == -1) {
25197bc98a2eSeg 		mdb_warn("failed to read 'heap_lp_end'\n");
25207bc98a2eSeg 		return (DCMD_ERR);
25217bc98a2eSeg 	}
25227bc98a2eSeg 
25237c478bd9Sstevel@tonic-gate 	kg.kg_cb = cb;
25247c478bd9Sstevel@tonic-gate 	kg.kg_cbdata = cbdata;
25257c478bd9Sstevel@tonic-gate 	kg.kg_kvseg = (uintptr_t)kvseg.st_value;
25267c478bd9Sstevel@tonic-gate 	kg.kg_kvseg32 = (uintptr_t)kvseg32.st_value;
25277c478bd9Sstevel@tonic-gate 	kg.kg_kvseg_core = (uintptr_t)kvseg_core.st_value;
25287c478bd9Sstevel@tonic-gate 	kg.kg_segkpm = (uintptr_t)segkpm.st_value;
25297c478bd9Sstevel@tonic-gate 
25307c478bd9Sstevel@tonic-gate 	if (mdb_pwalk("seg", (mdb_walk_cb_t)kgrep_walk_seg,
25317c478bd9Sstevel@tonic-gate 	    &kg, kas.st_value) == -1) {
25327c478bd9Sstevel@tonic-gate 		mdb_warn("failed to walk kas segments");
25337c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
25347c478bd9Sstevel@tonic-gate 	}
25357c478bd9Sstevel@tonic-gate 
25367c478bd9Sstevel@tonic-gate 	if (mdb_walk("vmem", (mdb_walk_cb_t)kgrep_walk_vmem, &kg) == -1) {
25377c478bd9Sstevel@tonic-gate 		mdb_warn("failed to walk heap/heap32 vmem arenas");
25387c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
25397c478bd9Sstevel@tonic-gate 	}
25407c478bd9Sstevel@tonic-gate 
25417c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
25427c478bd9Sstevel@tonic-gate }
25437c478bd9Sstevel@tonic-gate 
25447c478bd9Sstevel@tonic-gate size_t
25457c478bd9Sstevel@tonic-gate kgrep_subr_pagesize(void)
25467c478bd9Sstevel@tonic-gate {
25477c478bd9Sstevel@tonic-gate 	return (PAGESIZE);
25487c478bd9Sstevel@tonic-gate }
25497c478bd9Sstevel@tonic-gate 
25507c478bd9Sstevel@tonic-gate typedef struct file_walk_data {
25517c478bd9Sstevel@tonic-gate 	struct uf_entry *fw_flist;
25527c478bd9Sstevel@tonic-gate 	int fw_flistsz;
25537c478bd9Sstevel@tonic-gate 	int fw_ndx;
25547c478bd9Sstevel@tonic-gate 	int fw_nofiles;
25557c478bd9Sstevel@tonic-gate } file_walk_data_t;
25567c478bd9Sstevel@tonic-gate 
25577c478bd9Sstevel@tonic-gate int
25587c478bd9Sstevel@tonic-gate file_walk_init(mdb_walk_state_t *wsp)
25597c478bd9Sstevel@tonic-gate {
25607c478bd9Sstevel@tonic-gate 	file_walk_data_t *fw;
25617c478bd9Sstevel@tonic-gate 	proc_t p;
25627c478bd9Sstevel@tonic-gate 
25637c478bd9Sstevel@tonic-gate 	if (wsp->walk_addr == NULL) {
25647c478bd9Sstevel@tonic-gate 		mdb_warn("file walk doesn't support global walks\n");
25657c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
25667c478bd9Sstevel@tonic-gate 	}
25677c478bd9Sstevel@tonic-gate 
25687c478bd9Sstevel@tonic-gate 	fw = mdb_alloc(sizeof (file_walk_data_t), UM_SLEEP);
25697c478bd9Sstevel@tonic-gate 
25707c478bd9Sstevel@tonic-gate 	if (mdb_vread(&p, sizeof (p), wsp->walk_addr) == -1) {
25717c478bd9Sstevel@tonic-gate 		mdb_free(fw, sizeof (file_walk_data_t));
25727c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read proc structure at %p", wsp->walk_addr);
25737c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
25747c478bd9Sstevel@tonic-gate 	}
25757c478bd9Sstevel@tonic-gate 
25767c478bd9Sstevel@tonic-gate 	if (p.p_user.u_finfo.fi_nfiles == 0) {
25777c478bd9Sstevel@tonic-gate 		mdb_free(fw, sizeof (file_walk_data_t));
25787c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
25797c478bd9Sstevel@tonic-gate 	}
25807c478bd9Sstevel@tonic-gate 
25817c478bd9Sstevel@tonic-gate 	fw->fw_nofiles = p.p_user.u_finfo.fi_nfiles;
25827c478bd9Sstevel@tonic-gate 	fw->fw_flistsz = sizeof (struct uf_entry) * fw->fw_nofiles;
25837c478bd9Sstevel@tonic-gate 	fw->fw_flist = mdb_alloc(fw->fw_flistsz, UM_SLEEP);
25847c478bd9Sstevel@tonic-gate 
25857c478bd9Sstevel@tonic-gate 	if (mdb_vread(fw->fw_flist, fw->fw_flistsz,
25867c478bd9Sstevel@tonic-gate 	    (uintptr_t)p.p_user.u_finfo.fi_list) == -1) {
25877c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read file array at %p",
25887c478bd9Sstevel@tonic-gate 		    p.p_user.u_finfo.fi_list);
25897c478bd9Sstevel@tonic-gate 		mdb_free(fw->fw_flist, fw->fw_flistsz);
25907c478bd9Sstevel@tonic-gate 		mdb_free(fw, sizeof (file_walk_data_t));
25917c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
25927c478bd9Sstevel@tonic-gate 	}
25937c478bd9Sstevel@tonic-gate 
25947c478bd9Sstevel@tonic-gate 	fw->fw_ndx = 0;
25957c478bd9Sstevel@tonic-gate 	wsp->walk_data = fw;
25967c478bd9Sstevel@tonic-gate 
25977c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
25987c478bd9Sstevel@tonic-gate }
25997c478bd9Sstevel@tonic-gate 
26007c478bd9Sstevel@tonic-gate int
26017c478bd9Sstevel@tonic-gate file_walk_step(mdb_walk_state_t *wsp)
26027c478bd9Sstevel@tonic-gate {
26037c478bd9Sstevel@tonic-gate 	file_walk_data_t *fw = (file_walk_data_t *)wsp->walk_data;
26047c478bd9Sstevel@tonic-gate 	struct file file;
26057c478bd9Sstevel@tonic-gate 	uintptr_t fp;
26067c478bd9Sstevel@tonic-gate 
26077c478bd9Sstevel@tonic-gate again:
26087c478bd9Sstevel@tonic-gate 	if (fw->fw_ndx == fw->fw_nofiles)
26097c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
26107c478bd9Sstevel@tonic-gate 
26117c478bd9Sstevel@tonic-gate 	if ((fp = (uintptr_t)fw->fw_flist[fw->fw_ndx++].uf_file) == NULL)
26127c478bd9Sstevel@tonic-gate 		goto again;
26137c478bd9Sstevel@tonic-gate 
26147c478bd9Sstevel@tonic-gate 	(void) mdb_vread(&file, sizeof (file), (uintptr_t)fp);
26157c478bd9Sstevel@tonic-gate 	return (wsp->walk_callback(fp, &file, wsp->walk_cbdata));
26167c478bd9Sstevel@tonic-gate }
26177c478bd9Sstevel@tonic-gate 
26187c478bd9Sstevel@tonic-gate int
26197c478bd9Sstevel@tonic-gate allfile_walk_step(mdb_walk_state_t *wsp)
26207c478bd9Sstevel@tonic-gate {
26217c478bd9Sstevel@tonic-gate 	file_walk_data_t *fw = (file_walk_data_t *)wsp->walk_data;
26227c478bd9Sstevel@tonic-gate 	struct file file;
26237c478bd9Sstevel@tonic-gate 	uintptr_t fp;
26247c478bd9Sstevel@tonic-gate 
26257c478bd9Sstevel@tonic-gate 	if (fw->fw_ndx == fw->fw_nofiles)
26267c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
26277c478bd9Sstevel@tonic-gate 
26287c478bd9Sstevel@tonic-gate 	if ((fp = (uintptr_t)fw->fw_flist[fw->fw_ndx++].uf_file) != NULL)
26297c478bd9Sstevel@tonic-gate 		(void) mdb_vread(&file, sizeof (file), (uintptr_t)fp);
26307c478bd9Sstevel@tonic-gate 	else
26317c478bd9Sstevel@tonic-gate 		bzero(&file, sizeof (file));
26327c478bd9Sstevel@tonic-gate 
26337c478bd9Sstevel@tonic-gate 	return (wsp->walk_callback(fp, &file, wsp->walk_cbdata));
26347c478bd9Sstevel@tonic-gate }
26357c478bd9Sstevel@tonic-gate 
26367c478bd9Sstevel@tonic-gate void
26377c478bd9Sstevel@tonic-gate file_walk_fini(mdb_walk_state_t *wsp)
26387c478bd9Sstevel@tonic-gate {
26397c478bd9Sstevel@tonic-gate 	file_walk_data_t *fw = (file_walk_data_t *)wsp->walk_data;
26407c478bd9Sstevel@tonic-gate 
26417c478bd9Sstevel@tonic-gate 	mdb_free(fw->fw_flist, fw->fw_flistsz);
26427c478bd9Sstevel@tonic-gate 	mdb_free(fw, sizeof (file_walk_data_t));
26437c478bd9Sstevel@tonic-gate }
26447c478bd9Sstevel@tonic-gate 
26457c478bd9Sstevel@tonic-gate int
26467c478bd9Sstevel@tonic-gate port_walk_init(mdb_walk_state_t *wsp)
26477c478bd9Sstevel@tonic-gate {
26487c478bd9Sstevel@tonic-gate 	if (wsp->walk_addr == NULL) {
26497c478bd9Sstevel@tonic-gate 		mdb_warn("port walk doesn't support global walks\n");
26507c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
26517c478bd9Sstevel@tonic-gate 	}
26527c478bd9Sstevel@tonic-gate 
26537c478bd9Sstevel@tonic-gate 	if (mdb_layered_walk("file", wsp) == -1) {
26547c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't walk 'file'");
26557c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
26567c478bd9Sstevel@tonic-gate 	}
26577c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
26587c478bd9Sstevel@tonic-gate }
26597c478bd9Sstevel@tonic-gate 
26607c478bd9Sstevel@tonic-gate int
26617c478bd9Sstevel@tonic-gate port_walk_step(mdb_walk_state_t *wsp)
26627c478bd9Sstevel@tonic-gate {
26637c478bd9Sstevel@tonic-gate 	struct vnode	vn;
26647c478bd9Sstevel@tonic-gate 	uintptr_t	vp;
26657c478bd9Sstevel@tonic-gate 	uintptr_t	pp;
26667c478bd9Sstevel@tonic-gate 	struct port	port;
26677c478bd9Sstevel@tonic-gate 
26687c478bd9Sstevel@tonic-gate 	vp = (uintptr_t)((struct file *)wsp->walk_layer)->f_vnode;
26697c478bd9Sstevel@tonic-gate 	if (mdb_vread(&vn, sizeof (vn), vp) == -1) {
26707c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read vnode_t at %p", vp);
26717c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
26727c478bd9Sstevel@tonic-gate 	}
26737c478bd9Sstevel@tonic-gate 	if (vn.v_type != VPORT)
26747c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
26757c478bd9Sstevel@tonic-gate 
26767c478bd9Sstevel@tonic-gate 	pp = (uintptr_t)vn.v_data;
26777c478bd9Sstevel@tonic-gate 	if (mdb_vread(&port, sizeof (port), pp) == -1) {
26787c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read port_t at %p", pp);
26797c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
26807c478bd9Sstevel@tonic-gate 	}
26817c478bd9Sstevel@tonic-gate 	return (wsp->walk_callback(pp, &port, wsp->walk_cbdata));
26827c478bd9Sstevel@tonic-gate }
26837c478bd9Sstevel@tonic-gate 
26847c478bd9Sstevel@tonic-gate typedef struct portev_walk_data {
26857c478bd9Sstevel@tonic-gate 	list_node_t	*pev_node;
26867c478bd9Sstevel@tonic-gate 	list_node_t	*pev_last;
26877c478bd9Sstevel@tonic-gate 	size_t		pev_offset;
26887c478bd9Sstevel@tonic-gate } portev_walk_data_t;
26897c478bd9Sstevel@tonic-gate 
26907c478bd9Sstevel@tonic-gate int
26917c478bd9Sstevel@tonic-gate portev_walk_init(mdb_walk_state_t *wsp)
26927c478bd9Sstevel@tonic-gate {
26937c478bd9Sstevel@tonic-gate 	portev_walk_data_t *pevd;
26947c478bd9Sstevel@tonic-gate 	struct port	port;
26957c478bd9Sstevel@tonic-gate 	struct vnode	vn;
26967c478bd9Sstevel@tonic-gate 	struct list	*list;
26977c478bd9Sstevel@tonic-gate 	uintptr_t	vp;
26987c478bd9Sstevel@tonic-gate 
26997c478bd9Sstevel@tonic-gate 	if (wsp->walk_addr == NULL) {
27007c478bd9Sstevel@tonic-gate 		mdb_warn("portev walk doesn't support global walks\n");
27017c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
27027c478bd9Sstevel@tonic-gate 	}
27037c478bd9Sstevel@tonic-gate 
27047c478bd9Sstevel@tonic-gate 	pevd = mdb_alloc(sizeof (portev_walk_data_t), UM_SLEEP);
27057c478bd9Sstevel@tonic-gate 
27067c478bd9Sstevel@tonic-gate 	if (mdb_vread(&port, sizeof (port), wsp->walk_addr) == -1) {
27077c478bd9Sstevel@tonic-gate 		mdb_free(pevd, sizeof (portev_walk_data_t));
27087c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read port structure at %p", wsp->walk_addr);
27097c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
27107c478bd9Sstevel@tonic-gate 	}
27117c478bd9Sstevel@tonic-gate 
27127c478bd9Sstevel@tonic-gate 	vp = (uintptr_t)port.port_vnode;
27137c478bd9Sstevel@tonic-gate 	if (mdb_vread(&vn, sizeof (vn), vp) == -1) {
27147c478bd9Sstevel@tonic-gate 		mdb_free(pevd, sizeof (portev_walk_data_t));
27157c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read vnode_t at %p", vp);
27167c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
27177c478bd9Sstevel@tonic-gate 	}
27187c478bd9Sstevel@tonic-gate 
27197c478bd9Sstevel@tonic-gate 	if (vn.v_type != VPORT) {
27207c478bd9Sstevel@tonic-gate 		mdb_free(pevd, sizeof (portev_walk_data_t));
27217c478bd9Sstevel@tonic-gate 		mdb_warn("input address (%p) does not point to an event port",
27227c478bd9Sstevel@tonic-gate 		    wsp->walk_addr);
27237c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
27247c478bd9Sstevel@tonic-gate 	}
27257c478bd9Sstevel@tonic-gate 
27267c478bd9Sstevel@tonic-gate 	if (port.port_queue.portq_nent == 0) {
27277c478bd9Sstevel@tonic-gate 		mdb_free(pevd, sizeof (portev_walk_data_t));
27287c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
27297c478bd9Sstevel@tonic-gate 	}
27307c478bd9Sstevel@tonic-gate 	list = &port.port_queue.portq_list;
27317c478bd9Sstevel@tonic-gate 	pevd->pev_offset = list->list_offset;
27327c478bd9Sstevel@tonic-gate 	pevd->pev_last = list->list_head.list_prev;
27337c478bd9Sstevel@tonic-gate 	pevd->pev_node = list->list_head.list_next;
27347c478bd9Sstevel@tonic-gate 	wsp->walk_data = pevd;
27357c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
27367c478bd9Sstevel@tonic-gate }
27377c478bd9Sstevel@tonic-gate 
27387c478bd9Sstevel@tonic-gate int
27397c478bd9Sstevel@tonic-gate portev_walk_step(mdb_walk_state_t *wsp)
27407c478bd9Sstevel@tonic-gate {
27417c478bd9Sstevel@tonic-gate 	portev_walk_data_t	*pevd;
27427c478bd9Sstevel@tonic-gate 	struct port_kevent	ev;
27437c478bd9Sstevel@tonic-gate 	uintptr_t		evp;
27447c478bd9Sstevel@tonic-gate 
27457c478bd9Sstevel@tonic-gate 	pevd = (portev_walk_data_t *)wsp->walk_data;
27467c478bd9Sstevel@tonic-gate 
27477c478bd9Sstevel@tonic-gate 	if (pevd->pev_last == NULL)
27487c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
27497c478bd9Sstevel@tonic-gate 	if (pevd->pev_node == pevd->pev_last)
27507c478bd9Sstevel@tonic-gate 		pevd->pev_last = NULL;		/* last round */
27517c478bd9Sstevel@tonic-gate 
27527c478bd9Sstevel@tonic-gate 	evp = ((uintptr_t)(((char *)pevd->pev_node) - pevd->pev_offset));
27537c478bd9Sstevel@tonic-gate 	if (mdb_vread(&ev, sizeof (ev), evp) == -1) {
27547c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read port_kevent at %p", evp);
27557c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
27567c478bd9Sstevel@tonic-gate 	}
27577c478bd9Sstevel@tonic-gate 	pevd->pev_node = ev.portkev_node.list_next;
27587c478bd9Sstevel@tonic-gate 	return (wsp->walk_callback(evp, &ev, wsp->walk_cbdata));
27597c478bd9Sstevel@tonic-gate }
27607c478bd9Sstevel@tonic-gate 
27617c478bd9Sstevel@tonic-gate void
27627c478bd9Sstevel@tonic-gate portev_walk_fini(mdb_walk_state_t *wsp)
27637c478bd9Sstevel@tonic-gate {
27647c478bd9Sstevel@tonic-gate 	portev_walk_data_t *pevd = (portev_walk_data_t *)wsp->walk_data;
27657c478bd9Sstevel@tonic-gate 
27667c478bd9Sstevel@tonic-gate 	if (pevd != NULL)
27677c478bd9Sstevel@tonic-gate 		mdb_free(pevd, sizeof (portev_walk_data_t));
27687c478bd9Sstevel@tonic-gate }
27697c478bd9Sstevel@tonic-gate 
27707c478bd9Sstevel@tonic-gate typedef struct proc_walk_data {
27717c478bd9Sstevel@tonic-gate 	uintptr_t *pw_stack;
27727c478bd9Sstevel@tonic-gate 	int pw_depth;
27737c478bd9Sstevel@tonic-gate 	int pw_max;
27747c478bd9Sstevel@tonic-gate } proc_walk_data_t;
27757c478bd9Sstevel@tonic-gate 
27767c478bd9Sstevel@tonic-gate int
27777c478bd9Sstevel@tonic-gate proc_walk_init(mdb_walk_state_t *wsp)
27787c478bd9Sstevel@tonic-gate {
27797c478bd9Sstevel@tonic-gate 	GElf_Sym sym;
27807c478bd9Sstevel@tonic-gate 	proc_walk_data_t *pw;
27817c478bd9Sstevel@tonic-gate 
27827c478bd9Sstevel@tonic-gate 	if (wsp->walk_addr == NULL) {
27837c478bd9Sstevel@tonic-gate 		if (mdb_lookup_by_name("p0", &sym) == -1) {
27847c478bd9Sstevel@tonic-gate 			mdb_warn("failed to read 'practive'");
27857c478bd9Sstevel@tonic-gate 			return (WALK_ERR);
27867c478bd9Sstevel@tonic-gate 		}
27877c478bd9Sstevel@tonic-gate 		wsp->walk_addr = (uintptr_t)sym.st_value;
27887c478bd9Sstevel@tonic-gate 	}
27897c478bd9Sstevel@tonic-gate 
27907c478bd9Sstevel@tonic-gate 	pw = mdb_zalloc(sizeof (proc_walk_data_t), UM_SLEEP);
27917c478bd9Sstevel@tonic-gate 
27927c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&pw->pw_max, "nproc") == -1) {
27937c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read 'nproc'");
27947c478bd9Sstevel@tonic-gate 		mdb_free(pw, sizeof (pw));
27957c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
27967c478bd9Sstevel@tonic-gate 	}
27977c478bd9Sstevel@tonic-gate 
27987c478bd9Sstevel@tonic-gate 	pw->pw_stack = mdb_alloc(pw->pw_max * sizeof (uintptr_t), UM_SLEEP);
27997c478bd9Sstevel@tonic-gate 	wsp->walk_data = pw;
28007c478bd9Sstevel@tonic-gate 
28017c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
28027c478bd9Sstevel@tonic-gate }
28037c478bd9Sstevel@tonic-gate 
28047c478bd9Sstevel@tonic-gate int
28057c478bd9Sstevel@tonic-gate proc_walk_step(mdb_walk_state_t *wsp)
28067c478bd9Sstevel@tonic-gate {
28077c478bd9Sstevel@tonic-gate 	proc_walk_data_t *pw = wsp->walk_data;
28087c478bd9Sstevel@tonic-gate 	uintptr_t addr = wsp->walk_addr;
28097c478bd9Sstevel@tonic-gate 	uintptr_t cld, sib;
28107c478bd9Sstevel@tonic-gate 
28117c478bd9Sstevel@tonic-gate 	int status;
28127c478bd9Sstevel@tonic-gate 	proc_t pr;
28137c478bd9Sstevel@tonic-gate 
28147c478bd9Sstevel@tonic-gate 	if (mdb_vread(&pr, sizeof (proc_t), addr) == -1) {
28157c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read proc at %p", addr);
28167c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
28177c478bd9Sstevel@tonic-gate 	}
28187c478bd9Sstevel@tonic-gate 
28197c478bd9Sstevel@tonic-gate 	cld = (uintptr_t)pr.p_child;
28207c478bd9Sstevel@tonic-gate 	sib = (uintptr_t)pr.p_sibling;
28217c478bd9Sstevel@tonic-gate 
28227c478bd9Sstevel@tonic-gate 	if (pw->pw_depth > 0 && addr == pw->pw_stack[pw->pw_depth - 1]) {
28237c478bd9Sstevel@tonic-gate 		pw->pw_depth--;
28247c478bd9Sstevel@tonic-gate 		goto sib;
28257c478bd9Sstevel@tonic-gate 	}
28267c478bd9Sstevel@tonic-gate 
28277c478bd9Sstevel@tonic-gate 	status = wsp->walk_callback(addr, &pr, wsp->walk_cbdata);
28287c478bd9Sstevel@tonic-gate 
28297c478bd9Sstevel@tonic-gate 	if (status != WALK_NEXT)
28307c478bd9Sstevel@tonic-gate 		return (status);
28317c478bd9Sstevel@tonic-gate 
28327c478bd9Sstevel@tonic-gate 	if ((wsp->walk_addr = cld) != NULL) {
28337c478bd9Sstevel@tonic-gate 		if (mdb_vread(&pr, sizeof (proc_t), cld) == -1) {
28347c478bd9Sstevel@tonic-gate 			mdb_warn("proc %p has invalid p_child %p; skipping\n",
28357c478bd9Sstevel@tonic-gate 			    addr, cld);
28367c478bd9Sstevel@tonic-gate 			goto sib;
28377c478bd9Sstevel@tonic-gate 		}
28387c478bd9Sstevel@tonic-gate 
28397c478bd9Sstevel@tonic-gate 		pw->pw_stack[pw->pw_depth++] = addr;
28407c478bd9Sstevel@tonic-gate 
28417c478bd9Sstevel@tonic-gate 		if (pw->pw_depth == pw->pw_max) {
28427c478bd9Sstevel@tonic-gate 			mdb_warn("depth %d exceeds max depth; try again\n",
28437c478bd9Sstevel@tonic-gate 			    pw->pw_depth);
28447c478bd9Sstevel@tonic-gate 			return (WALK_DONE);
28457c478bd9Sstevel@tonic-gate 		}
28467c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
28477c478bd9Sstevel@tonic-gate 	}
28487c478bd9Sstevel@tonic-gate 
28497c478bd9Sstevel@tonic-gate sib:
28507c478bd9Sstevel@tonic-gate 	/*
28517c478bd9Sstevel@tonic-gate 	 * We know that p0 has no siblings, and if another starting proc
28527c478bd9Sstevel@tonic-gate 	 * was given, we don't want to walk its siblings anyway.
28537c478bd9Sstevel@tonic-gate 	 */
28547c478bd9Sstevel@tonic-gate 	if (pw->pw_depth == 0)
28557c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
28567c478bd9Sstevel@tonic-gate 
28577c478bd9Sstevel@tonic-gate 	if (sib != NULL && mdb_vread(&pr, sizeof (proc_t), sib) == -1) {
28587c478bd9Sstevel@tonic-gate 		mdb_warn("proc %p has invalid p_sibling %p; skipping\n",
28597c478bd9Sstevel@tonic-gate 		    addr, sib);
28607c478bd9Sstevel@tonic-gate 		sib = NULL;
28617c478bd9Sstevel@tonic-gate 	}
28627c478bd9Sstevel@tonic-gate 
28637c478bd9Sstevel@tonic-gate 	if ((wsp->walk_addr = sib) == NULL) {
28647c478bd9Sstevel@tonic-gate 		if (pw->pw_depth > 0) {
28657c478bd9Sstevel@tonic-gate 			wsp->walk_addr = pw->pw_stack[pw->pw_depth - 1];
28667c478bd9Sstevel@tonic-gate 			return (WALK_NEXT);
28677c478bd9Sstevel@tonic-gate 		}
28687c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
28697c478bd9Sstevel@tonic-gate 	}
28707c478bd9Sstevel@tonic-gate 
28717c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
28727c478bd9Sstevel@tonic-gate }
28737c478bd9Sstevel@tonic-gate 
28747c478bd9Sstevel@tonic-gate void
28757c478bd9Sstevel@tonic-gate proc_walk_fini(mdb_walk_state_t *wsp)
28767c478bd9Sstevel@tonic-gate {
28777c478bd9Sstevel@tonic-gate 	proc_walk_data_t *pw = wsp->walk_data;
28787c478bd9Sstevel@tonic-gate 
28797c478bd9Sstevel@tonic-gate 	mdb_free(pw->pw_stack, pw->pw_max * sizeof (uintptr_t));
28807c478bd9Sstevel@tonic-gate 	mdb_free(pw, sizeof (proc_walk_data_t));
28817c478bd9Sstevel@tonic-gate }
28827c478bd9Sstevel@tonic-gate 
28837c478bd9Sstevel@tonic-gate int
28847c478bd9Sstevel@tonic-gate task_walk_init(mdb_walk_state_t *wsp)
28857c478bd9Sstevel@tonic-gate {
28867c478bd9Sstevel@tonic-gate 	task_t task;
28877c478bd9Sstevel@tonic-gate 
28887c478bd9Sstevel@tonic-gate 	if (mdb_vread(&task, sizeof (task_t), wsp->walk_addr) == -1) {
28897c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read task at %p", wsp->walk_addr);
28907c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
28917c478bd9Sstevel@tonic-gate 	}
28927c478bd9Sstevel@tonic-gate 	wsp->walk_addr = (uintptr_t)task.tk_memb_list;
28937c478bd9Sstevel@tonic-gate 	wsp->walk_data = task.tk_memb_list;
28947c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
28957c478bd9Sstevel@tonic-gate }
28967c478bd9Sstevel@tonic-gate 
28977c478bd9Sstevel@tonic-gate int
28987c478bd9Sstevel@tonic-gate task_walk_step(mdb_walk_state_t *wsp)
28997c478bd9Sstevel@tonic-gate {
29007c478bd9Sstevel@tonic-gate 	proc_t proc;
29017c478bd9Sstevel@tonic-gate 	int status;
29027c478bd9Sstevel@tonic-gate 
29037c478bd9Sstevel@tonic-gate 	if (mdb_vread(&proc, sizeof (proc_t), wsp->walk_addr) == -1) {
29047c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read proc at %p", wsp->walk_addr);
29057c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
29067c478bd9Sstevel@tonic-gate 	}
29077c478bd9Sstevel@tonic-gate 
29087c478bd9Sstevel@tonic-gate 	status = wsp->walk_callback(wsp->walk_addr, NULL, wsp->walk_cbdata);
29097c478bd9Sstevel@tonic-gate 
29107c478bd9Sstevel@tonic-gate 	if (proc.p_tasknext == wsp->walk_data)
29117c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
29127c478bd9Sstevel@tonic-gate 
29137c478bd9Sstevel@tonic-gate 	wsp->walk_addr = (uintptr_t)proc.p_tasknext;
29147c478bd9Sstevel@tonic-gate 	return (status);
29157c478bd9Sstevel@tonic-gate }
29167c478bd9Sstevel@tonic-gate 
29177c478bd9Sstevel@tonic-gate int
29187c478bd9Sstevel@tonic-gate project_walk_init(mdb_walk_state_t *wsp)
29197c478bd9Sstevel@tonic-gate {
29207c478bd9Sstevel@tonic-gate 	if (wsp->walk_addr == NULL) {
29217c478bd9Sstevel@tonic-gate 		if (mdb_readvar(&wsp->walk_addr, "proj0p") == -1) {
29227c478bd9Sstevel@tonic-gate 			mdb_warn("failed to read 'proj0p'");
29237c478bd9Sstevel@tonic-gate 			return (WALK_ERR);
29247c478bd9Sstevel@tonic-gate 		}
29257c478bd9Sstevel@tonic-gate 	}
29267c478bd9Sstevel@tonic-gate 	wsp->walk_data = (void *)wsp->walk_addr;
29277c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
29287c478bd9Sstevel@tonic-gate }
29297c478bd9Sstevel@tonic-gate 
29307c478bd9Sstevel@tonic-gate int
29317c478bd9Sstevel@tonic-gate project_walk_step(mdb_walk_state_t *wsp)
29327c478bd9Sstevel@tonic-gate {
29337c478bd9Sstevel@tonic-gate 	uintptr_t addr = wsp->walk_addr;
29347c478bd9Sstevel@tonic-gate 	kproject_t pj;
29357c478bd9Sstevel@tonic-gate 	int status;
29367c478bd9Sstevel@tonic-gate 
29377c478bd9Sstevel@tonic-gate 	if (mdb_vread(&pj, sizeof (kproject_t), addr) == -1) {
29387c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read project at %p", addr);
29397c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
29407c478bd9Sstevel@tonic-gate 	}
29417c478bd9Sstevel@tonic-gate 	status = wsp->walk_callback(addr, &pj, wsp->walk_cbdata);
29427c478bd9Sstevel@tonic-gate 	if (status != WALK_NEXT)
29437c478bd9Sstevel@tonic-gate 		return (status);
29447c478bd9Sstevel@tonic-gate 	wsp->walk_addr = (uintptr_t)pj.kpj_next;
29457c478bd9Sstevel@tonic-gate 	if ((void *)wsp->walk_addr == wsp->walk_data)
29467c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
29477c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
29487c478bd9Sstevel@tonic-gate }
29497c478bd9Sstevel@tonic-gate 
29507c478bd9Sstevel@tonic-gate static int
29517c478bd9Sstevel@tonic-gate generic_walk_step(mdb_walk_state_t *wsp)
29527c478bd9Sstevel@tonic-gate {
29537c478bd9Sstevel@tonic-gate 	return (wsp->walk_callback(wsp->walk_addr, wsp->walk_layer,
29547c478bd9Sstevel@tonic-gate 	    wsp->walk_cbdata));
29557c478bd9Sstevel@tonic-gate }
29567c478bd9Sstevel@tonic-gate 
29577c478bd9Sstevel@tonic-gate int
29587c478bd9Sstevel@tonic-gate seg_walk_init(mdb_walk_state_t *wsp)
29597c478bd9Sstevel@tonic-gate {
29607c478bd9Sstevel@tonic-gate 	if (wsp->walk_addr == NULL) {
29617c478bd9Sstevel@tonic-gate 		mdb_warn("seg walk must begin at struct as *\n");
29627c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
29637c478bd9Sstevel@tonic-gate 	}
29647c478bd9Sstevel@tonic-gate 
29657c478bd9Sstevel@tonic-gate 	/*
29667c478bd9Sstevel@tonic-gate 	 * this is really just a wrapper to AVL tree walk
29677c478bd9Sstevel@tonic-gate 	 */
29687c478bd9Sstevel@tonic-gate 	wsp->walk_addr = (uintptr_t)&((struct as *)wsp->walk_addr)->a_segtree;
29697c478bd9Sstevel@tonic-gate 	return (avl_walk_init(wsp));
29707c478bd9Sstevel@tonic-gate }
29717c478bd9Sstevel@tonic-gate 
29727c478bd9Sstevel@tonic-gate static int
29737c478bd9Sstevel@tonic-gate cpu_walk_cmp(const void *l, const void *r)
29747c478bd9Sstevel@tonic-gate {
29757c478bd9Sstevel@tonic-gate 	uintptr_t lhs = *((uintptr_t *)l);
29767c478bd9Sstevel@tonic-gate 	uintptr_t rhs = *((uintptr_t *)r);
29777c478bd9Sstevel@tonic-gate 	cpu_t lcpu, rcpu;
29787c478bd9Sstevel@tonic-gate 
29797c478bd9Sstevel@tonic-gate 	(void) mdb_vread(&lcpu, sizeof (lcpu), lhs);
29807c478bd9Sstevel@tonic-gate 	(void) mdb_vread(&rcpu, sizeof (rcpu), rhs);
29817c478bd9Sstevel@tonic-gate 
29827c478bd9Sstevel@tonic-gate 	if (lcpu.cpu_id < rcpu.cpu_id)
29837c478bd9Sstevel@tonic-gate 		return (-1);
29847c478bd9Sstevel@tonic-gate 
29857c478bd9Sstevel@tonic-gate 	if (lcpu.cpu_id > rcpu.cpu_id)
29867c478bd9Sstevel@tonic-gate 		return (1);
29877c478bd9Sstevel@tonic-gate 
29887c478bd9Sstevel@tonic-gate 	return (0);
29897c478bd9Sstevel@tonic-gate }
29907c478bd9Sstevel@tonic-gate 
29917c478bd9Sstevel@tonic-gate typedef struct cpu_walk {
29927c478bd9Sstevel@tonic-gate 	uintptr_t *cw_array;
29937c478bd9Sstevel@tonic-gate 	int cw_ndx;
29947c478bd9Sstevel@tonic-gate } cpu_walk_t;
29957c478bd9Sstevel@tonic-gate 
29967c478bd9Sstevel@tonic-gate int
29977c478bd9Sstevel@tonic-gate cpu_walk_init(mdb_walk_state_t *wsp)
29987c478bd9Sstevel@tonic-gate {
29997c478bd9Sstevel@tonic-gate 	cpu_walk_t *cw;
30007c478bd9Sstevel@tonic-gate 	int max_ncpus, i = 0;
30017c478bd9Sstevel@tonic-gate 	uintptr_t current, first;
30027c478bd9Sstevel@tonic-gate 	cpu_t cpu, panic_cpu;
30037c478bd9Sstevel@tonic-gate 	uintptr_t panicstr, addr;
30047c478bd9Sstevel@tonic-gate 	GElf_Sym sym;
30057c478bd9Sstevel@tonic-gate 
30067c478bd9Sstevel@tonic-gate 	cw = mdb_zalloc(sizeof (cpu_walk_t), UM_SLEEP | UM_GC);
30077c478bd9Sstevel@tonic-gate 
30087c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&max_ncpus, "max_ncpus") == -1) {
30097c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read 'max_ncpus'");
30107c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
30117c478bd9Sstevel@tonic-gate 	}
30127c478bd9Sstevel@tonic-gate 
30137c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&panicstr, "panicstr") == -1) {
30147c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read 'panicstr'");
30157c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
30167c478bd9Sstevel@tonic-gate 	}
30177c478bd9Sstevel@tonic-gate 
30187c478bd9Sstevel@tonic-gate 	if (panicstr != NULL) {
30197c478bd9Sstevel@tonic-gate 		if (mdb_lookup_by_name("panic_cpu", &sym) == -1) {
30207c478bd9Sstevel@tonic-gate 			mdb_warn("failed to find 'panic_cpu'");
30217c478bd9Sstevel@tonic-gate 			return (WALK_ERR);
30227c478bd9Sstevel@tonic-gate 		}
30237c478bd9Sstevel@tonic-gate 
30247c478bd9Sstevel@tonic-gate 		addr = (uintptr_t)sym.st_value;
30257c478bd9Sstevel@tonic-gate 
30267c478bd9Sstevel@tonic-gate 		if (mdb_vread(&panic_cpu, sizeof (cpu_t), addr) == -1) {
30277c478bd9Sstevel@tonic-gate 			mdb_warn("failed to read 'panic_cpu'");
30287c478bd9Sstevel@tonic-gate 			return (WALK_ERR);
30297c478bd9Sstevel@tonic-gate 		}
30307c478bd9Sstevel@tonic-gate 	}
30317c478bd9Sstevel@tonic-gate 
30327c478bd9Sstevel@tonic-gate 	/*
30337c478bd9Sstevel@tonic-gate 	 * Unfortunately, there is no platform-independent way to walk
30347c478bd9Sstevel@tonic-gate 	 * CPUs in ID order.  We therefore loop through in cpu_next order,
30357c478bd9Sstevel@tonic-gate 	 * building an array of CPU pointers which will subsequently be
30367c478bd9Sstevel@tonic-gate 	 * sorted.
30377c478bd9Sstevel@tonic-gate 	 */
30387c478bd9Sstevel@tonic-gate 	cw->cw_array =
30397c478bd9Sstevel@tonic-gate 	    mdb_zalloc((max_ncpus + 1) * sizeof (uintptr_t), UM_SLEEP | UM_GC);
30407c478bd9Sstevel@tonic-gate 
30417c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&first, "cpu_list") == -1) {
30427c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read 'cpu_list'");
30437c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
30447c478bd9Sstevel@tonic-gate 	}
30457c478bd9Sstevel@tonic-gate 
30467c478bd9Sstevel@tonic-gate 	current = first;
30477c478bd9Sstevel@tonic-gate 	do {
30487c478bd9Sstevel@tonic-gate 		if (mdb_vread(&cpu, sizeof (cpu), current) == -1) {
30497c478bd9Sstevel@tonic-gate 			mdb_warn("failed to read cpu at %p", current);
30507c478bd9Sstevel@tonic-gate 			return (WALK_ERR);
30517c478bd9Sstevel@tonic-gate 		}
30527c478bd9Sstevel@tonic-gate 
30537c478bd9Sstevel@tonic-gate 		if (panicstr != NULL && panic_cpu.cpu_id == cpu.cpu_id) {
30547c478bd9Sstevel@tonic-gate 			cw->cw_array[i++] = addr;
30557c478bd9Sstevel@tonic-gate 		} else {
30567c478bd9Sstevel@tonic-gate 			cw->cw_array[i++] = current;
30577c478bd9Sstevel@tonic-gate 		}
30587c478bd9Sstevel@tonic-gate 	} while ((current = (uintptr_t)cpu.cpu_next) != first);
30597c478bd9Sstevel@tonic-gate 
30607c478bd9Sstevel@tonic-gate 	qsort(cw->cw_array, i, sizeof (uintptr_t), cpu_walk_cmp);
30617c478bd9Sstevel@tonic-gate 	wsp->walk_data = cw;
30627c478bd9Sstevel@tonic-gate 
30637c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
30647c478bd9Sstevel@tonic-gate }
30657c478bd9Sstevel@tonic-gate 
30667c478bd9Sstevel@tonic-gate int
30677c478bd9Sstevel@tonic-gate cpu_walk_step(mdb_walk_state_t *wsp)
30687c478bd9Sstevel@tonic-gate {
30697c478bd9Sstevel@tonic-gate 	cpu_walk_t *cw = wsp->walk_data;
30707c478bd9Sstevel@tonic-gate 	cpu_t cpu;
30717c478bd9Sstevel@tonic-gate 	uintptr_t addr = cw->cw_array[cw->cw_ndx++];
30727c478bd9Sstevel@tonic-gate 
30737c478bd9Sstevel@tonic-gate 	if (addr == NULL)
30747c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
30757c478bd9Sstevel@tonic-gate 
30767c478bd9Sstevel@tonic-gate 	if (mdb_vread(&cpu, sizeof (cpu), addr) == -1) {
30777c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read cpu at %p", addr);
30787c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
30797c478bd9Sstevel@tonic-gate 	}
30807c478bd9Sstevel@tonic-gate 
30817c478bd9Sstevel@tonic-gate 	return (wsp->walk_callback(addr, &cpu, wsp->walk_cbdata));
30827c478bd9Sstevel@tonic-gate }
30837c478bd9Sstevel@tonic-gate 
30847c478bd9Sstevel@tonic-gate typedef struct cpuinfo_data {
30857c478bd9Sstevel@tonic-gate 	intptr_t cid_cpu;
30867c478bd9Sstevel@tonic-gate 	uintptr_t cid_lbolt;
30877c478bd9Sstevel@tonic-gate 	uintptr_t **cid_ithr;
30887c478bd9Sstevel@tonic-gate 	char	cid_print_head;
30897c478bd9Sstevel@tonic-gate 	char	cid_print_thr;
30907c478bd9Sstevel@tonic-gate 	char	cid_print_ithr;
30917c478bd9Sstevel@tonic-gate 	char	cid_print_flags;
30927c478bd9Sstevel@tonic-gate } cpuinfo_data_t;
30937c478bd9Sstevel@tonic-gate 
30947c478bd9Sstevel@tonic-gate int
30957c478bd9Sstevel@tonic-gate cpuinfo_walk_ithread(uintptr_t addr, const kthread_t *thr, cpuinfo_data_t *cid)
30967c478bd9Sstevel@tonic-gate {
30977c478bd9Sstevel@tonic-gate 	cpu_t c;
30987c478bd9Sstevel@tonic-gate 	int id;
30997c478bd9Sstevel@tonic-gate 	uint8_t pil;
31007c478bd9Sstevel@tonic-gate 
31017c478bd9Sstevel@tonic-gate 	if (!(thr->t_flag & T_INTR_THREAD) || thr->t_state == TS_FREE)
31027c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
31037c478bd9Sstevel@tonic-gate 
31047c478bd9Sstevel@tonic-gate 	if (thr->t_bound_cpu == NULL) {
31057c478bd9Sstevel@tonic-gate 		mdb_warn("thr %p is intr thread w/out a CPU\n", addr);
31067c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
31077c478bd9Sstevel@tonic-gate 	}
31087c478bd9Sstevel@tonic-gate 
31097c478bd9Sstevel@tonic-gate 	(void) mdb_vread(&c, sizeof (c), (uintptr_t)thr->t_bound_cpu);
31107c478bd9Sstevel@tonic-gate 
31117c478bd9Sstevel@tonic-gate 	if ((id = c.cpu_id) >= NCPU) {
31127c478bd9Sstevel@tonic-gate 		mdb_warn("CPU %p has id (%d) greater than NCPU (%d)\n",
31137c478bd9Sstevel@tonic-gate 		    thr->t_bound_cpu, id, NCPU);
31147c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
31157c478bd9Sstevel@tonic-gate 	}
31167c478bd9Sstevel@tonic-gate 
31177c478bd9Sstevel@tonic-gate 	if ((pil = thr->t_pil) >= NINTR) {
31187c478bd9Sstevel@tonic-gate 		mdb_warn("thread %p has pil (%d) greater than %d\n",
31197c478bd9Sstevel@tonic-gate 		    addr, pil, NINTR);
31207c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
31217c478bd9Sstevel@tonic-gate 	}
31227c478bd9Sstevel@tonic-gate 
31237c478bd9Sstevel@tonic-gate 	if (cid->cid_ithr[id][pil] != NULL) {
31247c478bd9Sstevel@tonic-gate 		mdb_warn("CPU %d has multiple threads at pil %d (at least "
31257c478bd9Sstevel@tonic-gate 		    "%p and %p)\n", id, pil, addr, cid->cid_ithr[id][pil]);
31267c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
31277c478bd9Sstevel@tonic-gate 	}
31287c478bd9Sstevel@tonic-gate 
31297c478bd9Sstevel@tonic-gate 	cid->cid_ithr[id][pil] = addr;
31307c478bd9Sstevel@tonic-gate 
31317c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
31327c478bd9Sstevel@tonic-gate }
31337c478bd9Sstevel@tonic-gate 
31347c478bd9Sstevel@tonic-gate #define	CPUINFO_IDWIDTH		3
31357c478bd9Sstevel@tonic-gate #define	CPUINFO_FLAGWIDTH	9
31367c478bd9Sstevel@tonic-gate 
31377c478bd9Sstevel@tonic-gate #ifdef _LP64
3138f5533078Smishra #if defined(__amd64)
3139f5533078Smishra #define	CPUINFO_TWIDTH		16
3140f5533078Smishra #define	CPUINFO_CPUWIDTH	16
3141f5533078Smishra #else
31427c478bd9Sstevel@tonic-gate #define	CPUINFO_CPUWIDTH	11
31437c478bd9Sstevel@tonic-gate #define	CPUINFO_TWIDTH		11
3144f5533078Smishra #endif
31457c478bd9Sstevel@tonic-gate #else
31467c478bd9Sstevel@tonic-gate #define	CPUINFO_CPUWIDTH	8
31477c478bd9Sstevel@tonic-gate #define	CPUINFO_TWIDTH		8
31487c478bd9Sstevel@tonic-gate #endif
31497c478bd9Sstevel@tonic-gate 
31507c478bd9Sstevel@tonic-gate #define	CPUINFO_THRDELT		(CPUINFO_IDWIDTH + CPUINFO_CPUWIDTH + 9)
31517c478bd9Sstevel@tonic-gate #define	CPUINFO_FLAGDELT	(CPUINFO_IDWIDTH + CPUINFO_CPUWIDTH + 4)
31527c478bd9Sstevel@tonic-gate #define	CPUINFO_ITHRDELT	4
31537c478bd9Sstevel@tonic-gate 
31547c478bd9Sstevel@tonic-gate #define	CPUINFO_INDENT	mdb_printf("%*s", CPUINFO_THRDELT, \
31557c478bd9Sstevel@tonic-gate     flagline < nflaglines ? flagbuf[flagline++] : "")
31567c478bd9Sstevel@tonic-gate 
31577c478bd9Sstevel@tonic-gate int
31587c478bd9Sstevel@tonic-gate cpuinfo_walk_cpu(uintptr_t addr, const cpu_t *cpu, cpuinfo_data_t *cid)
31597c478bd9Sstevel@tonic-gate {
31607c478bd9Sstevel@tonic-gate 	kthread_t t;
31617c478bd9Sstevel@tonic-gate 	disp_t disp;
31627c478bd9Sstevel@tonic-gate 	proc_t p;
31637c478bd9Sstevel@tonic-gate 	uintptr_t pinned;
31647c478bd9Sstevel@tonic-gate 	char **flagbuf;
31657c478bd9Sstevel@tonic-gate 	int nflaglines = 0, flagline = 0, bspl, rval = WALK_NEXT;
31667c478bd9Sstevel@tonic-gate 
31677c478bd9Sstevel@tonic-gate 	const char *flags[] = {
31687c478bd9Sstevel@tonic-gate 	    "RUNNING", "READY", "QUIESCED", "EXISTS",
31697c478bd9Sstevel@tonic-gate 	    "ENABLE", "OFFLINE", "POWEROFF", "FROZEN",
31707c478bd9Sstevel@tonic-gate 	    "SPARE", "FAULTED", NULL
31717c478bd9Sstevel@tonic-gate 	};
31727c478bd9Sstevel@tonic-gate 
31737c478bd9Sstevel@tonic-gate 	if (cid->cid_cpu != -1) {
31747c478bd9Sstevel@tonic-gate 		if (addr != cid->cid_cpu && cpu->cpu_id != cid->cid_cpu)
31757c478bd9Sstevel@tonic-gate 			return (WALK_NEXT);
31767c478bd9Sstevel@tonic-gate 
31777c478bd9Sstevel@tonic-gate 		/*
31787c478bd9Sstevel@tonic-gate 		 * Set cid_cpu to -1 to indicate that we found a matching CPU.
31797c478bd9Sstevel@tonic-gate 		 */
31807c478bd9Sstevel@tonic-gate 		cid->cid_cpu = -1;
31817c478bd9Sstevel@tonic-gate 		rval = WALK_DONE;
31827c478bd9Sstevel@tonic-gate 	}
31837c478bd9Sstevel@tonic-gate 
31847c478bd9Sstevel@tonic-gate 	if (cid->cid_print_head) {
31857c478bd9Sstevel@tonic-gate 		mdb_printf("%3s %-*s %3s %4s %4s %3s %4s %5s %-6s %-*s %s\n",
31867c478bd9Sstevel@tonic-gate 		    "ID", CPUINFO_CPUWIDTH, "ADDR", "FLG", "NRUN", "BSPL",
31877c478bd9Sstevel@tonic-gate 		    "PRI", "RNRN", "KRNRN", "SWITCH", CPUINFO_TWIDTH, "THREAD",
31887c478bd9Sstevel@tonic-gate 		    "PROC");
31897c478bd9Sstevel@tonic-gate 		cid->cid_print_head = FALSE;
31907c478bd9Sstevel@tonic-gate 	}
31917c478bd9Sstevel@tonic-gate 
31927c478bd9Sstevel@tonic-gate 	bspl = cpu->cpu_base_spl;
31937c478bd9Sstevel@tonic-gate 
31947c478bd9Sstevel@tonic-gate 	if (mdb_vread(&disp, sizeof (disp_t), (uintptr_t)cpu->cpu_disp) == -1) {
31957c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read disp_t at %p", cpu->cpu_disp);
31967c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
31977c478bd9Sstevel@tonic-gate 	}
31987c478bd9Sstevel@tonic-gate 
31997c478bd9Sstevel@tonic-gate 	mdb_printf("%3d %0*p %3x %4d %4d ",
32007c478bd9Sstevel@tonic-gate 	    cpu->cpu_id, CPUINFO_CPUWIDTH, addr, cpu->cpu_flags,
32017c478bd9Sstevel@tonic-gate 	    disp.disp_nrunnable, bspl);
32027c478bd9Sstevel@tonic-gate 
32037c478bd9Sstevel@tonic-gate 	if (mdb_vread(&t, sizeof (t), (uintptr_t)cpu->cpu_thread) != -1) {
32047c478bd9Sstevel@tonic-gate 		mdb_printf("%3d ", t.t_pri);
32057c478bd9Sstevel@tonic-gate 	} else {
32067c478bd9Sstevel@tonic-gate 		mdb_printf("%3s ", "-");
32077c478bd9Sstevel@tonic-gate 	}
32087c478bd9Sstevel@tonic-gate 
32097c478bd9Sstevel@tonic-gate 	mdb_printf("%4s %5s ", cpu->cpu_runrun ? "yes" : "no",
32107c478bd9Sstevel@tonic-gate 	    cpu->cpu_kprunrun ? "yes" : "no");
32117c478bd9Sstevel@tonic-gate 
32127c478bd9Sstevel@tonic-gate 	if (cpu->cpu_last_swtch) {
32137c478bd9Sstevel@tonic-gate 		clock_t lbolt;
32147c478bd9Sstevel@tonic-gate 
32157c478bd9Sstevel@tonic-gate 		if (mdb_vread(&lbolt, sizeof (lbolt), cid->cid_lbolt) == -1) {
32167c478bd9Sstevel@tonic-gate 			mdb_warn("failed to read lbolt at %p", cid->cid_lbolt);
32177c478bd9Sstevel@tonic-gate 			return (WALK_ERR);
32187c478bd9Sstevel@tonic-gate 		}
32197c478bd9Sstevel@tonic-gate 		mdb_printf("t-%-4d ", lbolt - cpu->cpu_last_swtch);
32207c478bd9Sstevel@tonic-gate 	} else {
32217c478bd9Sstevel@tonic-gate 		mdb_printf("%-6s ", "-");
32227c478bd9Sstevel@tonic-gate 	}
32237c478bd9Sstevel@tonic-gate 
32247c478bd9Sstevel@tonic-gate 	mdb_printf("%0*p", CPUINFO_TWIDTH, cpu->cpu_thread);
32257c478bd9Sstevel@tonic-gate 
32267c478bd9Sstevel@tonic-gate 	if (cpu->cpu_thread == cpu->cpu_idle_thread)
32277c478bd9Sstevel@tonic-gate 		mdb_printf(" (idle)\n");
32287c478bd9Sstevel@tonic-gate 	else if (cpu->cpu_thread == NULL)
32297c478bd9Sstevel@tonic-gate 		mdb_printf(" -\n");
32307c478bd9Sstevel@tonic-gate 	else {
32317c478bd9Sstevel@tonic-gate 		if (mdb_vread(&p, sizeof (p), (uintptr_t)t.t_procp) != -1) {
32327c478bd9Sstevel@tonic-gate 			mdb_printf(" %s\n", p.p_user.u_comm);
32337c478bd9Sstevel@tonic-gate 		} else {
32347c478bd9Sstevel@tonic-gate 			mdb_printf(" ?\n");
32357c478bd9Sstevel@tonic-gate 		}
32367c478bd9Sstevel@tonic-gate 	}
32377c478bd9Sstevel@tonic-gate 
32387c478bd9Sstevel@tonic-gate 	flagbuf = mdb_zalloc(sizeof (flags), UM_SLEEP | UM_GC);
32397c478bd9Sstevel@tonic-gate 
32407c478bd9Sstevel@tonic-gate 	if (cid->cid_print_flags) {
32417c478bd9Sstevel@tonic-gate 		int first = 1, i, j, k;
32427c478bd9Sstevel@tonic-gate 		char *s;
32437c478bd9Sstevel@tonic-gate 
32447c478bd9Sstevel@tonic-gate 		cid->cid_print_head = TRUE;
32457c478bd9Sstevel@tonic-gate 
32467c478bd9Sstevel@tonic-gate 		for (i = 1, j = 0; flags[j] != NULL; i <<= 1, j++) {
32477c478bd9Sstevel@tonic-gate 			if (!(cpu->cpu_flags & i))
32487c478bd9Sstevel@tonic-gate 				continue;
32497c478bd9Sstevel@tonic-gate 
32507c478bd9Sstevel@tonic-gate 			if (first) {
32517c478bd9Sstevel@tonic-gate 				s = mdb_alloc(CPUINFO_THRDELT + 1,
32527c478bd9Sstevel@tonic-gate 				    UM_GC | UM_SLEEP);
32537c478bd9Sstevel@tonic-gate 
32547c478bd9Sstevel@tonic-gate 				(void) mdb_snprintf(s, CPUINFO_THRDELT + 1,
32557c478bd9Sstevel@tonic-gate 				    "%*s|%*s", CPUINFO_FLAGDELT, "",
32567c478bd9Sstevel@tonic-gate 				    CPUINFO_THRDELT - 1 - CPUINFO_FLAGDELT, "");
32577c478bd9Sstevel@tonic-gate 				flagbuf[nflaglines++] = s;
32587c478bd9Sstevel@tonic-gate 			}
32597c478bd9Sstevel@tonic-gate 
32607c478bd9Sstevel@tonic-gate 			s = mdb_alloc(CPUINFO_THRDELT + 1, UM_GC | UM_SLEEP);
32617c478bd9Sstevel@tonic-gate 			(void) mdb_snprintf(s, CPUINFO_THRDELT + 1, "%*s%*s %s",
32627c478bd9Sstevel@tonic-gate 			    CPUINFO_IDWIDTH + CPUINFO_CPUWIDTH -
32637c478bd9Sstevel@tonic-gate 			    CPUINFO_FLAGWIDTH, "", CPUINFO_FLAGWIDTH, flags[j],
32647c478bd9Sstevel@tonic-gate 			    first ? "<--+" : "");
32657c478bd9Sstevel@tonic-gate 
32667c478bd9Sstevel@tonic-gate 			for (k = strlen(s); k < CPUINFO_THRDELT; k++)
32677c478bd9Sstevel@tonic-gate 				s[k] = ' ';
32687c478bd9Sstevel@tonic-gate 			s[k] = '\0';
32697c478bd9Sstevel@tonic-gate 
32707c478bd9Sstevel@tonic-gate 			flagbuf[nflaglines++] = s;
32717c478bd9Sstevel@tonic-gate 			first = 0;
32727c478bd9Sstevel@tonic-gate 		}
32737c478bd9Sstevel@tonic-gate 	}
32747c478bd9Sstevel@tonic-gate 
32757c478bd9Sstevel@tonic-gate 	if (cid->cid_print_ithr) {
32767c478bd9Sstevel@tonic-gate 		int i, found_one = FALSE;
32777c478bd9Sstevel@tonic-gate 		int print_thr = disp.disp_nrunnable && cid->cid_print_thr;
32787c478bd9Sstevel@tonic-gate 
32797c478bd9Sstevel@tonic-gate 		for (i = NINTR - 1; i >= 0; i--) {
32807c478bd9Sstevel@tonic-gate 			uintptr_t iaddr = cid->cid_ithr[cpu->cpu_id][i];
32817c478bd9Sstevel@tonic-gate 
32827c478bd9Sstevel@tonic-gate 			if (iaddr == NULL)
32837c478bd9Sstevel@tonic-gate 				continue;
32847c478bd9Sstevel@tonic-gate 
32857c478bd9Sstevel@tonic-gate 			if (!found_one) {
32867c478bd9Sstevel@tonic-gate 				found_one = TRUE;
32877c478bd9Sstevel@tonic-gate 
32887c478bd9Sstevel@tonic-gate 				CPUINFO_INDENT;
32897c478bd9Sstevel@tonic-gate 				mdb_printf("%c%*s|\n", print_thr ? '|' : ' ',
32907c478bd9Sstevel@tonic-gate 				    CPUINFO_ITHRDELT, "");
32917c478bd9Sstevel@tonic-gate 
32927c478bd9Sstevel@tonic-gate 				CPUINFO_INDENT;
32937c478bd9Sstevel@tonic-gate 				mdb_printf("%c%*s+--> %3s %s\n",
32947c478bd9Sstevel@tonic-gate 				    print_thr ? '|' : ' ', CPUINFO_ITHRDELT,
32957c478bd9Sstevel@tonic-gate 				    "", "PIL", "THREAD");
32967c478bd9Sstevel@tonic-gate 			}
32977c478bd9Sstevel@tonic-gate 
32987c478bd9Sstevel@tonic-gate 			if (mdb_vread(&t, sizeof (t), iaddr) == -1) {
32997c478bd9Sstevel@tonic-gate 				mdb_warn("failed to read kthread_t at %p",
33007c478bd9Sstevel@tonic-gate 				    iaddr);
33017c478bd9Sstevel@tonic-gate 				return (WALK_ERR);
33027c478bd9Sstevel@tonic-gate 			}
33037c478bd9Sstevel@tonic-gate 
33047c478bd9Sstevel@tonic-gate 			CPUINFO_INDENT;
33057c478bd9Sstevel@tonic-gate 			mdb_printf("%c%*s     %3d %0*p\n",
33067c478bd9Sstevel@tonic-gate 			    print_thr ? '|' : ' ', CPUINFO_ITHRDELT, "",
33077c478bd9Sstevel@tonic-gate 			    t.t_pil, CPUINFO_TWIDTH, iaddr);
33087c478bd9Sstevel@tonic-gate 
33097c478bd9Sstevel@tonic-gate 			pinned = (uintptr_t)t.t_intr;
33107c478bd9Sstevel@tonic-gate 		}
33117c478bd9Sstevel@tonic-gate 
33127c478bd9Sstevel@tonic-gate 		if (found_one && pinned != NULL) {
33137c478bd9Sstevel@tonic-gate 			cid->cid_print_head = TRUE;
33147c478bd9Sstevel@tonic-gate 			(void) strcpy(p.p_user.u_comm, "?");
33157c478bd9Sstevel@tonic-gate 
33167c478bd9Sstevel@tonic-gate 			if (mdb_vread(&t, sizeof (t),
33177c478bd9Sstevel@tonic-gate 			    (uintptr_t)pinned) == -1) {
33187c478bd9Sstevel@tonic-gate 				mdb_warn("failed to read kthread_t at %p",
33197c478bd9Sstevel@tonic-gate 				    pinned);
33207c478bd9Sstevel@tonic-gate 				return (WALK_ERR);
33217c478bd9Sstevel@tonic-gate 			}
33227c478bd9Sstevel@tonic-gate 			if (mdb_vread(&p, sizeof (p),
33237c478bd9Sstevel@tonic-gate 			    (uintptr_t)t.t_procp) == -1) {
33247c478bd9Sstevel@tonic-gate 				mdb_warn("failed to read proc_t at %p",
33257c478bd9Sstevel@tonic-gate 				    t.t_procp);
33267c478bd9Sstevel@tonic-gate 				return (WALK_ERR);
33277c478bd9Sstevel@tonic-gate 			}
33287c478bd9Sstevel@tonic-gate 
33297c478bd9Sstevel@tonic-gate 			CPUINFO_INDENT;
33307c478bd9Sstevel@tonic-gate 			mdb_printf("%c%*s     %3s %0*p %s\n",
33317c478bd9Sstevel@tonic-gate 			    print_thr ? '|' : ' ', CPUINFO_ITHRDELT, "", "-",
33327c478bd9Sstevel@tonic-gate 			    CPUINFO_TWIDTH, pinned,
33337c478bd9Sstevel@tonic-gate 			    pinned == (uintptr_t)cpu->cpu_idle_thread ?
33347c478bd9Sstevel@tonic-gate 			    "(idle)" : p.p_user.u_comm);
33357c478bd9Sstevel@tonic-gate 		}
33367c478bd9Sstevel@tonic-gate 	}
33377c478bd9Sstevel@tonic-gate 
33387c478bd9Sstevel@tonic-gate 	if (disp.disp_nrunnable && cid->cid_print_thr) {
33397c478bd9Sstevel@tonic-gate 		dispq_t *dq;
33407c478bd9Sstevel@tonic-gate 
33417c478bd9Sstevel@tonic-gate 		int i, npri = disp.disp_npri;
33427c478bd9Sstevel@tonic-gate 
33437c478bd9Sstevel@tonic-gate 		dq = mdb_alloc(sizeof (dispq_t) * npri, UM_SLEEP | UM_GC);
33447c478bd9Sstevel@tonic-gate 
33457c478bd9Sstevel@tonic-gate 		if (mdb_vread(dq, sizeof (dispq_t) * npri,
33467c478bd9Sstevel@tonic-gate 		    (uintptr_t)disp.disp_q) == -1) {
33477c478bd9Sstevel@tonic-gate 			mdb_warn("failed to read dispq_t at %p", disp.disp_q);
33487c478bd9Sstevel@tonic-gate 			return (WALK_ERR);
33497c478bd9Sstevel@tonic-gate 		}
33507c478bd9Sstevel@tonic-gate 
33517c478bd9Sstevel@tonic-gate 		CPUINFO_INDENT;
33527c478bd9Sstevel@tonic-gate 		mdb_printf("|\n");
33537c478bd9Sstevel@tonic-gate 
33547c478bd9Sstevel@tonic-gate 		CPUINFO_INDENT;
33557c478bd9Sstevel@tonic-gate 		mdb_printf("+-->  %3s %-*s %s\n", "PRI",
33567c478bd9Sstevel@tonic-gate 		    CPUINFO_TWIDTH, "THREAD", "PROC");
33577c478bd9Sstevel@tonic-gate 
33587c478bd9Sstevel@tonic-gate 		for (i = npri - 1; i >= 0; i--) {
33597c478bd9Sstevel@tonic-gate 			uintptr_t taddr = (uintptr_t)dq[i].dq_first;
33607c478bd9Sstevel@tonic-gate 
33617c478bd9Sstevel@tonic-gate 			while (taddr != NULL) {
33627c478bd9Sstevel@tonic-gate 				if (mdb_vread(&t, sizeof (t), taddr) == -1) {
33637c478bd9Sstevel@tonic-gate 					mdb_warn("failed to read kthread_t "
33647c478bd9Sstevel@tonic-gate 					    "at %p", taddr);
33657c478bd9Sstevel@tonic-gate 					return (WALK_ERR);
33667c478bd9Sstevel@tonic-gate 				}
33677c478bd9Sstevel@tonic-gate 				if (mdb_vread(&p, sizeof (p),
33687c478bd9Sstevel@tonic-gate 				    (uintptr_t)t.t_procp) == -1) {
33697c478bd9Sstevel@tonic-gate 					mdb_warn("failed to read proc_t at %p",
33707c478bd9Sstevel@tonic-gate 					    t.t_procp);
33717c478bd9Sstevel@tonic-gate 					return (WALK_ERR);
33727c478bd9Sstevel@tonic-gate 				}
33737c478bd9Sstevel@tonic-gate 
33747c478bd9Sstevel@tonic-gate 				CPUINFO_INDENT;
33757c478bd9Sstevel@tonic-gate 				mdb_printf("      %3d %0*p %s\n", t.t_pri,
33767c478bd9Sstevel@tonic-gate 				    CPUINFO_TWIDTH, taddr, p.p_user.u_comm);
33777c478bd9Sstevel@tonic-gate 
33787c478bd9Sstevel@tonic-gate 				taddr = (uintptr_t)t.t_link;
33797c478bd9Sstevel@tonic-gate 			}
33807c478bd9Sstevel@tonic-gate 		}
33817c478bd9Sstevel@tonic-gate 		cid->cid_print_head = TRUE;
33827c478bd9Sstevel@tonic-gate 	}
33837c478bd9Sstevel@tonic-gate 
33847c478bd9Sstevel@tonic-gate 	while (flagline < nflaglines)
33857c478bd9Sstevel@tonic-gate 		mdb_printf("%s\n", flagbuf[flagline++]);
33867c478bd9Sstevel@tonic-gate 
33877c478bd9Sstevel@tonic-gate 	if (cid->cid_print_head)
33887c478bd9Sstevel@tonic-gate 		mdb_printf("\n");
33897c478bd9Sstevel@tonic-gate 
33907c478bd9Sstevel@tonic-gate 	return (rval);
33917c478bd9Sstevel@tonic-gate }
33927c478bd9Sstevel@tonic-gate 
33937c478bd9Sstevel@tonic-gate int
33947c478bd9Sstevel@tonic-gate cpuinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
33957c478bd9Sstevel@tonic-gate {
33967c478bd9Sstevel@tonic-gate 	uint_t verbose = FALSE;
33977c478bd9Sstevel@tonic-gate 	cpuinfo_data_t cid;
33987c478bd9Sstevel@tonic-gate 	GElf_Sym sym;
33997c478bd9Sstevel@tonic-gate 	clock_t lbolt;
34007c478bd9Sstevel@tonic-gate 
34017c478bd9Sstevel@tonic-gate 	cid.cid_print_ithr = FALSE;
34027c478bd9Sstevel@tonic-gate 	cid.cid_print_thr = FALSE;
34037c478bd9Sstevel@tonic-gate 	cid.cid_print_flags = FALSE;
34047c478bd9Sstevel@tonic-gate 	cid.cid_print_head = DCMD_HDRSPEC(flags) ? TRUE : FALSE;
34057c478bd9Sstevel@tonic-gate 	cid.cid_cpu = -1;
34067c478bd9Sstevel@tonic-gate 
34077c478bd9Sstevel@tonic-gate 	if (flags & DCMD_ADDRSPEC)
34087c478bd9Sstevel@tonic-gate 		cid.cid_cpu = addr;
34097c478bd9Sstevel@tonic-gate 
34107c478bd9Sstevel@tonic-gate 	if (mdb_getopts(argc, argv,
34117c478bd9Sstevel@tonic-gate 	    'v', MDB_OPT_SETBITS, TRUE, &verbose, NULL) != argc)
34127c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
34137c478bd9Sstevel@tonic-gate 
34147c478bd9Sstevel@tonic-gate 	if (verbose) {
34157c478bd9Sstevel@tonic-gate 		cid.cid_print_ithr = TRUE;
34167c478bd9Sstevel@tonic-gate 		cid.cid_print_thr = TRUE;
34177c478bd9Sstevel@tonic-gate 		cid.cid_print_flags = TRUE;
34187c478bd9Sstevel@tonic-gate 		cid.cid_print_head = TRUE;
34197c478bd9Sstevel@tonic-gate 	}
34207c478bd9Sstevel@tonic-gate 
34217c478bd9Sstevel@tonic-gate 	if (cid.cid_print_ithr) {
34227c478bd9Sstevel@tonic-gate 		int i;
34237c478bd9Sstevel@tonic-gate 
34247c478bd9Sstevel@tonic-gate 		cid.cid_ithr = mdb_alloc(sizeof (uintptr_t **)
34257c478bd9Sstevel@tonic-gate 		    * NCPU, UM_SLEEP | UM_GC);
34267c478bd9Sstevel@tonic-gate 
34277c478bd9Sstevel@tonic-gate 		for (i = 0; i < NCPU; i++)
34287c478bd9Sstevel@tonic-gate 			cid.cid_ithr[i] = mdb_zalloc(sizeof (uintptr_t *) *
34297c478bd9Sstevel@tonic-gate 			    NINTR, UM_SLEEP | UM_GC);
34307c478bd9Sstevel@tonic-gate 
34317c478bd9Sstevel@tonic-gate 		if (mdb_walk("thread", (mdb_walk_cb_t)cpuinfo_walk_ithread,
34327c478bd9Sstevel@tonic-gate 		    &cid) == -1) {
34337c478bd9Sstevel@tonic-gate 			mdb_warn("couldn't walk thread");
34347c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
34357c478bd9Sstevel@tonic-gate 		}
34367c478bd9Sstevel@tonic-gate 	}
34377c478bd9Sstevel@tonic-gate 
34387c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_name("panic_lbolt", &sym) == -1) {
34397c478bd9Sstevel@tonic-gate 		mdb_warn("failed to find panic_lbolt");
34407c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
34417c478bd9Sstevel@tonic-gate 	}
34427c478bd9Sstevel@tonic-gate 
34437c478bd9Sstevel@tonic-gate 	cid.cid_lbolt = (uintptr_t)sym.st_value;
34447c478bd9Sstevel@tonic-gate 
34457c478bd9Sstevel@tonic-gate 	if (mdb_vread(&lbolt, sizeof (lbolt), cid.cid_lbolt) == -1) {
34467c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read panic_lbolt");
34477c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
34487c478bd9Sstevel@tonic-gate 	}
34497c478bd9Sstevel@tonic-gate 
34507c478bd9Sstevel@tonic-gate 	if (lbolt == 0) {
34517c478bd9Sstevel@tonic-gate 		if (mdb_lookup_by_name("lbolt", &sym) == -1) {
34527c478bd9Sstevel@tonic-gate 			mdb_warn("failed to find lbolt");
34537c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
34547c478bd9Sstevel@tonic-gate 		}
34557c478bd9Sstevel@tonic-gate 		cid.cid_lbolt = (uintptr_t)sym.st_value;
34567c478bd9Sstevel@tonic-gate 	}
34577c478bd9Sstevel@tonic-gate 
34587c478bd9Sstevel@tonic-gate 	if (mdb_walk("cpu", (mdb_walk_cb_t)cpuinfo_walk_cpu, &cid) == -1) {
34597c478bd9Sstevel@tonic-gate 		mdb_warn("can't walk cpus");
34607c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
34617c478bd9Sstevel@tonic-gate 	}
34627c478bd9Sstevel@tonic-gate 
34637c478bd9Sstevel@tonic-gate 	if (cid.cid_cpu != -1) {
34647c478bd9Sstevel@tonic-gate 		/*
34657c478bd9Sstevel@tonic-gate 		 * We didn't find this CPU when we walked through the CPUs
34667c478bd9Sstevel@tonic-gate 		 * (i.e. the address specified doesn't show up in the "cpu"
34677c478bd9Sstevel@tonic-gate 		 * walk).  However, the specified address may still correspond
34687c478bd9Sstevel@tonic-gate 		 * to a valid cpu_t (for example, if the specified address is
34697c478bd9Sstevel@tonic-gate 		 * the actual panicking cpu_t and not the cached panic_cpu).
34707c478bd9Sstevel@tonic-gate 		 * Point is:  even if we didn't find it, we still want to try
34717c478bd9Sstevel@tonic-gate 		 * to print the specified address as a cpu_t.
34727c478bd9Sstevel@tonic-gate 		 */
34737c478bd9Sstevel@tonic-gate 		cpu_t cpu;
34747c478bd9Sstevel@tonic-gate 
34757c478bd9Sstevel@tonic-gate 		if (mdb_vread(&cpu, sizeof (cpu), cid.cid_cpu) == -1) {
34767c478bd9Sstevel@tonic-gate 			mdb_warn("%p is neither a valid CPU ID nor a "
34777c478bd9Sstevel@tonic-gate 			    "valid cpu_t address\n", cid.cid_cpu);
34787c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
34797c478bd9Sstevel@tonic-gate 		}
34807c478bd9Sstevel@tonic-gate 
34817c478bd9Sstevel@tonic-gate 		(void) cpuinfo_walk_cpu(cid.cid_cpu, &cpu, &cid);
34827c478bd9Sstevel@tonic-gate 	}
34837c478bd9Sstevel@tonic-gate 
34847c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
34857c478bd9Sstevel@tonic-gate }
34867c478bd9Sstevel@tonic-gate 
34877c478bd9Sstevel@tonic-gate /*ARGSUSED*/
34887c478bd9Sstevel@tonic-gate int
34897c478bd9Sstevel@tonic-gate flipone(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
34907c478bd9Sstevel@tonic-gate {
34917c478bd9Sstevel@tonic-gate 	int i;
34927c478bd9Sstevel@tonic-gate 
34937c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC))
34947c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
34957c478bd9Sstevel@tonic-gate 
34967c478bd9Sstevel@tonic-gate 	for (i = 0; i < sizeof (addr) * NBBY; i++)
34977c478bd9Sstevel@tonic-gate 		mdb_printf("%p\n", addr ^ (1UL << i));
34987c478bd9Sstevel@tonic-gate 
34997c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
35007c478bd9Sstevel@tonic-gate }
35017c478bd9Sstevel@tonic-gate 
35027c478bd9Sstevel@tonic-gate /*
35037c478bd9Sstevel@tonic-gate  * Grumble, grumble.
35047c478bd9Sstevel@tonic-gate  */
35057c478bd9Sstevel@tonic-gate #define	SMAP_HASHFUNC(vp, off)	\
35067c478bd9Sstevel@tonic-gate 	((((uintptr_t)(vp) >> 6) + ((uintptr_t)(vp) >> 3) + \
35077c478bd9Sstevel@tonic-gate 	((off) >> MAXBSHIFT)) & smd_hashmsk)
35087c478bd9Sstevel@tonic-gate 
35097c478bd9Sstevel@tonic-gate int
35107c478bd9Sstevel@tonic-gate vnode2smap(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
35117c478bd9Sstevel@tonic-gate {
35127c478bd9Sstevel@tonic-gate 	long smd_hashmsk;
35137c478bd9Sstevel@tonic-gate 	int hash;
35147c478bd9Sstevel@tonic-gate 	uintptr_t offset = 0;
35157c478bd9Sstevel@tonic-gate 	struct smap smp;
35167c478bd9Sstevel@tonic-gate 	uintptr_t saddr, kaddr;
35177c478bd9Sstevel@tonic-gate 	uintptr_t smd_hash, smd_smap;
35187c478bd9Sstevel@tonic-gate 	struct seg seg;
35197c478bd9Sstevel@tonic-gate 
35207c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC))
35217c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
35227c478bd9Sstevel@tonic-gate 
35237c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&smd_hashmsk, "smd_hashmsk") == -1) {
35247c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read smd_hashmsk");
35257c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
35267c478bd9Sstevel@tonic-gate 	}
35277c478bd9Sstevel@tonic-gate 
35287c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&smd_hash, "smd_hash") == -1) {
35297c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read smd_hash");
35307c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
35317c478bd9Sstevel@tonic-gate 	}
35327c478bd9Sstevel@tonic-gate 
35337c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&smd_smap, "smd_smap") == -1) {
35347c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read smd_hash");
35357c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
35367c478bd9Sstevel@tonic-gate 	}
35377c478bd9Sstevel@tonic-gate 
35387c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&kaddr, "segkmap") == -1) {
35397c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read segkmap");
35407c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
35417c478bd9Sstevel@tonic-gate 	}
35427c478bd9Sstevel@tonic-gate 
35437c478bd9Sstevel@tonic-gate 	if (mdb_vread(&seg, sizeof (seg), kaddr) == -1) {
35447c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read segkmap at %p", kaddr);
35457c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
35467c478bd9Sstevel@tonic-gate 	}
35477c478bd9Sstevel@tonic-gate 
35487c478bd9Sstevel@tonic-gate 	if (argc != 0) {
35497c478bd9Sstevel@tonic-gate 		const mdb_arg_t *arg = &argv[0];
35507c478bd9Sstevel@tonic-gate 
35517c478bd9Sstevel@tonic-gate 		if (arg->a_type == MDB_TYPE_IMMEDIATE)
35527c478bd9Sstevel@tonic-gate 			offset = arg->a_un.a_val;
35537c478bd9Sstevel@tonic-gate 		else
35547c478bd9Sstevel@tonic-gate 			offset = (uintptr_t)mdb_strtoull(arg->a_un.a_str);
35557c478bd9Sstevel@tonic-gate 	}
35567c478bd9Sstevel@tonic-gate 
35577c478bd9Sstevel@tonic-gate 	hash = SMAP_HASHFUNC(addr, offset);
35587c478bd9Sstevel@tonic-gate 
35597c478bd9Sstevel@tonic-gate 	if (mdb_vread(&saddr, sizeof (saddr),
35607c478bd9Sstevel@tonic-gate 	    smd_hash + hash * sizeof (uintptr_t)) == -1) {
35617c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't read smap at %p",
35627c478bd9Sstevel@tonic-gate 		    smd_hash + hash * sizeof (uintptr_t));
35637c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
35647c478bd9Sstevel@tonic-gate 	}
35657c478bd9Sstevel@tonic-gate 
35667c478bd9Sstevel@tonic-gate 	do {
35677c478bd9Sstevel@tonic-gate 		if (mdb_vread(&smp, sizeof (smp), saddr) == -1) {
35687c478bd9Sstevel@tonic-gate 			mdb_warn("couldn't read smap at %p", saddr);
35697c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
35707c478bd9Sstevel@tonic-gate 		}
35717c478bd9Sstevel@tonic-gate 
35727c478bd9Sstevel@tonic-gate 		if ((uintptr_t)smp.sm_vp == addr && smp.sm_off == offset) {
35737c478bd9Sstevel@tonic-gate 			mdb_printf("vnode %p, offs %p is smap %p, vaddr %p\n",
35747c478bd9Sstevel@tonic-gate 			    addr, offset, saddr, ((saddr - smd_smap) /
35757c478bd9Sstevel@tonic-gate 			    sizeof (smp)) * MAXBSIZE + seg.s_base);
35767c478bd9Sstevel@tonic-gate 			return (DCMD_OK);
35777c478bd9Sstevel@tonic-gate 		}
35787c478bd9Sstevel@tonic-gate 
35797c478bd9Sstevel@tonic-gate 		saddr = (uintptr_t)smp.sm_hash;
35807c478bd9Sstevel@tonic-gate 	} while (saddr != NULL);
35817c478bd9Sstevel@tonic-gate 
35827c478bd9Sstevel@tonic-gate 	mdb_printf("no smap for vnode %p, offs %p\n", addr, offset);
35837c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
35847c478bd9Sstevel@tonic-gate }
35857c478bd9Sstevel@tonic-gate 
35867c478bd9Sstevel@tonic-gate /*ARGSUSED*/
35877c478bd9Sstevel@tonic-gate int
35887c478bd9Sstevel@tonic-gate addr2smap(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
35897c478bd9Sstevel@tonic-gate {
35907c478bd9Sstevel@tonic-gate 	uintptr_t kaddr;
35917c478bd9Sstevel@tonic-gate 	struct seg seg;
35927c478bd9Sstevel@tonic-gate 	struct segmap_data sd;
35937c478bd9Sstevel@tonic-gate 
35947c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC))
35957c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
35967c478bd9Sstevel@tonic-gate 
35977c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&kaddr, "segkmap") == -1) {
35987c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read segkmap");
35997c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
36007c478bd9Sstevel@tonic-gate 	}
36017c478bd9Sstevel@tonic-gate 
36027c478bd9Sstevel@tonic-gate 	if (mdb_vread(&seg, sizeof (seg), kaddr) == -1) {
36037c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read segkmap at %p", kaddr);
36047c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
36057c478bd9Sstevel@tonic-gate 	}
36067c478bd9Sstevel@tonic-gate 
36077c478bd9Sstevel@tonic-gate 	if (mdb_vread(&sd, sizeof (sd), (uintptr_t)seg.s_data) == -1) {
36087c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read segmap_data at %p", seg.s_data);
36097c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
36107c478bd9Sstevel@tonic-gate 	}
36117c478bd9Sstevel@tonic-gate 
36127c478bd9Sstevel@tonic-gate 	mdb_printf("%p is smap %p\n", addr,
36137c478bd9Sstevel@tonic-gate 	    ((addr - (uintptr_t)seg.s_base) >> MAXBSHIFT) *
36147c478bd9Sstevel@tonic-gate 	    sizeof (struct smap) + (uintptr_t)sd.smd_sm);
36157c478bd9Sstevel@tonic-gate 
36167c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
36177c478bd9Sstevel@tonic-gate }
36187c478bd9Sstevel@tonic-gate 
36197c478bd9Sstevel@tonic-gate int
36207c478bd9Sstevel@tonic-gate as2proc_walk(uintptr_t addr, const proc_t *p, struct as **asp)
36217c478bd9Sstevel@tonic-gate {
36227c478bd9Sstevel@tonic-gate 	if (p->p_as == *asp)
36237c478bd9Sstevel@tonic-gate 		mdb_printf("%p\n", addr);
36247c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
36257c478bd9Sstevel@tonic-gate }
36267c478bd9Sstevel@tonic-gate 
36277c478bd9Sstevel@tonic-gate /*ARGSUSED*/
36287c478bd9Sstevel@tonic-gate int
36297c478bd9Sstevel@tonic-gate as2proc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
36307c478bd9Sstevel@tonic-gate {
36317c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC) || argc != 0)
36327c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
36337c478bd9Sstevel@tonic-gate 
36347c478bd9Sstevel@tonic-gate 	if (mdb_walk("proc", (mdb_walk_cb_t)as2proc_walk, &addr) == -1) {
36357c478bd9Sstevel@tonic-gate 		mdb_warn("failed to walk proc");
36367c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
36377c478bd9Sstevel@tonic-gate 	}
36387c478bd9Sstevel@tonic-gate 
36397c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
36407c478bd9Sstevel@tonic-gate }
36417c478bd9Sstevel@tonic-gate 
36427c478bd9Sstevel@tonic-gate /*ARGSUSED*/
36437c478bd9Sstevel@tonic-gate int
36447c478bd9Sstevel@tonic-gate ptree_walk(uintptr_t addr, const proc_t *p, void *ignored)
36457c478bd9Sstevel@tonic-gate {
36467c478bd9Sstevel@tonic-gate 	proc_t parent;
36477c478bd9Sstevel@tonic-gate 	int ident = 0;
36487c478bd9Sstevel@tonic-gate 	uintptr_t paddr;
36497c478bd9Sstevel@tonic-gate 
36507c478bd9Sstevel@tonic-gate 	for (paddr = (uintptr_t)p->p_parent; paddr != NULL; ident += 5) {
36517c478bd9Sstevel@tonic-gate 		mdb_vread(&parent, sizeof (parent), paddr);
36527c478bd9Sstevel@tonic-gate 		paddr = (uintptr_t)parent.p_parent;
36537c478bd9Sstevel@tonic-gate 	}
36547c478bd9Sstevel@tonic-gate 
36557c478bd9Sstevel@tonic-gate 	mdb_inc_indent(ident);
36567c478bd9Sstevel@tonic-gate 	mdb_printf("%0?p  %s\n", addr, p->p_user.u_comm);
36577c478bd9Sstevel@tonic-gate 	mdb_dec_indent(ident);
36587c478bd9Sstevel@tonic-gate 
36597c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
36607c478bd9Sstevel@tonic-gate }
36617c478bd9Sstevel@tonic-gate 
36627c478bd9Sstevel@tonic-gate void
36637c478bd9Sstevel@tonic-gate ptree_ancestors(uintptr_t addr, uintptr_t start)
36647c478bd9Sstevel@tonic-gate {
36657c478bd9Sstevel@tonic-gate 	proc_t p;
36667c478bd9Sstevel@tonic-gate 
36677c478bd9Sstevel@tonic-gate 	if (mdb_vread(&p, sizeof (p), addr) == -1) {
36687c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't read ancestor at %p", addr);
36697c478bd9Sstevel@tonic-gate 		return;
36707c478bd9Sstevel@tonic-gate 	}
36717c478bd9Sstevel@tonic-gate 
36727c478bd9Sstevel@tonic-gate 	if (p.p_parent != NULL)
36737c478bd9Sstevel@tonic-gate 		ptree_ancestors((uintptr_t)p.p_parent, start);
36747c478bd9Sstevel@tonic-gate 
36757c478bd9Sstevel@tonic-gate 	if (addr != start)
36767c478bd9Sstevel@tonic-gate 		(void) ptree_walk(addr, &p, NULL);
36777c478bd9Sstevel@tonic-gate }
36787c478bd9Sstevel@tonic-gate 
36797c478bd9Sstevel@tonic-gate /*ARGSUSED*/
36807c478bd9Sstevel@tonic-gate int
36817c478bd9Sstevel@tonic-gate ptree(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
36827c478bd9Sstevel@tonic-gate {
36837c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC))
36847c478bd9Sstevel@tonic-gate 		addr = NULL;
36857c478bd9Sstevel@tonic-gate 	else
36867c478bd9Sstevel@tonic-gate 		ptree_ancestors(addr, addr);
36877c478bd9Sstevel@tonic-gate 
36887c478bd9Sstevel@tonic-gate 	if (mdb_pwalk("proc", (mdb_walk_cb_t)ptree_walk, NULL, addr) == -1) {
36897c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't walk 'proc'");
36907c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
36917c478bd9Sstevel@tonic-gate 	}
36927c478bd9Sstevel@tonic-gate 
36937c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
36947c478bd9Sstevel@tonic-gate }
36957c478bd9Sstevel@tonic-gate 
36967c478bd9Sstevel@tonic-gate /*ARGSUSED*/
36977c478bd9Sstevel@tonic-gate static int
36987c478bd9Sstevel@tonic-gate fd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
36997c478bd9Sstevel@tonic-gate {
37007c478bd9Sstevel@tonic-gate 	int fdnum;
37017c478bd9Sstevel@tonic-gate 	const mdb_arg_t *argp = &argv[0];
37027c478bd9Sstevel@tonic-gate 	proc_t p;
37037c478bd9Sstevel@tonic-gate 	uf_entry_t uf;
37047c478bd9Sstevel@tonic-gate 
37057c478bd9Sstevel@tonic-gate 	if ((flags & DCMD_ADDRSPEC) == 0) {
37067c478bd9Sstevel@tonic-gate 		mdb_warn("fd doesn't give global information\n");
37077c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
37087c478bd9Sstevel@tonic-gate 	}
37097c478bd9Sstevel@tonic-gate 	if (argc != 1)
37107c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
37117c478bd9Sstevel@tonic-gate 
37127c478bd9Sstevel@tonic-gate 	if (argp->a_type == MDB_TYPE_IMMEDIATE)
37137c478bd9Sstevel@tonic-gate 		fdnum = argp->a_un.a_val;
37147c478bd9Sstevel@tonic-gate 	else
37157c478bd9Sstevel@tonic-gate 		fdnum = mdb_strtoull(argp->a_un.a_str);
37167c478bd9Sstevel@tonic-gate 
37177c478bd9Sstevel@tonic-gate 	if (mdb_vread(&p, sizeof (struct proc), addr) == -1) {
37187c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't read proc_t at %p", addr);
37197c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
37207c478bd9Sstevel@tonic-gate 	}
37217c478bd9Sstevel@tonic-gate 	if (fdnum > p.p_user.u_finfo.fi_nfiles) {
37227c478bd9Sstevel@tonic-gate 		mdb_warn("process %p only has %d files open.\n",
37237c478bd9Sstevel@tonic-gate 		    addr, p.p_user.u_finfo.fi_nfiles);
37247c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
37257c478bd9Sstevel@tonic-gate 	}
37267c478bd9Sstevel@tonic-gate 	if (mdb_vread(&uf, sizeof (uf_entry_t),
37277c478bd9Sstevel@tonic-gate 	    (uintptr_t)&p.p_user.u_finfo.fi_list[fdnum]) == -1) {
37287c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't read uf_entry_t at %p",
37297c478bd9Sstevel@tonic-gate 		    &p.p_user.u_finfo.fi_list[fdnum]);
37307c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
37317c478bd9Sstevel@tonic-gate 	}
37327c478bd9Sstevel@tonic-gate 
37337c478bd9Sstevel@tonic-gate 	mdb_printf("%p\n", uf.uf_file);
37347c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
37357c478bd9Sstevel@tonic-gate }
37367c478bd9Sstevel@tonic-gate 
37377c478bd9Sstevel@tonic-gate /*ARGSUSED*/
37387c478bd9Sstevel@tonic-gate static int
37397c478bd9Sstevel@tonic-gate pid2proc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
37407c478bd9Sstevel@tonic-gate {
37417c478bd9Sstevel@tonic-gate 	pid_t pid = (pid_t)addr;
37427c478bd9Sstevel@tonic-gate 
37437c478bd9Sstevel@tonic-gate 	if (argc != 0)
37447c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
37457c478bd9Sstevel@tonic-gate 
37467c478bd9Sstevel@tonic-gate 	if ((addr = mdb_pid2proc(pid, NULL)) == NULL) {
37477c478bd9Sstevel@tonic-gate 		mdb_warn("PID 0t%d not found\n", pid);
37487c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
37497c478bd9Sstevel@tonic-gate 	}
37507c478bd9Sstevel@tonic-gate 
37517c478bd9Sstevel@tonic-gate 	mdb_printf("%p\n", addr);
37527c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
37537c478bd9Sstevel@tonic-gate }
37547c478bd9Sstevel@tonic-gate 
37557c478bd9Sstevel@tonic-gate static char *sysfile_cmd[] = {
37567c478bd9Sstevel@tonic-gate 	"exclude:",
37577c478bd9Sstevel@tonic-gate 	"include:",
37587c478bd9Sstevel@tonic-gate 	"forceload:",
37597c478bd9Sstevel@tonic-gate 	"rootdev:",
37607c478bd9Sstevel@tonic-gate 	"rootfs:",
37617c478bd9Sstevel@tonic-gate 	"swapdev:",
37627c478bd9Sstevel@tonic-gate 	"swapfs:",
37637c478bd9Sstevel@tonic-gate 	"moddir:",
37647c478bd9Sstevel@tonic-gate 	"set",
37657c478bd9Sstevel@tonic-gate 	"unknown",
37667c478bd9Sstevel@tonic-gate };
37677c478bd9Sstevel@tonic-gate 
37687c478bd9Sstevel@tonic-gate static char *sysfile_ops[] = { "", "=", "&", "|" };
37697c478bd9Sstevel@tonic-gate 
37707c478bd9Sstevel@tonic-gate /*ARGSUSED*/
37717c478bd9Sstevel@tonic-gate static int
37727c478bd9Sstevel@tonic-gate sysfile_vmem_seg(uintptr_t addr, const vmem_seg_t *vsp, void **target)
37737c478bd9Sstevel@tonic-gate {
37747c478bd9Sstevel@tonic-gate 	if (vsp->vs_type == VMEM_ALLOC && (void *)vsp->vs_start == *target) {
37757c478bd9Sstevel@tonic-gate 		*target = NULL;
37767c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
37777c478bd9Sstevel@tonic-gate 	}
37787c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
37797c478bd9Sstevel@tonic-gate }
37807c478bd9Sstevel@tonic-gate 
37817c478bd9Sstevel@tonic-gate /*ARGSUSED*/
37827c478bd9Sstevel@tonic-gate static int
37837c478bd9Sstevel@tonic-gate sysfile(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
37847c478bd9Sstevel@tonic-gate {
37857c478bd9Sstevel@tonic-gate 	struct sysparam *sysp, sys;
37867c478bd9Sstevel@tonic-gate 	char var[256];
37877c478bd9Sstevel@tonic-gate 	char modname[256];
37887c478bd9Sstevel@tonic-gate 	char val[256];
37897c478bd9Sstevel@tonic-gate 	char strval[256];
37907c478bd9Sstevel@tonic-gate 	vmem_t *mod_sysfile_arena;
37917c478bd9Sstevel@tonic-gate 	void *straddr;
37927c478bd9Sstevel@tonic-gate 
37937c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&sysp, "sysparam_hd") == -1) {
37947c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read sysparam_hd");
37957c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
37967c478bd9Sstevel@tonic-gate 	}
37977c478bd9Sstevel@tonic-gate 
37987c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&mod_sysfile_arena, "mod_sysfile_arena") == -1) {
37997c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read mod_sysfile_arena");
38007c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
38017c478bd9Sstevel@tonic-gate 	}
38027c478bd9Sstevel@tonic-gate 
38037c478bd9Sstevel@tonic-gate 	while (sysp != NULL) {
38047c478bd9Sstevel@tonic-gate 		var[0] = '\0';
38057c478bd9Sstevel@tonic-gate 		val[0] = '\0';
38067c478bd9Sstevel@tonic-gate 		modname[0] = '\0';
38077c478bd9Sstevel@tonic-gate 		if (mdb_vread(&sys, sizeof (sys), (uintptr_t)sysp) == -1) {
38087c478bd9Sstevel@tonic-gate 			mdb_warn("couldn't read sysparam %p", sysp);
38097c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
38107c478bd9Sstevel@tonic-gate 		}
38117c478bd9Sstevel@tonic-gate 		if (sys.sys_modnam != NULL &&
38127c478bd9Sstevel@tonic-gate 		    mdb_readstr(modname, 256,
38137c478bd9Sstevel@tonic-gate 		    (uintptr_t)sys.sys_modnam) == -1) {
38147c478bd9Sstevel@tonic-gate 			mdb_warn("couldn't read modname in %p", sysp);
38157c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
38167c478bd9Sstevel@tonic-gate 		}
38177c478bd9Sstevel@tonic-gate 		if (sys.sys_ptr != NULL &&
38187c478bd9Sstevel@tonic-gate 		    mdb_readstr(var, 256, (uintptr_t)sys.sys_ptr) == -1) {
38197c478bd9Sstevel@tonic-gate 			mdb_warn("couldn't read ptr in %p", sysp);
38207c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
38217c478bd9Sstevel@tonic-gate 		}
38227c478bd9Sstevel@tonic-gate 		if (sys.sys_op != SETOP_NONE) {
38237c478bd9Sstevel@tonic-gate 			/*
38247c478bd9Sstevel@tonic-gate 			 * Is this an int or a string?  We determine this
38257c478bd9Sstevel@tonic-gate 			 * by checking whether straddr is contained in
38267c478bd9Sstevel@tonic-gate 			 * mod_sysfile_arena.  If so, the walker will set
38277c478bd9Sstevel@tonic-gate 			 * straddr to NULL.
38287c478bd9Sstevel@tonic-gate 			 */
38297c478bd9Sstevel@tonic-gate 			straddr = (void *)(uintptr_t)sys.sys_info;
38307c478bd9Sstevel@tonic-gate 			if (sys.sys_op == SETOP_ASSIGN &&
38317c478bd9Sstevel@tonic-gate 			    sys.sys_info != 0 &&
38327c478bd9Sstevel@tonic-gate 			    mdb_pwalk("vmem_seg",
38337c478bd9Sstevel@tonic-gate 			    (mdb_walk_cb_t)sysfile_vmem_seg, &straddr,
38347c478bd9Sstevel@tonic-gate 			    (uintptr_t)mod_sysfile_arena) == 0 &&
38357c478bd9Sstevel@tonic-gate 			    straddr == NULL &&
38367c478bd9Sstevel@tonic-gate 			    mdb_readstr(strval, 256,
38377c478bd9Sstevel@tonic-gate 			    (uintptr_t)sys.sys_info) != -1) {
38387c478bd9Sstevel@tonic-gate 				(void) mdb_snprintf(val, sizeof (val), "\"%s\"",
38397c478bd9Sstevel@tonic-gate 				    strval);
38407c478bd9Sstevel@tonic-gate 			} else {
38417c478bd9Sstevel@tonic-gate 				(void) mdb_snprintf(val, sizeof (val),
38427c478bd9Sstevel@tonic-gate 				    "0x%llx [0t%llu]", sys.sys_info,
38437c478bd9Sstevel@tonic-gate 				    sys.sys_info);
38447c478bd9Sstevel@tonic-gate 			}
38457c478bd9Sstevel@tonic-gate 		}
38467c478bd9Sstevel@tonic-gate 		mdb_printf("%s %s%s%s%s%s\n", sysfile_cmd[sys.sys_type],
38477c478bd9Sstevel@tonic-gate 		    modname, modname[0] == '\0' ? "" : ":",
38487c478bd9Sstevel@tonic-gate 		    var, sysfile_ops[sys.sys_op], val);
38497c478bd9Sstevel@tonic-gate 
38507c478bd9Sstevel@tonic-gate 		sysp = sys.sys_next;
38517c478bd9Sstevel@tonic-gate 	}
38527c478bd9Sstevel@tonic-gate 
38537c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
38547c478bd9Sstevel@tonic-gate }
38557c478bd9Sstevel@tonic-gate 
38567c478bd9Sstevel@tonic-gate /*
38577c478bd9Sstevel@tonic-gate  * Dump a taskq_ent_t given its address.
38587c478bd9Sstevel@tonic-gate  */
38597c478bd9Sstevel@tonic-gate /*ARGSUSED*/
38607c478bd9Sstevel@tonic-gate int
38617c478bd9Sstevel@tonic-gate taskq_ent(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
38627c478bd9Sstevel@tonic-gate {
38637c478bd9Sstevel@tonic-gate 	taskq_ent_t	taskq_ent;
38647c478bd9Sstevel@tonic-gate 	GElf_Sym	sym;
38657c478bd9Sstevel@tonic-gate 	char		buf[MDB_SYM_NAMLEN+1];
38667c478bd9Sstevel@tonic-gate 
38677c478bd9Sstevel@tonic-gate 
38687c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC)) {
38697c478bd9Sstevel@tonic-gate 		mdb_warn("expected explicit taskq_ent_t address before ::\n");
38707c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
38717c478bd9Sstevel@tonic-gate 	}
38727c478bd9Sstevel@tonic-gate 
38737c478bd9Sstevel@tonic-gate 	if (mdb_vread(&taskq_ent, sizeof (taskq_ent_t), addr) == -1) {
38747c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read taskq_ent_t at %p", addr);
38757c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
38767c478bd9Sstevel@tonic-gate 	}
38777c478bd9Sstevel@tonic-gate 
38787c478bd9Sstevel@tonic-gate 	if (DCMD_HDRSPEC(flags)) {
38797c478bd9Sstevel@tonic-gate 		mdb_printf("%<u>%-?s    %-?s    %-s%</u>\n",
38807c478bd9Sstevel@tonic-gate 		"ENTRY", "ARG", "FUNCTION");
38817c478bd9Sstevel@tonic-gate 	}
38827c478bd9Sstevel@tonic-gate 
38837c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_addr((uintptr_t)taskq_ent.tqent_func, MDB_SYM_EXACT,
38847c478bd9Sstevel@tonic-gate 	    buf, sizeof (buf), &sym) == -1) {
38857c478bd9Sstevel@tonic-gate 		(void) strcpy(buf, "????");
38867c478bd9Sstevel@tonic-gate 	}
38877c478bd9Sstevel@tonic-gate 
38887c478bd9Sstevel@tonic-gate 	mdb_printf("%-?p    %-?p    %s\n", addr, taskq_ent.tqent_arg, buf);
38897c478bd9Sstevel@tonic-gate 
38907c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
38917c478bd9Sstevel@tonic-gate }
38927c478bd9Sstevel@tonic-gate 
38937c478bd9Sstevel@tonic-gate /*
38947c478bd9Sstevel@tonic-gate  * Given the address of the (taskq_t) task queue head, walk the queue listing
38957c478bd9Sstevel@tonic-gate  * the address of every taskq_ent_t.
38967c478bd9Sstevel@tonic-gate  */
38977c478bd9Sstevel@tonic-gate int
38987c478bd9Sstevel@tonic-gate taskq_walk_init(mdb_walk_state_t *wsp)
38997c478bd9Sstevel@tonic-gate {
39007c478bd9Sstevel@tonic-gate 	taskq_t	tq_head;
39017c478bd9Sstevel@tonic-gate 
39027c478bd9Sstevel@tonic-gate 
39037c478bd9Sstevel@tonic-gate 	if (wsp->walk_addr == NULL) {
39047c478bd9Sstevel@tonic-gate 		mdb_warn("start address required\n");
39057c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
39067c478bd9Sstevel@tonic-gate 	}
39077c478bd9Sstevel@tonic-gate 
39087c478bd9Sstevel@tonic-gate 
39097c478bd9Sstevel@tonic-gate 	/*
39107c478bd9Sstevel@tonic-gate 	 * Save the address of the list head entry.  This terminates the list.
39117c478bd9Sstevel@tonic-gate 	 */
39127c478bd9Sstevel@tonic-gate 	wsp->walk_data = (void *)
39137c478bd9Sstevel@tonic-gate 	    ((size_t)wsp->walk_addr + offsetof(taskq_t, tq_task));
39147c478bd9Sstevel@tonic-gate 
39157c478bd9Sstevel@tonic-gate 
39167c478bd9Sstevel@tonic-gate 	/*
39177c478bd9Sstevel@tonic-gate 	 * Read in taskq head, set walk_addr to point to first taskq_ent_t.
39187c478bd9Sstevel@tonic-gate 	 */
39197c478bd9Sstevel@tonic-gate 	if (mdb_vread((void *)&tq_head, sizeof (taskq_t), wsp->walk_addr) ==
39207c478bd9Sstevel@tonic-gate 	    -1) {
39217c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read taskq list head at %p",
39227c478bd9Sstevel@tonic-gate 		    wsp->walk_addr);
39237c478bd9Sstevel@tonic-gate 	}
39247c478bd9Sstevel@tonic-gate 	wsp->walk_addr = (uintptr_t)tq_head.tq_task.tqent_next;
39257c478bd9Sstevel@tonic-gate 
39267c478bd9Sstevel@tonic-gate 
39277c478bd9Sstevel@tonic-gate 	/*
39287c478bd9Sstevel@tonic-gate 	 * Check for null list (next=head)
39297c478bd9Sstevel@tonic-gate 	 */
39307c478bd9Sstevel@tonic-gate 	if (wsp->walk_addr == (uintptr_t)wsp->walk_data) {
39317c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
39327c478bd9Sstevel@tonic-gate 	}
39337c478bd9Sstevel@tonic-gate 
39347c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
39357c478bd9Sstevel@tonic-gate }
39367c478bd9Sstevel@tonic-gate 
39377c478bd9Sstevel@tonic-gate 
39387c478bd9Sstevel@tonic-gate int
39397c478bd9Sstevel@tonic-gate taskq_walk_step(mdb_walk_state_t *wsp)
39407c478bd9Sstevel@tonic-gate {
39417c478bd9Sstevel@tonic-gate 	taskq_ent_t	tq_ent;
39427c478bd9Sstevel@tonic-gate 	int		status;
39437c478bd9Sstevel@tonic-gate 
39447c478bd9Sstevel@tonic-gate 
39457c478bd9Sstevel@tonic-gate 	if (mdb_vread((void *)&tq_ent, sizeof (taskq_ent_t), wsp->walk_addr) ==
39467c478bd9Sstevel@tonic-gate 	    -1) {
39477c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read taskq_ent_t at %p", wsp->walk_addr);
39487c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
39497c478bd9Sstevel@tonic-gate 	}
39507c478bd9Sstevel@tonic-gate 
39517c478bd9Sstevel@tonic-gate 	status = wsp->walk_callback(wsp->walk_addr, (void *)&tq_ent,
39527c478bd9Sstevel@tonic-gate 	    wsp->walk_cbdata);
39537c478bd9Sstevel@tonic-gate 
39547c478bd9Sstevel@tonic-gate 	wsp->walk_addr = (uintptr_t)tq_ent.tqent_next;
39557c478bd9Sstevel@tonic-gate 
39567c478bd9Sstevel@tonic-gate 
39577c478bd9Sstevel@tonic-gate 	/* Check if we're at the last element (next=head) */
39587c478bd9Sstevel@tonic-gate 	if (wsp->walk_addr == (uintptr_t)wsp->walk_data) {
39597c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
39607c478bd9Sstevel@tonic-gate 	}
39617c478bd9Sstevel@tonic-gate 
39627c478bd9Sstevel@tonic-gate 	return (status);
39637c478bd9Sstevel@tonic-gate }
39647c478bd9Sstevel@tonic-gate 
39657c478bd9Sstevel@tonic-gate int
39667c478bd9Sstevel@tonic-gate didmatch(uintptr_t addr, const kthread_t *thr, kt_did_t *didp)
39677c478bd9Sstevel@tonic-gate {
39687c478bd9Sstevel@tonic-gate 
39697c478bd9Sstevel@tonic-gate 	if (*didp == thr->t_did) {
39707c478bd9Sstevel@tonic-gate 		mdb_printf("%p\n", addr);
39717c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
39727c478bd9Sstevel@tonic-gate 	} else
39737c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
39747c478bd9Sstevel@tonic-gate }
39757c478bd9Sstevel@tonic-gate 
39767c478bd9Sstevel@tonic-gate /*ARGSUSED*/
39777c478bd9Sstevel@tonic-gate int
39787c478bd9Sstevel@tonic-gate did2thread(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
39797c478bd9Sstevel@tonic-gate {
39807c478bd9Sstevel@tonic-gate 	const mdb_arg_t *argp = &argv[0];
39817c478bd9Sstevel@tonic-gate 	kt_did_t	did;
39827c478bd9Sstevel@tonic-gate 
39837c478bd9Sstevel@tonic-gate 	if (argc != 1)
39847c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
39857c478bd9Sstevel@tonic-gate 
39867c478bd9Sstevel@tonic-gate 	did = (kt_did_t)mdb_strtoull(argp->a_un.a_str);
39877c478bd9Sstevel@tonic-gate 
39887c478bd9Sstevel@tonic-gate 	if (mdb_walk("thread", (mdb_walk_cb_t)didmatch, (void *)&did) == -1) {
39897c478bd9Sstevel@tonic-gate 		mdb_warn("failed to walk thread");
39907c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
39917c478bd9Sstevel@tonic-gate 
39927c478bd9Sstevel@tonic-gate 	}
39937c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
39947c478bd9Sstevel@tonic-gate 
39957c478bd9Sstevel@tonic-gate }
39967c478bd9Sstevel@tonic-gate 
39977c478bd9Sstevel@tonic-gate static int
39987c478bd9Sstevel@tonic-gate errorq_walk_init(mdb_walk_state_t *wsp)
39997c478bd9Sstevel@tonic-gate {
40007c478bd9Sstevel@tonic-gate 	if (wsp->walk_addr == NULL &&
40017c478bd9Sstevel@tonic-gate 	    mdb_readvar(&wsp->walk_addr, "errorq_list") == -1) {
40027c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read errorq_list");
40037c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
40047c478bd9Sstevel@tonic-gate 	}
40057c478bd9Sstevel@tonic-gate 
40067c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
40077c478bd9Sstevel@tonic-gate }
40087c478bd9Sstevel@tonic-gate 
40097c478bd9Sstevel@tonic-gate static int
40107c478bd9Sstevel@tonic-gate errorq_walk_step(mdb_walk_state_t *wsp)
40117c478bd9Sstevel@tonic-gate {
40127c478bd9Sstevel@tonic-gate 	uintptr_t addr = wsp->walk_addr;
40137c478bd9Sstevel@tonic-gate 	errorq_t eq;
40147c478bd9Sstevel@tonic-gate 
40157c478bd9Sstevel@tonic-gate 	if (addr == NULL)
40167c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
40177c478bd9Sstevel@tonic-gate 
40187c478bd9Sstevel@tonic-gate 	if (mdb_vread(&eq, sizeof (eq), addr) == -1) {
40197c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read errorq at %p", addr);
40207c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
40217c478bd9Sstevel@tonic-gate 	}
40227c478bd9Sstevel@tonic-gate 
40237c478bd9Sstevel@tonic-gate 	wsp->walk_addr = (uintptr_t)eq.eq_next;
40247c478bd9Sstevel@tonic-gate 	return (wsp->walk_callback(addr, &eq, wsp->walk_cbdata));
40257c478bd9Sstevel@tonic-gate }
40267c478bd9Sstevel@tonic-gate 
40277c478bd9Sstevel@tonic-gate typedef struct eqd_walk_data {
40287c478bd9Sstevel@tonic-gate 	uintptr_t *eqd_stack;
40297c478bd9Sstevel@tonic-gate 	void *eqd_buf;
40307c478bd9Sstevel@tonic-gate 	ulong_t eqd_qpos;
40317c478bd9Sstevel@tonic-gate 	ulong_t eqd_qlen;
40327c478bd9Sstevel@tonic-gate 	size_t eqd_size;
40337c478bd9Sstevel@tonic-gate } eqd_walk_data_t;
40347c478bd9Sstevel@tonic-gate 
40357c478bd9Sstevel@tonic-gate /*
40367c478bd9Sstevel@tonic-gate  * In order to walk the list of pending error queue elements, we push the
40377c478bd9Sstevel@tonic-gate  * addresses of the corresponding data buffers in to the eqd_stack array.
40387c478bd9Sstevel@tonic-gate  * The error lists are in reverse chronological order when iterating using
40397c478bd9Sstevel@tonic-gate  * eqe_prev, so we then pop things off the top in eqd_walk_step so that the
40407c478bd9Sstevel@tonic-gate  * walker client gets addresses in order from oldest error to newest error.
40417c478bd9Sstevel@tonic-gate  */
40427c478bd9Sstevel@tonic-gate static void
40437c478bd9Sstevel@tonic-gate eqd_push_list(eqd_walk_data_t *eqdp, uintptr_t addr)
40447c478bd9Sstevel@tonic-gate {
40457c478bd9Sstevel@tonic-gate 	errorq_elem_t eqe;
40467c478bd9Sstevel@tonic-gate 
40477c478bd9Sstevel@tonic-gate 	while (addr != NULL) {
40487c478bd9Sstevel@tonic-gate 		if (mdb_vread(&eqe, sizeof (eqe), addr) != sizeof (eqe)) {
40497c478bd9Sstevel@tonic-gate 			mdb_warn("failed to read errorq element at %p", addr);
40507c478bd9Sstevel@tonic-gate 			break;
40517c478bd9Sstevel@tonic-gate 		}
40527c478bd9Sstevel@tonic-gate 
40537c478bd9Sstevel@tonic-gate 		if (eqdp->eqd_qpos == eqdp->eqd_qlen) {
40547c478bd9Sstevel@tonic-gate 			mdb_warn("errorq is overfull -- more than %lu "
40557c478bd9Sstevel@tonic-gate 			    "elems found\n", eqdp->eqd_qlen);
40567c478bd9Sstevel@tonic-gate 			break;
40577c478bd9Sstevel@tonic-gate 		}
40587c478bd9Sstevel@tonic-gate 
40597c478bd9Sstevel@tonic-gate 		eqdp->eqd_stack[eqdp->eqd_qpos++] = (uintptr_t)eqe.eqe_data;
40607c478bd9Sstevel@tonic-gate 		addr = (uintptr_t)eqe.eqe_prev;
40617c478bd9Sstevel@tonic-gate 	}
40627c478bd9Sstevel@tonic-gate }
40637c478bd9Sstevel@tonic-gate 
40647c478bd9Sstevel@tonic-gate static int
40657c478bd9Sstevel@tonic-gate eqd_walk_init(mdb_walk_state_t *wsp)
40667c478bd9Sstevel@tonic-gate {
40677c478bd9Sstevel@tonic-gate 	eqd_walk_data_t *eqdp;
40687c478bd9Sstevel@tonic-gate 	errorq_elem_t eqe, *addr;
40697c478bd9Sstevel@tonic-gate 	errorq_t eq;
40707c478bd9Sstevel@tonic-gate 	ulong_t i;
40717c478bd9Sstevel@tonic-gate 
40727c478bd9Sstevel@tonic-gate 	if (mdb_vread(&eq, sizeof (eq), wsp->walk_addr) == -1) {
40737c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read errorq at %p", wsp->walk_addr);
40747c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
40757c478bd9Sstevel@tonic-gate 	}
40767c478bd9Sstevel@tonic-gate 
40777c478bd9Sstevel@tonic-gate 	if (eq.eq_ptail != NULL &&
40787c478bd9Sstevel@tonic-gate 	    mdb_vread(&eqe, sizeof (eqe), (uintptr_t)eq.eq_ptail) == -1) {
40797c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read errorq element at %p", eq.eq_ptail);
40807c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
40817c478bd9Sstevel@tonic-gate 	}
40827c478bd9Sstevel@tonic-gate 
40837c478bd9Sstevel@tonic-gate 	eqdp = mdb_alloc(sizeof (eqd_walk_data_t), UM_SLEEP);
40847c478bd9Sstevel@tonic-gate 	wsp->walk_data = eqdp;
40857c478bd9Sstevel@tonic-gate 
40867c478bd9Sstevel@tonic-gate 	eqdp->eqd_stack = mdb_zalloc(sizeof (uintptr_t) * eq.eq_qlen, UM_SLEEP);
40877c478bd9Sstevel@tonic-gate 	eqdp->eqd_buf = mdb_alloc(eq.eq_size, UM_SLEEP);
40887c478bd9Sstevel@tonic-gate 	eqdp->eqd_qlen = eq.eq_qlen;
40897c478bd9Sstevel@tonic-gate 	eqdp->eqd_qpos = 0;
40907c478bd9Sstevel@tonic-gate 	eqdp->eqd_size = eq.eq_size;
40917c478bd9Sstevel@tonic-gate 
40927c478bd9Sstevel@tonic-gate 	/*
40937c478bd9Sstevel@tonic-gate 	 * The newest elements in the queue are on the pending list, so we
40947c478bd9Sstevel@tonic-gate 	 * push those on to our stack first.
40957c478bd9Sstevel@tonic-gate 	 */
40967c478bd9Sstevel@tonic-gate 	eqd_push_list(eqdp, (uintptr_t)eq.eq_pend);
40977c478bd9Sstevel@tonic-gate 
40987c478bd9Sstevel@tonic-gate 	/*
40997c478bd9Sstevel@tonic-gate 	 * If eq_ptail is set, it may point to a subset of the errors on the
41007c478bd9Sstevel@tonic-gate 	 * pending list in the event a casptr() failed; if ptail's data is
41017c478bd9Sstevel@tonic-gate 	 * already in our stack, NULL out eq_ptail and ignore it.
41027c478bd9Sstevel@tonic-gate 	 */
41037c478bd9Sstevel@tonic-gate 	if (eq.eq_ptail != NULL) {
41047c478bd9Sstevel@tonic-gate 		for (i = 0; i < eqdp->eqd_qpos; i++) {
41057c478bd9Sstevel@tonic-gate 			if (eqdp->eqd_stack[i] == (uintptr_t)eqe.eqe_data) {
41067c478bd9Sstevel@tonic-gate 				eq.eq_ptail = NULL;
41077c478bd9Sstevel@tonic-gate 				break;
41087c478bd9Sstevel@tonic-gate 			}
41097c478bd9Sstevel@tonic-gate 		}
41107c478bd9Sstevel@tonic-gate 	}
41117c478bd9Sstevel@tonic-gate 
41127c478bd9Sstevel@tonic-gate 	/*
41137c478bd9Sstevel@tonic-gate 	 * If eq_phead is set, it has the processing list in order from oldest
41147c478bd9Sstevel@tonic-gate 	 * to newest.  Use this to recompute eq_ptail as best we can and then
41157c478bd9Sstevel@tonic-gate 	 * we nicely fall into eqd_push_list() of eq_ptail below.
41167c478bd9Sstevel@tonic-gate 	 */
41177c478bd9Sstevel@tonic-gate 	for (addr = eq.eq_phead; addr != NULL && mdb_vread(&eqe, sizeof (eqe),
41187c478bd9Sstevel@tonic-gate 	    (uintptr_t)addr) == sizeof (eqe); addr = eqe.eqe_next)
41197c478bd9Sstevel@tonic-gate 		eq.eq_ptail = addr;
41207c478bd9Sstevel@tonic-gate 
41217c478bd9Sstevel@tonic-gate 	/*
41227c478bd9Sstevel@tonic-gate 	 * The oldest elements in the queue are on the processing list, subject
41237c478bd9Sstevel@tonic-gate 	 * to machinations in the if-clauses above.  Push any such elements.
41247c478bd9Sstevel@tonic-gate 	 */
41257c478bd9Sstevel@tonic-gate 	eqd_push_list(eqdp, (uintptr_t)eq.eq_ptail);
41267c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
41277c478bd9Sstevel@tonic-gate }
41287c478bd9Sstevel@tonic-gate 
41297c478bd9Sstevel@tonic-gate static int
41307c478bd9Sstevel@tonic-gate eqd_walk_step(mdb_walk_state_t *wsp)
41317c478bd9Sstevel@tonic-gate {
41327c478bd9Sstevel@tonic-gate 	eqd_walk_data_t *eqdp = wsp->walk_data;
41337c478bd9Sstevel@tonic-gate 	uintptr_t addr;
41347c478bd9Sstevel@tonic-gate 
41357c478bd9Sstevel@tonic-gate 	if (eqdp->eqd_qpos == 0)
41367c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
41377c478bd9Sstevel@tonic-gate 
41387c478bd9Sstevel@tonic-gate 	addr = eqdp->eqd_stack[--eqdp->eqd_qpos];
41397c478bd9Sstevel@tonic-gate 
41407c478bd9Sstevel@tonic-gate 	if (mdb_vread(eqdp->eqd_buf, eqdp->eqd_size, addr) != eqdp->eqd_size) {
41417c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read errorq data at %p", addr);
41427c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
41437c478bd9Sstevel@tonic-gate 	}
41447c478bd9Sstevel@tonic-gate 
41457c478bd9Sstevel@tonic-gate 	return (wsp->walk_callback(addr, eqdp->eqd_buf, wsp->walk_cbdata));
41467c478bd9Sstevel@tonic-gate }
41477c478bd9Sstevel@tonic-gate 
41487c478bd9Sstevel@tonic-gate static void
41497c478bd9Sstevel@tonic-gate eqd_walk_fini(mdb_walk_state_t *wsp)
41507c478bd9Sstevel@tonic-gate {
41517c478bd9Sstevel@tonic-gate 	eqd_walk_data_t *eqdp = wsp->walk_data;
41527c478bd9Sstevel@tonic-gate 
41537c478bd9Sstevel@tonic-gate 	mdb_free(eqdp->eqd_stack, sizeof (uintptr_t) * eqdp->eqd_qlen);
41547c478bd9Sstevel@tonic-gate 	mdb_free(eqdp->eqd_buf, eqdp->eqd_size);
41557c478bd9Sstevel@tonic-gate 	mdb_free(eqdp, sizeof (eqd_walk_data_t));
41567c478bd9Sstevel@tonic-gate }
41577c478bd9Sstevel@tonic-gate 
41587c478bd9Sstevel@tonic-gate #define	EQKSVAL(eqv, what) (eqv.eq_kstat.what.value.ui64)
41597c478bd9Sstevel@tonic-gate 
41607c478bd9Sstevel@tonic-gate static int
41617c478bd9Sstevel@tonic-gate errorq(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
41627c478bd9Sstevel@tonic-gate {
41637c478bd9Sstevel@tonic-gate 	int i;
41647c478bd9Sstevel@tonic-gate 	errorq_t eq;
41657c478bd9Sstevel@tonic-gate 	uint_t opt_v = FALSE;
41667c478bd9Sstevel@tonic-gate 
41677c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC)) {
41687c478bd9Sstevel@tonic-gate 		if (mdb_walk_dcmd("errorq", "errorq", argc, argv) == -1) {
41697c478bd9Sstevel@tonic-gate 			mdb_warn("can't walk 'errorq'");
41707c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
41717c478bd9Sstevel@tonic-gate 		}
41727c478bd9Sstevel@tonic-gate 		return (DCMD_OK);
41737c478bd9Sstevel@tonic-gate 	}
41747c478bd9Sstevel@tonic-gate 
41757c478bd9Sstevel@tonic-gate 	i = mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, TRUE, &opt_v, NULL);
41767c478bd9Sstevel@tonic-gate 	argc -= i;
41777c478bd9Sstevel@tonic-gate 	argv += i;
41787c478bd9Sstevel@tonic-gate 
41797c478bd9Sstevel@tonic-gate 	if (argc != 0)
41807c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
41817c478bd9Sstevel@tonic-gate 
41827c478bd9Sstevel@tonic-gate 	if (opt_v || DCMD_HDRSPEC(flags)) {
41837c478bd9Sstevel@tonic-gate 		mdb_printf("%<u>%-11s %-16s %1s %1s %1s ",
41847c478bd9Sstevel@tonic-gate 		    "ADDR", "NAME", "S", "V", "N");
41857c478bd9Sstevel@tonic-gate 		if (!opt_v) {
41867c478bd9Sstevel@tonic-gate 			mdb_printf("%7s %7s %7s%</u>\n",
41877c478bd9Sstevel@tonic-gate 			    "ACCEPT", "DROP", "LOG");
41887c478bd9Sstevel@tonic-gate 		} else {
41897c478bd9Sstevel@tonic-gate 			mdb_printf("%5s %6s %6s %3s %16s%</u>\n",
41907c478bd9Sstevel@tonic-gate 			    "KSTAT", "QLEN", "SIZE", "IPL", "FUNC");
41917c478bd9Sstevel@tonic-gate 		}
41927c478bd9Sstevel@tonic-gate 	}
41937c478bd9Sstevel@tonic-gate 
41947c478bd9Sstevel@tonic-gate 	if (mdb_vread(&eq, sizeof (eq), addr) != sizeof (eq)) {
41957c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read errorq at %p", addr);
41967c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
41977c478bd9Sstevel@tonic-gate 	}
41987c478bd9Sstevel@tonic-gate 
41997c478bd9Sstevel@tonic-gate 	mdb_printf("%-11p %-16s %c %c %c ", addr, eq.eq_name,
42007c478bd9Sstevel@tonic-gate 	    (eq.eq_flags & ERRORQ_ACTIVE) ? '+' : '-',
42017c478bd9Sstevel@tonic-gate 	    (eq.eq_flags & ERRORQ_VITAL) ? '!' : ' ',
42027c478bd9Sstevel@tonic-gate 	    (eq.eq_flags & ERRORQ_NVLIST) ? '*' : ' ');
42037c478bd9Sstevel@tonic-gate 
42047c478bd9Sstevel@tonic-gate 	if (!opt_v) {
42057c478bd9Sstevel@tonic-gate 		mdb_printf("%7llu %7llu %7llu\n",
42067c478bd9Sstevel@tonic-gate 		    EQKSVAL(eq, eqk_dispatched) + EQKSVAL(eq, eqk_committed),
42077c478bd9Sstevel@tonic-gate 		    EQKSVAL(eq, eqk_dropped) + EQKSVAL(eq, eqk_reserve_fail) +
42087c478bd9Sstevel@tonic-gate 		    EQKSVAL(eq, eqk_commit_fail), EQKSVAL(eq, eqk_logged));
42097c478bd9Sstevel@tonic-gate 	} else {
42107c478bd9Sstevel@tonic-gate 		mdb_printf("%5s %6lu %6lu %3u %a\n",
42117c478bd9Sstevel@tonic-gate 		    "  |  ", eq.eq_qlen, eq.eq_size, eq.eq_ipl, eq.eq_func);
42127c478bd9Sstevel@tonic-gate 		mdb_printf("%38s\n%41s"
42137c478bd9Sstevel@tonic-gate 		    "%12s %llu\n"
42147c478bd9Sstevel@tonic-gate 		    "%53s %llu\n"
42157c478bd9Sstevel@tonic-gate 		    "%53s %llu\n"
42167c478bd9Sstevel@tonic-gate 		    "%53s %llu\n"
42177c478bd9Sstevel@tonic-gate 		    "%53s %llu\n"
42187c478bd9Sstevel@tonic-gate 		    "%53s %llu\n"
42197c478bd9Sstevel@tonic-gate 		    "%53s %llu\n"
42207c478bd9Sstevel@tonic-gate 		    "%53s %llu\n\n",
42217c478bd9Sstevel@tonic-gate 		    "|", "+-> ",
42227c478bd9Sstevel@tonic-gate 		    "DISPATCHED",	EQKSVAL(eq, eqk_dispatched),
42237c478bd9Sstevel@tonic-gate 		    "DROPPED",		EQKSVAL(eq, eqk_dropped),
42247c478bd9Sstevel@tonic-gate 		    "LOGGED",		EQKSVAL(eq, eqk_logged),
42257c478bd9Sstevel@tonic-gate 		    "RESERVED",		EQKSVAL(eq, eqk_reserved),
42267c478bd9Sstevel@tonic-gate 		    "RESERVE FAIL",	EQKSVAL(eq, eqk_reserve_fail),
42277c478bd9Sstevel@tonic-gate 		    "COMMITTED",	EQKSVAL(eq, eqk_committed),
42287c478bd9Sstevel@tonic-gate 		    "COMMIT FAIL",	EQKSVAL(eq, eqk_commit_fail),
42297c478bd9Sstevel@tonic-gate 		    "CANCELLED",	EQKSVAL(eq, eqk_cancelled));
42307c478bd9Sstevel@tonic-gate 	}
42317c478bd9Sstevel@tonic-gate 
42327c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
42337c478bd9Sstevel@tonic-gate }
42347c478bd9Sstevel@tonic-gate 
42357c478bd9Sstevel@tonic-gate /*ARGSUSED*/
42367c478bd9Sstevel@tonic-gate static int
42377c478bd9Sstevel@tonic-gate panicinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
42387c478bd9Sstevel@tonic-gate {
42397c478bd9Sstevel@tonic-gate 	cpu_t panic_cpu;
42407c478bd9Sstevel@tonic-gate 	kthread_t *panic_thread;
424149795412Spetede 	void *buf;
42427c478bd9Sstevel@tonic-gate 	panic_data_t *pd;
42437c478bd9Sstevel@tonic-gate 	int i, n;
42447c478bd9Sstevel@tonic-gate 
42457c478bd9Sstevel@tonic-gate 	if (!mdb_prop_postmortem) {
42467c478bd9Sstevel@tonic-gate 		mdb_warn("panicinfo can only be run on a system "
42477c478bd9Sstevel@tonic-gate 		    "dump; see dumpadm(1M)\n");
42487c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
42497c478bd9Sstevel@tonic-gate 	}
42507c478bd9Sstevel@tonic-gate 
42517c478bd9Sstevel@tonic-gate 	if (flags & DCMD_ADDRSPEC || argc != 0)
42527c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
42537c478bd9Sstevel@tonic-gate 
42547c478bd9Sstevel@tonic-gate 	if (mdb_readsym(&panic_cpu, sizeof (cpu_t), "panic_cpu") == -1)
42557c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read 'panic_cpu'");
42567c478bd9Sstevel@tonic-gate 	else
42577c478bd9Sstevel@tonic-gate 		mdb_printf("%16s %?d\n", "cpu", panic_cpu.cpu_id);
42587c478bd9Sstevel@tonic-gate 
42597c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&panic_thread, "panic_thread") == -1)
42607c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read 'panic_thread'");
42617c478bd9Sstevel@tonic-gate 	else
42627c478bd9Sstevel@tonic-gate 		mdb_printf("%16s %?p\n", "thread", panic_thread);
42637c478bd9Sstevel@tonic-gate 
426449795412Spetede 	buf = mdb_alloc(PANICBUFSIZE, UM_SLEEP);
426549795412Spetede 	pd = (panic_data_t *)buf;
42667c478bd9Sstevel@tonic-gate 
426749795412Spetede 	if (mdb_readsym(buf, PANICBUFSIZE, "panicbuf") == -1 ||
42687c478bd9Sstevel@tonic-gate 	    pd->pd_version != PANICBUFVERS) {
42697c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read 'panicbuf'");
427049795412Spetede 		mdb_free(buf, PANICBUFSIZE);
42717c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
42727c478bd9Sstevel@tonic-gate 	}
42737c478bd9Sstevel@tonic-gate 
427449795412Spetede 	mdb_printf("%16s %s\n", "message",  (char *)buf + pd->pd_msgoff);
42757c478bd9Sstevel@tonic-gate 
42767c478bd9Sstevel@tonic-gate 	n = (pd->pd_msgoff - (sizeof (panic_data_t) -
42777c478bd9Sstevel@tonic-gate 	    sizeof (panic_nv_t))) / sizeof (panic_nv_t);
42787c478bd9Sstevel@tonic-gate 
42797c478bd9Sstevel@tonic-gate 	for (i = 0; i < n; i++)
42807c478bd9Sstevel@tonic-gate 		mdb_printf("%16s %?llx\n",
42817c478bd9Sstevel@tonic-gate 		    pd->pd_nvdata[i].pnv_name, pd->pd_nvdata[i].pnv_value);
42827c478bd9Sstevel@tonic-gate 
428349795412Spetede 	mdb_free(buf, PANICBUFSIZE);
42847c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
42857c478bd9Sstevel@tonic-gate }
42867c478bd9Sstevel@tonic-gate 
42877c478bd9Sstevel@tonic-gate static const mdb_dcmd_t dcmds[] = {
42887c478bd9Sstevel@tonic-gate 
42897c478bd9Sstevel@tonic-gate 	/* from genunix.c */
42907c478bd9Sstevel@tonic-gate 	{ "addr2smap", ":[offset]", "translate address to smap", addr2smap },
42917c478bd9Sstevel@tonic-gate 	{ "as2proc", ":", "convert as to proc_t address", as2proc },
42927c478bd9Sstevel@tonic-gate 	{ "binding_hash_entry", ":", "print driver names hash table entry",
42937c478bd9Sstevel@tonic-gate 		binding_hash_entry },
429407247649SMadhavan Venkataraman 	{ "callout", "?[-r|n] [-s|l] [-xhB] [-t | -ab nsec [-dkD]]"
429587a18d3fSMadhavan Venkataraman 	    " [-C addr | -S seqid] [-f name|addr] [-p name| addr] [-T|L [-E]]"
429687a18d3fSMadhavan Venkataraman 	    " [-FivVA]",
429787a18d3fSMadhavan Venkataraman 	    "display callouts", callout, callout_help },
429887a18d3fSMadhavan Venkataraman 	{ "calloutid", "[-d|v] xid", "print callout by extended id",
429987a18d3fSMadhavan Venkataraman 	    calloutid, calloutid_help },
43007c478bd9Sstevel@tonic-gate 	{ "class", NULL, "print process scheduler classes", class },
43017c478bd9Sstevel@tonic-gate 	{ "cpuinfo", "?[-v]", "print CPUs and runnable threads", cpuinfo },
43027c478bd9Sstevel@tonic-gate 	{ "did2thread", "? kt_did", "find kernel thread for this id",
43037c478bd9Sstevel@tonic-gate 		did2thread },
43047c478bd9Sstevel@tonic-gate 	{ "errorq", "?[-v]", "display kernel error queues", errorq },
43057c478bd9Sstevel@tonic-gate 	{ "fd", ":[fd num]", "get a file pointer from an fd", fd },
43067c478bd9Sstevel@tonic-gate 	{ "flipone", ":", "the vik_rev_level 2 special", flipone },
43077c478bd9Sstevel@tonic-gate 	{ "lminfo", NULL, "print lock manager information", lminfo },
43087c478bd9Sstevel@tonic-gate 	{ "ndi_event_hdl", "?", "print ndi_event_hdl", ndi_event_hdl },
43097c478bd9Sstevel@tonic-gate 	{ "panicinfo", NULL, "print panic information", panicinfo },
43107c478bd9Sstevel@tonic-gate 	{ "pid2proc", "?", "convert PID to proc_t address", pid2proc },
43117c478bd9Sstevel@tonic-gate 	{ "pmap", ":[-q]", "print process memory map", pmap },
43127c478bd9Sstevel@tonic-gate 	{ "project", NULL, "display kernel project(s)", project },
43137c478bd9Sstevel@tonic-gate 	{ "ps", "[-fltzTP]", "list processes (and associated thr,lwp)", ps },
4314adb664e2Svb 	{ "pgrep", "[-x] [-n | -o] pattern",
4315adb664e2Svb 		"pattern match against all processes", pgrep },
43167c478bd9Sstevel@tonic-gate 	{ "ptree", NULL, "print process tree", ptree },
43177c478bd9Sstevel@tonic-gate 	{ "seg", ":", "print address space segment", seg },
43187c478bd9Sstevel@tonic-gate 	{ "sysevent", "?[-sv]", "print sysevent pending or sent queue",
43197c478bd9Sstevel@tonic-gate 		sysevent},
43207c478bd9Sstevel@tonic-gate 	{ "sysevent_channel", "?", "print sysevent channel database",
43217c478bd9Sstevel@tonic-gate 		sysevent_channel},
43227c478bd9Sstevel@tonic-gate 	{ "sysevent_class_list", ":", "print sysevent class list",
43237c478bd9Sstevel@tonic-gate 		sysevent_class_list},
43247c478bd9Sstevel@tonic-gate 	{ "sysevent_subclass_list", ":",
43257c478bd9Sstevel@tonic-gate 		"print sysevent subclass list", sysevent_subclass_list},
43267c478bd9Sstevel@tonic-gate 	{ "system", NULL, "print contents of /etc/system file", sysfile },
43277c478bd9Sstevel@tonic-gate 	{ "task", NULL, "display kernel task(s)", task },
43287c478bd9Sstevel@tonic-gate 	{ "taskq_entry", ":", "display a taskq_ent_t", taskq_ent },
43297c478bd9Sstevel@tonic-gate 	{ "vnode2path", ":[-F]", "vnode address to pathname", vnode2path },
43307c478bd9Sstevel@tonic-gate 	{ "vnode2smap", ":[offset]", "translate vnode to smap", vnode2smap },
43317c478bd9Sstevel@tonic-gate 	{ "whereopen", ":", "given a vnode, dumps procs which have it open",
43327c478bd9Sstevel@tonic-gate 	    whereopen },
43337c478bd9Sstevel@tonic-gate 
43347c478bd9Sstevel@tonic-gate 	/* from bio.c */
43357c478bd9Sstevel@tonic-gate 	{ "bufpagefind", ":addr", "find page_t on buf_t list", bufpagefind },
43367c478bd9Sstevel@tonic-gate 
4337*4c06356bSdh 	/* from bitset.c */
4338*4c06356bSdh 	{ "bitset", ":", "display a bitset", bitset, bitset_help },
4339*4c06356bSdh 
43407c478bd9Sstevel@tonic-gate 	/* from contract.c */
43417c478bd9Sstevel@tonic-gate 	{ "contract", "?", "display a contract", cmd_contract },
43427c478bd9Sstevel@tonic-gate 	{ "ctevent", ":", "display a contract event", cmd_ctevent },
43437c478bd9Sstevel@tonic-gate 	{ "ctid", ":", "convert id to a contract pointer", cmd_ctid },
43447c478bd9Sstevel@tonic-gate 
43457c478bd9Sstevel@tonic-gate 	/* from cpupart.c */
4346f5533078Smishra 	{ "cpupart", "?[-v]", "print cpu partition info", cpupart },
43477c478bd9Sstevel@tonic-gate 
43487c478bd9Sstevel@tonic-gate 	/* from cyclic.c */
43497c478bd9Sstevel@tonic-gate 	{ "cyccover", NULL, "dump cyclic coverage information", cyccover },
43507c478bd9Sstevel@tonic-gate 	{ "cycid", "?", "dump a cyclic id", cycid },
43517c478bd9Sstevel@tonic-gate 	{ "cycinfo", "?", "dump cyc_cpu info", cycinfo },
43527c478bd9Sstevel@tonic-gate 	{ "cyclic", ":", "developer information", cyclic },
43537c478bd9Sstevel@tonic-gate 	{ "cyctrace", "?", "dump cyclic trace buffer", cyctrace },
43547c478bd9Sstevel@tonic-gate 
4355*4c06356bSdh 	/* from damap.c */
4356*4c06356bSdh 	{ "damap", ":", "display a damap_t", damap, damap_help },
4357*4c06356bSdh 
43587c478bd9Sstevel@tonic-gate 	/* from devinfo.c */
43597c478bd9Sstevel@tonic-gate 	{ "devbindings", "?[-qs] [device-name | major-num]",
43607c478bd9Sstevel@tonic-gate 	    "print devinfo nodes bound to device-name or major-num",
43617c478bd9Sstevel@tonic-gate 	    devbindings, devinfo_help },
43627c478bd9Sstevel@tonic-gate 	{ "devinfo", ":[-qs]", "detailed devinfo of one node", devinfo,
43637c478bd9Sstevel@tonic-gate 	    devinfo_help },
43647c478bd9Sstevel@tonic-gate 	{ "devinfo_audit", ":[-v]", "devinfo configuration audit record",
43657c478bd9Sstevel@tonic-gate 	    devinfo_audit },
43667c478bd9Sstevel@tonic-gate 	{ "devinfo_audit_log", "?[-v]", "system wide devinfo configuration log",
43677c478bd9Sstevel@tonic-gate 	    devinfo_audit_log },
43687c478bd9Sstevel@tonic-gate 	{ "devinfo_audit_node", ":[-v]", "devinfo node configuration history",
43697c478bd9Sstevel@tonic-gate 	    devinfo_audit_node },
43707c478bd9Sstevel@tonic-gate 	{ "devinfo2driver", ":", "find driver name for this devinfo node",
43717c478bd9Sstevel@tonic-gate 	    devinfo2driver },
43727c478bd9Sstevel@tonic-gate 	{ "devnames", "?[-vm] [num]", "print devnames array", devnames },
43737c478bd9Sstevel@tonic-gate 	{ "dev2major", "?<dev_t>", "convert dev_t to a major number",
43747c478bd9Sstevel@tonic-gate 	    dev2major },
43757c478bd9Sstevel@tonic-gate 	{ "dev2minor", "?<dev_t>", "convert dev_t to a minor number",
43767c478bd9Sstevel@tonic-gate 	    dev2minor },
43777c478bd9Sstevel@tonic-gate 	{ "devt", "?<dev_t>", "display a dev_t's major and minor numbers",
43787c478bd9Sstevel@tonic-gate 	    devt },
43797c478bd9Sstevel@tonic-gate 	{ "major2name", "?<major-num>", "convert major number to dev name",
43807c478bd9Sstevel@tonic-gate 	    major2name },
43817c478bd9Sstevel@tonic-gate 	{ "minornodes", ":", "given a devinfo node, print its minor nodes",
43827c478bd9Sstevel@tonic-gate 	    minornodes },
43837c478bd9Sstevel@tonic-gate 	{ "modctl2devinfo", ":", "given a modctl, list its devinfos",
43847c478bd9Sstevel@tonic-gate 	    modctl2devinfo },
43857c478bd9Sstevel@tonic-gate 	{ "name2major", "<dev-name>", "convert dev name to major number",
43867c478bd9Sstevel@tonic-gate 	    name2major },
43877c478bd9Sstevel@tonic-gate 	{ "prtconf", "?[-vpc]", "print devinfo tree", prtconf, prtconf_help },
43887c478bd9Sstevel@tonic-gate 	{ "softstate", ":<instance>", "retrieve soft-state pointer",
43897c478bd9Sstevel@tonic-gate 	    softstate },
43907c478bd9Sstevel@tonic-gate 	{ "devinfo_fm", ":", "devinfo fault managment configuration",
43917c478bd9Sstevel@tonic-gate 	    devinfo_fm },
43927c478bd9Sstevel@tonic-gate 	{ "devinfo_fmce", ":", "devinfo fault managment cache entry",
43937c478bd9Sstevel@tonic-gate 	    devinfo_fmce},
43947c478bd9Sstevel@tonic-gate 
43959dd0f810Scindi 	/* from fm.c */
43969dd0f810Scindi 	{ "ereport", "[-v]", "print ereports logged in dump",
43979dd0f810Scindi 	    ereport },
43989dd0f810Scindi 
43997c478bd9Sstevel@tonic-gate 	/* from findstack.c */
44007c478bd9Sstevel@tonic-gate 	{ "findstack", ":[-v]", "find kernel thread stack", findstack },
44017c478bd9Sstevel@tonic-gate 	{ "findstack_debug", NULL, "toggle findstack debugging",
44027c478bd9Sstevel@tonic-gate 		findstack_debug },
4403e6fc74c6SGreg Price 	{ "stacks", "?[-afiv] [-c func] [-C func] [-m module] [-M module] "
4404e6fc74c6SGreg Price 		"[-s sobj | -S sobj] [-t tstate | -T tstate]",
4405346799e8SJonathan W Adams 		"print unique kernel thread stacks",
4406346799e8SJonathan W Adams 		stacks, stacks_help },
44077c478bd9Sstevel@tonic-gate 
4408*4c06356bSdh 	/* from group.c */
4409*4c06356bSdh 	{ "group", "?[-q]", "display a group", group},
4410*4c06356bSdh 
44115febcb4aSScott Carter, SD IOSW 	/* from irm.c */
44125febcb4aSScott Carter, SD IOSW 	{ "irmpools", NULL, "display interrupt pools", irmpools_dcmd },
44135febcb4aSScott Carter, SD IOSW 	{ "irmreqs", NULL, "display interrupt requests in an interrupt pool",
44145febcb4aSScott Carter, SD IOSW 	    irmreqs_dcmd },
44155febcb4aSScott Carter, SD IOSW 	{ "irmreq", NULL, "display an interrupt request", irmreq_dcmd },
44165febcb4aSScott Carter, SD IOSW 
44177c478bd9Sstevel@tonic-gate 	/* from kgrep.c + genunix.c */
4418154eb83fSjwadams 	{ "kgrep", KGREP_USAGE, "search kernel as for a pointer", kgrep,
4419154eb83fSjwadams 		kgrep_help },
44207c478bd9Sstevel@tonic-gate 
44217c478bd9Sstevel@tonic-gate 	/* from kmem.c */
44227c478bd9Sstevel@tonic-gate 	{ "allocdby", ":", "given a thread, print its allocated buffers",
44237c478bd9Sstevel@tonic-gate 		allocdby },
44247c478bd9Sstevel@tonic-gate 	{ "bufctl", ":[-vh] [-a addr] [-c caller] [-e earliest] [-l latest] "
44257c478bd9Sstevel@tonic-gate 		"[-t thd]", "print or filter a bufctl", bufctl, bufctl_help },
44267c478bd9Sstevel@tonic-gate 	{ "freedby", ":", "given a thread, print its freed buffers", freedby },
44277c478bd9Sstevel@tonic-gate 	{ "kmalog", "?[ fail | slab ]",
44287c478bd9Sstevel@tonic-gate 	    "display kmem transaction log and stack traces", kmalog },
4429c92ff650Sek 	{ "kmastat", "[-kmg]", "kernel memory allocator stats",
4430c92ff650Sek 	    kmastat },
44317c478bd9Sstevel@tonic-gate 	{ "kmausers", "?[-ef] [cache ...]", "current medium and large users "
44327c478bd9Sstevel@tonic-gate 		"of the kmem allocator", kmausers, kmausers_help },
4433b5fca8f8Stomee 	{ "kmem_cache", "?[-n name]",
4434b5fca8f8Stomee 		"print kernel memory caches", kmem_cache, kmem_cache_help},
4435b5fca8f8Stomee 	{ "kmem_slabs", "?[-v] [-n cache] [-N cache] [-b maxbins] "
4436b5fca8f8Stomee 		"[-B minbinsize]", "display slab usage per kmem cache",
44373893cb7fStomee 		kmem_slabs, kmem_slabs_help },
44387c478bd9Sstevel@tonic-gate 	{ "kmem_debug", NULL, "toggle kmem dcmd/walk debugging", kmem_debug },
44397c478bd9Sstevel@tonic-gate 	{ "kmem_log", "?[-b]", "dump kmem transaction log", kmem_log },
44407c478bd9Sstevel@tonic-gate 	{ "kmem_verify", "?", "check integrity of kmem-managed memory",
44417c478bd9Sstevel@tonic-gate 		kmem_verify },
44427c478bd9Sstevel@tonic-gate 	{ "vmem", "?", "print a vmem_t", vmem },
44437c478bd9Sstevel@tonic-gate 	{ "vmem_seg", ":[-sv] [-c caller] [-e earliest] [-l latest] "
44447c478bd9Sstevel@tonic-gate 		"[-m minsize] [-M maxsize] [-t thread] [-T type]",
44457c478bd9Sstevel@tonic-gate 		"print or filter a vmem_seg", vmem_seg, vmem_seg_help },
44467c478bd9Sstevel@tonic-gate 	{ "whatthread", ":[-v]", "print threads whose stack contains the "
44477c478bd9Sstevel@tonic-gate 		"given address", whatthread },
44487c478bd9Sstevel@tonic-gate 
44497c478bd9Sstevel@tonic-gate 	/* from ldi.c */
44507c478bd9Sstevel@tonic-gate 	{ "ldi_handle", "?[-i]", "display a layered driver handle",
44517c478bd9Sstevel@tonic-gate 	    ldi_handle, ldi_handle_help },
44527c478bd9Sstevel@tonic-gate 	{ "ldi_ident", NULL, "display a layered driver identifier",
44537c478bd9Sstevel@tonic-gate 	    ldi_ident, ldi_ident_help },
44547c478bd9Sstevel@tonic-gate 
44557c478bd9Sstevel@tonic-gate 	/* from leaky.c + leaky_subr.c */
44567c478bd9Sstevel@tonic-gate 	{ "findleaks", FINDLEAKS_USAGE,
44577c478bd9Sstevel@tonic-gate 	    "search for potential kernel memory leaks", findleaks,
44587c478bd9Sstevel@tonic-gate 	    findleaks_help },
44597c478bd9Sstevel@tonic-gate 
44607c478bd9Sstevel@tonic-gate 	/* from lgrp.c */
44617c478bd9Sstevel@tonic-gate 	{ "lgrp", "?[-q] [-p | -Pih]", "display an lgrp", lgrp},
4462c6402783Sakolb 	{ "lgrp_set", "", "display bitmask of lgroups as a list", lgrp_set},
44637c478bd9Sstevel@tonic-gate 
44647c478bd9Sstevel@tonic-gate 	/* from log.c */
44657c478bd9Sstevel@tonic-gate 	{ "msgbuf", "?[-v]", "print most recent console messages", msgbuf },
44667c478bd9Sstevel@tonic-gate 
4467*4c06356bSdh 	/* from mdi.c */
4468*4c06356bSdh 	{ "mdipi", NULL, "given a path, dump mdi_pathinfo "
4469*4c06356bSdh 		"and detailed pi_prop list", mdipi },
4470*4c06356bSdh 	{ "mdiprops", NULL, "given a pi_prop, dump the pi_prop list",
4471*4c06356bSdh 		mdiprops },
4472*4c06356bSdh 	{ "mdiphci", NULL, "given a phci, dump mdi_phci and "
4473*4c06356bSdh 		"list all paths", mdiphci },
4474*4c06356bSdh 	{ "mdivhci", NULL, "given a vhci, dump mdi_vhci and list "
4475*4c06356bSdh 		"all phcis", mdivhci },
4476*4c06356bSdh 	{ "mdiclient_paths", NULL, "given a path, walk mdi_pathinfo "
4477*4c06356bSdh 		"client links", mdiclient_paths },
4478*4c06356bSdh 	{ "mdiphci_paths", NULL, "given a path, walk through mdi_pathinfo "
4479*4c06356bSdh 		"phci links", mdiphci_paths },
4480*4c06356bSdh 	{ "mdiphcis", NULL, "given a phci, walk through mdi_phci ph_next links",
4481*4c06356bSdh 		mdiphcis },
4482*4c06356bSdh 
44837c478bd9Sstevel@tonic-gate 	/* from memory.c */
44847c478bd9Sstevel@tonic-gate 	{ "page", "?", "display a summarized page_t", page },
44857c478bd9Sstevel@tonic-gate 	{ "memstat", NULL, "display memory usage summary", memstat },
44867c478bd9Sstevel@tonic-gate 	{ "memlist", "?[-iav]", "display a struct memlist", memlist },
44877c478bd9Sstevel@tonic-gate 	{ "swapinfo", "?", "display a struct swapinfo", swapinfof },
44887c478bd9Sstevel@tonic-gate 
44897c478bd9Sstevel@tonic-gate 	/* from mmd.c */
44907c478bd9Sstevel@tonic-gate 	{ "multidata", ":[-sv]", "display a summarized multidata_t",
44917c478bd9Sstevel@tonic-gate 		multidata },
44927c478bd9Sstevel@tonic-gate 	{ "pattbl", ":", "display a summarized multidata attribute table",
44937c478bd9Sstevel@tonic-gate 		pattbl },
44947c478bd9Sstevel@tonic-gate 	{ "pattr2multidata", ":", "print multidata pointer from pattr_t",
44957c478bd9Sstevel@tonic-gate 		pattr2multidata },
44967c478bd9Sstevel@tonic-gate 	{ "pdesc2slab", ":", "print pdesc slab pointer from pdesc_t",
44977c478bd9Sstevel@tonic-gate 		pdesc2slab },
44987c478bd9Sstevel@tonic-gate 	{ "pdesc_verify", ":", "verify integrity of a pdesc_t", pdesc_verify },
44997c478bd9Sstevel@tonic-gate 	{ "slab2multidata", ":", "print multidata pointer from pdesc_slab_t",
45007c478bd9Sstevel@tonic-gate 		slab2multidata },
45017c478bd9Sstevel@tonic-gate 
45027c478bd9Sstevel@tonic-gate 	/* from modhash.c */
45037c478bd9Sstevel@tonic-gate 	{ "modhash", "?[-ceht] [-k key] [-v val] [-i index]",
45047c478bd9Sstevel@tonic-gate 		"display information about one or all mod_hash structures",
45057c478bd9Sstevel@tonic-gate 		modhash, modhash_help },
45067c478bd9Sstevel@tonic-gate 	{ "modent", ":[-k | -v | -t type]",
45077c478bd9Sstevel@tonic-gate 		"display information about a mod_hash_entry", modent,
45087c478bd9Sstevel@tonic-gate 		modent_help },
45097c478bd9Sstevel@tonic-gate 
45107c478bd9Sstevel@tonic-gate 	/* from net.c */
45114eaa4710SRishi Srivatsavai 	{ "dladm", "?<sub-command> [flags]", "show data link information",
45124eaa4710SRishi Srivatsavai 		dladm, dladm_help },
45137c478bd9Sstevel@tonic-gate 	{ "mi", ":[-p] [-d | -m]", "filter and display MI object or payload",
45147c478bd9Sstevel@tonic-gate 		mi },
4515d5b6ed4bSVasumathi Sundaram - Sun Microsystems 	{ "netstat", "[-arv] [-f inet | inet6 | unix] [-P tcp | udp | icmp]",
45167c478bd9Sstevel@tonic-gate 		"show network statistics", netstat },
45177c478bd9Sstevel@tonic-gate 	{ "sonode", "?[-f inet | inet6 | unix | #] "
45187c478bd9Sstevel@tonic-gate 		"[-t stream | dgram | raw | #] [-p #]",
45197c478bd9Sstevel@tonic-gate 		"filter and display sonode", sonode },
45207c478bd9Sstevel@tonic-gate 
4521f4b3ec61Sdh 	/* from netstack.c */
4522f4b3ec61Sdh 	{ "netstack", "", "show stack instances", netstack },
4523f4b3ec61Sdh 
45247c478bd9Sstevel@tonic-gate 	/* from nvpair.c */
45257c478bd9Sstevel@tonic-gate 	{ NVPAIR_DCMD_NAME, NVPAIR_DCMD_USAGE, NVPAIR_DCMD_DESCR,
45267c478bd9Sstevel@tonic-gate 		nvpair_print },
4527fa9e4066Sahrens 	{ NVLIST_DCMD_NAME, NVLIST_DCMD_USAGE, NVLIST_DCMD_DESCR,
45288a40a695Sgavinm 		print_nvlist },
45297c478bd9Sstevel@tonic-gate 
4530fb2f18f8Sesaxe 	/* from pg.c */
4531fb2f18f8Sesaxe 	{ "pg", "?[-q]", "display a pg", pg},
4532fb2f18f8Sesaxe 
45337c478bd9Sstevel@tonic-gate 	/* from rctl.c */
45347c478bd9Sstevel@tonic-gate 	{ "rctl_dict", "?", "print systemwide default rctl definitions",
45357c478bd9Sstevel@tonic-gate 		rctl_dict },
45367c478bd9Sstevel@tonic-gate 	{ "rctl_list", ":[handle]", "print rctls for the given proc",
45377c478bd9Sstevel@tonic-gate 		rctl_list },
45387c478bd9Sstevel@tonic-gate 	{ "rctl", ":[handle]", "print a rctl_t, only if it matches the handle",
45397c478bd9Sstevel@tonic-gate 		rctl },
45407c478bd9Sstevel@tonic-gate 	{ "rctl_validate", ":[-v] [-n #]", "test resource control value "
45417c478bd9Sstevel@tonic-gate 		"sequence", rctl_validate },
45427c478bd9Sstevel@tonic-gate 
45437c478bd9Sstevel@tonic-gate 	/* from sobj.c */
45447c478bd9Sstevel@tonic-gate 	{ "rwlock", ":", "dump out a readers/writer lock", rwlock },
45457c478bd9Sstevel@tonic-gate 	{ "mutex", ":[-f]", "dump out an adaptive or spin mutex", mutex,
45467c478bd9Sstevel@tonic-gate 		mutex_help },
45477c478bd9Sstevel@tonic-gate 	{ "sobj2ts", ":", "perform turnstile lookup on synch object", sobj2ts },
45487c478bd9Sstevel@tonic-gate 	{ "wchaninfo", "?[-v]", "dump condition variable", wchaninfo },
45497c478bd9Sstevel@tonic-gate 	{ "turnstile", "?", "display a turnstile", turnstile },
45507c478bd9Sstevel@tonic-gate 
45517c478bd9Sstevel@tonic-gate 	/* from stream.c */
45527c478bd9Sstevel@tonic-gate 	{ "mblk", ":[-q|v] [-f|F flag] [-t|T type] [-l|L|B len] [-d dbaddr]",
45537c478bd9Sstevel@tonic-gate 		"print an mblk", mblk_prt, mblk_help },
45547c478bd9Sstevel@tonic-gate 	{ "mblk_verify", "?", "verify integrity of an mblk", mblk_verify },
45557c478bd9Sstevel@tonic-gate 	{ "mblk2dblk", ":", "convert mblk_t address to dblk_t address",
45567c478bd9Sstevel@tonic-gate 		mblk2dblk },
45577c478bd9Sstevel@tonic-gate 	{ "q2otherq", ":", "print peer queue for a given queue", q2otherq },
45587c478bd9Sstevel@tonic-gate 	{ "q2rdq", ":", "print read queue for a given queue", q2rdq },
45597c478bd9Sstevel@tonic-gate 	{ "q2syncq", ":", "print syncq for a given queue", q2syncq },
45607c478bd9Sstevel@tonic-gate 	{ "q2stream", ":", "print stream pointer for a given queue", q2stream },
45617c478bd9Sstevel@tonic-gate 	{ "q2wrq", ":", "print write queue for a given queue", q2wrq },
45627c478bd9Sstevel@tonic-gate 	{ "queue", ":[-q|v] [-m mod] [-f flag] [-F flag] [-s syncq_addr]",
45637c478bd9Sstevel@tonic-gate 		"filter and display STREAM queue", queue, queue_help },
45647c478bd9Sstevel@tonic-gate 	{ "stdata", ":[-q|v] [-f flag] [-F flag]",
45657c478bd9Sstevel@tonic-gate 		"filter and display STREAM head", stdata, stdata_help },
45667c478bd9Sstevel@tonic-gate 	{ "str2mate", ":", "print mate of this stream", str2mate },
45677c478bd9Sstevel@tonic-gate 	{ "str2wrq", ":", "print write queue of this stream", str2wrq },
45687c478bd9Sstevel@tonic-gate 	{ "stream", ":", "display STREAM", stream },
45697c478bd9Sstevel@tonic-gate 	{ "strftevent", ":", "print STREAMS flow trace event", strftevent },
45707c478bd9Sstevel@tonic-gate 	{ "syncq", ":[-q|v] [-f flag] [-F flag] [-t type] [-T type]",
45717c478bd9Sstevel@tonic-gate 		"filter and display STREAM sync queue", syncq, syncq_help },
45727c478bd9Sstevel@tonic-gate 	{ "syncq2q", ":", "print queue for a given syncq", syncq2q },
45737c478bd9Sstevel@tonic-gate 
45747c478bd9Sstevel@tonic-gate 	/* from thread.c */
45757c478bd9Sstevel@tonic-gate 	{ "thread", "?[-bdfimps]", "display a summarized kthread_t", thread,
45767c478bd9Sstevel@tonic-gate 		thread_help },
4577ab4a9bebSjohnlev 	{ "threadlist", "?[-t] [-v [count]]",
45787c478bd9Sstevel@tonic-gate 		"display threads and associated C stack traces", threadlist,
45797c478bd9Sstevel@tonic-gate 		threadlist_help },
4580bff31d89SPhilippe Jung 	{ "stackinfo", "?[-h|-a]", "display kthread_t stack usage", stackinfo,
4581bff31d89SPhilippe Jung 		stackinfo_help },
45827c478bd9Sstevel@tonic-gate 
45837c478bd9Sstevel@tonic-gate 	/* from tsd.c */
45847c478bd9Sstevel@tonic-gate 	{ "tsd", ":-k key", "print tsd[key-1] for this thread", ttotsd },
45857c478bd9Sstevel@tonic-gate 	{ "tsdtot", ":", "find thread with this tsd", tsdtot },
45867c478bd9Sstevel@tonic-gate 
45877c478bd9Sstevel@tonic-gate 	/*
45887c478bd9Sstevel@tonic-gate 	 * typegraph does not work under kmdb, as it requires too much memory
45897c478bd9Sstevel@tonic-gate 	 * for its internal data structures.
45907c478bd9Sstevel@tonic-gate 	 */
45917c478bd9Sstevel@tonic-gate #ifndef _KMDB
45927c478bd9Sstevel@tonic-gate 	/* from typegraph.c */
45937c478bd9Sstevel@tonic-gate 	{ "findlocks", ":", "find locks held by specified thread", findlocks },
45947c478bd9Sstevel@tonic-gate 	{ "findfalse", "?[-v]", "find potentially falsely shared structures",
45957c478bd9Sstevel@tonic-gate 		findfalse },
45967c478bd9Sstevel@tonic-gate 	{ "typegraph", NULL, "build type graph", typegraph },
45977c478bd9Sstevel@tonic-gate 	{ "istype", ":type", "manually set object type", istype },
45987c478bd9Sstevel@tonic-gate 	{ "notype", ":", "manually clear object type", notype },
45997c478bd9Sstevel@tonic-gate 	{ "whattype", ":", "determine object type", whattype },
46007c478bd9Sstevel@tonic-gate #endif
46017c478bd9Sstevel@tonic-gate 
46027c478bd9Sstevel@tonic-gate 	/* from vfs.c */
46037c478bd9Sstevel@tonic-gate 	{ "fsinfo", "?[-v]", "print mounted filesystems", fsinfo },
46047c478bd9Sstevel@tonic-gate 	{ "pfiles", ":[-fp]", "print process file information", pfiles,
46057c478bd9Sstevel@tonic-gate 		pfiles_help },
46067c478bd9Sstevel@tonic-gate 
4607*4c06356bSdh 	/* from zone.c */
4608*4c06356bSdh 	{ "zone", "?", "display kernel zone(s)", zoneprt },
4609*4c06356bSdh 	{ "zsd", ":[-v] [zsd_key]", "display zone-specific-data entries for "
4610*4c06356bSdh 	    "selected zones", zsd },
461170ab954aSramat 
46127c478bd9Sstevel@tonic-gate 	{ NULL }
46137c478bd9Sstevel@tonic-gate };
46147c478bd9Sstevel@tonic-gate 
46157c478bd9Sstevel@tonic-gate static const mdb_walker_t walkers[] = {
46167c478bd9Sstevel@tonic-gate 
46177c478bd9Sstevel@tonic-gate 	/* from genunix.c */
46187c478bd9Sstevel@tonic-gate 	{ "anon", "given an amp, list of anon structures",
46197c478bd9Sstevel@tonic-gate 		anon_walk_init, anon_walk_step, anon_walk_fini },
462087a18d3fSMadhavan Venkataraman 	{ "callouts_bytime", "walk callouts by list chain (expiration time)",
462187a18d3fSMadhavan Venkataraman 		callout_walk_init, callout_walk_step, callout_walk_fini,
462287a18d3fSMadhavan Venkataraman 		(void *)CALLOUT_WALK_BYLIST },
462387a18d3fSMadhavan Venkataraman 	{ "callouts_byid", "walk callouts by id hash chain",
462487a18d3fSMadhavan Venkataraman 		callout_walk_init, callout_walk_step, callout_walk_fini,
462587a18d3fSMadhavan Venkataraman 		(void *)CALLOUT_WALK_BYID },
462687a18d3fSMadhavan Venkataraman 	{ "callout_list", "walk a callout list", callout_list_walk_init,
462787a18d3fSMadhavan Venkataraman 		callout_list_walk_step, callout_list_walk_fini },
462887a18d3fSMadhavan Venkataraman 	{ "callout_table", "walk callout table array", callout_table_walk_init,
462987a18d3fSMadhavan Venkataraman 		callout_table_walk_step, callout_table_walk_fini },
46307c478bd9Sstevel@tonic-gate 	{ "cpu", "walk cpu structures", cpu_walk_init, cpu_walk_step },
46319dd0f810Scindi 	{ "ereportq_dump", "walk list of ereports in dump error queue",
46329dd0f810Scindi 		ereportq_dump_walk_init, ereportq_dump_walk_step, NULL },
46339dd0f810Scindi 	{ "ereportq_pend", "walk list of ereports in pending error queue",
46349dd0f810Scindi 		ereportq_pend_walk_init, ereportq_pend_walk_step, NULL },
46357c478bd9Sstevel@tonic-gate 	{ "errorq", "walk list of system error queues",
46367c478bd9Sstevel@tonic-gate 		errorq_walk_init, errorq_walk_step, NULL },
46377c478bd9Sstevel@tonic-gate 	{ "errorq_data", "walk pending error queue data buffers",
46387c478bd9Sstevel@tonic-gate 		eqd_walk_init, eqd_walk_step, eqd_walk_fini },
46397c478bd9Sstevel@tonic-gate 	{ "allfile", "given a proc pointer, list all file pointers",
46407c478bd9Sstevel@tonic-gate 		file_walk_init, allfile_walk_step, file_walk_fini },
46417c478bd9Sstevel@tonic-gate 	{ "file", "given a proc pointer, list of open file pointers",
46427c478bd9Sstevel@tonic-gate 		file_walk_init, file_walk_step, file_walk_fini },
46437c478bd9Sstevel@tonic-gate 	{ "lock_descriptor", "walk lock_descriptor_t structures",
46447c478bd9Sstevel@tonic-gate 		ld_walk_init, ld_walk_step, NULL },
46457c478bd9Sstevel@tonic-gate 	{ "lock_graph", "walk lock graph",
46467c478bd9Sstevel@tonic-gate 		lg_walk_init, lg_walk_step, NULL },
46477c478bd9Sstevel@tonic-gate 	{ "port", "given a proc pointer, list of created event ports",
46487c478bd9Sstevel@tonic-gate 		port_walk_init, port_walk_step, NULL },
46497c478bd9Sstevel@tonic-gate 	{ "portev", "given a port pointer, list of events in the queue",
46507c478bd9Sstevel@tonic-gate 		portev_walk_init, portev_walk_step, portev_walk_fini },
46517c478bd9Sstevel@tonic-gate 	{ "proc", "list of active proc_t structures",
46527c478bd9Sstevel@tonic-gate 		proc_walk_init, proc_walk_step, proc_walk_fini },
46537c478bd9Sstevel@tonic-gate 	{ "projects", "walk a list of kernel projects",
46547c478bd9Sstevel@tonic-gate 		project_walk_init, project_walk_step, NULL },
46557c478bd9Sstevel@tonic-gate 	{ "seg", "given an as, list of segments",
46567c478bd9Sstevel@tonic-gate 		seg_walk_init, avl_walk_step, avl_walk_fini },
46577c478bd9Sstevel@tonic-gate 	{ "sysevent_pend", "walk sysevent pending queue",
46587c478bd9Sstevel@tonic-gate 		sysevent_pend_walk_init, sysevent_walk_step,
46597c478bd9Sstevel@tonic-gate 		sysevent_walk_fini},
46607c478bd9Sstevel@tonic-gate 	{ "sysevent_sent", "walk sysevent sent queue", sysevent_sent_walk_init,
46617c478bd9Sstevel@tonic-gate 		sysevent_walk_step, sysevent_walk_fini},
46627c478bd9Sstevel@tonic-gate 	{ "sysevent_channel", "walk sysevent channel subscriptions",
46637c478bd9Sstevel@tonic-gate 		sysevent_channel_walk_init, sysevent_channel_walk_step,
46647c478bd9Sstevel@tonic-gate 		sysevent_channel_walk_fini},
46657c478bd9Sstevel@tonic-gate 	{ "sysevent_class_list", "walk sysevent subscription's class list",
46667c478bd9Sstevel@tonic-gate 		sysevent_class_list_walk_init, sysevent_class_list_walk_step,
46677c478bd9Sstevel@tonic-gate 		sysevent_class_list_walk_fini},
46687c478bd9Sstevel@tonic-gate 	{ "sysevent_subclass_list",
46697c478bd9Sstevel@tonic-gate 		"walk sysevent subscription's subclass list",
46707c478bd9Sstevel@tonic-gate 		sysevent_subclass_list_walk_init,
46717c478bd9Sstevel@tonic-gate 		sysevent_subclass_list_walk_step,
46727c478bd9Sstevel@tonic-gate 		sysevent_subclass_list_walk_fini},
46737c478bd9Sstevel@tonic-gate 	{ "task", "given a task pointer, walk its processes",
46747c478bd9Sstevel@tonic-gate 		task_walk_init, task_walk_step, NULL },
46757c478bd9Sstevel@tonic-gate 	{ "taskq_entry", "given a taskq_t*, list all taskq_ent_t in the list",
46767c478bd9Sstevel@tonic-gate 		taskq_walk_init, taskq_walk_step, NULL, NULL },
46777c478bd9Sstevel@tonic-gate 
4678fa9e4066Sahrens 	/* from avl.c */
4679fa9e4066Sahrens 	{ AVL_WALK_NAME, AVL_WALK_DESC,
4680fa9e4066Sahrens 		avl_walk_init, avl_walk_step, avl_walk_fini },
4681fa9e4066Sahrens 
46827c478bd9Sstevel@tonic-gate 	/* from bio.c */
46837c478bd9Sstevel@tonic-gate 	{ "buf", "walk the bio buf hash",
46847c478bd9Sstevel@tonic-gate 		buf_walk_init, buf_walk_step, buf_walk_fini },
46857c478bd9Sstevel@tonic-gate 
46867c478bd9Sstevel@tonic-gate 	/* from contract.c */
46877c478bd9Sstevel@tonic-gate 	{ "contract", "walk all contracts, or those of the specified type",
46887c478bd9Sstevel@tonic-gate 		ct_walk_init, generic_walk_step, NULL },
46897c478bd9Sstevel@tonic-gate 	{ "ct_event", "walk events on a contract event queue",
46907c478bd9Sstevel@tonic-gate 		ct_event_walk_init, generic_walk_step, NULL },
46917c478bd9Sstevel@tonic-gate 	{ "ct_listener", "walk contract event queue listeners",
46927c478bd9Sstevel@tonic-gate 		ct_listener_walk_init, generic_walk_step, NULL },
46937c478bd9Sstevel@tonic-gate 
46947c478bd9Sstevel@tonic-gate 	/* from cpupart.c */
46957c478bd9Sstevel@tonic-gate 	{ "cpupart_cpulist", "given an cpupart_t, walk cpus in partition",
46967c478bd9Sstevel@tonic-gate 		cpupart_cpulist_walk_init, cpupart_cpulist_walk_step,
46977c478bd9Sstevel@tonic-gate 		NULL },
46987c478bd9Sstevel@tonic-gate 	{ "cpupart_walk", "walk the set of cpu partitions",
46997c478bd9Sstevel@tonic-gate 		cpupart_walk_init, cpupart_walk_step, NULL },
47007c478bd9Sstevel@tonic-gate 
47017c478bd9Sstevel@tonic-gate 	/* from ctxop.c */
47027c478bd9Sstevel@tonic-gate 	{ "ctxop", "walk list of context ops on a thread",
47037c478bd9Sstevel@tonic-gate 		ctxop_walk_init, ctxop_walk_step, ctxop_walk_fini },
47047c478bd9Sstevel@tonic-gate 
47057c478bd9Sstevel@tonic-gate 	/* from cyclic.c */
47067c478bd9Sstevel@tonic-gate 	{ "cyccpu", "walk per-CPU cyc_cpu structures",
47077c478bd9Sstevel@tonic-gate 		cyccpu_walk_init, cyccpu_walk_step, NULL },
47087c478bd9Sstevel@tonic-gate 	{ "cycomni", "for an omnipresent cyclic, walk cyc_omni_cpu list",
47097c478bd9Sstevel@tonic-gate 		cycomni_walk_init, cycomni_walk_step, NULL },
47107c478bd9Sstevel@tonic-gate 	{ "cyctrace", "walk cyclic trace buffer",
47117c478bd9Sstevel@tonic-gate 		cyctrace_walk_init, cyctrace_walk_step, cyctrace_walk_fini },
47127c478bd9Sstevel@tonic-gate 
47137c478bd9Sstevel@tonic-gate 	/* from devinfo.c */
47147c478bd9Sstevel@tonic-gate 	{ "binding_hash", "walk all entries in binding hash table",
47157c478bd9Sstevel@tonic-gate 		binding_hash_walk_init, binding_hash_walk_step, NULL },
47167c478bd9Sstevel@tonic-gate 	{ "devinfo", "walk devinfo tree or subtree",
47177c478bd9Sstevel@tonic-gate 		devinfo_walk_init, devinfo_walk_step, devinfo_walk_fini },
47187c478bd9Sstevel@tonic-gate 	{ "devinfo_audit_log", "walk devinfo audit system-wide log",
47197c478bd9Sstevel@tonic-gate 		devinfo_audit_log_walk_init, devinfo_audit_log_walk_step,
47207c478bd9Sstevel@tonic-gate 		devinfo_audit_log_walk_fini},
47217c478bd9Sstevel@tonic-gate 	{ "devinfo_audit_node", "walk per-devinfo audit history",
47227c478bd9Sstevel@tonic-gate 		devinfo_audit_node_walk_init, devinfo_audit_node_walk_step,
47237c478bd9Sstevel@tonic-gate 		devinfo_audit_node_walk_fini},
47247c478bd9Sstevel@tonic-gate 	{ "devinfo_children", "walk children of devinfo node",
47257c478bd9Sstevel@tonic-gate 		devinfo_children_walk_init, devinfo_children_walk_step,
47267c478bd9Sstevel@tonic-gate 		devinfo_children_walk_fini },
47277c478bd9Sstevel@tonic-gate 	{ "devinfo_parents", "walk ancestors of devinfo node",
47287c478bd9Sstevel@tonic-gate 		devinfo_parents_walk_init, devinfo_parents_walk_step,
47297c478bd9Sstevel@tonic-gate 		devinfo_parents_walk_fini },
47307c478bd9Sstevel@tonic-gate 	{ "devinfo_siblings", "walk siblings of devinfo node",
47317c478bd9Sstevel@tonic-gate 		devinfo_siblings_walk_init, devinfo_siblings_walk_step, NULL },
47327c478bd9Sstevel@tonic-gate 	{ "devi_next", "walk devinfo list",
47337c478bd9Sstevel@tonic-gate 		NULL, devi_next_walk_step, NULL },
47347c478bd9Sstevel@tonic-gate 	{ "devnames", "walk devnames array",
47357c478bd9Sstevel@tonic-gate 		devnames_walk_init, devnames_walk_step, devnames_walk_fini },
47367c478bd9Sstevel@tonic-gate 	{ "minornode", "given a devinfo node, walk minor nodes",
47377c478bd9Sstevel@tonic-gate 		minornode_walk_init, minornode_walk_step, NULL },
47387c478bd9Sstevel@tonic-gate 	{ "softstate",
47397c478bd9Sstevel@tonic-gate 		"given an i_ddi_soft_state*, list all in-use driver stateps",
47407c478bd9Sstevel@tonic-gate 		soft_state_walk_init, soft_state_walk_step,
47417c478bd9Sstevel@tonic-gate 		NULL, NULL },
47427c478bd9Sstevel@tonic-gate 	{ "softstate_all",
47437c478bd9Sstevel@tonic-gate 		"given an i_ddi_soft_state*, list all driver stateps",
47447c478bd9Sstevel@tonic-gate 		soft_state_walk_init, soft_state_all_walk_step,
47457c478bd9Sstevel@tonic-gate 		NULL, NULL },
47467c478bd9Sstevel@tonic-gate 	{ "devinfo_fmc",
47477c478bd9Sstevel@tonic-gate 		"walk a fault management handle cache active list",
47487c478bd9Sstevel@tonic-gate 		devinfo_fmc_walk_init, devinfo_fmc_walk_step, NULL },
47497c478bd9Sstevel@tonic-gate 
4750*4c06356bSdh 	/* from group.c */
4751*4c06356bSdh 	{ "group", "walk all elements of a group",
4752*4c06356bSdh 		group_walk_init, group_walk_step, NULL },
4753*4c06356bSdh 
47545febcb4aSScott Carter, SD IOSW 	/* from irm.c */
47555febcb4aSScott Carter, SD IOSW 	{ "irmpools", "walk global list of interrupt pools",
47565febcb4aSScott Carter, SD IOSW 	    irmpools_walk_init, list_walk_step, list_walk_fini },
47575febcb4aSScott Carter, SD IOSW 	{ "irmreqs", "walk list of interrupt requests in an interrupt pool",
47585febcb4aSScott Carter, SD IOSW 	    irmreqs_walk_init, list_walk_step, list_walk_fini },
47595febcb4aSScott Carter, SD IOSW 
47607c478bd9Sstevel@tonic-gate 	/* from kmem.c */
47617c478bd9Sstevel@tonic-gate 	{ "allocdby", "given a thread, walk its allocated bufctls",
47627c478bd9Sstevel@tonic-gate 		allocdby_walk_init, allocdby_walk_step, allocdby_walk_fini },
47637c478bd9Sstevel@tonic-gate 	{ "bufctl", "walk a kmem cache's bufctls",
47647c478bd9Sstevel@tonic-gate 		bufctl_walk_init, kmem_walk_step, kmem_walk_fini },
47657c478bd9Sstevel@tonic-gate 	{ "bufctl_history", "walk the available history of a bufctl",
47667c478bd9Sstevel@tonic-gate 		bufctl_history_walk_init, bufctl_history_walk_step,
47677c478bd9Sstevel@tonic-gate 		bufctl_history_walk_fini },
47687c478bd9Sstevel@tonic-gate 	{ "freedby", "given a thread, walk its freed bufctls",
47697c478bd9Sstevel@tonic-gate 		freedby_walk_init, allocdby_walk_step, allocdby_walk_fini },
47707c478bd9Sstevel@tonic-gate 	{ "freectl", "walk a kmem cache's free bufctls",
47717c478bd9Sstevel@tonic-gate 		freectl_walk_init, kmem_walk_step, kmem_walk_fini },
47727c478bd9Sstevel@tonic-gate 	{ "freectl_constructed", "walk a kmem cache's constructed free bufctls",
47737c478bd9Sstevel@tonic-gate 		freectl_constructed_walk_init, kmem_walk_step, kmem_walk_fini },
47747c478bd9Sstevel@tonic-gate 	{ "freemem", "walk a kmem cache's free memory",
47757c478bd9Sstevel@tonic-gate 		freemem_walk_init, kmem_walk_step, kmem_walk_fini },
47767c478bd9Sstevel@tonic-gate 	{ "freemem_constructed", "walk a kmem cache's constructed free memory",
47777c478bd9Sstevel@tonic-gate 		freemem_constructed_walk_init, kmem_walk_step, kmem_walk_fini },
47787c478bd9Sstevel@tonic-gate 	{ "kmem", "walk a kmem cache",
47797c478bd9Sstevel@tonic-gate 		kmem_walk_init, kmem_walk_step, kmem_walk_fini },
47807c478bd9Sstevel@tonic-gate 	{ "kmem_cpu_cache", "given a kmem cache, walk its per-CPU caches",
47817c478bd9Sstevel@tonic-gate 		kmem_cpu_cache_walk_init, kmem_cpu_cache_walk_step, NULL },
47827c478bd9Sstevel@tonic-gate 	{ "kmem_hash", "given a kmem cache, walk its allocated hash table",
47837c478bd9Sstevel@tonic-gate 		kmem_hash_walk_init, kmem_hash_walk_step, kmem_hash_walk_fini },
47847c478bd9Sstevel@tonic-gate 	{ "kmem_log", "walk the kmem transaction log",
47857c478bd9Sstevel@tonic-gate 		kmem_log_walk_init, kmem_log_walk_step, kmem_log_walk_fini },
47867c478bd9Sstevel@tonic-gate 	{ "kmem_slab", "given a kmem cache, walk its slabs",
4787b5fca8f8Stomee 		kmem_slab_walk_init, combined_walk_step, combined_walk_fini },
47887c478bd9Sstevel@tonic-gate 	{ "kmem_slab_partial",
47897c478bd9Sstevel@tonic-gate 	    "given a kmem cache, walk its partially allocated slabs (min 1)",
4790b5fca8f8Stomee 		kmem_slab_walk_partial_init, combined_walk_step,
4791b5fca8f8Stomee 		combined_walk_fini },
47927c478bd9Sstevel@tonic-gate 	{ "vmem", "walk vmem structures in pre-fix, depth-first order",
47937c478bd9Sstevel@tonic-gate 		vmem_walk_init, vmem_walk_step, vmem_walk_fini },
47947c478bd9Sstevel@tonic-gate 	{ "vmem_alloc", "given a vmem_t, walk its allocated vmem_segs",
47957c478bd9Sstevel@tonic-gate 		vmem_alloc_walk_init, vmem_seg_walk_step, vmem_seg_walk_fini },
47967c478bd9Sstevel@tonic-gate 	{ "vmem_free", "given a vmem_t, walk its free vmem_segs",
47977c478bd9Sstevel@tonic-gate 		vmem_free_walk_init, vmem_seg_walk_step, vmem_seg_walk_fini },
47987c478bd9Sstevel@tonic-gate 	{ "vmem_postfix", "walk vmem structures in post-fix, depth-first order",
47997c478bd9Sstevel@tonic-gate 		vmem_walk_init, vmem_postfix_walk_step, vmem_walk_fini },
48007c478bd9Sstevel@tonic-gate 	{ "vmem_seg", "given a vmem_t, walk all of its vmem_segs",
48017c478bd9Sstevel@tonic-gate 		vmem_seg_walk_init, vmem_seg_walk_step, vmem_seg_walk_fini },
48027c478bd9Sstevel@tonic-gate 	{ "vmem_span", "given a vmem_t, walk its spanning vmem_segs",
48037c478bd9Sstevel@tonic-gate 		vmem_span_walk_init, vmem_seg_walk_step, vmem_seg_walk_fini },
48047c478bd9Sstevel@tonic-gate 
48057c478bd9Sstevel@tonic-gate 	/* from ldi.c */
48067c478bd9Sstevel@tonic-gate 	{ "ldi_handle", "walk the layered driver handle hash",
48077c478bd9Sstevel@tonic-gate 		ldi_handle_walk_init, ldi_handle_walk_step, NULL },
48087c478bd9Sstevel@tonic-gate 	{ "ldi_ident", "walk the layered driver identifier hash",
48097c478bd9Sstevel@tonic-gate 		ldi_ident_walk_init, ldi_ident_walk_step, NULL },
48107c478bd9Sstevel@tonic-gate 
48117c478bd9Sstevel@tonic-gate 	/* from leaky.c + leaky_subr.c */
48127c478bd9Sstevel@tonic-gate 	{ "leak", "given a leaked bufctl or vmem_seg, find leaks w/ same "
48137c478bd9Sstevel@tonic-gate 	    "stack trace",
48147c478bd9Sstevel@tonic-gate 		leaky_walk_init, leaky_walk_step, leaky_walk_fini },
48157c478bd9Sstevel@tonic-gate 	{ "leakbuf", "given a leaked bufctl or vmem_seg, walk buffers for "
48167c478bd9Sstevel@tonic-gate 	    "leaks w/ same stack trace",
48177c478bd9Sstevel@tonic-gate 		leaky_walk_init, leaky_buf_walk_step, leaky_walk_fini },
48187c478bd9Sstevel@tonic-gate 
48197c478bd9Sstevel@tonic-gate 	/* from lgrp.c */
4820c6402783Sakolb 	{ "lgrp_cpulist", "walk CPUs in a given lgroup",
4821c6402783Sakolb 		lgrp_cpulist_walk_init, lgrp_cpulist_walk_step, NULL },
4822c6402783Sakolb 	{ "lgrptbl", "walk lgroup table",
48237c478bd9Sstevel@tonic-gate 		lgrp_walk_init, lgrp_walk_step, NULL },
4824c6402783Sakolb 	{ "lgrp_parents", "walk up lgroup lineage from given lgroup",
4825c6402783Sakolb 		lgrp_parents_walk_init, lgrp_parents_walk_step, NULL },
4826c6402783Sakolb 	{ "lgrp_rsrc_mem", "walk lgroup memory resources of given lgroup",
4827c6402783Sakolb 		lgrp_rsrc_mem_walk_init, lgrp_set_walk_step, NULL },
4828c6402783Sakolb 	{ "lgrp_rsrc_cpu", "walk lgroup CPU resources of given lgroup",
4829c6402783Sakolb 		lgrp_rsrc_cpu_walk_init, lgrp_set_walk_step, NULL },
48307c478bd9Sstevel@tonic-gate 
48317c478bd9Sstevel@tonic-gate 	/* from list.c */
4832fa9e4066Sahrens 	{ LIST_WALK_NAME, LIST_WALK_DESC,
48337c478bd9Sstevel@tonic-gate 		list_walk_init, list_walk_step, list_walk_fini },
48347c478bd9Sstevel@tonic-gate 
4835*4c06356bSdh 	/* from mdi.c */
4836*4c06356bSdh 	{ "mdipi_client_list", "Walker for mdi_pathinfo pi_client_link",
4837*4c06356bSdh 		mdi_pi_client_link_walk_init,
4838*4c06356bSdh 		mdi_pi_client_link_walk_step,
4839*4c06356bSdh 		mdi_pi_client_link_walk_fini },
4840*4c06356bSdh 	{ "mdipi_phci_list", "Walker for mdi_pathinfo pi_phci_link",
4841*4c06356bSdh 		mdi_pi_phci_link_walk_init,
4842*4c06356bSdh 		mdi_pi_phci_link_walk_step,
4843*4c06356bSdh 		mdi_pi_phci_link_walk_fini },
4844*4c06356bSdh 	{ "mdiphci_list", "Walker for mdi_phci ph_next link",
4845*4c06356bSdh 		mdi_phci_ph_next_walk_init,
4846*4c06356bSdh 		mdi_phci_ph_next_walk_step,
4847*4c06356bSdh 		mdi_phci_ph_next_walk_fini },
4848*4c06356bSdh 
48497c478bd9Sstevel@tonic-gate 	/* from memory.c */
48507c478bd9Sstevel@tonic-gate 	{ "page", "walk all pages, or those from the specified vnode",
48517c478bd9Sstevel@tonic-gate 		page_walk_init, page_walk_step, page_walk_fini },
4852d20abfaaSPavel Tatashin 	{ "allpages", "walk all pages, including free pages",
4853d20abfaaSPavel Tatashin 		allpages_walk_init, allpages_walk_step, allpages_walk_fini },
48547c478bd9Sstevel@tonic-gate 	{ "memlist", "walk specified memlist",
48557c478bd9Sstevel@tonic-gate 		NULL, memlist_walk_step, NULL },
48567c478bd9Sstevel@tonic-gate 	{ "swapinfo", "walk swapinfo structures",
48577c478bd9Sstevel@tonic-gate 		swap_walk_init, swap_walk_step, NULL },
48587c478bd9Sstevel@tonic-gate 
48597c478bd9Sstevel@tonic-gate 	/* from mmd.c */
48607c478bd9Sstevel@tonic-gate 	{ "pattr", "walk pattr_t structures", pattr_walk_init,
48617c478bd9Sstevel@tonic-gate 		mmdq_walk_step, mmdq_walk_fini },
48627c478bd9Sstevel@tonic-gate 	{ "pdesc", "walk pdesc_t structures",
48637c478bd9Sstevel@tonic-gate 		pdesc_walk_init, mmdq_walk_step, mmdq_walk_fini },
48647c478bd9Sstevel@tonic-gate 	{ "pdesc_slab", "walk pdesc_slab_t structures",
48657c478bd9Sstevel@tonic-gate 		pdesc_slab_walk_init, mmdq_walk_step, mmdq_walk_fini },
48667c478bd9Sstevel@tonic-gate 
48677c478bd9Sstevel@tonic-gate 	/* from modhash.c */
48687c478bd9Sstevel@tonic-gate 	{ "modhash", "walk list of mod_hash structures", modhash_walk_init,
48697c478bd9Sstevel@tonic-gate 		modhash_walk_step, NULL },
48707c478bd9Sstevel@tonic-gate 	{ "modent", "walk list of entries in a given mod_hash",
48717c478bd9Sstevel@tonic-gate 		modent_walk_init, modent_walk_step, modent_walk_fini },
48727c478bd9Sstevel@tonic-gate 	{ "modchain", "walk list of entries in a given mod_hash_entry",
48737c478bd9Sstevel@tonic-gate 		NULL, modchain_walk_step, NULL },
48747c478bd9Sstevel@tonic-gate 
48757c478bd9Sstevel@tonic-gate 	/* from net.c */
4876f4b3ec61Sdh 	{ "ar", "walk ar_t structures using MI for all stacks",
4877f4b3ec61Sdh 		mi_payload_walk_init, mi_payload_walk_step, NULL, &mi_ar_arg },
4878f4b3ec61Sdh 	{ "icmp", "walk ICMP control structures using MI for all stacks",
4879f4b3ec61Sdh 		mi_payload_walk_init, mi_payload_walk_step, NULL,
4880f4b3ec61Sdh 		&mi_icmp_arg },
48817c478bd9Sstevel@tonic-gate 	{ "mi", "given a MI_O, walk the MI",
48827c478bd9Sstevel@tonic-gate 		mi_walk_init, mi_walk_step, mi_walk_fini, NULL },
48837c478bd9Sstevel@tonic-gate 	{ "sonode", "given a sonode, walk its children",
48847c478bd9Sstevel@tonic-gate 		sonode_walk_init, sonode_walk_step, sonode_walk_fini, NULL },
4885f4b3ec61Sdh 	{ "ar_stacks", "walk all the ar_stack_t",
4886f4b3ec61Sdh 		ar_stacks_walk_init, ar_stacks_walk_step, NULL },
4887f4b3ec61Sdh 	{ "icmp_stacks", "walk all the icmp_stack_t",
4888f4b3ec61Sdh 		icmp_stacks_walk_init, icmp_stacks_walk_step, NULL },
4889f4b3ec61Sdh 	{ "tcp_stacks", "walk all the tcp_stack_t",
4890f4b3ec61Sdh 		tcp_stacks_walk_init, tcp_stacks_walk_step, NULL },
4891f4b3ec61Sdh 	{ "udp_stacks", "walk all the udp_stack_t",
4892f4b3ec61Sdh 		udp_stacks_walk_init, udp_stacks_walk_step, NULL },
4893f4b3ec61Sdh 
4894*4c06356bSdh 	/* from netstack.c */
4895*4c06356bSdh 	{ "netstack", "walk a list of kernel netstacks",
4896*4c06356bSdh 		netstack_walk_init, netstack_walk_step, NULL },
4897*4c06356bSdh 
48987c478bd9Sstevel@tonic-gate 	/* from nvpair.c */
48997c478bd9Sstevel@tonic-gate 	{ NVPAIR_WALKER_NAME, NVPAIR_WALKER_DESCR,
49007c478bd9Sstevel@tonic-gate 		nvpair_walk_init, nvpair_walk_step, NULL },
49017c478bd9Sstevel@tonic-gate 
49027c478bd9Sstevel@tonic-gate 	/* from rctl.c */
49037c478bd9Sstevel@tonic-gate 	{ "rctl_dict_list", "walk all rctl_dict_entry_t's from rctl_lists",
49047c478bd9Sstevel@tonic-gate 		rctl_dict_walk_init, rctl_dict_walk_step, NULL },
49057c478bd9Sstevel@tonic-gate 	{ "rctl_set", "given a rctl_set, walk all rctls", rctl_set_walk_init,
49067c478bd9Sstevel@tonic-gate 		rctl_set_walk_step, NULL },
49077c478bd9Sstevel@tonic-gate 	{ "rctl_val", "given a rctl_t, walk all rctl_val entries associated",
49087c478bd9Sstevel@tonic-gate 		rctl_val_walk_init, rctl_val_walk_step },
49097c478bd9Sstevel@tonic-gate 
49107c478bd9Sstevel@tonic-gate 	/* from sobj.c */
49117c478bd9Sstevel@tonic-gate 	{ "blocked", "walk threads blocked on a given sobj",
49127c478bd9Sstevel@tonic-gate 		blocked_walk_init, blocked_walk_step, NULL },
49137c478bd9Sstevel@tonic-gate 	{ "wchan", "given a wchan, list of blocked threads",
49147c478bd9Sstevel@tonic-gate 		wchan_walk_init, wchan_walk_step, wchan_walk_fini },
49157c478bd9Sstevel@tonic-gate 
49167c478bd9Sstevel@tonic-gate 	/* from stream.c */
49177c478bd9Sstevel@tonic-gate 	{ "b_cont", "walk mblk_t list using b_cont",
49187c478bd9Sstevel@tonic-gate 		mblk_walk_init, b_cont_step, mblk_walk_fini },
49197c478bd9Sstevel@tonic-gate 	{ "b_next", "walk mblk_t list using b_next",
49207c478bd9Sstevel@tonic-gate 		mblk_walk_init, b_next_step, mblk_walk_fini },
49217c478bd9Sstevel@tonic-gate 	{ "qlink", "walk queue_t list using q_link",
49227c478bd9Sstevel@tonic-gate 		queue_walk_init, queue_link_step, queue_walk_fini },
49237c478bd9Sstevel@tonic-gate 	{ "qnext", "walk queue_t list using q_next",
49247c478bd9Sstevel@tonic-gate 		queue_walk_init, queue_next_step, queue_walk_fini },
49257c478bd9Sstevel@tonic-gate 	{ "strftblk", "given a dblk_t, walk STREAMS flow trace event list",
49267c478bd9Sstevel@tonic-gate 		strftblk_walk_init, strftblk_step, strftblk_walk_fini },
49277c478bd9Sstevel@tonic-gate 	{ "readq", "walk read queue side of stdata",
49287c478bd9Sstevel@tonic-gate 		str_walk_init, strr_walk_step, str_walk_fini },
49297c478bd9Sstevel@tonic-gate 	{ "writeq", "walk write queue side of stdata",
49307c478bd9Sstevel@tonic-gate 		str_walk_init, strw_walk_step, str_walk_fini },
49317c478bd9Sstevel@tonic-gate 
49327c478bd9Sstevel@tonic-gate 	/* from thread.c */
49337c478bd9Sstevel@tonic-gate 	{ "deathrow", "walk threads on both lwp_ and thread_deathrow",
49347c478bd9Sstevel@tonic-gate 		deathrow_walk_init, deathrow_walk_step, NULL },
49357c478bd9Sstevel@tonic-gate 	{ "cpu_dispq", "given a cpu_t, walk threads in dispatcher queues",
49367c478bd9Sstevel@tonic-gate 		cpu_dispq_walk_init, dispq_walk_step, dispq_walk_fini },
49377c478bd9Sstevel@tonic-gate 	{ "cpupart_dispq",
49387c478bd9Sstevel@tonic-gate 		"given a cpupart_t, walk threads in dispatcher queues",
49397c478bd9Sstevel@tonic-gate 		cpupart_dispq_walk_init, dispq_walk_step, dispq_walk_fini },
49407c478bd9Sstevel@tonic-gate 	{ "lwp_deathrow", "walk lwp_deathrow",
49417c478bd9Sstevel@tonic-gate 		lwp_deathrow_walk_init, deathrow_walk_step, NULL },
49427c478bd9Sstevel@tonic-gate 	{ "thread", "global or per-process kthread_t structures",
49437c478bd9Sstevel@tonic-gate 		thread_walk_init, thread_walk_step, thread_walk_fini },
49447c478bd9Sstevel@tonic-gate 	{ "thread_deathrow", "walk threads on thread_deathrow",
49457c478bd9Sstevel@tonic-gate 		thread_deathrow_walk_init, deathrow_walk_step, NULL },
49467c478bd9Sstevel@tonic-gate 
49477c478bd9Sstevel@tonic-gate 	/* from tsd.c */
49487c478bd9Sstevel@tonic-gate 	{ "tsd", "walk list of thread-specific data",
49497c478bd9Sstevel@tonic-gate 		tsd_walk_init, tsd_walk_step, tsd_walk_fini },
49507c478bd9Sstevel@tonic-gate 
495145916cd2Sjpk 	/* from tsol.c */
495245916cd2Sjpk 	{ "tnrh", "walk remote host cache structures",
495345916cd2Sjpk 	    tnrh_walk_init, tnrh_walk_step, tnrh_walk_fini },
495445916cd2Sjpk 	{ "tnrhtp", "walk remote host template structures",
495545916cd2Sjpk 	    tnrhtp_walk_init, tnrhtp_walk_step, tnrhtp_walk_fini },
495645916cd2Sjpk 
49577c478bd9Sstevel@tonic-gate 	/*
49587c478bd9Sstevel@tonic-gate 	 * typegraph does not work under kmdb, as it requires too much memory
49597c478bd9Sstevel@tonic-gate 	 * for its internal data structures.
49607c478bd9Sstevel@tonic-gate 	 */
49617c478bd9Sstevel@tonic-gate #ifndef _KMDB
49627c478bd9Sstevel@tonic-gate 	/* from typegraph.c */
49637c478bd9Sstevel@tonic-gate 	{ "typeconflict", "walk buffers with conflicting type inferences",
49647c478bd9Sstevel@tonic-gate 		typegraph_walk_init, typeconflict_walk_step },
49657c478bd9Sstevel@tonic-gate 	{ "typeunknown", "walk buffers with unknown types",
49667c478bd9Sstevel@tonic-gate 		typegraph_walk_init, typeunknown_walk_step },
49677c478bd9Sstevel@tonic-gate #endif
49687c478bd9Sstevel@tonic-gate 
49697c478bd9Sstevel@tonic-gate 	/* from vfs.c */
49707c478bd9Sstevel@tonic-gate 	{ "vfs", "walk file system list",
49717c478bd9Sstevel@tonic-gate 		vfs_walk_init, vfs_walk_step },
497270ab954aSramat 
4973*4c06356bSdh 	/* from zone.c */
4974*4c06356bSdh 	{ "zone", "walk a list of kernel zones",
4975*4c06356bSdh 		zone_walk_init, zone_walk_step, NULL },
4976*4c06356bSdh 	{ "zsd", "walk list of zsd entries for a zone",
4977*4c06356bSdh 		zsd_walk_init, zsd_walk_step, NULL },
4978f4b3ec61Sdh 
49797c478bd9Sstevel@tonic-gate 	{ NULL }
49807c478bd9Sstevel@tonic-gate };
49817c478bd9Sstevel@tonic-gate 
49827c478bd9Sstevel@tonic-gate static const mdb_modinfo_t modinfo = { MDB_API_VERSION, dcmds, walkers };
49837c478bd9Sstevel@tonic-gate 
4984346799e8SJonathan W Adams /*ARGSUSED*/
4985346799e8SJonathan W Adams static void
4986346799e8SJonathan W Adams genunix_statechange_cb(void *ignored)
4987346799e8SJonathan W Adams {
4988346799e8SJonathan W Adams 	/*
4989346799e8SJonathan W Adams 	 * Force ::findleaks and ::stacks to let go any cached state.
4990346799e8SJonathan W Adams 	 */
4991346799e8SJonathan W Adams 	leaky_cleanup(1);
4992346799e8SJonathan W Adams 	stacks_cleanup(1);
4993346799e8SJonathan W Adams 
4994346799e8SJonathan W Adams 	kmem_statechange();	/* notify kmem */
4995346799e8SJonathan W Adams }
4996346799e8SJonathan W Adams 
49977c478bd9Sstevel@tonic-gate const mdb_modinfo_t *
49987c478bd9Sstevel@tonic-gate _mdb_init(void)
49997c478bd9Sstevel@tonic-gate {
50007c478bd9Sstevel@tonic-gate 	kmem_init();
50017c478bd9Sstevel@tonic-gate 
5002346799e8SJonathan W Adams 	(void) mdb_callback_add(MDB_CALLBACK_STCHG,
5003346799e8SJonathan W Adams 	    genunix_statechange_cb, NULL);
5004346799e8SJonathan W Adams 
50057c478bd9Sstevel@tonic-gate 	return (&modinfo);
50067c478bd9Sstevel@tonic-gate }
50077c478bd9Sstevel@tonic-gate 
50087c478bd9Sstevel@tonic-gate void
50097c478bd9Sstevel@tonic-gate _mdb_fini(void)
50107c478bd9Sstevel@tonic-gate {
50117c478bd9Sstevel@tonic-gate 	leaky_cleanup(1);
5012346799e8SJonathan W Adams 	stacks_cleanup(1);
50137c478bd9Sstevel@tonic-gate }
5014