xref: /illumos-gate/usr/src/cmd/mdb/common/modules/genunix/genunix.c (revision 892ad1623e11186cba8b2eb40d70318d2cb89605)
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 /*
220605fe78SGordon Ross  * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
23d7025c85SJonathan Adams  * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
24ab618543SJohn Levon  * Copyright (c) 2018, Joyent, Inc.
252a12f85aSJeremy Jones  * Copyright (c) 2013 by Delphix. All rights reserved.
267c478bd9Sstevel@tonic-gate  */
277c478bd9Sstevel@tonic-gate 
287c478bd9Sstevel@tonic-gate #include <mdb/mdb_param.h>
297c478bd9Sstevel@tonic-gate #include <mdb/mdb_modapi.h>
307c478bd9Sstevel@tonic-gate #include <mdb/mdb_ks.h>
317c478bd9Sstevel@tonic-gate #include <mdb/mdb_ctf.h>
327c478bd9Sstevel@tonic-gate 
337c478bd9Sstevel@tonic-gate #include <sys/types.h>
347c478bd9Sstevel@tonic-gate #include <sys/thread.h>
357c478bd9Sstevel@tonic-gate #include <sys/session.h>
367c478bd9Sstevel@tonic-gate #include <sys/user.h>
377c478bd9Sstevel@tonic-gate #include <sys/proc.h>
387c478bd9Sstevel@tonic-gate #include <sys/var.h>
397c478bd9Sstevel@tonic-gate #include <sys/t_lock.h>
407c478bd9Sstevel@tonic-gate #include <sys/callo.h>
417c478bd9Sstevel@tonic-gate #include <sys/priocntl.h>
427c478bd9Sstevel@tonic-gate #include <sys/class.h>
437c478bd9Sstevel@tonic-gate #include <sys/regset.h>
447c478bd9Sstevel@tonic-gate #include <sys/stack.h>
457c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h>
467c478bd9Sstevel@tonic-gate #include <sys/vnode.h>
477c478bd9Sstevel@tonic-gate #include <sys/vfs.h>
487c478bd9Sstevel@tonic-gate #include <sys/flock_impl.h>
497c478bd9Sstevel@tonic-gate #include <sys/kmem_impl.h>
507c478bd9Sstevel@tonic-gate #include <sys/vmem_impl.h>
517c478bd9Sstevel@tonic-gate #include <sys/kstat.h>
527c478bd9Sstevel@tonic-gate #include <sys/dditypes.h>
537c478bd9Sstevel@tonic-gate #include <sys/ddi_impldefs.h>
547c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
557c478bd9Sstevel@tonic-gate #include <sys/sysconf.h>
567c478bd9Sstevel@tonic-gate #include <sys/task.h>
577c478bd9Sstevel@tonic-gate #include <sys/project.h>
587c478bd9Sstevel@tonic-gate #include <sys/errorq_impl.h>
597c478bd9Sstevel@tonic-gate #include <sys/cred_impl.h>
607c478bd9Sstevel@tonic-gate #include <sys/zone.h>
617c478bd9Sstevel@tonic-gate #include <sys/panic.h>
627c478bd9Sstevel@tonic-gate #include <regex.h>
637c478bd9Sstevel@tonic-gate #include <sys/port_impl.h>
647c478bd9Sstevel@tonic-gate 
65fa9e4066Sahrens #include "avl.h"
664c06356bSdh #include "bio.h"
674c06356bSdh #include "bitset.h"
68b5fca8f8Stomee #include "combined.h"
697c478bd9Sstevel@tonic-gate #include "contract.h"
707c478bd9Sstevel@tonic-gate #include "cpupart_mdb.h"
710605fe78SGordon Ross #include "cred.h"
724c06356bSdh #include "ctxop.h"
734c06356bSdh #include "cyclic.h"
744c06356bSdh #include "damap.h"
75a288e5a9SJoshua M. Clulow #include "ddi_periodic.h"
767c478bd9Sstevel@tonic-gate #include "devinfo.h"
7739f030b8SPatrick Mooney #include "dnlc.h"
784c06356bSdh #include "findstack.h"
794c06356bSdh #include "fm.h"
802a12f85aSJeremy Jones #include "gcore.h"
814c06356bSdh #include "group.h"
825febcb4aSScott Carter, SD IOSW #include "irm.h"
834c06356bSdh #include "kgrep.h"
844c06356bSdh #include "kmem.h"
854c06356bSdh #include "ldi.h"
867c478bd9Sstevel@tonic-gate #include "leaky.h"
877c478bd9Sstevel@tonic-gate #include "lgrp.h"
887c478bd9Sstevel@tonic-gate #include "list.h"
897c478bd9Sstevel@tonic-gate #include "log.h"
904c06356bSdh #include "mdi.h"
914c06356bSdh #include "memory.h"
927c478bd9Sstevel@tonic-gate #include "mmd.h"
934c06356bSdh #include "modhash.h"
944c06356bSdh #include "ndievents.h"
957c478bd9Sstevel@tonic-gate #include "net.h"
96f4b3ec61Sdh #include "netstack.h"
977c478bd9Sstevel@tonic-gate #include "nvpair.h"
984c06356bSdh #include "pg.h"
994c06356bSdh #include "rctl.h"
1007c478bd9Sstevel@tonic-gate #include "sobj.h"
1014c06356bSdh #include "streams.h"
1027c478bd9Sstevel@tonic-gate #include "sysevent.h"
103e0ad97e3SJonathan Adams #include "taskq.h"
1044c06356bSdh #include "thread.h"
1054c06356bSdh #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"
11026947304SEvan Yan #include "hotplug.h"
1117c478bd9Sstevel@tonic-gate 
1127c478bd9Sstevel@tonic-gate /*
1137c478bd9Sstevel@tonic-gate  * Surely this is defined somewhere...
1147c478bd9Sstevel@tonic-gate  */
1157c478bd9Sstevel@tonic-gate #define	NINTR		16
1167c478bd9Sstevel@tonic-gate 
117bb8b5132Sek #define	KILOS		10
118bb8b5132Sek #define	MEGS		20
119bb8b5132Sek #define	GIGS		30
120bb8b5132Sek 
1217c478bd9Sstevel@tonic-gate #ifndef STACK_BIAS
1227c478bd9Sstevel@tonic-gate #define	STACK_BIAS	0
1237c478bd9Sstevel@tonic-gate #endif
1247c478bd9Sstevel@tonic-gate 
1257c478bd9Sstevel@tonic-gate static char
1267c478bd9Sstevel@tonic-gate pstat2ch(uchar_t state)
1277c478bd9Sstevel@tonic-gate {
1287c478bd9Sstevel@tonic-gate 	switch (state) {
1297c478bd9Sstevel@tonic-gate 		case SSLEEP: return ('S');
1307c478bd9Sstevel@tonic-gate 		case SRUN: return ('R');
1317c478bd9Sstevel@tonic-gate 		case SZOMB: return ('Z');
1327c478bd9Sstevel@tonic-gate 		case SIDL: return ('I');
1337c478bd9Sstevel@tonic-gate 		case SONPROC: return ('O');
1347c478bd9Sstevel@tonic-gate 		case SSTOP: return ('T');
135c97ad5cdSakolb 		case SWAIT: return ('W');
1367c478bd9Sstevel@tonic-gate 		default: return ('?');
1377c478bd9Sstevel@tonic-gate 	}
1387c478bd9Sstevel@tonic-gate }
1397c478bd9Sstevel@tonic-gate 
1407c478bd9Sstevel@tonic-gate #define	PS_PRTTHREADS	0x1
1417c478bd9Sstevel@tonic-gate #define	PS_PRTLWPS	0x2
1427c478bd9Sstevel@tonic-gate #define	PS_PSARGS	0x4
1437c478bd9Sstevel@tonic-gate #define	PS_TASKS	0x8
1447c478bd9Sstevel@tonic-gate #define	PS_PROJECTS	0x10
1457c478bd9Sstevel@tonic-gate #define	PS_ZONES	0x20
1467c478bd9Sstevel@tonic-gate 
1477c478bd9Sstevel@tonic-gate static int
1487c478bd9Sstevel@tonic-gate ps_threadprint(uintptr_t addr, const void *data, void *private)
1497c478bd9Sstevel@tonic-gate {
1507c478bd9Sstevel@tonic-gate 	const kthread_t *t = (const kthread_t *)data;
1517c478bd9Sstevel@tonic-gate 	uint_t prt_flags = *((uint_t *)private);
1527c478bd9Sstevel@tonic-gate 
1537c478bd9Sstevel@tonic-gate 	static const mdb_bitmask_t t_state_bits[] = {
1547c478bd9Sstevel@tonic-gate 		{ "TS_FREE",	UINT_MAX,	TS_FREE		},
1557c478bd9Sstevel@tonic-gate 		{ "TS_SLEEP",	TS_SLEEP,	TS_SLEEP	},
1567c478bd9Sstevel@tonic-gate 		{ "TS_RUN",	TS_RUN,		TS_RUN		},
1577c478bd9Sstevel@tonic-gate 		{ "TS_ONPROC",	TS_ONPROC,	TS_ONPROC	},
1587c478bd9Sstevel@tonic-gate 		{ "TS_ZOMB",	TS_ZOMB,	TS_ZOMB		},
1597c478bd9Sstevel@tonic-gate 		{ "TS_STOPPED",	TS_STOPPED,	TS_STOPPED	},
160c97ad5cdSakolb 		{ "TS_WAIT",	TS_WAIT,	TS_WAIT		},
1617c478bd9Sstevel@tonic-gate 		{ NULL,		0,		0		}
1627c478bd9Sstevel@tonic-gate 	};
1637c478bd9Sstevel@tonic-gate 
1647c478bd9Sstevel@tonic-gate 	if (prt_flags & PS_PRTTHREADS)
1657c478bd9Sstevel@tonic-gate 		mdb_printf("\tT  %?a <%b>\n", addr, t->t_state, t_state_bits);
1667c478bd9Sstevel@tonic-gate 
167ab618543SJohn Levon 	if (prt_flags & PS_PRTLWPS) {
168ab618543SJohn Levon 		char desc[128] = "";
169ab618543SJohn Levon 
170ab618543SJohn Levon 		(void) thread_getdesc(addr, B_FALSE, desc, sizeof (desc));
171ab618543SJohn Levon 
172ab618543SJohn Levon 		mdb_printf("\tL  %?a ID: %s\n", t->t_lwp, desc);
173ab618543SJohn Levon 	}
1747c478bd9Sstevel@tonic-gate 
1757c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
1767c478bd9Sstevel@tonic-gate }
1777c478bd9Sstevel@tonic-gate 
17875cebdd1SRyan Zezeski typedef struct mdb_pflags_proc {
179ab618543SJohn Levon 	struct pid	*p_pidp;
18075cebdd1SRyan Zezeski 	ushort_t	p_pidflag;
18175cebdd1SRyan Zezeski 	uint_t		p_proc_flag;
18275cebdd1SRyan Zezeski 	uint_t		p_flag;
18375cebdd1SRyan Zezeski } mdb_pflags_proc_t;
18475cebdd1SRyan Zezeski 
1855b91507bSJoshua M. Clulow static int
1865b91507bSJoshua M. Clulow pflags(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1875b91507bSJoshua M. Clulow {
18875cebdd1SRyan Zezeski 	mdb_pflags_proc_t pr;
1895b91507bSJoshua M. Clulow 	struct pid pid;
1905b91507bSJoshua M. Clulow 
1915b91507bSJoshua M. Clulow 	static const mdb_bitmask_t p_flag_bits[] = {
1925b91507bSJoshua M. Clulow 		{ "SSYS",		SSYS,		SSYS		},
1935b91507bSJoshua M. Clulow 		{ "SEXITING",		SEXITING,	SEXITING	},
1945b91507bSJoshua M. Clulow 		{ "SITBUSY",		SITBUSY,	SITBUSY		},
1955b91507bSJoshua M. Clulow 		{ "SFORKING",		SFORKING,	SFORKING	},
1965b91507bSJoshua M. Clulow 		{ "SWATCHOK",		SWATCHOK,	SWATCHOK	},
1975b91507bSJoshua M. Clulow 		{ "SKILLED",		SKILLED,	SKILLED		},
1985b91507bSJoshua M. Clulow 		{ "SSCONT",		SSCONT,		SSCONT		},
1995b91507bSJoshua M. Clulow 		{ "SZONETOP",		SZONETOP,	SZONETOP	},
2005b91507bSJoshua M. Clulow 		{ "SEXTKILLED",		SEXTKILLED,	SEXTKILLED	},
2015b91507bSJoshua M. Clulow 		{ "SUGID",		SUGID,		SUGID		},
2025b91507bSJoshua M. Clulow 		{ "SEXECED",		SEXECED,	SEXECED		},
2035b91507bSJoshua M. Clulow 		{ "SJCTL",		SJCTL,		SJCTL		},
2045b91507bSJoshua M. Clulow 		{ "SNOWAIT",		SNOWAIT,	SNOWAIT		},
2055b91507bSJoshua M. Clulow 		{ "SVFORK",		SVFORK,		SVFORK		},
2065b91507bSJoshua M. Clulow 		{ "SVFWAIT",		SVFWAIT,	SVFWAIT		},
2075b91507bSJoshua M. Clulow 		{ "SEXITLWPS",		SEXITLWPS,	SEXITLWPS	},
2085b91507bSJoshua M. Clulow 		{ "SHOLDFORK",		SHOLDFORK,	SHOLDFORK	},
2095b91507bSJoshua M. Clulow 		{ "SHOLDFORK1",		SHOLDFORK1,	SHOLDFORK1	},
2105b91507bSJoshua M. Clulow 		{ "SCOREDUMP",		SCOREDUMP,	SCOREDUMP	},
2115b91507bSJoshua M. Clulow 		{ "SMSACCT",		SMSACCT,	SMSACCT		},
2125b91507bSJoshua M. Clulow 		{ "SLWPWRAP",		SLWPWRAP,	SLWPWRAP	},
2135b91507bSJoshua M. Clulow 		{ "SAUTOLPG",		SAUTOLPG,	SAUTOLPG	},
2145b91507bSJoshua M. Clulow 		{ "SNOCD",		SNOCD,		SNOCD		},
2155b91507bSJoshua M. Clulow 		{ "SHOLDWATCH",		SHOLDWATCH,	SHOLDWATCH	},
2165b91507bSJoshua M. Clulow 		{ "SMSFORK",		SMSFORK,	SMSFORK		},
2175b91507bSJoshua M. Clulow 		{ "SDOCORE",		SDOCORE,	SDOCORE		},
2185b91507bSJoshua M. Clulow 		{ NULL,			0,		0		}
2195b91507bSJoshua M. Clulow 	};
2205b91507bSJoshua M. Clulow 
2215b91507bSJoshua M. Clulow 	static const mdb_bitmask_t p_pidflag_bits[] = {
2225b91507bSJoshua M. Clulow 		{ "CLDPEND",		CLDPEND,	CLDPEND		},
2235b91507bSJoshua M. Clulow 		{ "CLDCONT",		CLDCONT,	CLDCONT		},
2245b91507bSJoshua M. Clulow 		{ "CLDNOSIGCHLD",	CLDNOSIGCHLD,	CLDNOSIGCHLD	},
2255b91507bSJoshua M. Clulow 		{ "CLDWAITPID",		CLDWAITPID,	CLDWAITPID	},
2265b91507bSJoshua M. Clulow 		{ NULL,			0,		0		}
2275b91507bSJoshua M. Clulow 	};
2285b91507bSJoshua M. Clulow 
2295b91507bSJoshua M. Clulow 	static const mdb_bitmask_t p_proc_flag_bits[] = {
2305b91507bSJoshua M. Clulow 		{ "P_PR_TRACE",		P_PR_TRACE,	P_PR_TRACE	},
2315b91507bSJoshua M. Clulow 		{ "P_PR_PTRACE",	P_PR_PTRACE,	P_PR_PTRACE	},
2325b91507bSJoshua M. Clulow 		{ "P_PR_FORK",		P_PR_FORK,	P_PR_FORK	},
2335b91507bSJoshua M. Clulow 		{ "P_PR_LOCK",		P_PR_LOCK,	P_PR_LOCK	},
2345b91507bSJoshua M. Clulow 		{ "P_PR_ASYNC",		P_PR_ASYNC,	P_PR_ASYNC	},
2355b91507bSJoshua M. Clulow 		{ "P_PR_EXEC",		P_PR_EXEC,	P_PR_EXEC	},
2365b91507bSJoshua M. Clulow 		{ "P_PR_BPTADJ",	P_PR_BPTADJ,	P_PR_BPTADJ	},
2375b91507bSJoshua M. Clulow 		{ "P_PR_RUNLCL",	P_PR_RUNLCL,	P_PR_RUNLCL	},
2385b91507bSJoshua M. Clulow 		{ "P_PR_KILLCL",	P_PR_KILLCL,	P_PR_KILLCL	},
2395b91507bSJoshua M. Clulow 		{ NULL,			0,		0		}
2405b91507bSJoshua M. Clulow 	};
2415b91507bSJoshua M. Clulow 
2425b91507bSJoshua M. Clulow 	if (!(flags & DCMD_ADDRSPEC)) {
2435b91507bSJoshua M. Clulow 		if (mdb_walk_dcmd("proc", "pflags", argc, argv) == -1) {
2445b91507bSJoshua M. Clulow 			mdb_warn("can't walk 'proc'");
2455b91507bSJoshua M. Clulow 			return (DCMD_ERR);
2465b91507bSJoshua M. Clulow 		}
2475b91507bSJoshua M. Clulow 		return (DCMD_OK);
2485b91507bSJoshua M. Clulow 	}
2495b91507bSJoshua M. Clulow 
25075cebdd1SRyan Zezeski 	if (mdb_ctf_vread(&pr, "proc_t", "mdb_pflags_proc_t", addr, 0) == -1 ||
2515b91507bSJoshua M. Clulow 	    mdb_vread(&pid, sizeof (pid), (uintptr_t)pr.p_pidp) == -1) {
2525b91507bSJoshua M. Clulow 		mdb_warn("cannot read proc_t or pid");
2535b91507bSJoshua M. Clulow 		return (DCMD_ERR);
2545b91507bSJoshua M. Clulow 	}
2555b91507bSJoshua M. Clulow 
2565b91507bSJoshua M. Clulow 	mdb_printf("%p [pid %d]:\n", addr, pid.pid_id);
2575b91507bSJoshua M. Clulow 	mdb_printf("\tp_flag:      %08x <%b>\n", pr.p_flag, pr.p_flag,
2585b91507bSJoshua M. Clulow 	    p_flag_bits);
2595b91507bSJoshua M. Clulow 	mdb_printf("\tp_pidflag:   %08x <%b>\n", pr.p_pidflag, pr.p_pidflag,
2605b91507bSJoshua M. Clulow 	    p_pidflag_bits);
2615b91507bSJoshua M. Clulow 	mdb_printf("\tp_proc_flag: %08x <%b>\n", pr.p_proc_flag, pr.p_proc_flag,
2625b91507bSJoshua M. Clulow 	    p_proc_flag_bits);
2635b91507bSJoshua M. Clulow 
2645b91507bSJoshua M. Clulow 	return (DCMD_OK);
2655b91507bSJoshua M. Clulow }
2665b91507bSJoshua M. Clulow 
26775cebdd1SRyan Zezeski typedef struct mdb_ps_proc {
26875cebdd1SRyan Zezeski 	char		p_stat;
269ab618543SJohn Levon 	struct pid	*p_pidp;
270ab618543SJohn Levon 	struct pid	*p_pgidp;
27175cebdd1SRyan Zezeski 	struct cred	*p_cred;
27275cebdd1SRyan Zezeski 	struct sess	*p_sessp;
27375cebdd1SRyan Zezeski 	struct task	*p_task;
27475cebdd1SRyan Zezeski 	struct zone	*p_zone;
27575cebdd1SRyan Zezeski 	pid_t		p_ppid;
27675cebdd1SRyan Zezeski 	uint_t		p_flag;
27775cebdd1SRyan Zezeski 	struct {
27875cebdd1SRyan Zezeski 		char		u_comm[MAXCOMLEN + 1];
27975cebdd1SRyan Zezeski 		char		u_psargs[PSARGSZ];
28075cebdd1SRyan Zezeski 	} p_user;
28175cebdd1SRyan Zezeski } mdb_ps_proc_t;
28275cebdd1SRyan Zezeski 
2837c478bd9Sstevel@tonic-gate int
2847c478bd9Sstevel@tonic-gate ps(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2857c478bd9Sstevel@tonic-gate {
2867c478bd9Sstevel@tonic-gate 	uint_t prt_flags = 0;
28775cebdd1SRyan Zezeski 	mdb_ps_proc_t pr;
2887c478bd9Sstevel@tonic-gate 	struct pid pid, pgid, sid;
2897c478bd9Sstevel@tonic-gate 	sess_t session;
2907c478bd9Sstevel@tonic-gate 	cred_t cred;
2917c478bd9Sstevel@tonic-gate 	task_t tk;
2927c478bd9Sstevel@tonic-gate 	kproject_t pj;
2937c478bd9Sstevel@tonic-gate 	zone_t zn;
2947c478bd9Sstevel@tonic-gate 
2957c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC)) {
2967c478bd9Sstevel@tonic-gate 		if (mdb_walk_dcmd("proc", "ps", argc, argv) == -1) {
2977c478bd9Sstevel@tonic-gate 			mdb_warn("can't walk 'proc'");
2987c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
2997c478bd9Sstevel@tonic-gate 		}
3007c478bd9Sstevel@tonic-gate 		return (DCMD_OK);
3017c478bd9Sstevel@tonic-gate 	}
3027c478bd9Sstevel@tonic-gate 
3037c478bd9Sstevel@tonic-gate 	if (mdb_getopts(argc, argv,
3047c478bd9Sstevel@tonic-gate 	    'f', MDB_OPT_SETBITS, PS_PSARGS, &prt_flags,
3057c478bd9Sstevel@tonic-gate 	    'l', MDB_OPT_SETBITS, PS_PRTLWPS, &prt_flags,
3067c478bd9Sstevel@tonic-gate 	    'T', MDB_OPT_SETBITS, PS_TASKS, &prt_flags,
3077c478bd9Sstevel@tonic-gate 	    'P', MDB_OPT_SETBITS, PS_PROJECTS, &prt_flags,
3087c478bd9Sstevel@tonic-gate 	    'z', MDB_OPT_SETBITS, PS_ZONES, &prt_flags,
3097c478bd9Sstevel@tonic-gate 	    't', MDB_OPT_SETBITS, PS_PRTTHREADS, &prt_flags, NULL) != argc)
3107c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
3117c478bd9Sstevel@tonic-gate 
3127c478bd9Sstevel@tonic-gate 	if (DCMD_HDRSPEC(flags)) {
3137c478bd9Sstevel@tonic-gate 		mdb_printf("%<u>%1s %6s %6s %6s %6s ",
3147c478bd9Sstevel@tonic-gate 		    "S", "PID", "PPID", "PGID", "SID");
3157c478bd9Sstevel@tonic-gate 		if (prt_flags & PS_TASKS)
3167c478bd9Sstevel@tonic-gate 			mdb_printf("%5s ", "TASK");
3177c478bd9Sstevel@tonic-gate 		if (prt_flags & PS_PROJECTS)
3187c478bd9Sstevel@tonic-gate 			mdb_printf("%5s ", "PROJ");
3197c478bd9Sstevel@tonic-gate 		if (prt_flags & PS_ZONES)
3207c478bd9Sstevel@tonic-gate 			mdb_printf("%5s ", "ZONE");
3217c478bd9Sstevel@tonic-gate 		mdb_printf("%6s %10s %?s %s%</u>\n",
3227c478bd9Sstevel@tonic-gate 		    "UID", "FLAGS", "ADDR", "NAME");
3237c478bd9Sstevel@tonic-gate 	}
3247c478bd9Sstevel@tonic-gate 
32575cebdd1SRyan Zezeski 	if (mdb_ctf_vread(&pr, "proc_t", "mdb_ps_proc_t", addr, 0) == -1)
32675cebdd1SRyan Zezeski 		return (DCMD_ERR);
32775cebdd1SRyan Zezeski 
3287c478bd9Sstevel@tonic-gate 	mdb_vread(&pid, sizeof (pid), (uintptr_t)pr.p_pidp);
3297c478bd9Sstevel@tonic-gate 	mdb_vread(&pgid, sizeof (pgid), (uintptr_t)pr.p_pgidp);
3307c478bd9Sstevel@tonic-gate 	mdb_vread(&cred, sizeof (cred), (uintptr_t)pr.p_cred);
3317c478bd9Sstevel@tonic-gate 	mdb_vread(&session, sizeof (session), (uintptr_t)pr.p_sessp);
3327c478bd9Sstevel@tonic-gate 	mdb_vread(&sid, sizeof (sid), (uintptr_t)session.s_sidp);
3337c478bd9Sstevel@tonic-gate 	if (prt_flags & (PS_TASKS | PS_PROJECTS))
3347c478bd9Sstevel@tonic-gate 		mdb_vread(&tk, sizeof (tk), (uintptr_t)pr.p_task);
3357c478bd9Sstevel@tonic-gate 	if (prt_flags & PS_PROJECTS)
3367c478bd9Sstevel@tonic-gate 		mdb_vread(&pj, sizeof (pj), (uintptr_t)tk.tk_proj);
3377c478bd9Sstevel@tonic-gate 	if (prt_flags & PS_ZONES)
33875cebdd1SRyan Zezeski 		mdb_vread(&zn, sizeof (zn), (uintptr_t)pr.p_zone);
3397c478bd9Sstevel@tonic-gate 
3407c478bd9Sstevel@tonic-gate 	mdb_printf("%c %6d %6d %6d %6d ",
3417c478bd9Sstevel@tonic-gate 	    pstat2ch(pr.p_stat), pid.pid_id, pr.p_ppid, pgid.pid_id,
3427c478bd9Sstevel@tonic-gate 	    sid.pid_id);
3437c478bd9Sstevel@tonic-gate 	if (prt_flags & PS_TASKS)
3447c478bd9Sstevel@tonic-gate 		mdb_printf("%5d ", tk.tk_tkid);
3457c478bd9Sstevel@tonic-gate 	if (prt_flags & PS_PROJECTS)
3467c478bd9Sstevel@tonic-gate 		mdb_printf("%5d ", pj.kpj_id);
3477c478bd9Sstevel@tonic-gate 	if (prt_flags & PS_ZONES)
3487c478bd9Sstevel@tonic-gate 		mdb_printf("%5d ", zn.zone_id);
3497c478bd9Sstevel@tonic-gate 	mdb_printf("%6d 0x%08x %0?p %s\n",
3507c478bd9Sstevel@tonic-gate 	    cred.cr_uid, pr.p_flag, addr,
3517c478bd9Sstevel@tonic-gate 	    (prt_flags & PS_PSARGS) ? pr.p_user.u_psargs : pr.p_user.u_comm);
3527c478bd9Sstevel@tonic-gate 
3537c478bd9Sstevel@tonic-gate 	if (prt_flags & ~PS_PSARGS)
3547c478bd9Sstevel@tonic-gate 		(void) mdb_pwalk("thread", ps_threadprint, &prt_flags, addr);
3557c478bd9Sstevel@tonic-gate 
3567c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
3577c478bd9Sstevel@tonic-gate }
3587c478bd9Sstevel@tonic-gate 
3597c478bd9Sstevel@tonic-gate #define	PG_NEWEST	0x0001
3607c478bd9Sstevel@tonic-gate #define	PG_OLDEST	0x0002
3617c478bd9Sstevel@tonic-gate #define	PG_PIPE_OUT	0x0004
362adb664e2Svb #define	PG_EXACT_MATCH	0x0008
3637c478bd9Sstevel@tonic-gate 
3647c478bd9Sstevel@tonic-gate typedef struct pgrep_data {
3657c478bd9Sstevel@tonic-gate 	uint_t pg_flags;
3667c478bd9Sstevel@tonic-gate 	uint_t pg_psflags;
3677c478bd9Sstevel@tonic-gate 	uintptr_t pg_xaddr;
3687c478bd9Sstevel@tonic-gate 	hrtime_t pg_xstart;
3697c478bd9Sstevel@tonic-gate 	const char *pg_pat;
3707c478bd9Sstevel@tonic-gate #ifndef _KMDB
3717c478bd9Sstevel@tonic-gate 	regex_t pg_reg;
3727c478bd9Sstevel@tonic-gate #endif
3737c478bd9Sstevel@tonic-gate } pgrep_data_t;
3747c478bd9Sstevel@tonic-gate 
37575cebdd1SRyan Zezeski typedef struct mdb_pgrep_proc {
37675cebdd1SRyan Zezeski 	struct {
37775cebdd1SRyan Zezeski 		timestruc_t	u_start;
37875cebdd1SRyan Zezeski 		char		u_comm[MAXCOMLEN + 1];
37975cebdd1SRyan Zezeski 	} p_user;
38075cebdd1SRyan Zezeski } mdb_pgrep_proc_t;
38175cebdd1SRyan Zezeski 
3827c478bd9Sstevel@tonic-gate /*ARGSUSED*/
3837c478bd9Sstevel@tonic-gate static int
38475cebdd1SRyan Zezeski pgrep_cb(uintptr_t addr, const void *ignored, void *data)
3857c478bd9Sstevel@tonic-gate {
38675cebdd1SRyan Zezeski 	mdb_pgrep_proc_t p;
3877c478bd9Sstevel@tonic-gate 	pgrep_data_t *pgp = data;
3887c478bd9Sstevel@tonic-gate #ifndef _KMDB
3897c478bd9Sstevel@tonic-gate 	regmatch_t pmatch;
3907c478bd9Sstevel@tonic-gate #endif
3917c478bd9Sstevel@tonic-gate 
39275cebdd1SRyan Zezeski 	if (mdb_ctf_vread(&p, "proc_t", "mdb_pgrep_proc_t", addr, 0) == -1)
39375cebdd1SRyan Zezeski 		return (WALK_ERR);
39475cebdd1SRyan Zezeski 
3957c478bd9Sstevel@tonic-gate 	/*
3967c478bd9Sstevel@tonic-gate 	 * kmdb doesn't have access to the reg* functions, so we fall back
397adb664e2Svb 	 * to strstr/strcmp.
3987c478bd9Sstevel@tonic-gate 	 */
3997c478bd9Sstevel@tonic-gate #ifdef _KMDB
400adb664e2Svb 	if ((pgp->pg_flags & PG_EXACT_MATCH) ?
40175cebdd1SRyan Zezeski 	    (strcmp(p.p_user.u_comm, pgp->pg_pat) != 0) :
40275cebdd1SRyan Zezeski 	    (strstr(p.p_user.u_comm, pgp->pg_pat) == NULL))
4037c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
4047c478bd9Sstevel@tonic-gate #else
40575cebdd1SRyan Zezeski 	if (regexec(&pgp->pg_reg, p.p_user.u_comm, 1, &pmatch, 0) != 0)
4067c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
407adb664e2Svb 
408adb664e2Svb 	if ((pgp->pg_flags & PG_EXACT_MATCH) &&
40975cebdd1SRyan Zezeski 	    (pmatch.rm_so != 0 || p.p_user.u_comm[pmatch.rm_eo] != '\0'))
410adb664e2Svb 		return (WALK_NEXT);
4117c478bd9Sstevel@tonic-gate #endif
4127c478bd9Sstevel@tonic-gate 
4137c478bd9Sstevel@tonic-gate 	if (pgp->pg_flags & (PG_NEWEST | PG_OLDEST)) {
4147c478bd9Sstevel@tonic-gate 		hrtime_t start;
4157c478bd9Sstevel@tonic-gate 
41675cebdd1SRyan Zezeski 		start = (hrtime_t)p.p_user.u_start.tv_sec * NANOSEC +
41775cebdd1SRyan Zezeski 		    p.p_user.u_start.tv_nsec;
4187c478bd9Sstevel@tonic-gate 
4197c478bd9Sstevel@tonic-gate 		if (pgp->pg_flags & PG_NEWEST) {
420*892ad162SToomas Soome 			if (pgp->pg_xaddr == 0 || start > pgp->pg_xstart) {
4217c478bd9Sstevel@tonic-gate 				pgp->pg_xaddr = addr;
4227c478bd9Sstevel@tonic-gate 				pgp->pg_xstart = start;
4237c478bd9Sstevel@tonic-gate 			}
4247c478bd9Sstevel@tonic-gate 		} else {
425*892ad162SToomas Soome 			if (pgp->pg_xaddr == 0 || start < pgp->pg_xstart) {
4267c478bd9Sstevel@tonic-gate 				pgp->pg_xaddr = addr;
4277c478bd9Sstevel@tonic-gate 				pgp->pg_xstart = start;
4287c478bd9Sstevel@tonic-gate 			}
4297c478bd9Sstevel@tonic-gate 		}
4307c478bd9Sstevel@tonic-gate 
4317c478bd9Sstevel@tonic-gate 	} else if (pgp->pg_flags & PG_PIPE_OUT) {
4327c478bd9Sstevel@tonic-gate 		mdb_printf("%p\n", addr);
4337c478bd9Sstevel@tonic-gate 
4347c478bd9Sstevel@tonic-gate 	} else {
4357c478bd9Sstevel@tonic-gate 		if (mdb_call_dcmd("ps", addr, pgp->pg_psflags, 0, NULL) != 0) {
4367c478bd9Sstevel@tonic-gate 			mdb_warn("can't invoke 'ps'");
4377c478bd9Sstevel@tonic-gate 			return (WALK_DONE);
4387c478bd9Sstevel@tonic-gate 		}
4397c478bd9Sstevel@tonic-gate 		pgp->pg_psflags &= ~DCMD_LOOPFIRST;
4407c478bd9Sstevel@tonic-gate 	}
4417c478bd9Sstevel@tonic-gate 
4427c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
4437c478bd9Sstevel@tonic-gate }
4447c478bd9Sstevel@tonic-gate 
4457c478bd9Sstevel@tonic-gate /*ARGSUSED*/
4467c478bd9Sstevel@tonic-gate int
4477c478bd9Sstevel@tonic-gate pgrep(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
4487c478bd9Sstevel@tonic-gate {
4497c478bd9Sstevel@tonic-gate 	pgrep_data_t pg;
4507c478bd9Sstevel@tonic-gate 	int i;
4517c478bd9Sstevel@tonic-gate #ifndef _KMDB
4527c478bd9Sstevel@tonic-gate 	int err;
4537c478bd9Sstevel@tonic-gate #endif
4547c478bd9Sstevel@tonic-gate 
4557c478bd9Sstevel@tonic-gate 	if (flags & DCMD_ADDRSPEC)
4567c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
4577c478bd9Sstevel@tonic-gate 
4587c478bd9Sstevel@tonic-gate 	pg.pg_flags = 0;
4597c478bd9Sstevel@tonic-gate 	pg.pg_xaddr = 0;
4607c478bd9Sstevel@tonic-gate 
4617c478bd9Sstevel@tonic-gate 	i = mdb_getopts(argc, argv,
4627c478bd9Sstevel@tonic-gate 	    'n', MDB_OPT_SETBITS, PG_NEWEST, &pg.pg_flags,
4637c478bd9Sstevel@tonic-gate 	    'o', MDB_OPT_SETBITS, PG_OLDEST, &pg.pg_flags,
464adb664e2Svb 	    'x', MDB_OPT_SETBITS, PG_EXACT_MATCH, &pg.pg_flags,
4657c478bd9Sstevel@tonic-gate 	    NULL);
4667c478bd9Sstevel@tonic-gate 
4677c478bd9Sstevel@tonic-gate 	argc -= i;
4687c478bd9Sstevel@tonic-gate 	argv += i;
4697c478bd9Sstevel@tonic-gate 
4707c478bd9Sstevel@tonic-gate 	if (argc != 1)
4717c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
4727c478bd9Sstevel@tonic-gate 
4737c478bd9Sstevel@tonic-gate 	/*
4747c478bd9Sstevel@tonic-gate 	 * -n and -o are mutually exclusive.
4757c478bd9Sstevel@tonic-gate 	 */
4767c478bd9Sstevel@tonic-gate 	if ((pg.pg_flags & PG_NEWEST) && (pg.pg_flags & PG_OLDEST))
4777c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
4787c478bd9Sstevel@tonic-gate 
4797c478bd9Sstevel@tonic-gate 	if (argv->a_type != MDB_TYPE_STRING)
4807c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
4817c478bd9Sstevel@tonic-gate 
4827c478bd9Sstevel@tonic-gate 	if (flags & DCMD_PIPE_OUT)
4837c478bd9Sstevel@tonic-gate 		pg.pg_flags |= PG_PIPE_OUT;
4847c478bd9Sstevel@tonic-gate 
4857c478bd9Sstevel@tonic-gate 	pg.pg_pat = argv->a_un.a_str;
4867c478bd9Sstevel@tonic-gate 	if (DCMD_HDRSPEC(flags))
4877c478bd9Sstevel@tonic-gate 		pg.pg_psflags = DCMD_ADDRSPEC | DCMD_LOOP | DCMD_LOOPFIRST;
4887c478bd9Sstevel@tonic-gate 	else
4897c478bd9Sstevel@tonic-gate 		pg.pg_psflags = DCMD_ADDRSPEC | DCMD_LOOP;
4907c478bd9Sstevel@tonic-gate 
4917c478bd9Sstevel@tonic-gate #ifndef _KMDB
4927c478bd9Sstevel@tonic-gate 	if ((err = regcomp(&pg.pg_reg, pg.pg_pat, REG_EXTENDED)) != 0) {
4937c478bd9Sstevel@tonic-gate 		size_t nbytes;
4947c478bd9Sstevel@tonic-gate 		char *buf;
4957c478bd9Sstevel@tonic-gate 
4967c478bd9Sstevel@tonic-gate 		nbytes = regerror(err, &pg.pg_reg, NULL, 0);
4977c478bd9Sstevel@tonic-gate 		buf = mdb_alloc(nbytes + 1, UM_SLEEP | UM_GC);
4987c478bd9Sstevel@tonic-gate 		(void) regerror(err, &pg.pg_reg, buf, nbytes);
4997c478bd9Sstevel@tonic-gate 		mdb_warn("%s\n", buf);
5007c478bd9Sstevel@tonic-gate 
5017c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
5027c478bd9Sstevel@tonic-gate 	}
5037c478bd9Sstevel@tonic-gate #endif
5047c478bd9Sstevel@tonic-gate 
5057c478bd9Sstevel@tonic-gate 	if (mdb_walk("proc", pgrep_cb, &pg) != 0) {
5067c478bd9Sstevel@tonic-gate 		mdb_warn("can't walk 'proc'");
5077c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
5087c478bd9Sstevel@tonic-gate 	}
5097c478bd9Sstevel@tonic-gate 
5107c478bd9Sstevel@tonic-gate 	if (pg.pg_xaddr != 0 && (pg.pg_flags & (PG_NEWEST | PG_OLDEST))) {
5117c478bd9Sstevel@tonic-gate 		if (pg.pg_flags & PG_PIPE_OUT) {
5127c478bd9Sstevel@tonic-gate 			mdb_printf("%p\n", pg.pg_xaddr);
5137c478bd9Sstevel@tonic-gate 		} else {
5147c478bd9Sstevel@tonic-gate 			if (mdb_call_dcmd("ps", pg.pg_xaddr, pg.pg_psflags,
5157c478bd9Sstevel@tonic-gate 			    0, NULL) != 0) {
5167c478bd9Sstevel@tonic-gate 				mdb_warn("can't invoke 'ps'");
5177c478bd9Sstevel@tonic-gate 				return (DCMD_ERR);
5187c478bd9Sstevel@tonic-gate 			}
5197c478bd9Sstevel@tonic-gate 		}
5207c478bd9Sstevel@tonic-gate 	}
5217c478bd9Sstevel@tonic-gate 
5227c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
5237c478bd9Sstevel@tonic-gate }
5247c478bd9Sstevel@tonic-gate 
5257c478bd9Sstevel@tonic-gate int
5267c478bd9Sstevel@tonic-gate task(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
5277c478bd9Sstevel@tonic-gate {
5287c478bd9Sstevel@tonic-gate 	task_t tk;
5297c478bd9Sstevel@tonic-gate 	kproject_t pj;
5307c478bd9Sstevel@tonic-gate 
5317c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC)) {
5327c478bd9Sstevel@tonic-gate 		if (mdb_walk_dcmd("task_cache", "task", argc, argv) == -1) {
5337c478bd9Sstevel@tonic-gate 			mdb_warn("can't walk task_cache");
5347c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
5357c478bd9Sstevel@tonic-gate 		}
5367c478bd9Sstevel@tonic-gate 		return (DCMD_OK);
5377c478bd9Sstevel@tonic-gate 	}
5387c478bd9Sstevel@tonic-gate 	if (DCMD_HDRSPEC(flags)) {
5397c478bd9Sstevel@tonic-gate 		mdb_printf("%<u>%?s %6s %6s %6s %6s %10s%</u>\n",
5407c478bd9Sstevel@tonic-gate 		    "ADDR", "TASKID", "PROJID", "ZONEID", "REFCNT", "FLAGS");
5417c478bd9Sstevel@tonic-gate 	}
5427c478bd9Sstevel@tonic-gate 	if (mdb_vread(&tk, sizeof (task_t), addr) == -1) {
5437c478bd9Sstevel@tonic-gate 		mdb_warn("can't read task_t structure at %p", addr);
5447c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
5457c478bd9Sstevel@tonic-gate 	}
5467c478bd9Sstevel@tonic-gate 	if (mdb_vread(&pj, sizeof (kproject_t), (uintptr_t)tk.tk_proj) == -1) {
5477c478bd9Sstevel@tonic-gate 		mdb_warn("can't read project_t structure at %p", addr);
5487c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
5497c478bd9Sstevel@tonic-gate 	}
5507c478bd9Sstevel@tonic-gate 	mdb_printf("%0?p %6d %6d %6d %6u 0x%08x\n",
5517c478bd9Sstevel@tonic-gate 	    addr, tk.tk_tkid, pj.kpj_id, pj.kpj_zoneid, tk.tk_hold_count,
5527c478bd9Sstevel@tonic-gate 	    tk.tk_flags);
5537c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
5547c478bd9Sstevel@tonic-gate }
5557c478bd9Sstevel@tonic-gate 
5567c478bd9Sstevel@tonic-gate int
5577c478bd9Sstevel@tonic-gate project(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
5587c478bd9Sstevel@tonic-gate {
5597c478bd9Sstevel@tonic-gate 	kproject_t pj;
5607c478bd9Sstevel@tonic-gate 
5617c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC)) {
5627c478bd9Sstevel@tonic-gate 		if (mdb_walk_dcmd("projects", "project", argc, argv) == -1) {
5637c478bd9Sstevel@tonic-gate 			mdb_warn("can't walk projects");
5647c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
5657c478bd9Sstevel@tonic-gate 		}
5667c478bd9Sstevel@tonic-gate 		return (DCMD_OK);
5677c478bd9Sstevel@tonic-gate 	}
5687c478bd9Sstevel@tonic-gate 	if (DCMD_HDRSPEC(flags)) {
5697c478bd9Sstevel@tonic-gate 		mdb_printf("%<u>%?s %6s %6s %6s%</u>\n",
5707c478bd9Sstevel@tonic-gate 		    "ADDR", "PROJID", "ZONEID", "REFCNT");
5717c478bd9Sstevel@tonic-gate 	}
5727c478bd9Sstevel@tonic-gate 	if (mdb_vread(&pj, sizeof (kproject_t), addr) == -1) {
5737c478bd9Sstevel@tonic-gate 		mdb_warn("can't read kproject_t structure at %p", addr);
5747c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
5757c478bd9Sstevel@tonic-gate 	}
5767c478bd9Sstevel@tonic-gate 	mdb_printf("%0?p %6d %6d %6u\n", addr, pj.kpj_id, pj.kpj_zoneid,
5777c478bd9Sstevel@tonic-gate 	    pj.kpj_count);
5787c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
5797c478bd9Sstevel@tonic-gate }
5807c478bd9Sstevel@tonic-gate 
58187a18d3fSMadhavan Venkataraman /* walk callouts themselves, either by list or id hash. */
5827c478bd9Sstevel@tonic-gate int
58387a18d3fSMadhavan Venkataraman callout_walk_init(mdb_walk_state_t *wsp)
5847c478bd9Sstevel@tonic-gate {
585*892ad162SToomas Soome 	if (wsp->walk_addr == 0) {
58687a18d3fSMadhavan Venkataraman 		mdb_warn("callout doesn't support global walk");
58787a18d3fSMadhavan Venkataraman 		return (WALK_ERR);
58887a18d3fSMadhavan Venkataraman 	}
58987a18d3fSMadhavan Venkataraman 	wsp->walk_data = mdb_alloc(sizeof (callout_t), UM_SLEEP);
59087a18d3fSMadhavan Venkataraman 	return (WALK_NEXT);
59187a18d3fSMadhavan Venkataraman }
5927c478bd9Sstevel@tonic-gate 
59387a18d3fSMadhavan Venkataraman #define	CALLOUT_WALK_BYLIST	0
59487a18d3fSMadhavan Venkataraman #define	CALLOUT_WALK_BYID	1
59587a18d3fSMadhavan Venkataraman 
59687a18d3fSMadhavan Venkataraman /* the walker arg switches between walking by list (0) and walking by id (1). */
59787a18d3fSMadhavan Venkataraman int
59887a18d3fSMadhavan Venkataraman callout_walk_step(mdb_walk_state_t *wsp)
59987a18d3fSMadhavan Venkataraman {
60087a18d3fSMadhavan Venkataraman 	int retval;
6017c478bd9Sstevel@tonic-gate 
602*892ad162SToomas Soome 	if (wsp->walk_addr == 0) {
60387a18d3fSMadhavan Venkataraman 		return (WALK_DONE);
60487a18d3fSMadhavan Venkataraman 	}
60587a18d3fSMadhavan Venkataraman 	if (mdb_vread(wsp->walk_data, sizeof (callout_t),
60687a18d3fSMadhavan Venkataraman 	    wsp->walk_addr) == -1) {
60787a18d3fSMadhavan Venkataraman 		mdb_warn("failed to read callout at %p", wsp->walk_addr);
60887a18d3fSMadhavan Venkataraman 		return (WALK_DONE);
60987a18d3fSMadhavan Venkataraman 	}
61087a18d3fSMadhavan Venkataraman 	retval = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
61187a18d3fSMadhavan Venkataraman 	    wsp->walk_cbdata);
61287a18d3fSMadhavan Venkataraman 
61387a18d3fSMadhavan Venkataraman 	if ((ulong_t)wsp->walk_arg == CALLOUT_WALK_BYID) {
61487a18d3fSMadhavan Venkataraman 		wsp->walk_addr =
61587a18d3fSMadhavan Venkataraman 		    (uintptr_t)(((callout_t *)wsp->walk_data)->c_idnext);
616843e1988Sjohnlev 	} else {
61787a18d3fSMadhavan Venkataraman 		wsp->walk_addr =
61887a18d3fSMadhavan Venkataraman 		    (uintptr_t)(((callout_t *)wsp->walk_data)->c_clnext);
619843e1988Sjohnlev 	}
6207c478bd9Sstevel@tonic-gate 
62187a18d3fSMadhavan Venkataraman 	return (retval);
62287a18d3fSMadhavan Venkataraman }
62387a18d3fSMadhavan Venkataraman 
62487a18d3fSMadhavan Venkataraman void
62587a18d3fSMadhavan Venkataraman callout_walk_fini(mdb_walk_state_t *wsp)
62687a18d3fSMadhavan Venkataraman {
62787a18d3fSMadhavan Venkataraman 	mdb_free(wsp->walk_data, sizeof (callout_t));
62887a18d3fSMadhavan Venkataraman }
62987a18d3fSMadhavan Venkataraman 
63087a18d3fSMadhavan Venkataraman /*
63187a18d3fSMadhavan Venkataraman  * walker for callout lists. This is different from hashes and callouts.
63287a18d3fSMadhavan Venkataraman  * Thankfully, it's also simpler.
63387a18d3fSMadhavan Venkataraman  */
63487a18d3fSMadhavan Venkataraman int
63587a18d3fSMadhavan Venkataraman callout_list_walk_init(mdb_walk_state_t *wsp)
63687a18d3fSMadhavan Venkataraman {
637*892ad162SToomas Soome 	if (wsp->walk_addr == 0) {
63887a18d3fSMadhavan Venkataraman 		mdb_warn("callout list doesn't support global walk");
63987a18d3fSMadhavan Venkataraman 		return (WALK_ERR);
6407c478bd9Sstevel@tonic-gate 	}
64187a18d3fSMadhavan Venkataraman 	wsp->walk_data = mdb_alloc(sizeof (callout_list_t), UM_SLEEP);
64287a18d3fSMadhavan Venkataraman 	return (WALK_NEXT);
64387a18d3fSMadhavan Venkataraman }
6447c478bd9Sstevel@tonic-gate 
64587a18d3fSMadhavan Venkataraman int
64687a18d3fSMadhavan Venkataraman callout_list_walk_step(mdb_walk_state_t *wsp)
64787a18d3fSMadhavan Venkataraman {
64887a18d3fSMadhavan Venkataraman 	int retval;
64987a18d3fSMadhavan Venkataraman 
650*892ad162SToomas Soome 	if (wsp->walk_addr == 0) {
65187a18d3fSMadhavan Venkataraman 		return (WALK_DONE);
6527c478bd9Sstevel@tonic-gate 	}
65387a18d3fSMadhavan Venkataraman 	if (mdb_vread(wsp->walk_data, sizeof (callout_list_t),
65487a18d3fSMadhavan Venkataraman 	    wsp->walk_addr) != sizeof (callout_list_t)) {
65587a18d3fSMadhavan Venkataraman 		mdb_warn("failed to read callout_list at %p", wsp->walk_addr);
65687a18d3fSMadhavan Venkataraman 		return (WALK_ERR);
65787a18d3fSMadhavan Venkataraman 	}
65887a18d3fSMadhavan Venkataraman 	retval = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
65987a18d3fSMadhavan Venkataraman 	    wsp->walk_cbdata);
6607c478bd9Sstevel@tonic-gate 
66187a18d3fSMadhavan Venkataraman 	wsp->walk_addr = (uintptr_t)
66287a18d3fSMadhavan Venkataraman 	    (((callout_list_t *)wsp->walk_data)->cl_next);
66387a18d3fSMadhavan Venkataraman 
66487a18d3fSMadhavan Venkataraman 	return (retval);
66587a18d3fSMadhavan Venkataraman }
66687a18d3fSMadhavan Venkataraman 
66787a18d3fSMadhavan Venkataraman void
66887a18d3fSMadhavan Venkataraman callout_list_walk_fini(mdb_walk_state_t *wsp)
66987a18d3fSMadhavan Venkataraman {
67087a18d3fSMadhavan Venkataraman 	mdb_free(wsp->walk_data, sizeof (callout_list_t));
67187a18d3fSMadhavan Venkataraman }
67287a18d3fSMadhavan Venkataraman 
67387a18d3fSMadhavan Venkataraman /* routines/structs to walk callout table(s) */
67487a18d3fSMadhavan Venkataraman typedef struct cot_data {
67587a18d3fSMadhavan Venkataraman 	callout_table_t *ct0;
67687a18d3fSMadhavan Venkataraman 	callout_table_t ct;
67787a18d3fSMadhavan Venkataraman 	callout_hash_t cot_idhash[CALLOUT_BUCKETS];
67887a18d3fSMadhavan Venkataraman 	callout_hash_t cot_clhash[CALLOUT_BUCKETS];
67987a18d3fSMadhavan Venkataraman 	kstat_named_t ct_kstat_data[CALLOUT_NUM_STATS];
68087a18d3fSMadhavan Venkataraman 	int cotndx;
68187a18d3fSMadhavan Venkataraman 	int cotsize;
68287a18d3fSMadhavan Venkataraman } cot_data_t;
68387a18d3fSMadhavan Venkataraman 
68487a18d3fSMadhavan Venkataraman int
68587a18d3fSMadhavan Venkataraman callout_table_walk_init(mdb_walk_state_t *wsp)
68687a18d3fSMadhavan Venkataraman {
68787a18d3fSMadhavan Venkataraman 	int max_ncpus;
68887a18d3fSMadhavan Venkataraman 	cot_data_t *cot_walk_data;
68987a18d3fSMadhavan Venkataraman 
69087a18d3fSMadhavan Venkataraman 	cot_walk_data = mdb_alloc(sizeof (cot_data_t), UM_SLEEP);
69187a18d3fSMadhavan Venkataraman 
692*892ad162SToomas Soome 	if (wsp->walk_addr == 0) {
69387a18d3fSMadhavan Venkataraman 		if (mdb_readvar(&cot_walk_data->ct0, "callout_table") == -1) {
69487a18d3fSMadhavan Venkataraman 			mdb_warn("failed to read 'callout_table'");
69587a18d3fSMadhavan Venkataraman 			return (WALK_ERR);
69687a18d3fSMadhavan Venkataraman 		}
69787a18d3fSMadhavan Venkataraman 		if (mdb_readvar(&max_ncpus, "max_ncpus") == -1) {
69887a18d3fSMadhavan Venkataraman 			mdb_warn("failed to get callout_table array size");
69987a18d3fSMadhavan Venkataraman 			return (WALK_ERR);
70087a18d3fSMadhavan Venkataraman 		}
70187a18d3fSMadhavan Venkataraman 		cot_walk_data->cotsize = CALLOUT_NTYPES * max_ncpus;
70287a18d3fSMadhavan Venkataraman 		wsp->walk_addr = (uintptr_t)cot_walk_data->ct0;
70387a18d3fSMadhavan Venkataraman 	} else {
70487a18d3fSMadhavan Venkataraman 		/* not a global walk */
70587a18d3fSMadhavan Venkataraman 		cot_walk_data->cotsize = 1;
7067c478bd9Sstevel@tonic-gate 	}
7077c478bd9Sstevel@tonic-gate 
70887a18d3fSMadhavan Venkataraman 	cot_walk_data->cotndx = 0;
70987a18d3fSMadhavan Venkataraman 	wsp->walk_data = cot_walk_data;
7107c478bd9Sstevel@tonic-gate 
71187a18d3fSMadhavan Venkataraman 	return (WALK_NEXT);
71287a18d3fSMadhavan Venkataraman }
7137c478bd9Sstevel@tonic-gate 
71487a18d3fSMadhavan Venkataraman int
71587a18d3fSMadhavan Venkataraman callout_table_walk_step(mdb_walk_state_t *wsp)
71687a18d3fSMadhavan Venkataraman {
71787a18d3fSMadhavan Venkataraman 	int retval;
71887a18d3fSMadhavan Venkataraman 	cot_data_t *cotwd = (cot_data_t *)wsp->walk_data;
71987a18d3fSMadhavan Venkataraman 	size_t size;
7207c478bd9Sstevel@tonic-gate 
72187a18d3fSMadhavan Venkataraman 	if (cotwd->cotndx >= cotwd->cotsize) {
72287a18d3fSMadhavan Venkataraman 		return (WALK_DONE);
72387a18d3fSMadhavan Venkataraman 	}
72487a18d3fSMadhavan Venkataraman 	if (mdb_vread(&(cotwd->ct), sizeof (callout_table_t),
72587a18d3fSMadhavan Venkataraman 	    wsp->walk_addr) != sizeof (callout_table_t)) {
72687a18d3fSMadhavan Venkataraman 		mdb_warn("failed to read callout_table at %p", wsp->walk_addr);
72787a18d3fSMadhavan Venkataraman 		return (WALK_ERR);
72887a18d3fSMadhavan Venkataraman 	}
72987a18d3fSMadhavan Venkataraman 
73087a18d3fSMadhavan Venkataraman 	size = sizeof (callout_hash_t) * CALLOUT_BUCKETS;
73187a18d3fSMadhavan Venkataraman 	if (cotwd->ct.ct_idhash != NULL) {
73287a18d3fSMadhavan Venkataraman 		if (mdb_vread(cotwd->cot_idhash, size,
73387a18d3fSMadhavan Venkataraman 		    (uintptr_t)(cotwd->ct.ct_idhash)) != size) {
73487a18d3fSMadhavan Venkataraman 			mdb_warn("failed to read id_hash at %p",
73587a18d3fSMadhavan Venkataraman 			    cotwd->ct.ct_idhash);
73687a18d3fSMadhavan Venkataraman 			return (WALK_ERR);
73787a18d3fSMadhavan Venkataraman 		}
73887a18d3fSMadhavan Venkataraman 	}
73987a18d3fSMadhavan Venkataraman 	if (cotwd->ct.ct_clhash != NULL) {
74087a18d3fSMadhavan Venkataraman 		if (mdb_vread(&(cotwd->cot_clhash), size,
74187a18d3fSMadhavan Venkataraman 		    (uintptr_t)cotwd->ct.ct_clhash) == -1) {
74287a18d3fSMadhavan Venkataraman 			mdb_warn("failed to read cl_hash at %p",
74387a18d3fSMadhavan Venkataraman 			    cotwd->ct.ct_clhash);
74487a18d3fSMadhavan Venkataraman 			return (WALK_ERR);
74587a18d3fSMadhavan Venkataraman 		}
74687a18d3fSMadhavan Venkataraman 	}
74787a18d3fSMadhavan Venkataraman 	size = sizeof (kstat_named_t) * CALLOUT_NUM_STATS;
74887a18d3fSMadhavan Venkataraman 	if (cotwd->ct.ct_kstat_data != NULL) {
74987a18d3fSMadhavan Venkataraman 		if (mdb_vread(&(cotwd->ct_kstat_data), size,
75087a18d3fSMadhavan Venkataraman 		    (uintptr_t)cotwd->ct.ct_kstat_data) == -1) {
75187a18d3fSMadhavan Venkataraman 			mdb_warn("failed to read kstats at %p",
75287a18d3fSMadhavan Venkataraman 			    cotwd->ct.ct_kstat_data);
75387a18d3fSMadhavan Venkataraman 			return (WALK_ERR);
75487a18d3fSMadhavan Venkataraman 		}
75587a18d3fSMadhavan Venkataraman 	}
75687a18d3fSMadhavan Venkataraman 	retval = wsp->walk_callback(wsp->walk_addr, (void *)cotwd,
75787a18d3fSMadhavan Venkataraman 	    wsp->walk_cbdata);
75887a18d3fSMadhavan Venkataraman 
75987a18d3fSMadhavan Venkataraman 	cotwd->cotndx++;
76087a18d3fSMadhavan Venkataraman 	if (cotwd->cotndx >= cotwd->cotsize) {
76187a18d3fSMadhavan Venkataraman 		return (WALK_DONE);
76287a18d3fSMadhavan Venkataraman 	}
76387a18d3fSMadhavan Venkataraman 	wsp->walk_addr = (uintptr_t)((char *)wsp->walk_addr +
76487a18d3fSMadhavan Venkataraman 	    sizeof (callout_table_t));
76587a18d3fSMadhavan Venkataraman 
76687a18d3fSMadhavan Venkataraman 	return (retval);
76787a18d3fSMadhavan Venkataraman }
76887a18d3fSMadhavan Venkataraman 
76987a18d3fSMadhavan Venkataraman void
77087a18d3fSMadhavan Venkataraman callout_table_walk_fini(mdb_walk_state_t *wsp)
77187a18d3fSMadhavan Venkataraman {
77287a18d3fSMadhavan Venkataraman 	mdb_free(wsp->walk_data, sizeof (cot_data_t));
77387a18d3fSMadhavan Venkataraman }
77487a18d3fSMadhavan Venkataraman 
77587a18d3fSMadhavan Venkataraman static const char *co_typenames[] = { "R", "N" };
77687a18d3fSMadhavan Venkataraman 
77707247649SMadhavan Venkataraman #define	CO_PLAIN_ID(xid)	((xid) & CALLOUT_ID_MASK)
77887a18d3fSMadhavan Venkataraman 
77987a18d3fSMadhavan Venkataraman #define	TABLE_TO_SEQID(x)	((x) >> CALLOUT_TYPE_BITS)
78087a18d3fSMadhavan Venkataraman 
78187a18d3fSMadhavan Venkataraman /* callout flags, in no particular order */
782060cedfbSMadhavan Venkataraman #define	COF_REAL	0x00000001
783060cedfbSMadhavan Venkataraman #define	COF_NORM	0x00000002
784060cedfbSMadhavan Venkataraman #define	COF_LONG	0x00000004
785060cedfbSMadhavan Venkataraman #define	COF_SHORT	0x00000008
786060cedfbSMadhavan Venkataraman #define	COF_EMPTY	0x00000010
787060cedfbSMadhavan Venkataraman #define	COF_TIME	0x00000020
788060cedfbSMadhavan Venkataraman #define	COF_BEFORE	0x00000040
789060cedfbSMadhavan Venkataraman #define	COF_AFTER	0x00000080
790060cedfbSMadhavan Venkataraman #define	COF_SEQID	0x00000100
791060cedfbSMadhavan Venkataraman #define	COF_FUNC	0x00000200
792060cedfbSMadhavan Venkataraman #define	COF_ADDR	0x00000400
793060cedfbSMadhavan Venkataraman #define	COF_EXEC	0x00000800
794060cedfbSMadhavan Venkataraman #define	COF_HIRES	0x00001000
795060cedfbSMadhavan Venkataraman #define	COF_ABS		0x00002000
796060cedfbSMadhavan Venkataraman #define	COF_TABLE	0x00004000
797060cedfbSMadhavan Venkataraman #define	COF_BYIDH	0x00008000
798060cedfbSMadhavan Venkataraman #define	COF_FREE	0x00010000
799060cedfbSMadhavan Venkataraman #define	COF_LIST	0x00020000
800060cedfbSMadhavan Venkataraman #define	COF_EXPREL	0x00040000
801060cedfbSMadhavan Venkataraman #define	COF_HDR		0x00080000
802060cedfbSMadhavan Venkataraman #define	COF_VERBOSE	0x00100000
803060cedfbSMadhavan Venkataraman #define	COF_LONGLIST	0x00200000
804060cedfbSMadhavan Venkataraman #define	COF_THDR	0x00400000
805060cedfbSMadhavan Venkataraman #define	COF_LHDR	0x00800000
806060cedfbSMadhavan Venkataraman #define	COF_CHDR	0x01000000
807060cedfbSMadhavan Venkataraman #define	COF_PARAM	0x02000000
808060cedfbSMadhavan Venkataraman #define	COF_DECODE	0x04000000
809060cedfbSMadhavan Venkataraman #define	COF_HEAP	0x08000000
810060cedfbSMadhavan Venkataraman #define	COF_QUEUE	0x10000000
81187a18d3fSMadhavan Venkataraman 
81287a18d3fSMadhavan Venkataraman /* show real and normal, short and long, expired and unexpired. */
81387a18d3fSMadhavan Venkataraman #define	COF_DEFAULT	(COF_REAL | COF_NORM | COF_LONG | COF_SHORT)
81487a18d3fSMadhavan Venkataraman 
81551b32bddSMadhavan Venkataraman #define	COF_LIST_FLAGS	\
81651b32bddSMadhavan Venkataraman 	(CALLOUT_LIST_FLAG_HRESTIME | CALLOUT_LIST_FLAG_ABSOLUTE)
81751b32bddSMadhavan Venkataraman 
81887a18d3fSMadhavan Venkataraman /* private callout data for callback functions */
81987a18d3fSMadhavan Venkataraman typedef struct callout_data {
82087a18d3fSMadhavan Venkataraman 	uint_t flags;		/* COF_* */
82187a18d3fSMadhavan Venkataraman 	cpu_t *cpu;		/* cpu pointer if given */
82287a18d3fSMadhavan Venkataraman 	int seqid;		/* cpu seqid, or -1 */
82387a18d3fSMadhavan Venkataraman 	hrtime_t time;		/* expiration time value */
82487a18d3fSMadhavan Venkataraman 	hrtime_t atime;		/* expiration before value */
82587a18d3fSMadhavan Venkataraman 	hrtime_t btime;		/* expiration after value */
82687a18d3fSMadhavan Venkataraman 	uintptr_t funcaddr;	/* function address or NULL */
82787a18d3fSMadhavan Venkataraman 	uintptr_t param;	/* parameter to function or NULL */
82887a18d3fSMadhavan Venkataraman 	hrtime_t now;		/* current system time */
82987a18d3fSMadhavan Venkataraman 	int nsec_per_tick;	/* for conversions */
83087a18d3fSMadhavan Venkataraman 	ulong_t ctbits;		/* for decoding xid */
83187a18d3fSMadhavan Venkataraman 	callout_table_t *co_table;	/* top of callout table array */
83287a18d3fSMadhavan Venkataraman 	int ndx;		/* table index. */
83387a18d3fSMadhavan Venkataraman 	int bucket;		/* which list/id bucket are we in */
83487a18d3fSMadhavan Venkataraman 	hrtime_t exp;		/* expire time */
83507247649SMadhavan Venkataraman 	int list_flags;		/* copy of cl_flags */
83687a18d3fSMadhavan Venkataraman } callout_data_t;
83787a18d3fSMadhavan Venkataraman 
83887a18d3fSMadhavan Venkataraman /* this callback does the actual callback itself (finally). */
83987a18d3fSMadhavan Venkataraman /*ARGSUSED*/
84087a18d3fSMadhavan Venkataraman static int
84187a18d3fSMadhavan Venkataraman callouts_cb(uintptr_t addr, const void *data, void *priv)
84287a18d3fSMadhavan Venkataraman {
84387a18d3fSMadhavan Venkataraman 	callout_data_t *coargs = (callout_data_t *)priv;
84487a18d3fSMadhavan Venkataraman 	callout_t *co = (callout_t *)data;
84551b32bddSMadhavan Venkataraman 	int tableid, list_flags;
84687a18d3fSMadhavan Venkataraman 	callout_id_t coid;
84787a18d3fSMadhavan Venkataraman 
84887a18d3fSMadhavan Venkataraman 	if ((coargs == NULL) || (co == NULL)) {
84987a18d3fSMadhavan Venkataraman 		return (WALK_ERR);
85087a18d3fSMadhavan Venkataraman 	}
85187a18d3fSMadhavan Venkataraman 
852060cedfbSMadhavan Venkataraman 	if ((coargs->flags & COF_FREE) && !(co->c_xid & CALLOUT_ID_FREE)) {
85351b32bddSMadhavan Venkataraman 		/*
85451b32bddSMadhavan Venkataraman 		 * The callout must have been reallocated. No point in
85551b32bddSMadhavan Venkataraman 		 * walking any more.
85651b32bddSMadhavan Venkataraman 		 */
85751b32bddSMadhavan Venkataraman 		return (WALK_DONE);
85851b32bddSMadhavan Venkataraman 	}
859060cedfbSMadhavan Venkataraman 	if (!(coargs->flags & COF_FREE) && (co->c_xid & CALLOUT_ID_FREE)) {
86051b32bddSMadhavan Venkataraman 		/*
86151b32bddSMadhavan Venkataraman 		 * The callout must have been freed. No point in
86251b32bddSMadhavan Venkataraman 		 * walking any more.
86351b32bddSMadhavan Venkataraman 		 */
86451b32bddSMadhavan Venkataraman 		return (WALK_DONE);
86551b32bddSMadhavan Venkataraman 	}
86687a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_FUNC) &&
86787a18d3fSMadhavan Venkataraman 	    (coargs->funcaddr != (uintptr_t)co->c_func)) {
86887a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
86987a18d3fSMadhavan Venkataraman 	}
87087a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_PARAM) &&
87187a18d3fSMadhavan Venkataraman 	    (coargs->param != (uintptr_t)co->c_arg)) {
87287a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
87387a18d3fSMadhavan Venkataraman 	}
87487a18d3fSMadhavan Venkataraman 	if (!(coargs->flags & COF_LONG) && (co->c_xid & CALLOUT_LONGTERM)) {
87587a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
87687a18d3fSMadhavan Venkataraman 	}
87787a18d3fSMadhavan Venkataraman 	if (!(coargs->flags & COF_SHORT) && !(co->c_xid & CALLOUT_LONGTERM)) {
87887a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
87987a18d3fSMadhavan Venkataraman 	}
88087a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_EXEC) && !(co->c_xid & CALLOUT_EXECUTING)) {
88187a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
88287a18d3fSMadhavan Venkataraman 	}
88351b32bddSMadhavan Venkataraman 	/* it is possible we don't have the exp time or flags */
88487a18d3fSMadhavan Venkataraman 	if (coargs->flags & COF_BYIDH) {
88587a18d3fSMadhavan Venkataraman 		if (!(coargs->flags & COF_FREE)) {
88687a18d3fSMadhavan Venkataraman 			/* we have to fetch the expire time ourselves. */
88787a18d3fSMadhavan Venkataraman 			if (mdb_vread(&coargs->exp, sizeof (hrtime_t),
88887a18d3fSMadhavan Venkataraman 			    (uintptr_t)co->c_list + offsetof(callout_list_t,
88987a18d3fSMadhavan Venkataraman 			    cl_expiration)) == -1) {
89087a18d3fSMadhavan Venkataraman 				mdb_warn("failed to read expiration "
89187a18d3fSMadhavan Venkataraman 				    "time from %p", co->c_list);
89287a18d3fSMadhavan Venkataraman 				coargs->exp = 0;
8937c478bd9Sstevel@tonic-gate 			}
89407247649SMadhavan Venkataraman 			/* and flags. */
89507247649SMadhavan Venkataraman 			if (mdb_vread(&coargs->list_flags, sizeof (int),
89607247649SMadhavan Venkataraman 			    (uintptr_t)co->c_list + offsetof(callout_list_t,
89707247649SMadhavan Venkataraman 			    cl_flags)) == -1) {
89807247649SMadhavan Venkataraman 				mdb_warn("failed to read list flags"
89907247649SMadhavan Venkataraman 				    "from %p", co->c_list);
90007247649SMadhavan Venkataraman 				coargs->list_flags = 0;
90107247649SMadhavan Venkataraman 			}
90287a18d3fSMadhavan Venkataraman 		} else {
90387a18d3fSMadhavan Venkataraman 			/* free callouts can't use list pointer. */
90487a18d3fSMadhavan Venkataraman 			coargs->exp = 0;
90507247649SMadhavan Venkataraman 			coargs->list_flags = 0;
90607247649SMadhavan Venkataraman 		}
90707247649SMadhavan Venkataraman 		if (coargs->exp != 0) {
90807247649SMadhavan Venkataraman 			if ((coargs->flags & COF_TIME) &&
90907247649SMadhavan Venkataraman 			    (coargs->exp != coargs->time)) {
91007247649SMadhavan Venkataraman 				return (WALK_NEXT);
91107247649SMadhavan Venkataraman 			}
91207247649SMadhavan Venkataraman 			if ((coargs->flags & COF_BEFORE) &&
91307247649SMadhavan Venkataraman 			    (coargs->exp > coargs->btime)) {
91407247649SMadhavan Venkataraman 				return (WALK_NEXT);
91507247649SMadhavan Venkataraman 			}
91607247649SMadhavan Venkataraman 			if ((coargs->flags & COF_AFTER) &&
91707247649SMadhavan Venkataraman 			    (coargs->exp < coargs->atime)) {
91807247649SMadhavan Venkataraman 				return (WALK_NEXT);
91907247649SMadhavan Venkataraman 			}
92007247649SMadhavan Venkataraman 		}
92107247649SMadhavan Venkataraman 		/* tricky part, since both HIRES and ABS can be set */
92251b32bddSMadhavan Venkataraman 		list_flags = coargs->list_flags;
92307247649SMadhavan Venkataraman 		if ((coargs->flags & COF_HIRES) && (coargs->flags & COF_ABS)) {
92407247649SMadhavan Venkataraman 			/* both flags are set, only skip "regular" ones */
92551b32bddSMadhavan Venkataraman 			if (! (list_flags & COF_LIST_FLAGS)) {
92607247649SMadhavan Venkataraman 				return (WALK_NEXT);
92707247649SMadhavan Venkataraman 			}
92807247649SMadhavan Venkataraman 		} else {
92907247649SMadhavan Venkataraman 			/* individual flags, or no flags */
93007247649SMadhavan Venkataraman 			if ((coargs->flags & COF_HIRES) &&
93151b32bddSMadhavan Venkataraman 			    !(list_flags & CALLOUT_LIST_FLAG_HRESTIME)) {
93207247649SMadhavan Venkataraman 				return (WALK_NEXT);
93307247649SMadhavan Venkataraman 			}
93407247649SMadhavan Venkataraman 			if ((coargs->flags & COF_ABS) &&
93551b32bddSMadhavan Venkataraman 			    !(list_flags & CALLOUT_LIST_FLAG_ABSOLUTE)) {
93607247649SMadhavan Venkataraman 				return (WALK_NEXT);
93707247649SMadhavan Venkataraman 			}
93887a18d3fSMadhavan Venkataraman 		}
939060cedfbSMadhavan Venkataraman 		/*
940060cedfbSMadhavan Venkataraman 		 * We do the checks for COF_HEAP and COF_QUEUE here only if we
941060cedfbSMadhavan Venkataraman 		 * are traversing BYIDH. If the traversal is by callout list,
942060cedfbSMadhavan Venkataraman 		 * we do this check in callout_list_cb() to be more
943060cedfbSMadhavan Venkataraman 		 * efficient.
944060cedfbSMadhavan Venkataraman 		 */
945060cedfbSMadhavan Venkataraman 		if ((coargs->flags & COF_HEAP) &&
946060cedfbSMadhavan Venkataraman 		    !(list_flags & CALLOUT_LIST_FLAG_HEAPED)) {
947060cedfbSMadhavan Venkataraman 			return (WALK_NEXT);
948060cedfbSMadhavan Venkataraman 		}
949060cedfbSMadhavan Venkataraman 
950060cedfbSMadhavan Venkataraman 		if ((coargs->flags & COF_QUEUE) &&
951060cedfbSMadhavan Venkataraman 		    !(list_flags & CALLOUT_LIST_FLAG_QUEUED)) {
952060cedfbSMadhavan Venkataraman 			return (WALK_NEXT);
953060cedfbSMadhavan Venkataraman 		}
95487a18d3fSMadhavan Venkataraman 	}
95587a18d3fSMadhavan Venkataraman 
95687a18d3fSMadhavan Venkataraman #define	callout_table_mask	((1 << coargs->ctbits) - 1)
95787a18d3fSMadhavan Venkataraman 	tableid = CALLOUT_ID_TO_TABLE(co->c_xid);
95887a18d3fSMadhavan Venkataraman #undef	callout_table_mask
95987a18d3fSMadhavan Venkataraman 	coid = CO_PLAIN_ID(co->c_xid);
96087a18d3fSMadhavan Venkataraman 
96187a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_CHDR) && !(coargs->flags & COF_ADDR)) {
96287a18d3fSMadhavan Venkataraman 		/*
96387a18d3fSMadhavan Venkataraman 		 * We need to print the headers. If walking by id, then
96487a18d3fSMadhavan Venkataraman 		 * the list header isn't printed, so we must include
96587a18d3fSMadhavan Venkataraman 		 * that info here.
96687a18d3fSMadhavan Venkataraman 		 */
96787a18d3fSMadhavan Venkataraman 		if (!(coargs->flags & COF_VERBOSE)) {
96887a18d3fSMadhavan Venkataraman 			mdb_printf("%<u>%3s %-1s %-14s %</u>",
96987a18d3fSMadhavan Venkataraman 			    "SEQ", "T", "EXP");
97087a18d3fSMadhavan Venkataraman 		} else if (coargs->flags & COF_BYIDH) {
97187a18d3fSMadhavan Venkataraman 			mdb_printf("%<u>%-14s %</u>", "EXP");
97287a18d3fSMadhavan Venkataraman 		}
97307247649SMadhavan Venkataraman 		mdb_printf("%<u>%-4s %-?s %-20s%</u>",
97407247649SMadhavan Venkataraman 		    "XHAL", "XID", "FUNC(ARG)");
97587a18d3fSMadhavan Venkataraman 		if (coargs->flags & COF_LONGLIST) {
97687a18d3fSMadhavan Venkataraman 			mdb_printf("%<u> %-?s %-?s %-?s %-?s%</u>",
97787a18d3fSMadhavan Venkataraman 			    "PREVID", "NEXTID", "PREVL", "NEXTL");
97807247649SMadhavan Venkataraman 			mdb_printf("%<u> %-?s %-4s %-?s%</u>",
97907247649SMadhavan Venkataraman 			    "DONE", "UTOS", "THREAD");
98087a18d3fSMadhavan Venkataraman 		}
98187a18d3fSMadhavan Venkataraman 		mdb_printf("\n");
98287a18d3fSMadhavan Venkataraman 		coargs->flags &= ~COF_CHDR;
98387a18d3fSMadhavan Venkataraman 		coargs->flags |= (COF_THDR | COF_LHDR);
98487a18d3fSMadhavan Venkataraman 	}
98587a18d3fSMadhavan Venkataraman 
98687a18d3fSMadhavan Venkataraman 	if (!(coargs->flags & COF_ADDR)) {
98787a18d3fSMadhavan Venkataraman 		if (!(coargs->flags & COF_VERBOSE)) {
98887a18d3fSMadhavan Venkataraman 			mdb_printf("%-3d %1s %-14llx ",
98987a18d3fSMadhavan Venkataraman 			    TABLE_TO_SEQID(tableid),
99087a18d3fSMadhavan Venkataraman 			    co_typenames[tableid & CALLOUT_TYPE_MASK],
99187a18d3fSMadhavan Venkataraman 			    (coargs->flags & COF_EXPREL) ?
99287a18d3fSMadhavan Venkataraman 			    coargs->exp - coargs->now : coargs->exp);
99387a18d3fSMadhavan Venkataraman 		} else if (coargs->flags & COF_BYIDH) {
99487a18d3fSMadhavan Venkataraman 			mdb_printf("%-14x ",
99587a18d3fSMadhavan Venkataraman 			    (coargs->flags & COF_EXPREL) ?
99687a18d3fSMadhavan Venkataraman 			    coargs->exp - coargs->now : coargs->exp);
99787a18d3fSMadhavan Venkataraman 		}
99851b32bddSMadhavan Venkataraman 		list_flags = coargs->list_flags;
99907247649SMadhavan Venkataraman 		mdb_printf("%1s%1s%1s%1s %-?llx %a(%p)",
100087a18d3fSMadhavan Venkataraman 		    (co->c_xid & CALLOUT_EXECUTING) ? "X" : " ",
100151b32bddSMadhavan Venkataraman 		    (list_flags & CALLOUT_LIST_FLAG_HRESTIME) ? "H" : " ",
100251b32bddSMadhavan Venkataraman 		    (list_flags & CALLOUT_LIST_FLAG_ABSOLUTE) ? "A" : " ",
100387a18d3fSMadhavan Venkataraman 		    (co->c_xid & CALLOUT_LONGTERM) ? "L" : " ",
100487a18d3fSMadhavan Venkataraman 		    (long long)coid, co->c_func, co->c_arg);
100587a18d3fSMadhavan Venkataraman 		if (coargs->flags & COF_LONGLIST) {
100687a18d3fSMadhavan Venkataraman 			mdb_printf(" %-?p %-?p %-?p %-?p",
100787a18d3fSMadhavan Venkataraman 			    co->c_idprev, co->c_idnext, co->c_clprev,
100887a18d3fSMadhavan Venkataraman 			    co->c_clnext);
100907247649SMadhavan Venkataraman 			mdb_printf(" %-?p %-4d %-0?p",
101007247649SMadhavan Venkataraman 			    co->c_done, co->c_waiting, co->c_executor);
101187a18d3fSMadhavan Venkataraman 		}
101287a18d3fSMadhavan Venkataraman 	} else {
101387a18d3fSMadhavan Venkataraman 		/* address only */
101487a18d3fSMadhavan Venkataraman 		mdb_printf("%-0p", addr);
101587a18d3fSMadhavan Venkataraman 	}
101687a18d3fSMadhavan Venkataraman 	mdb_printf("\n");
101787a18d3fSMadhavan Venkataraman 	return (WALK_NEXT);
101887a18d3fSMadhavan Venkataraman }
101987a18d3fSMadhavan Venkataraman 
102087a18d3fSMadhavan Venkataraman /* this callback is for callout list handling. idhash is done by callout_t_cb */
102187a18d3fSMadhavan Venkataraman /*ARGSUSED*/
102287a18d3fSMadhavan Venkataraman static int
102387a18d3fSMadhavan Venkataraman callout_list_cb(uintptr_t addr, const void *data, void *priv)
102487a18d3fSMadhavan Venkataraman {
102587a18d3fSMadhavan Venkataraman 	callout_data_t *coargs = (callout_data_t *)priv;
102687a18d3fSMadhavan Venkataraman 	callout_list_t *cl = (callout_list_t *)data;
102787a18d3fSMadhavan Venkataraman 	callout_t *coptr;
102851b32bddSMadhavan Venkataraman 	int list_flags;
102987a18d3fSMadhavan Venkataraman 
103087a18d3fSMadhavan Venkataraman 	if ((coargs == NULL) || (cl == NULL)) {
103187a18d3fSMadhavan Venkataraman 		return (WALK_ERR);
103287a18d3fSMadhavan Venkataraman 	}
103387a18d3fSMadhavan Venkataraman 
103487a18d3fSMadhavan Venkataraman 	coargs->exp = cl->cl_expiration;
103507247649SMadhavan Venkataraman 	coargs->list_flags = cl->cl_flags;
103651b32bddSMadhavan Venkataraman 	if ((coargs->flags & COF_FREE) &&
103751b32bddSMadhavan Venkataraman 	    !(cl->cl_flags & CALLOUT_LIST_FLAG_FREE)) {
103851b32bddSMadhavan Venkataraman 		/*
103951b32bddSMadhavan Venkataraman 		 * The callout list must have been reallocated. No point in
104051b32bddSMadhavan Venkataraman 		 * walking any more.
104151b32bddSMadhavan Venkataraman 		 */
104251b32bddSMadhavan Venkataraman 		return (WALK_DONE);
104351b32bddSMadhavan Venkataraman 	}
104451b32bddSMadhavan Venkataraman 	if (!(coargs->flags & COF_FREE) &&
104551b32bddSMadhavan Venkataraman 	    (cl->cl_flags & CALLOUT_LIST_FLAG_FREE)) {
104651b32bddSMadhavan Venkataraman 		/*
104751b32bddSMadhavan Venkataraman 		 * The callout list must have been freed. No point in
104851b32bddSMadhavan Venkataraman 		 * walking any more.
104951b32bddSMadhavan Venkataraman 		 */
105051b32bddSMadhavan Venkataraman 		return (WALK_DONE);
105151b32bddSMadhavan Venkataraman 	}
105287a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_TIME) &&
105387a18d3fSMadhavan Venkataraman 	    (cl->cl_expiration != coargs->time)) {
105487a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
105587a18d3fSMadhavan Venkataraman 	}
105687a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_BEFORE) &&
105787a18d3fSMadhavan Venkataraman 	    (cl->cl_expiration > coargs->btime)) {
105887a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
105987a18d3fSMadhavan Venkataraman 	}
106087a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_AFTER) &&
106187a18d3fSMadhavan Venkataraman 	    (cl->cl_expiration < coargs->atime)) {
106287a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
106387a18d3fSMadhavan Venkataraman 	}
106487a18d3fSMadhavan Venkataraman 	if (!(coargs->flags & COF_EMPTY) &&
106587a18d3fSMadhavan Venkataraman 	    (cl->cl_callouts.ch_head == NULL)) {
106687a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
106787a18d3fSMadhavan Venkataraman 	}
106807247649SMadhavan Venkataraman 	/* FOUR cases, each different, !A!B, !AB, A!B, AB */
106907247649SMadhavan Venkataraman 	if ((coargs->flags & COF_HIRES) && (coargs->flags & COF_ABS)) {
107007247649SMadhavan Venkataraman 		/* both flags are set, only skip "regular" ones */
107151b32bddSMadhavan Venkataraman 		if (! (cl->cl_flags & COF_LIST_FLAGS)) {
107207247649SMadhavan Venkataraman 			return (WALK_NEXT);
107307247649SMadhavan Venkataraman 		}
107407247649SMadhavan Venkataraman 	} else {
107507247649SMadhavan Venkataraman 		if ((coargs->flags & COF_HIRES) &&
107651b32bddSMadhavan Venkataraman 		    !(cl->cl_flags & CALLOUT_LIST_FLAG_HRESTIME)) {
107707247649SMadhavan Venkataraman 			return (WALK_NEXT);
107807247649SMadhavan Venkataraman 		}
107907247649SMadhavan Venkataraman 		if ((coargs->flags & COF_ABS) &&
108051b32bddSMadhavan Venkataraman 		    !(cl->cl_flags & CALLOUT_LIST_FLAG_ABSOLUTE)) {
108107247649SMadhavan Venkataraman 			return (WALK_NEXT);
108207247649SMadhavan Venkataraman 		}
108307247649SMadhavan Venkataraman 	}
108487a18d3fSMadhavan Venkataraman 
1085060cedfbSMadhavan Venkataraman 	if ((coargs->flags & COF_HEAP) &&
1086060cedfbSMadhavan Venkataraman 	    !(coargs->list_flags & CALLOUT_LIST_FLAG_HEAPED)) {
1087060cedfbSMadhavan Venkataraman 		return (WALK_NEXT);
1088060cedfbSMadhavan Venkataraman 	}
1089060cedfbSMadhavan Venkataraman 
1090060cedfbSMadhavan Venkataraman 	if ((coargs->flags & COF_QUEUE) &&
1091060cedfbSMadhavan Venkataraman 	    !(coargs->list_flags & CALLOUT_LIST_FLAG_QUEUED)) {
1092060cedfbSMadhavan Venkataraman 		return (WALK_NEXT);
1093060cedfbSMadhavan Venkataraman 	}
1094060cedfbSMadhavan Venkataraman 
109587a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_LHDR) && !(coargs->flags & COF_ADDR) &&
109687a18d3fSMadhavan Venkataraman 	    (coargs->flags & (COF_LIST | COF_VERBOSE))) {
109787a18d3fSMadhavan Venkataraman 		if (!(coargs->flags & COF_VERBOSE)) {
109887a18d3fSMadhavan Venkataraman 			/* don't be redundant again */
109987a18d3fSMadhavan Venkataraman 			mdb_printf("%<u>SEQ T %</u>");
110087a18d3fSMadhavan Venkataraman 		}
110107247649SMadhavan Venkataraman 		mdb_printf("%<u>EXP            HA BUCKET "
110207247649SMadhavan Venkataraman 		    "CALLOUTS         %</u>");
110387a18d3fSMadhavan Venkataraman 
110487a18d3fSMadhavan Venkataraman 		if (coargs->flags & COF_LONGLIST) {
110507247649SMadhavan Venkataraman 			mdb_printf("%<u> %-?s %-?s%</u>",
110607247649SMadhavan Venkataraman 			    "PREV", "NEXT");
110787a18d3fSMadhavan Venkataraman 		}
110887a18d3fSMadhavan Venkataraman 		mdb_printf("\n");
110987a18d3fSMadhavan Venkataraman 		coargs->flags &= ~COF_LHDR;
111087a18d3fSMadhavan Venkataraman 		coargs->flags |= (COF_THDR | COF_CHDR);
111187a18d3fSMadhavan Venkataraman 	}
111287a18d3fSMadhavan Venkataraman 	if (coargs->flags & (COF_LIST | COF_VERBOSE)) {
111387a18d3fSMadhavan Venkataraman 		if (!(coargs->flags & COF_ADDR)) {
111487a18d3fSMadhavan Venkataraman 			if (!(coargs->flags & COF_VERBOSE)) {
111587a18d3fSMadhavan Venkataraman 				mdb_printf("%3d %1s ",
111687a18d3fSMadhavan Venkataraman 				    TABLE_TO_SEQID(coargs->ndx),
111787a18d3fSMadhavan Venkataraman 				    co_typenames[coargs->ndx &
111887a18d3fSMadhavan Venkataraman 				    CALLOUT_TYPE_MASK]);
111987a18d3fSMadhavan Venkataraman 			}
112087a18d3fSMadhavan Venkataraman 
112151b32bddSMadhavan Venkataraman 			list_flags = coargs->list_flags;
112207247649SMadhavan Venkataraman 			mdb_printf("%-14llx %1s%1s %-6d %-0?p ",
112387a18d3fSMadhavan Venkataraman 			    (coargs->flags & COF_EXPREL) ?
112487a18d3fSMadhavan Venkataraman 			    coargs->exp - coargs->now : coargs->exp,
112551b32bddSMadhavan Venkataraman 			    (list_flags & CALLOUT_LIST_FLAG_HRESTIME) ?
112607247649SMadhavan Venkataraman 			    "H" : " ",
112751b32bddSMadhavan Venkataraman 			    (list_flags & CALLOUT_LIST_FLAG_ABSOLUTE) ?
112807247649SMadhavan Venkataraman 			    "A" : " ",
112907247649SMadhavan Venkataraman 			    coargs->bucket, cl->cl_callouts.ch_head);
113087a18d3fSMadhavan Venkataraman 
113187a18d3fSMadhavan Venkataraman 			if (coargs->flags & COF_LONGLIST) {
113207247649SMadhavan Venkataraman 				mdb_printf(" %-?p %-?p",
113307247649SMadhavan Venkataraman 				    cl->cl_prev, cl->cl_next);
113487a18d3fSMadhavan Venkataraman 			}
113587a18d3fSMadhavan Venkataraman 		} else {
113687a18d3fSMadhavan Venkataraman 			/* address only */
113787a18d3fSMadhavan Venkataraman 			mdb_printf("%-0p", addr);
113887a18d3fSMadhavan Venkataraman 		}
113987a18d3fSMadhavan Venkataraman 		mdb_printf("\n");
114087a18d3fSMadhavan Venkataraman 		if (coargs->flags & COF_LIST) {
114187a18d3fSMadhavan Venkataraman 			return (WALK_NEXT);
114287a18d3fSMadhavan Venkataraman 		}
114387a18d3fSMadhavan Venkataraman 	}
114487a18d3fSMadhavan Venkataraman 	/* yet another layer as we walk the actual callouts via list. */
114587a18d3fSMadhavan Venkataraman 	if (cl->cl_callouts.ch_head == NULL) {
114687a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
114787a18d3fSMadhavan Venkataraman 	}
114887a18d3fSMadhavan Venkataraman 	/* free list structures do not have valid callouts off of them. */
114987a18d3fSMadhavan Venkataraman 	if (coargs->flags & COF_FREE) {
115087a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
115187a18d3fSMadhavan Venkataraman 	}
115287a18d3fSMadhavan Venkataraman 	coptr = (callout_t *)cl->cl_callouts.ch_head;
115387a18d3fSMadhavan Venkataraman 
115487a18d3fSMadhavan Venkataraman 	if (coargs->flags & COF_VERBOSE) {
115587a18d3fSMadhavan Venkataraman 		mdb_inc_indent(4);
115687a18d3fSMadhavan Venkataraman 	}
115787a18d3fSMadhavan Venkataraman 	/*
115887a18d3fSMadhavan Venkataraman 	 * walk callouts using yet another callback routine.
115987a18d3fSMadhavan Venkataraman 	 * we use callouts_bytime because id hash is handled via
116087a18d3fSMadhavan Venkataraman 	 * the callout_t_cb callback.
116187a18d3fSMadhavan Venkataraman 	 */
116287a18d3fSMadhavan Venkataraman 	if (mdb_pwalk("callouts_bytime", callouts_cb, coargs,
116387a18d3fSMadhavan Venkataraman 	    (uintptr_t)coptr) == -1) {
116487a18d3fSMadhavan Venkataraman 		mdb_warn("cannot walk callouts at %p", coptr);
116587a18d3fSMadhavan Venkataraman 		return (WALK_ERR);
116687a18d3fSMadhavan Venkataraman 	}
116787a18d3fSMadhavan Venkataraman 	if (coargs->flags & COF_VERBOSE) {
116887a18d3fSMadhavan Venkataraman 		mdb_dec_indent(4);
116987a18d3fSMadhavan Venkataraman 	}
117087a18d3fSMadhavan Venkataraman 
117187a18d3fSMadhavan Venkataraman 	return (WALK_NEXT);
117287a18d3fSMadhavan Venkataraman }
117387a18d3fSMadhavan Venkataraman 
117487a18d3fSMadhavan Venkataraman /* this callback handles the details of callout table walking. */
117587a18d3fSMadhavan Venkataraman static int
117687a18d3fSMadhavan Venkataraman callout_t_cb(uintptr_t addr, const void *data, void *priv)
117787a18d3fSMadhavan Venkataraman {
117887a18d3fSMadhavan Venkataraman 	callout_data_t *coargs = (callout_data_t *)priv;
117987a18d3fSMadhavan Venkataraman 	cot_data_t *cotwd = (cot_data_t *)data;
118087a18d3fSMadhavan Venkataraman 	callout_table_t *ct = &(cotwd->ct);
118187a18d3fSMadhavan Venkataraman 	int index, seqid, cotype;
118287a18d3fSMadhavan Venkataraman 	int i;
118387a18d3fSMadhavan Venkataraman 	callout_list_t *clptr;
118487a18d3fSMadhavan Venkataraman 	callout_t *coptr;
118587a18d3fSMadhavan Venkataraman 
118687a18d3fSMadhavan Venkataraman 	if ((coargs == NULL) || (ct == NULL) || (coargs->co_table == NULL)) {
118787a18d3fSMadhavan Venkataraman 		return (WALK_ERR);
118887a18d3fSMadhavan Venkataraman 	}
118987a18d3fSMadhavan Venkataraman 
119087a18d3fSMadhavan Venkataraman 	index =  ((char *)addr - (char *)coargs->co_table) /
119187a18d3fSMadhavan Venkataraman 	    sizeof (callout_table_t);
119287a18d3fSMadhavan Venkataraman 	cotype = index & CALLOUT_TYPE_MASK;
119387a18d3fSMadhavan Venkataraman 	seqid = TABLE_TO_SEQID(index);
11947c478bd9Sstevel@tonic-gate 
119587a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_SEQID) && (coargs->seqid != seqid)) {
119687a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
119787a18d3fSMadhavan Venkataraman 	}
11987c478bd9Sstevel@tonic-gate 
119987a18d3fSMadhavan Venkataraman 	if (!(coargs->flags & COF_REAL) && (cotype == CALLOUT_REALTIME)) {
120087a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
120187a18d3fSMadhavan Venkataraman 	}
12027c478bd9Sstevel@tonic-gate 
120387a18d3fSMadhavan Venkataraman 	if (!(coargs->flags & COF_NORM) && (cotype == CALLOUT_NORMAL)) {
120487a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
120587a18d3fSMadhavan Venkataraman 	}
12067c478bd9Sstevel@tonic-gate 
120787a18d3fSMadhavan Venkataraman 	if (!(coargs->flags & COF_EMPTY) && (
1208*892ad162SToomas Soome 	    (ct->ct_heap == NULL) || (ct->ct_cyclic == 0))) {
120987a18d3fSMadhavan Venkataraman 		return (WALK_NEXT);
121087a18d3fSMadhavan Venkataraman 	}
121187a18d3fSMadhavan Venkataraman 
121287a18d3fSMadhavan Venkataraman 	if ((coargs->flags & COF_THDR) && !(coargs->flags & COF_ADDR) &&
121387a18d3fSMadhavan Venkataraman 	    (coargs->flags & (COF_TABLE | COF_VERBOSE))) {
121487a18d3fSMadhavan Venkataraman 		/* print table hdr */
121587a18d3fSMadhavan Venkataraman 		mdb_printf("%<u>%-3s %-1s %-?s %-?s %-?s %-?s%</u>",
121687a18d3fSMadhavan Venkataraman 		    "SEQ", "T", "FREE", "LFREE", "CYCLIC", "HEAP");
121787a18d3fSMadhavan Venkataraman 		coargs->flags &= ~COF_THDR;
121887a18d3fSMadhavan Venkataraman 		coargs->flags |= (COF_LHDR | COF_CHDR);
121987a18d3fSMadhavan Venkataraman 		if (coargs->flags & COF_LONGLIST) {
122087a18d3fSMadhavan Venkataraman 			/* more info! */
1221060cedfbSMadhavan Venkataraman 			mdb_printf("%<u> %-T%-7s %-7s %-?s %-?s %-?s"
122287a18d3fSMadhavan Venkataraman 			    " %-?s %-?s %-?s%</u>",
1223060cedfbSMadhavan Venkataraman 			    "HEAPNUM", "HEAPMAX", "TASKQ", "EXPQ", "QUE",
122487a18d3fSMadhavan Venkataraman 			    "PEND", "FREE", "LOCK");
122587a18d3fSMadhavan Venkataraman 		}
122687a18d3fSMadhavan Venkataraman 		mdb_printf("\n");
122787a18d3fSMadhavan Venkataraman 	}
122887a18d3fSMadhavan Venkataraman 	if (coargs->flags & (COF_TABLE | COF_VERBOSE)) {
122987a18d3fSMadhavan Venkataraman 		if (!(coargs->flags & COF_ADDR)) {
123087a18d3fSMadhavan Venkataraman 			mdb_printf("%-3d %-1s %-0?p %-0?p %-0?p %-?p",
123187a18d3fSMadhavan Venkataraman 			    seqid, co_typenames[cotype],
123287a18d3fSMadhavan Venkataraman 			    ct->ct_free, ct->ct_lfree, ct->ct_cyclic,
123387a18d3fSMadhavan Venkataraman 			    ct->ct_heap);
123487a18d3fSMadhavan Venkataraman 			if (coargs->flags & COF_LONGLIST)  {
123587a18d3fSMadhavan Venkataraman 				/* more info! */
1236060cedfbSMadhavan Venkataraman 				mdb_printf(" %-7d %-7d %-?p %-?p %-?p"
123787a18d3fSMadhavan Venkataraman 				    " %-?lld %-?lld %-?p",
123887a18d3fSMadhavan Venkataraman 				    ct->ct_heap_num,  ct->ct_heap_max,
123987a18d3fSMadhavan Venkataraman 				    ct->ct_taskq, ct->ct_expired.ch_head,
1240060cedfbSMadhavan Venkataraman 				    ct->ct_queue.ch_head,
124187a18d3fSMadhavan Venkataraman 				    cotwd->ct_timeouts_pending,
124287a18d3fSMadhavan Venkataraman 				    cotwd->ct_allocations -
124387a18d3fSMadhavan Venkataraman 				    cotwd->ct_timeouts_pending,
124487a18d3fSMadhavan Venkataraman 				    ct->ct_mutex);
124587a18d3fSMadhavan Venkataraman 			}
124687a18d3fSMadhavan Venkataraman 		} else {
124787a18d3fSMadhavan Venkataraman 			/* address only */
124887a18d3fSMadhavan Venkataraman 			mdb_printf("%-0?p", addr);
124987a18d3fSMadhavan Venkataraman 		}
125087a18d3fSMadhavan Venkataraman 		mdb_printf("\n");
125187a18d3fSMadhavan Venkataraman 		if (coargs->flags & COF_TABLE) {
125287a18d3fSMadhavan Venkataraman 			return (WALK_NEXT);
125387a18d3fSMadhavan Venkataraman 		}
125487a18d3fSMadhavan Venkataraman 	}
125587a18d3fSMadhavan Venkataraman 
125687a18d3fSMadhavan Venkataraman 	coargs->ndx = index;
125787a18d3fSMadhavan Venkataraman 	if (coargs->flags & COF_VERBOSE) {
125887a18d3fSMadhavan Venkataraman 		mdb_inc_indent(4);
125987a18d3fSMadhavan Venkataraman 	}
126087a18d3fSMadhavan Venkataraman 	/* keep digging. */
126187a18d3fSMadhavan Venkataraman 	if (!(coargs->flags & COF_BYIDH)) {
126287a18d3fSMadhavan Venkataraman 		/* walk the list hash table */
126387a18d3fSMadhavan Venkataraman 		if (coargs->flags & COF_FREE) {
126487a18d3fSMadhavan Venkataraman 			clptr = ct->ct_lfree;
126587a18d3fSMadhavan Venkataraman 			coargs->bucket = 0;
126687a18d3fSMadhavan Venkataraman 			if (clptr == NULL) {
126787a18d3fSMadhavan Venkataraman 				return (WALK_NEXT);
126887a18d3fSMadhavan Venkataraman 			}
126987a18d3fSMadhavan Venkataraman 			if (mdb_pwalk("callout_list", callout_list_cb, coargs,
127087a18d3fSMadhavan Venkataraman 			    (uintptr_t)clptr) == -1) {
127187a18d3fSMadhavan Venkataraman 				mdb_warn("cannot walk callout free list at %p",
127287a18d3fSMadhavan Venkataraman 				    clptr);
127387a18d3fSMadhavan Venkataraman 				return (WALK_ERR);
127487a18d3fSMadhavan Venkataraman 			}
127587a18d3fSMadhavan Venkataraman 		} else {
127687a18d3fSMadhavan Venkataraman 			/* first print the expired list. */
127787a18d3fSMadhavan Venkataraman 			clptr = (callout_list_t *)ct->ct_expired.ch_head;
127887a18d3fSMadhavan Venkataraman 			if (clptr != NULL) {
127987a18d3fSMadhavan Venkataraman 				coargs->bucket = -1;
128087a18d3fSMadhavan Venkataraman 				if (mdb_pwalk("callout_list", callout_list_cb,
128187a18d3fSMadhavan Venkataraman 				    coargs, (uintptr_t)clptr) == -1) {
128287a18d3fSMadhavan Venkataraman 					mdb_warn("cannot walk callout_list"
128387a18d3fSMadhavan Venkataraman 					    " at %p", clptr);
128487a18d3fSMadhavan Venkataraman 					return (WALK_ERR);
128587a18d3fSMadhavan Venkataraman 				}
128687a18d3fSMadhavan Venkataraman 			}
1287060cedfbSMadhavan Venkataraman 			/* then, print the callout queue */
1288060cedfbSMadhavan Venkataraman 			clptr = (callout_list_t *)ct->ct_queue.ch_head;
1289060cedfbSMadhavan Venkataraman 			if (clptr != NULL) {
1290060cedfbSMadhavan Venkataraman 				coargs->bucket = -1;
1291060cedfbSMadhavan Venkataraman 				if (mdb_pwalk("callout_list", callout_list_cb,
1292060cedfbSMadhavan Venkataraman 				    coargs, (uintptr_t)clptr) == -1) {
1293060cedfbSMadhavan Venkataraman 					mdb_warn("cannot walk callout_list"
1294060cedfbSMadhavan Venkataraman 					    " at %p", clptr);
1295060cedfbSMadhavan Venkataraman 					return (WALK_ERR);
1296060cedfbSMadhavan Venkataraman 				}
1297060cedfbSMadhavan Venkataraman 			}
129887a18d3fSMadhavan Venkataraman 			for (i = 0; i < CALLOUT_BUCKETS; i++) {
129987a18d3fSMadhavan Venkataraman 				if (ct->ct_clhash == NULL) {
130087a18d3fSMadhavan Venkataraman 					/* nothing to do */
130187a18d3fSMadhavan Venkataraman 					break;
130287a18d3fSMadhavan Venkataraman 				}
130387a18d3fSMadhavan Venkataraman 				if (cotwd->cot_clhash[i].ch_head == NULL) {
130487a18d3fSMadhavan Venkataraman 					continue;
13057c478bd9Sstevel@tonic-gate 				}
130687a18d3fSMadhavan Venkataraman 				clptr = (callout_list_t *)
130787a18d3fSMadhavan Venkataraman 				    cotwd->cot_clhash[i].ch_head;
130887a18d3fSMadhavan Venkataraman 				coargs->bucket = i;
130987a18d3fSMadhavan Venkataraman 				/* walk list with callback routine. */
131087a18d3fSMadhavan Venkataraman 				if (mdb_pwalk("callout_list", callout_list_cb,
131187a18d3fSMadhavan Venkataraman 				    coargs, (uintptr_t)clptr) == -1) {
131287a18d3fSMadhavan Venkataraman 					mdb_warn("cannot walk callout_list"
131387a18d3fSMadhavan Venkataraman 					    " at %p", clptr);
131487a18d3fSMadhavan Venkataraman 					return (WALK_ERR);
131587a18d3fSMadhavan Venkataraman 				}
131687a18d3fSMadhavan Venkataraman 			}
131787a18d3fSMadhavan Venkataraman 		}
131887a18d3fSMadhavan Venkataraman 	} else {
131987a18d3fSMadhavan Venkataraman 		/* walk the id hash table. */
132087a18d3fSMadhavan Venkataraman 		if (coargs->flags & COF_FREE) {
132187a18d3fSMadhavan Venkataraman 			coptr = ct->ct_free;
132287a18d3fSMadhavan Venkataraman 			coargs->bucket = 0;
132387a18d3fSMadhavan Venkataraman 			if (coptr == NULL) {
132487a18d3fSMadhavan Venkataraman 				return (WALK_NEXT);
13257c478bd9Sstevel@tonic-gate 			}
132687a18d3fSMadhavan Venkataraman 			if (mdb_pwalk("callouts_byid", callouts_cb, coargs,
132787a18d3fSMadhavan Venkataraman 			    (uintptr_t)coptr) == -1) {
132887a18d3fSMadhavan Venkataraman 				mdb_warn("cannot walk callout id free list"
132987a18d3fSMadhavan Venkataraman 				    " at %p", coptr);
133087a18d3fSMadhavan Venkataraman 				return (WALK_ERR);
133187a18d3fSMadhavan Venkataraman 			}
133287a18d3fSMadhavan Venkataraman 		} else {
133387a18d3fSMadhavan Venkataraman 			for (i = 0; i < CALLOUT_BUCKETS; i++) {
133487a18d3fSMadhavan Venkataraman 				if (ct->ct_idhash == NULL) {
133587a18d3fSMadhavan Venkataraman 					break;
133687a18d3fSMadhavan Venkataraman 				}
133787a18d3fSMadhavan Venkataraman 				coptr = (callout_t *)
133887a18d3fSMadhavan Venkataraman 				    cotwd->cot_idhash[i].ch_head;
133987a18d3fSMadhavan Venkataraman 				if (coptr == NULL) {
134087a18d3fSMadhavan Venkataraman 					continue;
134187a18d3fSMadhavan Venkataraman 				}
134287a18d3fSMadhavan Venkataraman 				coargs->bucket = i;
134387a18d3fSMadhavan Venkataraman 
134487a18d3fSMadhavan Venkataraman 				/*
134587a18d3fSMadhavan Venkataraman 				 * walk callouts directly by id. For id
134687a18d3fSMadhavan Venkataraman 				 * chain, the callout list is just a header,
134787a18d3fSMadhavan Venkataraman 				 * so there's no need to walk it.
134887a18d3fSMadhavan Venkataraman 				 */
134987a18d3fSMadhavan Venkataraman 				if (mdb_pwalk("callouts_byid", callouts_cb,
135087a18d3fSMadhavan Venkataraman 				    coargs, (uintptr_t)coptr) == -1) {
135187a18d3fSMadhavan Venkataraman 					mdb_warn("cannot walk callouts at %p",
135287a18d3fSMadhavan Venkataraman 					    coptr);
135387a18d3fSMadhavan Venkataraman 					return (WALK_ERR);
135487a18d3fSMadhavan Venkataraman 				}
135587a18d3fSMadhavan Venkataraman 			}
135687a18d3fSMadhavan Venkataraman 		}
135787a18d3fSMadhavan Venkataraman 	}
135887a18d3fSMadhavan Venkataraman 	if (coargs->flags & COF_VERBOSE) {
135987a18d3fSMadhavan Venkataraman 		mdb_dec_indent(4);
136087a18d3fSMadhavan Venkataraman 	}
136187a18d3fSMadhavan Venkataraman 	return (WALK_NEXT);
136287a18d3fSMadhavan Venkataraman }
136387a18d3fSMadhavan Venkataraman 
136487a18d3fSMadhavan Venkataraman /*
136587a18d3fSMadhavan Venkataraman  * initialize some common info for both callout dcmds.
136687a18d3fSMadhavan Venkataraman  */
136787a18d3fSMadhavan Venkataraman int
136887a18d3fSMadhavan Venkataraman callout_common_init(callout_data_t *coargs)
136987a18d3fSMadhavan Venkataraman {
137087a18d3fSMadhavan Venkataraman 	/* we need a couple of things */
137187a18d3fSMadhavan Venkataraman 	if (mdb_readvar(&(coargs->co_table), "callout_table") == -1) {
137287a18d3fSMadhavan Venkataraman 		mdb_warn("failed to read 'callout_table'");
137387a18d3fSMadhavan Venkataraman 		return (DCMD_ERR);
137487a18d3fSMadhavan Venkataraman 	}
137587a18d3fSMadhavan Venkataraman 	/* need to get now in nsecs. Approximate with hrtime vars */
137687a18d3fSMadhavan Venkataraman 	if (mdb_readsym(&(coargs->now), sizeof (hrtime_t), "hrtime_last") !=
137787a18d3fSMadhavan Venkataraman 	    sizeof (hrtime_t)) {
137887a18d3fSMadhavan Venkataraman 		if (mdb_readsym(&(coargs->now), sizeof (hrtime_t),
137987a18d3fSMadhavan Venkataraman 		    "hrtime_base") != sizeof (hrtime_t)) {
138087a18d3fSMadhavan Venkataraman 			mdb_warn("Could not determine current system time");
138187a18d3fSMadhavan Venkataraman 			return (DCMD_ERR);
138287a18d3fSMadhavan Venkataraman 		}
138387a18d3fSMadhavan Venkataraman 	}
138487a18d3fSMadhavan Venkataraman 
138587a18d3fSMadhavan Venkataraman 	if (mdb_readvar(&(coargs->ctbits), "callout_table_bits") == -1) {
138687a18d3fSMadhavan Venkataraman 		mdb_warn("failed to read 'callout_table_bits'");
138787a18d3fSMadhavan Venkataraman 		return (DCMD_ERR);
138887a18d3fSMadhavan Venkataraman 	}
138987a18d3fSMadhavan Venkataraman 	if (mdb_readvar(&(coargs->nsec_per_tick), "nsec_per_tick") == -1) {
139087a18d3fSMadhavan Venkataraman 		mdb_warn("failed to read 'nsec_per_tick'");
139187a18d3fSMadhavan Venkataraman 		return (DCMD_ERR);
139287a18d3fSMadhavan Venkataraman 	}
139387a18d3fSMadhavan Venkataraman 	return (DCMD_OK);
139487a18d3fSMadhavan Venkataraman }
139587a18d3fSMadhavan Venkataraman 
139687a18d3fSMadhavan Venkataraman /*
139787a18d3fSMadhavan Venkataraman  * dcmd to print callouts.  Optional addr limits to specific table.
139887a18d3fSMadhavan Venkataraman  * Parses lots of options that get passed to callbacks for walkers.
139987a18d3fSMadhavan Venkataraman  * Has it's own help function.
140087a18d3fSMadhavan Venkataraman  */
140187a18d3fSMadhavan Venkataraman /*ARGSUSED*/
140287a18d3fSMadhavan Venkataraman int
140387a18d3fSMadhavan Venkataraman callout(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
140487a18d3fSMadhavan Venkataraman {
140587a18d3fSMadhavan Venkataraman 	callout_data_t coargs;
140687a18d3fSMadhavan Venkataraman 	/* getopts doesn't help much with stuff like this */
140787a18d3fSMadhavan Venkataraman 	boolean_t Sflag, Cflag, tflag, aflag, bflag, dflag, kflag;
140887a18d3fSMadhavan Venkataraman 	char *funcname = NULL;
140987a18d3fSMadhavan Venkataraman 	char *paramstr = NULL;
141087a18d3fSMadhavan Venkataraman 	uintptr_t Stmp, Ctmp;	/* for getopt. */
141187a18d3fSMadhavan Venkataraman 	int retval;
141287a18d3fSMadhavan Venkataraman 
141387a18d3fSMadhavan Venkataraman 	coargs.flags = COF_DEFAULT;
141487a18d3fSMadhavan Venkataraman 	Sflag = Cflag = tflag = bflag = aflag = dflag = kflag = FALSE;
141587a18d3fSMadhavan Venkataraman 	coargs.seqid = -1;
141687a18d3fSMadhavan Venkataraman 
141787a18d3fSMadhavan Venkataraman 	if (mdb_getopts(argc, argv,
141887a18d3fSMadhavan Venkataraman 	    'r', MDB_OPT_CLRBITS, COF_NORM, &coargs.flags,
141987a18d3fSMadhavan Venkataraman 	    'n', MDB_OPT_CLRBITS, COF_REAL, &coargs.flags,
142087a18d3fSMadhavan Venkataraman 	    'l', MDB_OPT_CLRBITS, COF_SHORT, &coargs.flags,
142187a18d3fSMadhavan Venkataraman 	    's', MDB_OPT_CLRBITS, COF_LONG, &coargs.flags,
142287a18d3fSMadhavan Venkataraman 	    'x', MDB_OPT_SETBITS, COF_EXEC, &coargs.flags,
142387a18d3fSMadhavan Venkataraman 	    'h', MDB_OPT_SETBITS, COF_HIRES, &coargs.flags,
142407247649SMadhavan Venkataraman 	    'B', MDB_OPT_SETBITS, COF_ABS, &coargs.flags,
142587a18d3fSMadhavan Venkataraman 	    'E', MDB_OPT_SETBITS, COF_EMPTY, &coargs.flags,
142687a18d3fSMadhavan Venkataraman 	    'd', MDB_OPT_SETBITS, 1, &dflag,
142787a18d3fSMadhavan Venkataraman 	    'C', MDB_OPT_UINTPTR_SET, &Cflag, &Ctmp,
142887a18d3fSMadhavan Venkataraman 	    'S', MDB_OPT_UINTPTR_SET, &Sflag, &Stmp,
142987a18d3fSMadhavan Venkataraman 	    't', MDB_OPT_UINTPTR_SET, &tflag, (uintptr_t *)&coargs.time,
143087a18d3fSMadhavan Venkataraman 	    'a', MDB_OPT_UINTPTR_SET, &aflag, (uintptr_t *)&coargs.atime,
143187a18d3fSMadhavan Venkataraman 	    'b', MDB_OPT_UINTPTR_SET, &bflag, (uintptr_t *)&coargs.btime,
143287a18d3fSMadhavan Venkataraman 	    'k', MDB_OPT_SETBITS, 1, &kflag,
143387a18d3fSMadhavan Venkataraman 	    'f', MDB_OPT_STR, &funcname,
143487a18d3fSMadhavan Venkataraman 	    'p', MDB_OPT_STR, &paramstr,
143587a18d3fSMadhavan Venkataraman 	    'T', MDB_OPT_SETBITS, COF_TABLE, &coargs.flags,
143687a18d3fSMadhavan Venkataraman 	    'D', MDB_OPT_SETBITS, COF_EXPREL, &coargs.flags,
143787a18d3fSMadhavan Venkataraman 	    'L', MDB_OPT_SETBITS, COF_LIST, &coargs.flags,
143887a18d3fSMadhavan Venkataraman 	    'V', MDB_OPT_SETBITS, COF_VERBOSE, &coargs.flags,
143987a18d3fSMadhavan Venkataraman 	    'v', MDB_OPT_SETBITS, COF_LONGLIST, &coargs.flags,
144087a18d3fSMadhavan Venkataraman 	    'i', MDB_OPT_SETBITS, COF_BYIDH, &coargs.flags,
144187a18d3fSMadhavan Venkataraman 	    'F', MDB_OPT_SETBITS, COF_FREE, &coargs.flags,
1442060cedfbSMadhavan Venkataraman 	    'H', MDB_OPT_SETBITS, COF_HEAP, &coargs.flags,
1443060cedfbSMadhavan Venkataraman 	    'Q', MDB_OPT_SETBITS, COF_QUEUE, &coargs.flags,
144487a18d3fSMadhavan Venkataraman 	    'A', MDB_OPT_SETBITS, COF_ADDR, &coargs.flags,
144587a18d3fSMadhavan Venkataraman 	    NULL) != argc) {
144687a18d3fSMadhavan Venkataraman 		return (DCMD_USAGE);
144787a18d3fSMadhavan Venkataraman 	}
144887a18d3fSMadhavan Venkataraman 
144987a18d3fSMadhavan Venkataraman 	/* initialize from kernel variables */
145087a18d3fSMadhavan Venkataraman 	if ((retval = callout_common_init(&coargs)) != DCMD_OK) {
145187a18d3fSMadhavan Venkataraman 		return (retval);
145287a18d3fSMadhavan Venkataraman 	}
145387a18d3fSMadhavan Venkataraman 
145487a18d3fSMadhavan Venkataraman 	/* do some option post-processing */
145587a18d3fSMadhavan Venkataraman 	if (kflag) {
145687a18d3fSMadhavan Venkataraman 		coargs.time *= coargs.nsec_per_tick;
145787a18d3fSMadhavan Venkataraman 		coargs.atime *= coargs.nsec_per_tick;
145887a18d3fSMadhavan Venkataraman 		coargs.btime *= coargs.nsec_per_tick;
145987a18d3fSMadhavan Venkataraman 	}
146087a18d3fSMadhavan Venkataraman 
146187a18d3fSMadhavan Venkataraman 	if (dflag) {
146287a18d3fSMadhavan Venkataraman 		coargs.time += coargs.now;
146387a18d3fSMadhavan Venkataraman 		coargs.atime += coargs.now;
146487a18d3fSMadhavan Venkataraman 		coargs.btime += coargs.now;
146587a18d3fSMadhavan Venkataraman 	}
146687a18d3fSMadhavan Venkataraman 	if (Sflag) {
146787a18d3fSMadhavan Venkataraman 		if (flags & DCMD_ADDRSPEC) {
146887a18d3fSMadhavan Venkataraman 			mdb_printf("-S option conflicts with explicit"
146987a18d3fSMadhavan Venkataraman 			    " address\n");
147087a18d3fSMadhavan Venkataraman 			return (DCMD_USAGE);
147187a18d3fSMadhavan Venkataraman 		}
147287a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_SEQID;
147387a18d3fSMadhavan Venkataraman 		coargs.seqid = (int)Stmp;
147487a18d3fSMadhavan Venkataraman 	}
147587a18d3fSMadhavan Venkataraman 	if (Cflag) {
147687a18d3fSMadhavan Venkataraman 		if (flags & DCMD_ADDRSPEC) {
147787a18d3fSMadhavan Venkataraman 			mdb_printf("-C option conflicts with explicit"
147887a18d3fSMadhavan Venkataraman 			    " address\n");
147987a18d3fSMadhavan Venkataraman 			return (DCMD_USAGE);
148087a18d3fSMadhavan Venkataraman 		}
148187a18d3fSMadhavan Venkataraman 		if (coargs.flags & COF_SEQID) {
148287a18d3fSMadhavan Venkataraman 			mdb_printf("-C and -S are mutually exclusive\n");
148387a18d3fSMadhavan Venkataraman 			return (DCMD_USAGE);
148487a18d3fSMadhavan Venkataraman 		}
148587a18d3fSMadhavan Venkataraman 		coargs.cpu = (cpu_t *)Ctmp;
148687a18d3fSMadhavan Venkataraman 		if (mdb_vread(&coargs.seqid, sizeof (processorid_t),
148787a18d3fSMadhavan Venkataraman 		    (uintptr_t)&(coargs.cpu->cpu_seqid)) == -1) {
148887a18d3fSMadhavan Venkataraman 			mdb_warn("failed to read cpu_t at %p", Ctmp);
148987a18d3fSMadhavan Venkataraman 			return (DCMD_ERR);
149087a18d3fSMadhavan Venkataraman 		}
149187a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_SEQID;
149287a18d3fSMadhavan Venkataraman 	}
149387a18d3fSMadhavan Venkataraman 	/* avoid null outputs. */
149487a18d3fSMadhavan Venkataraman 	if (!(coargs.flags & (COF_REAL | COF_NORM))) {
149587a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_REAL | COF_NORM;
149687a18d3fSMadhavan Venkataraman 	}
149787a18d3fSMadhavan Venkataraman 	if (!(coargs.flags & (COF_LONG | COF_SHORT))) {
149887a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_LONG | COF_SHORT;
149987a18d3fSMadhavan Venkataraman 	}
150087a18d3fSMadhavan Venkataraman 	if (tflag) {
150187a18d3fSMadhavan Venkataraman 		if (aflag || bflag) {
150287a18d3fSMadhavan Venkataraman 			mdb_printf("-t and -a|b are mutually exclusive\n");
150387a18d3fSMadhavan Venkataraman 			return (DCMD_USAGE);
15047c478bd9Sstevel@tonic-gate 		}
150587a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_TIME;
150687a18d3fSMadhavan Venkataraman 	}
150787a18d3fSMadhavan Venkataraman 	if (aflag) {
150887a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_AFTER;
150987a18d3fSMadhavan Venkataraman 	}
151087a18d3fSMadhavan Venkataraman 	if (bflag) {
151187a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_BEFORE;
151287a18d3fSMadhavan Venkataraman 	}
151387a18d3fSMadhavan Venkataraman 	if ((aflag && bflag) && (coargs.btime <= coargs.atime)) {
151487a18d3fSMadhavan Venkataraman 		mdb_printf("value for -a must be earlier than the value"
151587a18d3fSMadhavan Venkataraman 		    " for -b.\n");
151687a18d3fSMadhavan Venkataraman 		return (DCMD_USAGE);
15177c478bd9Sstevel@tonic-gate 	}
15187c478bd9Sstevel@tonic-gate 
1519060cedfbSMadhavan Venkataraman 	if ((coargs.flags & COF_HEAP) && (coargs.flags & COF_QUEUE)) {
1520060cedfbSMadhavan Venkataraman 		mdb_printf("-H and -Q are mutually exclusive\n");
1521060cedfbSMadhavan Venkataraman 		return (DCMD_USAGE);
1522060cedfbSMadhavan Venkataraman 	}
1523060cedfbSMadhavan Venkataraman 
152487a18d3fSMadhavan Venkataraman 	if (funcname != NULL) {
152587a18d3fSMadhavan Venkataraman 		GElf_Sym sym;
152687a18d3fSMadhavan Venkataraman 
152787a18d3fSMadhavan Venkataraman 		if (mdb_lookup_by_name(funcname, &sym) != 0) {
152887a18d3fSMadhavan Venkataraman 			coargs.funcaddr = mdb_strtoull(funcname);
152987a18d3fSMadhavan Venkataraman 		} else {
153087a18d3fSMadhavan Venkataraman 			coargs.funcaddr = sym.st_value;
153187a18d3fSMadhavan Venkataraman 		}
153287a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_FUNC;
153387a18d3fSMadhavan Venkataraman 	}
153487a18d3fSMadhavan Venkataraman 
153587a18d3fSMadhavan Venkataraman 	if (paramstr != NULL) {
153687a18d3fSMadhavan Venkataraman 		GElf_Sym sym;
153787a18d3fSMadhavan Venkataraman 
153887a18d3fSMadhavan Venkataraman 		if (mdb_lookup_by_name(paramstr, &sym) != 0) {
153987a18d3fSMadhavan Venkataraman 			coargs.param = mdb_strtoull(paramstr);
154087a18d3fSMadhavan Venkataraman 		} else {
154187a18d3fSMadhavan Venkataraman 			coargs.param = sym.st_value;
154287a18d3fSMadhavan Venkataraman 		}
154387a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_PARAM;
154487a18d3fSMadhavan Venkataraman 	}
154587a18d3fSMadhavan Venkataraman 
154687a18d3fSMadhavan Venkataraman 	if (!(flags & DCMD_ADDRSPEC)) {
154787a18d3fSMadhavan Venkataraman 		/* don't pass "dot" if no addr. */
1548*892ad162SToomas Soome 		addr = 0;
154987a18d3fSMadhavan Venkataraman 	}
1550*892ad162SToomas Soome 	if (addr != 0) {
155187a18d3fSMadhavan Venkataraman 		/*
155287a18d3fSMadhavan Venkataraman 		 * a callout table was specified. Ignore -r|n option
155387a18d3fSMadhavan Venkataraman 		 * to avoid null output.
155487a18d3fSMadhavan Venkataraman 		 */
155587a18d3fSMadhavan Venkataraman 		coargs.flags |= (COF_REAL | COF_NORM);
155687a18d3fSMadhavan Venkataraman 	}
155787a18d3fSMadhavan Venkataraman 
155887a18d3fSMadhavan Venkataraman 	if (DCMD_HDRSPEC(flags) || (coargs.flags & COF_VERBOSE)) {
155987a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_THDR | COF_LHDR | COF_CHDR;
156087a18d3fSMadhavan Venkataraman 	}
156187a18d3fSMadhavan Venkataraman 	if (coargs.flags & COF_FREE) {
156287a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_EMPTY;
156387a18d3fSMadhavan Venkataraman 		/* -F = free callouts, -FL = free lists */
156487a18d3fSMadhavan Venkataraman 		if (!(coargs.flags & COF_LIST)) {
156587a18d3fSMadhavan Venkataraman 			coargs.flags |= COF_BYIDH;
156687a18d3fSMadhavan Venkataraman 		}
156787a18d3fSMadhavan Venkataraman 	}
156887a18d3fSMadhavan Venkataraman 
156987a18d3fSMadhavan Venkataraman 	/* walk table, using specialized callback routine. */
157087a18d3fSMadhavan Venkataraman 	if (mdb_pwalk("callout_table", callout_t_cb, &coargs, addr) == -1) {
157187a18d3fSMadhavan Venkataraman 		mdb_warn("cannot walk callout_table");
157287a18d3fSMadhavan Venkataraman 		return (DCMD_ERR);
157387a18d3fSMadhavan Venkataraman 	}
15747c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
15757c478bd9Sstevel@tonic-gate }
15767c478bd9Sstevel@tonic-gate 
157787a18d3fSMadhavan Venkataraman 
157887a18d3fSMadhavan Venkataraman /*
157987a18d3fSMadhavan Venkataraman  * Given an extended callout id, dump its information.
158087a18d3fSMadhavan Venkataraman  */
158187a18d3fSMadhavan Venkataraman /*ARGSUSED*/
158287a18d3fSMadhavan Venkataraman int
158387a18d3fSMadhavan Venkataraman calloutid(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
158487a18d3fSMadhavan Venkataraman {
158587a18d3fSMadhavan Venkataraman 	callout_data_t coargs;
158687a18d3fSMadhavan Venkataraman 	callout_table_t *ctptr;
158787a18d3fSMadhavan Venkataraman 	callout_table_t ct;
158887a18d3fSMadhavan Venkataraman 	callout_id_t coid;
158987a18d3fSMadhavan Venkataraman 	callout_t *coptr;
159087a18d3fSMadhavan Venkataraman 	int tableid;
159187a18d3fSMadhavan Venkataraman 	callout_id_t xid;
159287a18d3fSMadhavan Venkataraman 	ulong_t idhash;
159387a18d3fSMadhavan Venkataraman 	int i, retval;
159487a18d3fSMadhavan Venkataraman 	const mdb_arg_t *arg;
159587a18d3fSMadhavan Venkataraman 	size_t size;
159687a18d3fSMadhavan Venkataraman 	callout_hash_t cot_idhash[CALLOUT_BUCKETS];
159787a18d3fSMadhavan Venkataraman 
159887a18d3fSMadhavan Venkataraman 	coargs.flags = COF_DEFAULT | COF_BYIDH;
159987a18d3fSMadhavan Venkataraman 	i = mdb_getopts(argc, argv,
160087a18d3fSMadhavan Venkataraman 	    'd', MDB_OPT_SETBITS, COF_DECODE, &coargs.flags,
160187a18d3fSMadhavan Venkataraman 	    'v', MDB_OPT_SETBITS, COF_LONGLIST, &coargs.flags,
160287a18d3fSMadhavan Venkataraman 	    NULL);
160387a18d3fSMadhavan Venkataraman 	argc -= i;
160487a18d3fSMadhavan Venkataraman 	argv += i;
160587a18d3fSMadhavan Venkataraman 
160687a18d3fSMadhavan Venkataraman 	if (argc != 1) {
160787a18d3fSMadhavan Venkataraman 		return (DCMD_USAGE);
160887a18d3fSMadhavan Venkataraman 	}
160987a18d3fSMadhavan Venkataraman 	arg = &argv[0];
161087a18d3fSMadhavan Venkataraman 
161187a18d3fSMadhavan Venkataraman 	if (arg->a_type == MDB_TYPE_IMMEDIATE) {
161287a18d3fSMadhavan Venkataraman 		xid = arg->a_un.a_val;
161387a18d3fSMadhavan Venkataraman 	} else {
161487a18d3fSMadhavan Venkataraman 		xid = (callout_id_t)mdb_strtoull(arg->a_un.a_str);
161587a18d3fSMadhavan Venkataraman 	}
161687a18d3fSMadhavan Venkataraman 
161787a18d3fSMadhavan Venkataraman 	if (DCMD_HDRSPEC(flags)) {
161887a18d3fSMadhavan Venkataraman 		coargs.flags |= COF_CHDR;
161987a18d3fSMadhavan Venkataraman 	}
162087a18d3fSMadhavan Venkataraman 
162187a18d3fSMadhavan Venkataraman 
162287a18d3fSMadhavan Venkataraman 	/* initialize from kernel variables */
162387a18d3fSMadhavan Venkataraman 	if ((retval = callout_common_init(&coargs)) != DCMD_OK) {
162487a18d3fSMadhavan Venkataraman 		return (retval);
162587a18d3fSMadhavan Venkataraman 	}
162687a18d3fSMadhavan Venkataraman 
162787a18d3fSMadhavan Venkataraman 	/* we must massage the environment so that the macros will play nice */
162887a18d3fSMadhavan Venkataraman #define	callout_table_mask	((1 << coargs.ctbits) - 1)
162987a18d3fSMadhavan Venkataraman #define	callout_table_bits	coargs.ctbits
163087a18d3fSMadhavan Venkataraman #define	nsec_per_tick		coargs.nsec_per_tick
163187a18d3fSMadhavan Venkataraman 	tableid = CALLOUT_ID_TO_TABLE(xid);
163287a18d3fSMadhavan Venkataraman 	idhash = CALLOUT_IDHASH(xid);
163387a18d3fSMadhavan Venkataraman #undef	callouts_table_bits
163487a18d3fSMadhavan Venkataraman #undef	callout_table_mask
163587a18d3fSMadhavan Venkataraman #undef	nsec_per_tick
163687a18d3fSMadhavan Venkataraman 	coid = CO_PLAIN_ID(xid);
163787a18d3fSMadhavan Venkataraman 
163887a18d3fSMadhavan Venkataraman 	if (flags & DCMD_ADDRSPEC) {
163987a18d3fSMadhavan Venkataraman 		mdb_printf("calloutid does not accept explicit address.\n");
164087a18d3fSMadhavan Venkataraman 		return (DCMD_USAGE);
164187a18d3fSMadhavan Venkataraman 	}
164287a18d3fSMadhavan Venkataraman 
164387a18d3fSMadhavan Venkataraman 	if (coargs.flags & COF_DECODE) {
164487a18d3fSMadhavan Venkataraman 		if (DCMD_HDRSPEC(flags)) {
164507247649SMadhavan Venkataraman 			mdb_printf("%<u>%3s %1s %2s %-?s %-6s %</u>\n",
164607247649SMadhavan Venkataraman 			    "SEQ", "T", "XL", "XID", "IDHASH");
164787a18d3fSMadhavan Venkataraman 		}
164807247649SMadhavan Venkataraman 		mdb_printf("%-3d %1s %1s%1s %-?llx %-6d\n",
164987a18d3fSMadhavan Venkataraman 		    TABLE_TO_SEQID(tableid),
165087a18d3fSMadhavan Venkataraman 		    co_typenames[tableid & CALLOUT_TYPE_MASK],
165187a18d3fSMadhavan Venkataraman 		    (xid & CALLOUT_EXECUTING) ? "X" : " ",
165287a18d3fSMadhavan Venkataraman 		    (xid & CALLOUT_LONGTERM) ? "L" : " ",
165387a18d3fSMadhavan Venkataraman 		    (long long)coid, idhash);
165487a18d3fSMadhavan Venkataraman 		return (DCMD_OK);
165587a18d3fSMadhavan Venkataraman 	}
165687a18d3fSMadhavan Venkataraman 
165787a18d3fSMadhavan Venkataraman 	/* get our table. Note this relies on the types being correct */
165887a18d3fSMadhavan Venkataraman 	ctptr = coargs.co_table + tableid;
165987a18d3fSMadhavan Venkataraman 	if (mdb_vread(&ct, sizeof (callout_table_t), (uintptr_t)ctptr) == -1) {
166087a18d3fSMadhavan Venkataraman 		mdb_warn("failed to read callout_table at %p", ctptr);
166187a18d3fSMadhavan Venkataraman 		return (DCMD_ERR);
166287a18d3fSMadhavan Venkataraman 	}
166387a18d3fSMadhavan Venkataraman 	size = sizeof (callout_hash_t) * CALLOUT_BUCKETS;
166487a18d3fSMadhavan Venkataraman 	if (ct.ct_idhash != NULL) {
166587a18d3fSMadhavan Venkataraman 		if (mdb_vread(&(cot_idhash), size,
166687a18d3fSMadhavan Venkataraman 		    (uintptr_t)ct.ct_idhash) == -1) {
166787a18d3fSMadhavan Venkataraman 			mdb_warn("failed to read id_hash at %p",
166887a18d3fSMadhavan Venkataraman 			    ct.ct_idhash);
166987a18d3fSMadhavan Venkataraman 			return (WALK_ERR);
167087a18d3fSMadhavan Venkataraman 		}
167187a18d3fSMadhavan Venkataraman 	}
167287a18d3fSMadhavan Venkataraman 
167387a18d3fSMadhavan Venkataraman 	/* callout at beginning of hash chain */
167487a18d3fSMadhavan Venkataraman 	if (ct.ct_idhash == NULL) {
167587a18d3fSMadhavan Venkataraman 		mdb_printf("id hash chain for this xid is empty\n");
167687a18d3fSMadhavan Venkataraman 		return (DCMD_ERR);
167787a18d3fSMadhavan Venkataraman 	}
167887a18d3fSMadhavan Venkataraman 	coptr = (callout_t *)cot_idhash[idhash].ch_head;
167987a18d3fSMadhavan Venkataraman 	if (coptr == NULL) {
168087a18d3fSMadhavan Venkataraman 		mdb_printf("id hash chain for this xid is empty\n");
168187a18d3fSMadhavan Venkataraman 		return (DCMD_ERR);
168287a18d3fSMadhavan Venkataraman 	}
168387a18d3fSMadhavan Venkataraman 
168487a18d3fSMadhavan Venkataraman 	coargs.ndx = tableid;
168587a18d3fSMadhavan Venkataraman 	coargs.bucket = idhash;
168687a18d3fSMadhavan Venkataraman 
168787a18d3fSMadhavan Venkataraman 	/* use the walker, luke */
168887a18d3fSMadhavan Venkataraman 	if (mdb_pwalk("callouts_byid", callouts_cb, &coargs,
168987a18d3fSMadhavan Venkataraman 	    (uintptr_t)coptr) == -1) {
169087a18d3fSMadhavan Venkataraman 		mdb_warn("cannot walk callouts at %p", coptr);
169187a18d3fSMadhavan Venkataraman 		return (WALK_ERR);
169287a18d3fSMadhavan Venkataraman 	}
169387a18d3fSMadhavan Venkataraman 
169487a18d3fSMadhavan Venkataraman 	return (DCMD_OK);
169587a18d3fSMadhavan Venkataraman }
169687a18d3fSMadhavan Venkataraman 
169787a18d3fSMadhavan Venkataraman void
169887a18d3fSMadhavan Venkataraman callout_help(void)
169987a18d3fSMadhavan Venkataraman {
170087a18d3fSMadhavan Venkataraman 	mdb_printf("callout: display callouts.\n"
170187a18d3fSMadhavan Venkataraman 	    "Given a callout table address, display callouts from table.\n"
170287a18d3fSMadhavan Venkataraman 	    "Without an address, display callouts from all tables.\n"
170387a18d3fSMadhavan Venkataraman 	    "options:\n"
170487a18d3fSMadhavan Venkataraman 	    " -r|n : limit display to (r)ealtime or (n)ormal type callouts\n"
170587a18d3fSMadhavan Venkataraman 	    " -s|l : limit display to (s)hort-term ids or (l)ong-term ids\n"
170687a18d3fSMadhavan Venkataraman 	    " -x : limit display to callouts which are executing\n"
170787a18d3fSMadhavan Venkataraman 	    " -h : limit display to callouts based on hrestime\n"
170807247649SMadhavan Venkataraman 	    " -B : limit display to callouts based on absolute time\n"
170987a18d3fSMadhavan Venkataraman 	    " -t|a|b nsec: limit display to callouts that expire a(t) time,"
171087a18d3fSMadhavan Venkataraman 	    " (a)fter time,\n     or (b)efore time. Use -a and -b together "
171187a18d3fSMadhavan Venkataraman 	    " to specify a range.\n     For \"now\", use -d[t|a|b] 0.\n"
171287a18d3fSMadhavan Venkataraman 	    " -d : interpret time option to -t|a|b as delta from current time\n"
171387a18d3fSMadhavan Venkataraman 	    " -k : use ticks instead of nanoseconds as arguments to"
171487a18d3fSMadhavan Venkataraman 	    " -t|a|b. Note that\n     ticks are less accurate and may not"
171587a18d3fSMadhavan Venkataraman 	    " match other tick times (ie: lbolt).\n"
171687a18d3fSMadhavan Venkataraman 	    " -D : display exiration time as delta from current time\n"
171787a18d3fSMadhavan Venkataraman 	    " -S seqid : limit display to callouts for this cpu sequence id\n"
171887a18d3fSMadhavan Venkataraman 	    " -C addr :  limit display to callouts for this cpu pointer\n"
171987a18d3fSMadhavan Venkataraman 	    " -f name|addr : limit display to callouts with this function\n"
172087a18d3fSMadhavan Venkataraman 	    " -p name|addr : limit display to callouts functions with this"
172187a18d3fSMadhavan Venkataraman 	    " parameter\n"
172287a18d3fSMadhavan Venkataraman 	    " -T : display the callout table itself, instead of callouts\n"
172387a18d3fSMadhavan Venkataraman 	    " -L : display callout lists instead of callouts\n"
172487a18d3fSMadhavan Venkataraman 	    " -E : with -T or L, display empty data structures.\n"
172587a18d3fSMadhavan Venkataraman 	    " -i : traverse callouts by id hash instead of list hash\n"
172687a18d3fSMadhavan Venkataraman 	    " -F : walk free callout list (free list with -i) instead\n"
172787a18d3fSMadhavan Venkataraman 	    " -v : display more info for each item\n"
172887a18d3fSMadhavan Venkataraman 	    " -V : show details of each level of info as it is traversed\n"
1729060cedfbSMadhavan Venkataraman 	    " -H : limit display to callouts in the callout heap\n"
1730060cedfbSMadhavan Venkataraman 	    " -Q : limit display to callouts in the callout queue\n"
173187a18d3fSMadhavan Venkataraman 	    " -A : show only addresses. Useful for pipelines.\n");
173287a18d3fSMadhavan Venkataraman }
173387a18d3fSMadhavan Venkataraman 
173487a18d3fSMadhavan Venkataraman void
173587a18d3fSMadhavan Venkataraman calloutid_help(void)
173687a18d3fSMadhavan Venkataraman {
173787a18d3fSMadhavan Venkataraman 	mdb_printf("calloutid: display callout by id.\n"
173887a18d3fSMadhavan Venkataraman 	    "Given an extended callout id, display the callout infomation.\n"
173987a18d3fSMadhavan Venkataraman 	    "options:\n"
174087a18d3fSMadhavan Venkataraman 	    " -d : do not dereference callout, just decode the id.\n"
174187a18d3fSMadhavan Venkataraman 	    " -v : verbose display more info about the callout\n");
174287a18d3fSMadhavan Venkataraman }
174387a18d3fSMadhavan Venkataraman 
17447c478bd9Sstevel@tonic-gate /*ARGSUSED*/
17457c478bd9Sstevel@tonic-gate int
17467c478bd9Sstevel@tonic-gate class(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
17477c478bd9Sstevel@tonic-gate {
17487c478bd9Sstevel@tonic-gate 	long num_classes, i;
17497c478bd9Sstevel@tonic-gate 	sclass_t *class_tbl;
17507c478bd9Sstevel@tonic-gate 	GElf_Sym g_sclass;
17517c478bd9Sstevel@tonic-gate 	char class_name[PC_CLNMSZ];
17527c478bd9Sstevel@tonic-gate 	size_t tbl_size;
17537c478bd9Sstevel@tonic-gate 
17547c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_name("sclass", &g_sclass) == -1) {
17557c478bd9Sstevel@tonic-gate 		mdb_warn("failed to find symbol sclass\n");
17567c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
17577c478bd9Sstevel@tonic-gate 	}
17587c478bd9Sstevel@tonic-gate 
17597c478bd9Sstevel@tonic-gate 	tbl_size = (size_t)g_sclass.st_size;
17607c478bd9Sstevel@tonic-gate 	num_classes = tbl_size / (sizeof (sclass_t));
17617c478bd9Sstevel@tonic-gate 	class_tbl = mdb_alloc(tbl_size, UM_SLEEP | UM_GC);
17627c478bd9Sstevel@tonic-gate 
17637c478bd9Sstevel@tonic-gate 	if (mdb_readsym(class_tbl, tbl_size, "sclass") == -1) {
17647c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read sclass");
17657c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
17667c478bd9Sstevel@tonic-gate 	}
17677c478bd9Sstevel@tonic-gate 
17687c478bd9Sstevel@tonic-gate 	mdb_printf("%<u>%4s %-10s %-24s %-24s%</u>\n", "SLOT", "NAME",
17697c478bd9Sstevel@tonic-gate 	    "INIT FCN", "CLASS FCN");
17707c478bd9Sstevel@tonic-gate 
17717c478bd9Sstevel@tonic-gate 	for (i = 0; i < num_classes; i++) {
17727c478bd9Sstevel@tonic-gate 		if (mdb_vread(class_name, sizeof (class_name),
17737c478bd9Sstevel@tonic-gate 		    (uintptr_t)class_tbl[i].cl_name) == -1)
17747c478bd9Sstevel@tonic-gate 			(void) strcpy(class_name, "???");
17757c478bd9Sstevel@tonic-gate 
17767c478bd9Sstevel@tonic-gate 		mdb_printf("%4ld %-10s %-24a %-24a\n", i, class_name,
17777c478bd9Sstevel@tonic-gate 		    class_tbl[i].cl_init, class_tbl[i].cl_funcs);
17787c478bd9Sstevel@tonic-gate 	}
17797c478bd9Sstevel@tonic-gate 
17807c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
17817c478bd9Sstevel@tonic-gate }
17827c478bd9Sstevel@tonic-gate 
17837c478bd9Sstevel@tonic-gate #define	FSNAMELEN	32	/* Max len of FS name we read from vnodeops */
17847c478bd9Sstevel@tonic-gate 
17857c478bd9Sstevel@tonic-gate int
17867c478bd9Sstevel@tonic-gate vnode2path(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
17877c478bd9Sstevel@tonic-gate {
17887c478bd9Sstevel@tonic-gate 	uintptr_t rootdir;
17897c478bd9Sstevel@tonic-gate 	vnode_t vn;
17907c478bd9Sstevel@tonic-gate 	char buf[MAXPATHLEN];
17917c478bd9Sstevel@tonic-gate 
17927c478bd9Sstevel@tonic-gate 	uint_t opt_F = FALSE;
17937c478bd9Sstevel@tonic-gate 
17947c478bd9Sstevel@tonic-gate 	if (mdb_getopts(argc, argv,
17957c478bd9Sstevel@tonic-gate 	    'F', MDB_OPT_SETBITS, TRUE, &opt_F, NULL) != argc)
17967c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
17977c478bd9Sstevel@tonic-gate 
17987c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC)) {
17997c478bd9Sstevel@tonic-gate 		mdb_warn("expected explicit vnode_t address before ::\n");
18007c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
18017c478bd9Sstevel@tonic-gate 	}
18027c478bd9Sstevel@tonic-gate 
18037c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&rootdir, "rootdir") == -1) {
18047c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read rootdir");
18057c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
18067c478bd9Sstevel@tonic-gate 	}
18077c478bd9Sstevel@tonic-gate 
18087c478bd9Sstevel@tonic-gate 	if (mdb_vnode2path(addr, buf, sizeof (buf)) == -1)
18097c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
18107c478bd9Sstevel@tonic-gate 
18117c478bd9Sstevel@tonic-gate 	if (*buf == '\0') {
18127c478bd9Sstevel@tonic-gate 		mdb_printf("??\n");
18137c478bd9Sstevel@tonic-gate 		return (DCMD_OK);
18147c478bd9Sstevel@tonic-gate 	}
18157c478bd9Sstevel@tonic-gate 
18167c478bd9Sstevel@tonic-gate 	mdb_printf("%s", buf);
18177c478bd9Sstevel@tonic-gate 	if (opt_F && buf[strlen(buf)-1] != '/' &&
18187c478bd9Sstevel@tonic-gate 	    mdb_vread(&vn, sizeof (vn), addr) == sizeof (vn))
18197c478bd9Sstevel@tonic-gate 		mdb_printf("%c", mdb_vtype2chr(vn.v_type, 0));
18207c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
18217c478bd9Sstevel@tonic-gate 
18227c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
18237c478bd9Sstevel@tonic-gate }
18247c478bd9Sstevel@tonic-gate 
18257c478bd9Sstevel@tonic-gate int
18267c478bd9Sstevel@tonic-gate ld_walk_init(mdb_walk_state_t *wsp)
18277c478bd9Sstevel@tonic-gate {
18287c478bd9Sstevel@tonic-gate 	wsp->walk_data = (void *)wsp->walk_addr;
18297c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
18307c478bd9Sstevel@tonic-gate }
18317c478bd9Sstevel@tonic-gate 
18327c478bd9Sstevel@tonic-gate int
18337c478bd9Sstevel@tonic-gate ld_walk_step(mdb_walk_state_t *wsp)
18347c478bd9Sstevel@tonic-gate {
18357c478bd9Sstevel@tonic-gate 	int status;
18367c478bd9Sstevel@tonic-gate 	lock_descriptor_t ld;
18377c478bd9Sstevel@tonic-gate 
18387c478bd9Sstevel@tonic-gate 	if (mdb_vread(&ld, sizeof (lock_descriptor_t), wsp->walk_addr) == -1) {
18397c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't read lock_descriptor_t at %p\n",
18407c478bd9Sstevel@tonic-gate 		    wsp->walk_addr);
18417c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
18427c478bd9Sstevel@tonic-gate 	}
18437c478bd9Sstevel@tonic-gate 
18447c478bd9Sstevel@tonic-gate 	status = wsp->walk_callback(wsp->walk_addr, &ld, wsp->walk_cbdata);
18457c478bd9Sstevel@tonic-gate 	if (status == WALK_ERR)
18467c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
18477c478bd9Sstevel@tonic-gate 
18487c478bd9Sstevel@tonic-gate 	wsp->walk_addr = (uintptr_t)ld.l_next;
18497c478bd9Sstevel@tonic-gate 	if (wsp->walk_addr == (uintptr_t)wsp->walk_data)
18507c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
18517c478bd9Sstevel@tonic-gate 
18527c478bd9Sstevel@tonic-gate 	return (status);
18537c478bd9Sstevel@tonic-gate }
18547c478bd9Sstevel@tonic-gate 
18557c478bd9Sstevel@tonic-gate int
18567c478bd9Sstevel@tonic-gate lg_walk_init(mdb_walk_state_t *wsp)
18577c478bd9Sstevel@tonic-gate {
18587c478bd9Sstevel@tonic-gate 	GElf_Sym sym;
18597c478bd9Sstevel@tonic-gate 
18607c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_name("lock_graph", &sym) == -1) {
18617c478bd9Sstevel@tonic-gate 		mdb_warn("failed to find symbol 'lock_graph'\n");
18627c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
18637c478bd9Sstevel@tonic-gate 	}
18647c478bd9Sstevel@tonic-gate 
18657c478bd9Sstevel@tonic-gate 	wsp->walk_addr = (uintptr_t)sym.st_value;
186689518a1cSdmick 	wsp->walk_data = (void *)(uintptr_t)(sym.st_value + sym.st_size);
18677c478bd9Sstevel@tonic-gate 
18687c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
18697c478bd9Sstevel@tonic-gate }
18707c478bd9Sstevel@tonic-gate 
18717c478bd9Sstevel@tonic-gate typedef struct lg_walk_data {
18727c478bd9Sstevel@tonic-gate 	uintptr_t startaddr;
18737c478bd9Sstevel@tonic-gate 	mdb_walk_cb_t callback;
18747c478bd9Sstevel@tonic-gate 	void *data;
18757c478bd9Sstevel@tonic-gate } lg_walk_data_t;
18767c478bd9Sstevel@tonic-gate 
18777c478bd9Sstevel@tonic-gate /*
18787c478bd9Sstevel@tonic-gate  * We can't use ::walk lock_descriptor directly, because the head of each graph
18797c478bd9Sstevel@tonic-gate  * is really a dummy lock.  Rather than trying to dynamically determine if this
18807c478bd9Sstevel@tonic-gate  * is a dummy node or not, we just filter out the initial element of the
18817c478bd9Sstevel@tonic-gate  * list.
18827c478bd9Sstevel@tonic-gate  */
18837c478bd9Sstevel@tonic-gate static int
18847c478bd9Sstevel@tonic-gate lg_walk_cb(uintptr_t addr, const void *data, void *priv)
18857c478bd9Sstevel@tonic-gate {
18867c478bd9Sstevel@tonic-gate 	lg_walk_data_t *lw = priv;
18877c478bd9Sstevel@tonic-gate 
18887c478bd9Sstevel@tonic-gate 	if (addr != lw->startaddr)
18897c478bd9Sstevel@tonic-gate 		return (lw->callback(addr, data, lw->data));
18907c478bd9Sstevel@tonic-gate 
18917c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
18927c478bd9Sstevel@tonic-gate }
18937c478bd9Sstevel@tonic-gate 
18947c478bd9Sstevel@tonic-gate int
18957c478bd9Sstevel@tonic-gate lg_walk_step(mdb_walk_state_t *wsp)
18967c478bd9Sstevel@tonic-gate {
18977c478bd9Sstevel@tonic-gate 	graph_t *graph;
18987c478bd9Sstevel@tonic-gate 	lg_walk_data_t lw;
18997c478bd9Sstevel@tonic-gate 
19007c478bd9Sstevel@tonic-gate 	if (wsp->walk_addr >= (uintptr_t)wsp->walk_data)
19017c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
19027c478bd9Sstevel@tonic-gate 
19037c478bd9Sstevel@tonic-gate 	if (mdb_vread(&graph, sizeof (graph), wsp->walk_addr) == -1) {
19047c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read graph_t at %p", wsp->walk_addr);
19057c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
19067c478bd9Sstevel@tonic-gate 	}
19077c478bd9Sstevel@tonic-gate 
19087c478bd9Sstevel@tonic-gate 	wsp->walk_addr += sizeof (graph);
19097c478bd9Sstevel@tonic-gate 
19107c478bd9Sstevel@tonic-gate 	if (graph == NULL)
19117c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
19127c478bd9Sstevel@tonic-gate 
19137c478bd9Sstevel@tonic-gate 	lw.callback = wsp->walk_callback;
19147c478bd9Sstevel@tonic-gate 	lw.data = wsp->walk_cbdata;
19157c478bd9Sstevel@tonic-gate 
19167c478bd9Sstevel@tonic-gate 	lw.startaddr = (uintptr_t)&(graph->active_locks);
19177c478bd9Sstevel@tonic-gate 	if (mdb_pwalk("lock_descriptor", lg_walk_cb, &lw, lw.startaddr)) {
19187c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't walk lock_descriptor at %p\n", lw.startaddr);
19197c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
19207c478bd9Sstevel@tonic-gate 	}
19217c478bd9Sstevel@tonic-gate 
19227c478bd9Sstevel@tonic-gate 	lw.startaddr = (uintptr_t)&(graph->sleeping_locks);
19237c478bd9Sstevel@tonic-gate 	if (mdb_pwalk("lock_descriptor", lg_walk_cb, &lw, lw.startaddr)) {
19247c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't walk lock_descriptor at %p\n", lw.startaddr);
19257c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
19267c478bd9Sstevel@tonic-gate 	}
19277c478bd9Sstevel@tonic-gate 
19287c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
19297c478bd9Sstevel@tonic-gate }
19307c478bd9Sstevel@tonic-gate 
19317c478bd9Sstevel@tonic-gate /*
19327c478bd9Sstevel@tonic-gate  * The space available for the path corresponding to the locked vnode depends
19337c478bd9Sstevel@tonic-gate  * on whether we are printing 32- or 64-bit addresses.
19347c478bd9Sstevel@tonic-gate  */
19357c478bd9Sstevel@tonic-gate #ifdef _LP64
19367c478bd9Sstevel@tonic-gate #define	LM_VNPATHLEN	20
19377c478bd9Sstevel@tonic-gate #else
19387c478bd9Sstevel@tonic-gate #define	LM_VNPATHLEN	30
19397c478bd9Sstevel@tonic-gate #endif
19407c478bd9Sstevel@tonic-gate 
194175cebdd1SRyan Zezeski typedef struct mdb_lminfo_proc {
194275cebdd1SRyan Zezeski 	struct {
194375cebdd1SRyan Zezeski 		char		u_comm[MAXCOMLEN + 1];
194475cebdd1SRyan Zezeski 	} p_user;
194575cebdd1SRyan Zezeski } mdb_lminfo_proc_t;
194675cebdd1SRyan Zezeski 
19477c478bd9Sstevel@tonic-gate /*ARGSUSED*/
19487c478bd9Sstevel@tonic-gate static int
19497c478bd9Sstevel@tonic-gate lminfo_cb(uintptr_t addr, const void *data, void *priv)
19507c478bd9Sstevel@tonic-gate {
19517c478bd9Sstevel@tonic-gate 	const lock_descriptor_t *ld = data;
19527c478bd9Sstevel@tonic-gate 	char buf[LM_VNPATHLEN];
195375cebdd1SRyan Zezeski 	mdb_lminfo_proc_t p;
195475cebdd1SRyan Zezeski 	uintptr_t paddr = 0;
195575cebdd1SRyan Zezeski 
195675cebdd1SRyan Zezeski 	if (ld->l_flock.l_pid != 0)
195775cebdd1SRyan Zezeski 		paddr = mdb_pid2proc(ld->l_flock.l_pid, NULL);
195875cebdd1SRyan Zezeski 
195975cebdd1SRyan Zezeski 	if (paddr != 0)
196075cebdd1SRyan Zezeski 		mdb_ctf_vread(&p, "proc_t", "mdb_lminfo_proc_t", paddr, 0);
19617c478bd9Sstevel@tonic-gate 
19627c478bd9Sstevel@tonic-gate 	mdb_printf("%-?p %2s %04x %6d %-16s %-?p ",
19637c478bd9Sstevel@tonic-gate 	    addr, ld->l_type == F_RDLCK ? "RD" :
19647c478bd9Sstevel@tonic-gate 	    ld->l_type == F_WRLCK ? "WR" : "??",
19657c478bd9Sstevel@tonic-gate 	    ld->l_state, ld->l_flock.l_pid,
19667c478bd9Sstevel@tonic-gate 	    ld->l_flock.l_pid == 0 ? "<kernel>" :
196775cebdd1SRyan Zezeski 	    paddr == 0 ? "<defunct>" : p.p_user.u_comm, ld->l_vnode);
19687c478bd9Sstevel@tonic-gate 
19697c478bd9Sstevel@tonic-gate 	mdb_vnode2path((uintptr_t)ld->l_vnode, buf,
19707c478bd9Sstevel@tonic-gate 	    sizeof (buf));
19717c478bd9Sstevel@tonic-gate 	mdb_printf("%s\n", buf);
19727c478bd9Sstevel@tonic-gate 
19737c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
19747c478bd9Sstevel@tonic-gate }
19757c478bd9Sstevel@tonic-gate 
19767c478bd9Sstevel@tonic-gate /*ARGSUSED*/
19777c478bd9Sstevel@tonic-gate int
19787c478bd9Sstevel@tonic-gate lminfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
19797c478bd9Sstevel@tonic-gate {
19807c478bd9Sstevel@tonic-gate 	if (DCMD_HDRSPEC(flags))
19817c478bd9Sstevel@tonic-gate 		mdb_printf("%<u>%-?s %2s %4s %6s %-16s %-?s %s%</u>\n",
19827c478bd9Sstevel@tonic-gate 		    "ADDR", "TP", "FLAG", "PID", "COMM", "VNODE", "PATH");
19837c478bd9Sstevel@tonic-gate 
1984*892ad162SToomas Soome 	return (mdb_pwalk("lock_graph", lminfo_cb, NULL, 0));
19857c478bd9Sstevel@tonic-gate }
19867c478bd9Sstevel@tonic-gate 
19877c478bd9Sstevel@tonic-gate /*ARGSUSED*/
19887c478bd9Sstevel@tonic-gate int
19897c478bd9Sstevel@tonic-gate whereopen_fwalk(uintptr_t addr, struct file *f, uintptr_t *target)
19907c478bd9Sstevel@tonic-gate {
19917c478bd9Sstevel@tonic-gate 	if ((uintptr_t)f->f_vnode == *target) {
19927c478bd9Sstevel@tonic-gate 		mdb_printf("file %p\n", addr);
1993*892ad162SToomas Soome 		*target = 0;
19947c478bd9Sstevel@tonic-gate 	}
19957c478bd9Sstevel@tonic-gate 
19967c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
19977c478bd9Sstevel@tonic-gate }
19987c478bd9Sstevel@tonic-gate 
19997c478bd9Sstevel@tonic-gate /*ARGSUSED*/
20007c478bd9Sstevel@tonic-gate int
20017c478bd9Sstevel@tonic-gate whereopen_pwalk(uintptr_t addr, void *ignored, uintptr_t *target)
20027c478bd9Sstevel@tonic-gate {
20037c478bd9Sstevel@tonic-gate 	uintptr_t t = *target;
20047c478bd9Sstevel@tonic-gate 
20057c478bd9Sstevel@tonic-gate 	if (mdb_pwalk("file", (mdb_walk_cb_t)whereopen_fwalk, &t, addr) == -1) {
20067c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't file walk proc %p", addr);
20077c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
20087c478bd9Sstevel@tonic-gate 	}
20097c478bd9Sstevel@tonic-gate 
2010*892ad162SToomas Soome 	if (t == 0)
20117c478bd9Sstevel@tonic-gate 		mdb_printf("%p\n", addr);
20127c478bd9Sstevel@tonic-gate 
20137c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
20147c478bd9Sstevel@tonic-gate }
20157c478bd9Sstevel@tonic-gate 
20167c478bd9Sstevel@tonic-gate /*ARGSUSED*/
20177c478bd9Sstevel@tonic-gate int
20187c478bd9Sstevel@tonic-gate whereopen(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
20197c478bd9Sstevel@tonic-gate {
20207c478bd9Sstevel@tonic-gate 	uintptr_t target = addr;
20217c478bd9Sstevel@tonic-gate 
2022*892ad162SToomas Soome 	if (!(flags & DCMD_ADDRSPEC) || addr == 0)
20237c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
20247c478bd9Sstevel@tonic-gate 
20257c478bd9Sstevel@tonic-gate 	if (mdb_walk("proc", (mdb_walk_cb_t)whereopen_pwalk, &target) == -1) {
20267c478bd9Sstevel@tonic-gate 		mdb_warn("can't proc walk");
20277c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
20287c478bd9Sstevel@tonic-gate 	}
20297c478bd9Sstevel@tonic-gate 
20307c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
20317c478bd9Sstevel@tonic-gate }
20327c478bd9Sstevel@tonic-gate 
20337c478bd9Sstevel@tonic-gate typedef struct datafmt {
20347c478bd9Sstevel@tonic-gate 	char	*hdr1;
20357c478bd9Sstevel@tonic-gate 	char	*hdr2;
20367c478bd9Sstevel@tonic-gate 	char	*dashes;
20377c478bd9Sstevel@tonic-gate 	char	*fmt;
20387c478bd9Sstevel@tonic-gate } datafmt_t;
20397c478bd9Sstevel@tonic-gate 
20407c478bd9Sstevel@tonic-gate static datafmt_t kmemfmt[] = {
20417c478bd9Sstevel@tonic-gate 	{ "cache                    ", "name                     ",
20427c478bd9Sstevel@tonic-gate 	"-------------------------", "%-25s "				},
20437c478bd9Sstevel@tonic-gate 	{ "   buf",	"  size",	"------",	"%6u "		},
20447c478bd9Sstevel@tonic-gate 	{ "   buf",	"in use",	"------",	"%6u "		},
20457c478bd9Sstevel@tonic-gate 	{ "   buf",	" total",	"------",	"%6u "		},
2046555c8a42SJonathan Haslam 	{ "   memory",	"   in use",	"----------",	"%10lu%c "	},
20477c478bd9Sstevel@tonic-gate 	{ "    alloc",	"  succeed",	"---------",	"%9u "		},
20487c478bd9Sstevel@tonic-gate 	{ "alloc",	" fail",	"-----",	"%5u "		},
20497c478bd9Sstevel@tonic-gate 	{ NULL,		NULL,		NULL,		NULL		}
20507c478bd9Sstevel@tonic-gate };
20517c478bd9Sstevel@tonic-gate 
20527c478bd9Sstevel@tonic-gate static datafmt_t vmemfmt[] = {
20537c478bd9Sstevel@tonic-gate 	{ "vmem                     ", "name                     ",
20547c478bd9Sstevel@tonic-gate 	"-------------------------", "%-*s "				},
2055bb8b5132Sek 	{ "   memory",	"   in use",	"----------",	"%9llu%c "	},
2056bb8b5132Sek 	{ "    memory",	"     total",	"-----------",	"%10llu%c "	},
2057bb8b5132Sek 	{ "   memory",	"   import",	"----------",	"%9llu%c "	},
20587c478bd9Sstevel@tonic-gate 	{ "    alloc",	"  succeed",	"---------",	"%9llu "	},
20597c478bd9Sstevel@tonic-gate 	{ "alloc",	" fail",	"-----",	"%5llu "	},
20607c478bd9Sstevel@tonic-gate 	{ NULL,		NULL,		NULL,		NULL		}
20617c478bd9Sstevel@tonic-gate };
20627c478bd9Sstevel@tonic-gate 
20637c478bd9Sstevel@tonic-gate /*ARGSUSED*/
20647c478bd9Sstevel@tonic-gate static int
20657c478bd9Sstevel@tonic-gate kmastat_cpu_avail(uintptr_t addr, const kmem_cpu_cache_t *ccp, int *avail)
20667c478bd9Sstevel@tonic-gate {
20679dd77bc8SDave Plauger 	short rounds, prounds;
20689dd77bc8SDave Plauger 
20699dd77bc8SDave Plauger 	if (KMEM_DUMPCC(ccp)) {
20709dd77bc8SDave Plauger 		rounds = ccp->cc_dump_rounds;
20719dd77bc8SDave Plauger 		prounds = ccp->cc_dump_prounds;
20729dd77bc8SDave Plauger 	} else {
20739dd77bc8SDave Plauger 		rounds = ccp->cc_rounds;
20749dd77bc8SDave Plauger 		prounds = ccp->cc_prounds;
20759dd77bc8SDave Plauger 	}
20769dd77bc8SDave Plauger 	if (rounds > 0)
20779dd77bc8SDave Plauger 		*avail += rounds;
20789dd77bc8SDave Plauger 	if (prounds > 0)
20799dd77bc8SDave Plauger 		*avail += prounds;
20807c478bd9Sstevel@tonic-gate 
20817c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
20827c478bd9Sstevel@tonic-gate }
20837c478bd9Sstevel@tonic-gate 
20847c478bd9Sstevel@tonic-gate /*ARGSUSED*/
20857c478bd9Sstevel@tonic-gate static int
20867c478bd9Sstevel@tonic-gate kmastat_cpu_alloc(uintptr_t addr, const kmem_cpu_cache_t *ccp, int *alloc)
20877c478bd9Sstevel@tonic-gate {
20887c478bd9Sstevel@tonic-gate 	*alloc += ccp->cc_alloc;
20897c478bd9Sstevel@tonic-gate 
20907c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
20917c478bd9Sstevel@tonic-gate }
20927c478bd9Sstevel@tonic-gate 
20937c478bd9Sstevel@tonic-gate /*ARGSUSED*/
20947c478bd9Sstevel@tonic-gate static int
20957c478bd9Sstevel@tonic-gate kmastat_slab_avail(uintptr_t addr, const kmem_slab_t *sp, int *avail)
20967c478bd9Sstevel@tonic-gate {
20977c478bd9Sstevel@tonic-gate 	*avail += sp->slab_chunks - sp->slab_refcnt;
20987c478bd9Sstevel@tonic-gate 
20997c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
21007c478bd9Sstevel@tonic-gate }
21017c478bd9Sstevel@tonic-gate 
21027c478bd9Sstevel@tonic-gate typedef struct kmastat_vmem {
21037c478bd9Sstevel@tonic-gate 	uintptr_t kv_addr;
21047c478bd9Sstevel@tonic-gate 	struct kmastat_vmem *kv_next;
2105555c8a42SJonathan Haslam 	size_t kv_meminuse;
21067c478bd9Sstevel@tonic-gate 	int kv_alloc;
21077c478bd9Sstevel@tonic-gate 	int kv_fail;
21087c478bd9Sstevel@tonic-gate } kmastat_vmem_t;
21097c478bd9Sstevel@tonic-gate 
2110c92ff650Sek typedef struct kmastat_args {
2111c92ff650Sek 	kmastat_vmem_t **ka_kvpp;
2112c92ff650Sek 	uint_t ka_shift;
2113c92ff650Sek } kmastat_args_t;
2114c92ff650Sek 
21157c478bd9Sstevel@tonic-gate static int
2116c92ff650Sek kmastat_cache(uintptr_t addr, const kmem_cache_t *cp, kmastat_args_t *kap)
21177c478bd9Sstevel@tonic-gate {
2118af4c679fSSean McEnroe 	kmastat_vmem_t **kvpp = kap->ka_kvpp;
21197c478bd9Sstevel@tonic-gate 	kmastat_vmem_t *kv;
21207c478bd9Sstevel@tonic-gate 	datafmt_t *dfp = kmemfmt;
21217c478bd9Sstevel@tonic-gate 	int magsize;
21227c478bd9Sstevel@tonic-gate 
21237c478bd9Sstevel@tonic-gate 	int avail, alloc, total;
21247c478bd9Sstevel@tonic-gate 	size_t meminuse = (cp->cache_slab_create - cp->cache_slab_destroy) *
21257c478bd9Sstevel@tonic-gate 	    cp->cache_slabsize;
21267c478bd9Sstevel@tonic-gate 
21277c478bd9Sstevel@tonic-gate 	mdb_walk_cb_t cpu_avail = (mdb_walk_cb_t)kmastat_cpu_avail;
21287c478bd9Sstevel@tonic-gate 	mdb_walk_cb_t cpu_alloc = (mdb_walk_cb_t)kmastat_cpu_alloc;
21297c478bd9Sstevel@tonic-gate 	mdb_walk_cb_t slab_avail = (mdb_walk_cb_t)kmastat_slab_avail;
21307c478bd9Sstevel@tonic-gate 
21317c478bd9Sstevel@tonic-gate 	magsize = kmem_get_magsize(cp);
21327c478bd9Sstevel@tonic-gate 
21337c478bd9Sstevel@tonic-gate 	alloc = cp->cache_slab_alloc + cp->cache_full.ml_alloc;
21347c478bd9Sstevel@tonic-gate 	avail = cp->cache_full.ml_total * magsize;
21357c478bd9Sstevel@tonic-gate 	total = cp->cache_buftotal;
21367c478bd9Sstevel@tonic-gate 
21377c478bd9Sstevel@tonic-gate 	(void) mdb_pwalk("kmem_cpu_cache", cpu_alloc, &alloc, addr);
21387c478bd9Sstevel@tonic-gate 	(void) mdb_pwalk("kmem_cpu_cache", cpu_avail, &avail, addr);
21397c478bd9Sstevel@tonic-gate 	(void) mdb_pwalk("kmem_slab_partial", slab_avail, &avail, addr);
21407c478bd9Sstevel@tonic-gate 
2141af4c679fSSean McEnroe 	for (kv = *kvpp; kv != NULL; kv = kv->kv_next) {
21427c478bd9Sstevel@tonic-gate 		if (kv->kv_addr == (uintptr_t)cp->cache_arena)
21437c478bd9Sstevel@tonic-gate 			goto out;
21447c478bd9Sstevel@tonic-gate 	}
21457c478bd9Sstevel@tonic-gate 
21467c478bd9Sstevel@tonic-gate 	kv = mdb_zalloc(sizeof (kmastat_vmem_t), UM_SLEEP | UM_GC);
2147af4c679fSSean McEnroe 	kv->kv_next = *kvpp;
21487c478bd9Sstevel@tonic-gate 	kv->kv_addr = (uintptr_t)cp->cache_arena;
2149af4c679fSSean McEnroe 	*kvpp = kv;
21507c478bd9Sstevel@tonic-gate out:
21517c478bd9Sstevel@tonic-gate 	kv->kv_meminuse += meminuse;
21527c478bd9Sstevel@tonic-gate 	kv->kv_alloc += alloc;
21537c478bd9Sstevel@tonic-gate 	kv->kv_fail += cp->cache_alloc_fail;
21547c478bd9Sstevel@tonic-gate 
21557c478bd9Sstevel@tonic-gate 	mdb_printf((dfp++)->fmt, cp->cache_name);
21567c478bd9Sstevel@tonic-gate 	mdb_printf((dfp++)->fmt, cp->cache_bufsize);
21577c478bd9Sstevel@tonic-gate 	mdb_printf((dfp++)->fmt, total - avail);
21587c478bd9Sstevel@tonic-gate 	mdb_printf((dfp++)->fmt, total);
2159bb8b5132Sek 	mdb_printf((dfp++)->fmt, meminuse >> kap->ka_shift,
2160bb8b5132Sek 	    kap->ka_shift == GIGS ? 'G' : kap->ka_shift == MEGS ? 'M' :
2161bb8b5132Sek 	    kap->ka_shift == KILOS ? 'K' : 'B');
21627c478bd9Sstevel@tonic-gate 	mdb_printf((dfp++)->fmt, alloc);
21637c478bd9Sstevel@tonic-gate 	mdb_printf((dfp++)->fmt, cp->cache_alloc_fail);
21647c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
21657c478bd9Sstevel@tonic-gate 
21667c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
21677c478bd9Sstevel@tonic-gate }
21687c478bd9Sstevel@tonic-gate 
21697c478bd9Sstevel@tonic-gate static int
2170c92ff650Sek kmastat_vmem_totals(uintptr_t addr, const vmem_t *v, kmastat_args_t *kap)
21717c478bd9Sstevel@tonic-gate {
2172c92ff650Sek 	kmastat_vmem_t *kv = *kap->ka_kvpp;
21737c478bd9Sstevel@tonic-gate 	size_t len;
21747c478bd9Sstevel@tonic-gate 
21757c478bd9Sstevel@tonic-gate 	while (kv != NULL && kv->kv_addr != addr)
21767c478bd9Sstevel@tonic-gate 		kv = kv->kv_next;
21777c478bd9Sstevel@tonic-gate 
21787c478bd9Sstevel@tonic-gate 	if (kv == NULL || kv->kv_alloc == 0)
21797c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
21807c478bd9Sstevel@tonic-gate 
21817c478bd9Sstevel@tonic-gate 	len = MIN(17, strlen(v->vm_name));
21827c478bd9Sstevel@tonic-gate 
2183555c8a42SJonathan Haslam 	mdb_printf("Total [%s]%*s %6s %6s %6s %10lu%c %9u %5u\n", v->vm_name,
21847c478bd9Sstevel@tonic-gate 	    17 - len, "", "", "", "",
2185bb8b5132Sek 	    kv->kv_meminuse >> kap->ka_shift,
2186bb8b5132Sek 	    kap->ka_shift == GIGS ? 'G' : kap->ka_shift == MEGS ? 'M' :
2187bb8b5132Sek 	    kap->ka_shift == KILOS ? 'K' : 'B', kv->kv_alloc, kv->kv_fail);
21887c478bd9Sstevel@tonic-gate 
21897c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
21907c478bd9Sstevel@tonic-gate }
21917c478bd9Sstevel@tonic-gate 
21927c478bd9Sstevel@tonic-gate /*ARGSUSED*/
21937c478bd9Sstevel@tonic-gate static int
2194c92ff650Sek kmastat_vmem(uintptr_t addr, const vmem_t *v, const uint_t *shiftp)
21957c478bd9Sstevel@tonic-gate {
21967c478bd9Sstevel@tonic-gate 	datafmt_t *dfp = vmemfmt;
21977c478bd9Sstevel@tonic-gate 	const vmem_kstat_t *vkp = &v->vm_kstat;
21987c478bd9Sstevel@tonic-gate 	uintptr_t paddr;
21997c478bd9Sstevel@tonic-gate 	vmem_t parent;
22007c478bd9Sstevel@tonic-gate 	int ident = 0;
22017c478bd9Sstevel@tonic-gate 
2202*892ad162SToomas Soome 	for (paddr = (uintptr_t)v->vm_source; paddr != 0; ident += 4) {
22037c478bd9Sstevel@tonic-gate 		if (mdb_vread(&parent, sizeof (parent), paddr) == -1) {
22047c478bd9Sstevel@tonic-gate 			mdb_warn("couldn't trace %p's ancestry", addr);
22057c478bd9Sstevel@tonic-gate 			ident = 0;
22067c478bd9Sstevel@tonic-gate 			break;
22077c478bd9Sstevel@tonic-gate 		}
22087c478bd9Sstevel@tonic-gate 		paddr = (uintptr_t)parent.vm_source;
22097c478bd9Sstevel@tonic-gate 	}
22107c478bd9Sstevel@tonic-gate 
22117c478bd9Sstevel@tonic-gate 	mdb_printf("%*s", ident, "");
22127c478bd9Sstevel@tonic-gate 	mdb_printf((dfp++)->fmt, 25 - ident, v->vm_name);
2213bb8b5132Sek 	mdb_printf((dfp++)->fmt, vkp->vk_mem_inuse.value.ui64 >> *shiftp,
2214bb8b5132Sek 	    *shiftp == GIGS ? 'G' : *shiftp == MEGS ? 'M' :
2215bb8b5132Sek 	    *shiftp == KILOS ? 'K' : 'B');
2216bb8b5132Sek 	mdb_printf((dfp++)->fmt, vkp->vk_mem_total.value.ui64 >> *shiftp,
2217bb8b5132Sek 	    *shiftp == GIGS ? 'G' : *shiftp == MEGS ? 'M' :
2218bb8b5132Sek 	    *shiftp == KILOS ? 'K' : 'B');
2219bb8b5132Sek 	mdb_printf((dfp++)->fmt, vkp->vk_mem_import.value.ui64 >> *shiftp,
2220bb8b5132Sek 	    *shiftp == GIGS ? 'G' : *shiftp == MEGS ? 'M' :
2221bb8b5132Sek 	    *shiftp == KILOS ? 'K' : 'B');
22227c478bd9Sstevel@tonic-gate 	mdb_printf((dfp++)->fmt, vkp->vk_alloc.value.ui64);
22237c478bd9Sstevel@tonic-gate 	mdb_printf((dfp++)->fmt, vkp->vk_fail.value.ui64);
22247c478bd9Sstevel@tonic-gate 
22257c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
22267c478bd9Sstevel@tonic-gate 
22277c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
22287c478bd9Sstevel@tonic-gate }
22297c478bd9Sstevel@tonic-gate 
22307c478bd9Sstevel@tonic-gate /*ARGSUSED*/
22317c478bd9Sstevel@tonic-gate int
22327c478bd9Sstevel@tonic-gate kmastat(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
22337c478bd9Sstevel@tonic-gate {
22347c478bd9Sstevel@tonic-gate 	kmastat_vmem_t *kv = NULL;
22357c478bd9Sstevel@tonic-gate 	datafmt_t *dfp;
2236c92ff650Sek 	kmastat_args_t ka;
22377c478bd9Sstevel@tonic-gate 
2238c92ff650Sek 	ka.ka_shift = 0;
2239c92ff650Sek 	if (mdb_getopts(argc, argv,
2240bb8b5132Sek 	    'k', MDB_OPT_SETBITS, KILOS, &ka.ka_shift,
2241bb8b5132Sek 	    'm', MDB_OPT_SETBITS, MEGS, &ka.ka_shift,
2242bb8b5132Sek 	    'g', MDB_OPT_SETBITS, GIGS, &ka.ka_shift, NULL) != argc)
22437c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
22447c478bd9Sstevel@tonic-gate 
22457c478bd9Sstevel@tonic-gate 	for (dfp = kmemfmt; dfp->hdr1 != NULL; dfp++)
22467c478bd9Sstevel@tonic-gate 		mdb_printf("%s ", dfp->hdr1);
22477c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
22487c478bd9Sstevel@tonic-gate 
22497c478bd9Sstevel@tonic-gate 	for (dfp = kmemfmt; dfp->hdr1 != NULL; dfp++)
22507c478bd9Sstevel@tonic-gate 		mdb_printf("%s ", dfp->hdr2);
22517c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
22527c478bd9Sstevel@tonic-gate 
22537c478bd9Sstevel@tonic-gate 	for (dfp = kmemfmt; dfp->hdr1 != NULL; dfp++)
22547c478bd9Sstevel@tonic-gate 		mdb_printf("%s ", dfp->dashes);
22557c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
22567c478bd9Sstevel@tonic-gate 
2257c92ff650Sek 	ka.ka_kvpp = &kv;
2258c92ff650Sek 	if (mdb_walk("kmem_cache", (mdb_walk_cb_t)kmastat_cache, &ka) == -1) {
22597c478bd9Sstevel@tonic-gate 		mdb_warn("can't walk 'kmem_cache'");
22607c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
22617c478bd9Sstevel@tonic-gate 	}
22627c478bd9Sstevel@tonic-gate 
22637c478bd9Sstevel@tonic-gate 	for (dfp = kmemfmt; dfp->hdr1 != NULL; dfp++)
22647c478bd9Sstevel@tonic-gate 		mdb_printf("%s ", dfp->dashes);
22657c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
22667c478bd9Sstevel@tonic-gate 
2267c92ff650Sek 	if (mdb_walk("vmem", (mdb_walk_cb_t)kmastat_vmem_totals, &ka) == -1) {
22687c478bd9Sstevel@tonic-gate 		mdb_warn("can't walk 'vmem'");
22697c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
22707c478bd9Sstevel@tonic-gate 	}
22717c478bd9Sstevel@tonic-gate 
22727c478bd9Sstevel@tonic-gate 	for (dfp = kmemfmt; dfp->hdr1 != NULL; dfp++)
22737c478bd9Sstevel@tonic-gate 		mdb_printf("%s ", dfp->dashes);
22747c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
22757c478bd9Sstevel@tonic-gate 
22767c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
22777c478bd9Sstevel@tonic-gate 
22787c478bd9Sstevel@tonic-gate 	for (dfp = vmemfmt; dfp->hdr1 != NULL; dfp++)
22797c478bd9Sstevel@tonic-gate 		mdb_printf("%s ", dfp->hdr1);
22807c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
22817c478bd9Sstevel@tonic-gate 
22827c478bd9Sstevel@tonic-gate 	for (dfp = vmemfmt; dfp->hdr1 != NULL; dfp++)
22837c478bd9Sstevel@tonic-gate 		mdb_printf("%s ", dfp->hdr2);
22847c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
22857c478bd9Sstevel@tonic-gate 
22867c478bd9Sstevel@tonic-gate 	for (dfp = vmemfmt; dfp->hdr1 != NULL; dfp++)
22877c478bd9Sstevel@tonic-gate 		mdb_printf("%s ", dfp->dashes);
22887c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
22897c478bd9Sstevel@tonic-gate 
2290c92ff650Sek 	if (mdb_walk("vmem", (mdb_walk_cb_t)kmastat_vmem, &ka.ka_shift) == -1) {
22917c478bd9Sstevel@tonic-gate 		mdb_warn("can't walk 'vmem'");
22927c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
22937c478bd9Sstevel@tonic-gate 	}
22947c478bd9Sstevel@tonic-gate 
22957c478bd9Sstevel@tonic-gate 	for (dfp = vmemfmt; dfp->hdr1 != NULL; dfp++)
22967c478bd9Sstevel@tonic-gate 		mdb_printf("%s ", dfp->dashes);
22977c478bd9Sstevel@tonic-gate 	mdb_printf("\n");
22987c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
22997c478bd9Sstevel@tonic-gate }
23007c478bd9Sstevel@tonic-gate 
23017c478bd9Sstevel@tonic-gate /*
23027c478bd9Sstevel@tonic-gate  * Our ::kgrep callback scans the entire kernel VA space (kas).  kas is made
23037c478bd9Sstevel@tonic-gate  * up of a set of 'struct seg's.  We could just scan each seg en masse, but
23047c478bd9Sstevel@tonic-gate  * unfortunately, a few of the segs are both large and sparse, so we could
23057c478bd9Sstevel@tonic-gate  * spend quite a bit of time scanning VAs which have no backing pages.
23067c478bd9Sstevel@tonic-gate  *
23077c478bd9Sstevel@tonic-gate  * So for the few very sparse segs, we skip the segment itself, and scan
23087c478bd9Sstevel@tonic-gate  * the allocated vmem_segs in the vmem arena which manages that part of kas.
23097c478bd9Sstevel@tonic-gate  * Currently, we do this for:
23107c478bd9Sstevel@tonic-gate  *
23117c478bd9Sstevel@tonic-gate  *	SEG		VMEM ARENA
23127c478bd9Sstevel@tonic-gate  *	kvseg		heap_arena
23137c478bd9Sstevel@tonic-gate  *	kvseg32		heap32_arena
23147c478bd9Sstevel@tonic-gate  *	kvseg_core	heap_core_arena
23157c478bd9Sstevel@tonic-gate  *
23167c478bd9Sstevel@tonic-gate  * In addition, we skip the segkpm segment in its entirety, since it is very
23177c478bd9Sstevel@tonic-gate  * sparse, and contains no new kernel data.
23187c478bd9Sstevel@tonic-gate  */
23197c478bd9Sstevel@tonic-gate typedef struct kgrep_walk_data {
23207c478bd9Sstevel@tonic-gate 	kgrep_cb_func *kg_cb;
23217c478bd9Sstevel@tonic-gate 	void *kg_cbdata;
23227c478bd9Sstevel@tonic-gate 	uintptr_t kg_kvseg;
23237c478bd9Sstevel@tonic-gate 	uintptr_t kg_kvseg32;
23247c478bd9Sstevel@tonic-gate 	uintptr_t kg_kvseg_core;
23257c478bd9Sstevel@tonic-gate 	uintptr_t kg_segkpm;
23267bc98a2eSeg 	uintptr_t kg_heap_lp_base;
23277bc98a2eSeg 	uintptr_t kg_heap_lp_end;
23287c478bd9Sstevel@tonic-gate } kgrep_walk_data_t;
23297c478bd9Sstevel@tonic-gate 
23307c478bd9Sstevel@tonic-gate static int
23317c478bd9Sstevel@tonic-gate kgrep_walk_seg(uintptr_t addr, const struct seg *seg, kgrep_walk_data_t *kg)
23327c478bd9Sstevel@tonic-gate {
23337c478bd9Sstevel@tonic-gate 	uintptr_t base = (uintptr_t)seg->s_base;
23347c478bd9Sstevel@tonic-gate 
23357c478bd9Sstevel@tonic-gate 	if (addr == kg->kg_kvseg || addr == kg->kg_kvseg32 ||
23367c478bd9Sstevel@tonic-gate 	    addr == kg->kg_kvseg_core)
23377c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
23387c478bd9Sstevel@tonic-gate 
23397c478bd9Sstevel@tonic-gate 	if ((uintptr_t)seg->s_ops == kg->kg_segkpm)
23407c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
23417c478bd9Sstevel@tonic-gate 
23427c478bd9Sstevel@tonic-gate 	return (kg->kg_cb(base, base + seg->s_size, kg->kg_cbdata));
23437c478bd9Sstevel@tonic-gate }
23447c478bd9Sstevel@tonic-gate 
23457c478bd9Sstevel@tonic-gate /*ARGSUSED*/
23467c478bd9Sstevel@tonic-gate static int
23477c478bd9Sstevel@tonic-gate kgrep_walk_vseg(uintptr_t addr, const vmem_seg_t *seg, kgrep_walk_data_t *kg)
23487bc98a2eSeg {
23497bc98a2eSeg 	/*
23507bc98a2eSeg 	 * skip large page heap address range - it is scanned by walking
23517bc98a2eSeg 	 * allocated vmem_segs in the heap_lp_arena
23527bc98a2eSeg 	 */
23537bc98a2eSeg 	if (seg->vs_start == kg->kg_heap_lp_base &&
23547bc98a2eSeg 	    seg->vs_end == kg->kg_heap_lp_end)
23557bc98a2eSeg 		return (WALK_NEXT);
23567bc98a2eSeg 
23577bc98a2eSeg 	return (kg->kg_cb(seg->vs_start, seg->vs_end, kg->kg_cbdata));
23587bc98a2eSeg }
23597bc98a2eSeg 
23607bc98a2eSeg /*ARGSUSED*/
23617bc98a2eSeg static int
23627bc98a2eSeg kgrep_xwalk_vseg(uintptr_t addr, const vmem_seg_t *seg, kgrep_walk_data_t *kg)
23637c478bd9Sstevel@tonic-gate {
23647c478bd9Sstevel@tonic-gate 	return (kg->kg_cb(seg->vs_start, seg->vs_end, kg->kg_cbdata));
23657c478bd9Sstevel@tonic-gate }
23667c478bd9Sstevel@tonic-gate 
23677c478bd9Sstevel@tonic-gate static int
23687c478bd9Sstevel@tonic-gate kgrep_walk_vmem(uintptr_t addr, const vmem_t *vmem, kgrep_walk_data_t *kg)
23697c478bd9Sstevel@tonic-gate {
23707bc98a2eSeg 	mdb_walk_cb_t walk_vseg = (mdb_walk_cb_t)kgrep_walk_vseg;
23717bc98a2eSeg 
23727c478bd9Sstevel@tonic-gate 	if (strcmp(vmem->vm_name, "heap") != 0 &&
23737c478bd9Sstevel@tonic-gate 	    strcmp(vmem->vm_name, "heap32") != 0 &&
23747bc98a2eSeg 	    strcmp(vmem->vm_name, "heap_core") != 0 &&
23757bc98a2eSeg 	    strcmp(vmem->vm_name, "heap_lp") != 0)
23767c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
23777c478bd9Sstevel@tonic-gate 
23787bc98a2eSeg 	if (strcmp(vmem->vm_name, "heap_lp") == 0)
23797bc98a2eSeg 		walk_vseg = (mdb_walk_cb_t)kgrep_xwalk_vseg;
23807bc98a2eSeg 
23817bc98a2eSeg 	if (mdb_pwalk("vmem_alloc", walk_vseg, kg, addr) == -1) {
23827c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't walk vmem_alloc for vmem %p", addr);
23837c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
23847c478bd9Sstevel@tonic-gate 	}
23857c478bd9Sstevel@tonic-gate 
23867c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
23877c478bd9Sstevel@tonic-gate }
23887c478bd9Sstevel@tonic-gate 
23897c478bd9Sstevel@tonic-gate int
23907c478bd9Sstevel@tonic-gate kgrep_subr(kgrep_cb_func *cb, void *cbdata)
23917c478bd9Sstevel@tonic-gate {
23927c478bd9Sstevel@tonic-gate 	GElf_Sym kas, kvseg, kvseg32, kvseg_core, segkpm;
23937c478bd9Sstevel@tonic-gate 	kgrep_walk_data_t kg;
23947c478bd9Sstevel@tonic-gate 
23957c478bd9Sstevel@tonic-gate 	if (mdb_get_state() == MDB_STATE_RUNNING) {
23967c478bd9Sstevel@tonic-gate 		mdb_warn("kgrep can only be run on a system "
23977c478bd9Sstevel@tonic-gate 		    "dump or under kmdb; see dumpadm(1M)\n");
23987c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
23997c478bd9Sstevel@tonic-gate 	}
24007c478bd9Sstevel@tonic-gate 
24017c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_name("kas", &kas) == -1) {
24027c478bd9Sstevel@tonic-gate 		mdb_warn("failed to locate 'kas' symbol\n");
24037c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
24047c478bd9Sstevel@tonic-gate 	}
24057c478bd9Sstevel@tonic-gate 
24067c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_name("kvseg", &kvseg) == -1) {
24077c478bd9Sstevel@tonic-gate 		mdb_warn("failed to locate 'kvseg' symbol\n");
24087c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
24097c478bd9Sstevel@tonic-gate 	}
24107c478bd9Sstevel@tonic-gate 
24117c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_name("kvseg32", &kvseg32) == -1) {
24127c478bd9Sstevel@tonic-gate 		mdb_warn("failed to locate 'kvseg32' symbol\n");
24137c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
24147c478bd9Sstevel@tonic-gate 	}
24157c478bd9Sstevel@tonic-gate 
24167c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_name("kvseg_core", &kvseg_core) == -1) {
24177c478bd9Sstevel@tonic-gate 		mdb_warn("failed to locate 'kvseg_core' symbol\n");
24187c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
24197c478bd9Sstevel@tonic-gate 	}
24207c478bd9Sstevel@tonic-gate 
24217c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_name("segkpm_ops", &segkpm) == -1) {
24227c478bd9Sstevel@tonic-gate 		mdb_warn("failed to locate 'segkpm_ops' symbol\n");
24237c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
24247c478bd9Sstevel@tonic-gate 	}
24257c478bd9Sstevel@tonic-gate 
24267bc98a2eSeg 	if (mdb_readvar(&kg.kg_heap_lp_base, "heap_lp_base") == -1) {
24277bc98a2eSeg 		mdb_warn("failed to read 'heap_lp_base'\n");
24287bc98a2eSeg 		return (DCMD_ERR);
24297bc98a2eSeg 	}
24307bc98a2eSeg 
24317bc98a2eSeg 	if (mdb_readvar(&kg.kg_heap_lp_end, "heap_lp_end") == -1) {
24327bc98a2eSeg 		mdb_warn("failed to read 'heap_lp_end'\n");
24337bc98a2eSeg 		return (DCMD_ERR);
24347bc98a2eSeg 	}
24357bc98a2eSeg 
24367c478bd9Sstevel@tonic-gate 	kg.kg_cb = cb;
24377c478bd9Sstevel@tonic-gate 	kg.kg_cbdata = cbdata;
24387c478bd9Sstevel@tonic-gate 	kg.kg_kvseg = (uintptr_t)kvseg.st_value;
24397c478bd9Sstevel@tonic-gate 	kg.kg_kvseg32 = (uintptr_t)kvseg32.st_value;
24407c478bd9Sstevel@tonic-gate 	kg.kg_kvseg_core = (uintptr_t)kvseg_core.st_value;
24417c478bd9Sstevel@tonic-gate 	kg.kg_segkpm = (uintptr_t)segkpm.st_value;
24427c478bd9Sstevel@tonic-gate 
24437c478bd9Sstevel@tonic-gate 	if (mdb_pwalk("seg", (mdb_walk_cb_t)kgrep_walk_seg,
24447c478bd9Sstevel@tonic-gate 	    &kg, kas.st_value) == -1) {
24457c478bd9Sstevel@tonic-gate 		mdb_warn("failed to walk kas segments");
24467c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
24477c478bd9Sstevel@tonic-gate 	}
24487c478bd9Sstevel@tonic-gate 
24497c478bd9Sstevel@tonic-gate 	if (mdb_walk("vmem", (mdb_walk_cb_t)kgrep_walk_vmem, &kg) == -1) {
24507c478bd9Sstevel@tonic-gate 		mdb_warn("failed to walk heap/heap32 vmem arenas");
24517c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
24527c478bd9Sstevel@tonic-gate 	}
24537c478bd9Sstevel@tonic-gate 
24547c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
24557c478bd9Sstevel@tonic-gate }
24567c478bd9Sstevel@tonic-gate 
24577c478bd9Sstevel@tonic-gate size_t
24587c478bd9Sstevel@tonic-gate kgrep_subr_pagesize(void)
24597c478bd9Sstevel@tonic-gate {
24607c478bd9Sstevel@tonic-gate 	return (PAGESIZE);
24617c478bd9Sstevel@tonic-gate }
24627c478bd9Sstevel@tonic-gate 
24637c478bd9Sstevel@tonic-gate typedef struct file_walk_data {
24647c478bd9Sstevel@tonic-gate 	struct uf_entry *fw_flist;
24657c478bd9Sstevel@tonic-gate 	int fw_flistsz;
24667c478bd9Sstevel@tonic-gate 	int fw_ndx;
24677c478bd9Sstevel@tonic-gate 	int fw_nofiles;
24687c478bd9Sstevel@tonic-gate } file_walk_data_t;
24697c478bd9Sstevel@tonic-gate 
247075cebdd1SRyan Zezeski typedef struct mdb_file_proc {
247175cebdd1SRyan Zezeski 	struct {
247275cebdd1SRyan Zezeski 		struct {
247375cebdd1SRyan Zezeski 			int			fi_nfiles;
247475cebdd1SRyan Zezeski 			uf_entry_t *volatile	fi_list;
247575cebdd1SRyan Zezeski 		} u_finfo;
247675cebdd1SRyan Zezeski 	} p_user;
247775cebdd1SRyan Zezeski } mdb_file_proc_t;
247875cebdd1SRyan Zezeski 
24797c478bd9Sstevel@tonic-gate int
24807c478bd9Sstevel@tonic-gate file_walk_init(mdb_walk_state_t *wsp)
24817c478bd9Sstevel@tonic-gate {
24827c478bd9Sstevel@tonic-gate 	file_walk_data_t *fw;
248375cebdd1SRyan Zezeski 	mdb_file_proc_t p;
24847c478bd9Sstevel@tonic-gate 
2485*892ad162SToomas Soome 	if (wsp->walk_addr == 0) {
24867c478bd9Sstevel@tonic-gate 		mdb_warn("file walk doesn't support global walks\n");
24877c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
24887c478bd9Sstevel@tonic-gate 	}
24897c478bd9Sstevel@tonic-gate 
24907c478bd9Sstevel@tonic-gate 	fw = mdb_alloc(sizeof (file_walk_data_t), UM_SLEEP);
24917c478bd9Sstevel@tonic-gate 
249275cebdd1SRyan Zezeski 	if (mdb_ctf_vread(&p, "proc_t", "mdb_file_proc_t",
249375cebdd1SRyan Zezeski 	    wsp->walk_addr, 0) == -1) {
24947c478bd9Sstevel@tonic-gate 		mdb_free(fw, sizeof (file_walk_data_t));
24957c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read proc structure at %p", wsp->walk_addr);
24967c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
24977c478bd9Sstevel@tonic-gate 	}
24987c478bd9Sstevel@tonic-gate 
24997c478bd9Sstevel@tonic-gate 	if (p.p_user.u_finfo.fi_nfiles == 0) {
25007c478bd9Sstevel@tonic-gate 		mdb_free(fw, sizeof (file_walk_data_t));
25017c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
25027c478bd9Sstevel@tonic-gate 	}
25037c478bd9Sstevel@tonic-gate 
25047c478bd9Sstevel@tonic-gate 	fw->fw_nofiles = p.p_user.u_finfo.fi_nfiles;
25057c478bd9Sstevel@tonic-gate 	fw->fw_flistsz = sizeof (struct uf_entry) * fw->fw_nofiles;
25067c478bd9Sstevel@tonic-gate 	fw->fw_flist = mdb_alloc(fw->fw_flistsz, UM_SLEEP);
25077c478bd9Sstevel@tonic-gate 
25087c478bd9Sstevel@tonic-gate 	if (mdb_vread(fw->fw_flist, fw->fw_flistsz,
25097c478bd9Sstevel@tonic-gate 	    (uintptr_t)p.p_user.u_finfo.fi_list) == -1) {
25107c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read file array at %p",
25117c478bd9Sstevel@tonic-gate 		    p.p_user.u_finfo.fi_list);
25127c478bd9Sstevel@tonic-gate 		mdb_free(fw->fw_flist, fw->fw_flistsz);
25137c478bd9Sstevel@tonic-gate 		mdb_free(fw, sizeof (file_walk_data_t));
25147c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
25157c478bd9Sstevel@tonic-gate 	}
25167c478bd9Sstevel@tonic-gate 
25177c478bd9Sstevel@tonic-gate 	fw->fw_ndx = 0;
25187c478bd9Sstevel@tonic-gate 	wsp->walk_data = fw;
25197c478bd9Sstevel@tonic-gate 
25207c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
25217c478bd9Sstevel@tonic-gate }
25227c478bd9Sstevel@tonic-gate 
25237c478bd9Sstevel@tonic-gate int
25247c478bd9Sstevel@tonic-gate file_walk_step(mdb_walk_state_t *wsp)
25257c478bd9Sstevel@tonic-gate {
25267c478bd9Sstevel@tonic-gate 	file_walk_data_t *fw = (file_walk_data_t *)wsp->walk_data;
25277c478bd9Sstevel@tonic-gate 	struct file file;
25287c478bd9Sstevel@tonic-gate 	uintptr_t fp;
25297c478bd9Sstevel@tonic-gate 
25307c478bd9Sstevel@tonic-gate again:
25317c478bd9Sstevel@tonic-gate 	if (fw->fw_ndx == fw->fw_nofiles)
25327c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
25337c478bd9Sstevel@tonic-gate 
2534*892ad162SToomas Soome 	if ((fp = (uintptr_t)fw->fw_flist[fw->fw_ndx++].uf_file) == 0)
25357c478bd9Sstevel@tonic-gate 		goto again;
25367c478bd9Sstevel@tonic-gate 
25377c478bd9Sstevel@tonic-gate 	(void) mdb_vread(&file, sizeof (file), (uintptr_t)fp);
25387c478bd9Sstevel@tonic-gate 	return (wsp->walk_callback(fp, &file, wsp->walk_cbdata));
25397c478bd9Sstevel@tonic-gate }
25407c478bd9Sstevel@tonic-gate 
25417c478bd9Sstevel@tonic-gate int
25427c478bd9Sstevel@tonic-gate allfile_walk_step(mdb_walk_state_t *wsp)
25437c478bd9Sstevel@tonic-gate {
25447c478bd9Sstevel@tonic-gate 	file_walk_data_t *fw = (file_walk_data_t *)wsp->walk_data;
25457c478bd9Sstevel@tonic-gate 	struct file file;
25467c478bd9Sstevel@tonic-gate 	uintptr_t fp;
25477c478bd9Sstevel@tonic-gate 
25487c478bd9Sstevel@tonic-gate 	if (fw->fw_ndx == fw->fw_nofiles)
25497c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
25507c478bd9Sstevel@tonic-gate 
2551*892ad162SToomas Soome 	if ((fp = (uintptr_t)fw->fw_flist[fw->fw_ndx++].uf_file) != 0)
25527c478bd9Sstevel@tonic-gate 		(void) mdb_vread(&file, sizeof (file), (uintptr_t)fp);
25537c478bd9Sstevel@tonic-gate 	else
25547c478bd9Sstevel@tonic-gate 		bzero(&file, sizeof (file));
25557c478bd9Sstevel@tonic-gate 
25567c478bd9Sstevel@tonic-gate 	return (wsp->walk_callback(fp, &file, wsp->walk_cbdata));
25577c478bd9Sstevel@tonic-gate }
25587c478bd9Sstevel@tonic-gate 
25597c478bd9Sstevel@tonic-gate void
25607c478bd9Sstevel@tonic-gate file_walk_fini(mdb_walk_state_t *wsp)
25617c478bd9Sstevel@tonic-gate {
25627c478bd9Sstevel@tonic-gate 	file_walk_data_t *fw = (file_walk_data_t *)wsp->walk_data;
25637c478bd9Sstevel@tonic-gate 
25647c478bd9Sstevel@tonic-gate 	mdb_free(fw->fw_flist, fw->fw_flistsz);
25657c478bd9Sstevel@tonic-gate 	mdb_free(fw, sizeof (file_walk_data_t));
25667c478bd9Sstevel@tonic-gate }
25677c478bd9Sstevel@tonic-gate 
25687c478bd9Sstevel@tonic-gate int
25697c478bd9Sstevel@tonic-gate port_walk_init(mdb_walk_state_t *wsp)
25707c478bd9Sstevel@tonic-gate {
2571*892ad162SToomas Soome 	if (wsp->walk_addr == 0) {
25727c478bd9Sstevel@tonic-gate 		mdb_warn("port walk doesn't support global walks\n");
25737c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
25747c478bd9Sstevel@tonic-gate 	}
25757c478bd9Sstevel@tonic-gate 
25767c478bd9Sstevel@tonic-gate 	if (mdb_layered_walk("file", wsp) == -1) {
25777c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't walk 'file'");
25787c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
25797c478bd9Sstevel@tonic-gate 	}
25807c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
25817c478bd9Sstevel@tonic-gate }
25827c478bd9Sstevel@tonic-gate 
25837c478bd9Sstevel@tonic-gate int
25847c478bd9Sstevel@tonic-gate port_walk_step(mdb_walk_state_t *wsp)
25857c478bd9Sstevel@tonic-gate {
25867c478bd9Sstevel@tonic-gate 	struct vnode	vn;
25877c478bd9Sstevel@tonic-gate 	uintptr_t	vp;
25887c478bd9Sstevel@tonic-gate 	uintptr_t	pp;
25897c478bd9Sstevel@tonic-gate 	struct port	port;
25907c478bd9Sstevel@tonic-gate 
25917c478bd9Sstevel@tonic-gate 	vp = (uintptr_t)((struct file *)wsp->walk_layer)->f_vnode;
25927c478bd9Sstevel@tonic-gate 	if (mdb_vread(&vn, sizeof (vn), vp) == -1) {
25937c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read vnode_t at %p", vp);
25947c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
25957c478bd9Sstevel@tonic-gate 	}
25967c478bd9Sstevel@tonic-gate 	if (vn.v_type != VPORT)
25977c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
25987c478bd9Sstevel@tonic-gate 
25997c478bd9Sstevel@tonic-gate 	pp = (uintptr_t)vn.v_data;
26007c478bd9Sstevel@tonic-gate 	if (mdb_vread(&port, sizeof (port), pp) == -1) {
26017c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read port_t at %p", pp);
26027c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
26037c478bd9Sstevel@tonic-gate 	}
26047c478bd9Sstevel@tonic-gate 	return (wsp->walk_callback(pp, &port, wsp->walk_cbdata));
26057c478bd9Sstevel@tonic-gate }
26067c478bd9Sstevel@tonic-gate 
26077c478bd9Sstevel@tonic-gate typedef struct portev_walk_data {
26087c478bd9Sstevel@tonic-gate 	list_node_t	*pev_node;
26097c478bd9Sstevel@tonic-gate 	list_node_t	*pev_last;
26107c478bd9Sstevel@tonic-gate 	size_t		pev_offset;
26117c478bd9Sstevel@tonic-gate } portev_walk_data_t;
26127c478bd9Sstevel@tonic-gate 
26137c478bd9Sstevel@tonic-gate int
26147c478bd9Sstevel@tonic-gate portev_walk_init(mdb_walk_state_t *wsp)
26157c478bd9Sstevel@tonic-gate {
26167c478bd9Sstevel@tonic-gate 	portev_walk_data_t *pevd;
26177c478bd9Sstevel@tonic-gate 	struct port	port;
26187c478bd9Sstevel@tonic-gate 	struct vnode	vn;
26197c478bd9Sstevel@tonic-gate 	struct list	*list;
26207c478bd9Sstevel@tonic-gate 	uintptr_t	vp;
26217c478bd9Sstevel@tonic-gate 
2622*892ad162SToomas Soome 	if (wsp->walk_addr == 0) {
26237c478bd9Sstevel@tonic-gate 		mdb_warn("portev walk doesn't support global walks\n");
26247c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
26257c478bd9Sstevel@tonic-gate 	}
26267c478bd9Sstevel@tonic-gate 
26277c478bd9Sstevel@tonic-gate 	pevd = mdb_alloc(sizeof (portev_walk_data_t), UM_SLEEP);
26287c478bd9Sstevel@tonic-gate 
26297c478bd9Sstevel@tonic-gate 	if (mdb_vread(&port, sizeof (port), wsp->walk_addr) == -1) {
26307c478bd9Sstevel@tonic-gate 		mdb_free(pevd, sizeof (portev_walk_data_t));
26317c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read port structure at %p", wsp->walk_addr);
26327c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
26337c478bd9Sstevel@tonic-gate 	}
26347c478bd9Sstevel@tonic-gate 
26357c478bd9Sstevel@tonic-gate 	vp = (uintptr_t)port.port_vnode;
26367c478bd9Sstevel@tonic-gate 	if (mdb_vread(&vn, sizeof (vn), vp) == -1) {
26377c478bd9Sstevel@tonic-gate 		mdb_free(pevd, sizeof (portev_walk_data_t));
26387c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read vnode_t at %p", vp);
26397c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
26407c478bd9Sstevel@tonic-gate 	}
26417c478bd9Sstevel@tonic-gate 
26427c478bd9Sstevel@tonic-gate 	if (vn.v_type != VPORT) {
26437c478bd9Sstevel@tonic-gate 		mdb_free(pevd, sizeof (portev_walk_data_t));
26447c478bd9Sstevel@tonic-gate 		mdb_warn("input address (%p) does not point to an event port",
26457c478bd9Sstevel@tonic-gate 		    wsp->walk_addr);
26467c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
26477c478bd9Sstevel@tonic-gate 	}
26487c478bd9Sstevel@tonic-gate 
26497c478bd9Sstevel@tonic-gate 	if (port.port_queue.portq_nent == 0) {
26507c478bd9Sstevel@tonic-gate 		mdb_free(pevd, sizeof (portev_walk_data_t));
26517c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
26527c478bd9Sstevel@tonic-gate 	}
26537c478bd9Sstevel@tonic-gate 	list = &port.port_queue.portq_list;
26547c478bd9Sstevel@tonic-gate 	pevd->pev_offset = list->list_offset;
26557c478bd9Sstevel@tonic-gate 	pevd->pev_last = list->list_head.list_prev;
26567c478bd9Sstevel@tonic-gate 	pevd->pev_node = list->list_head.list_next;
26577c478bd9Sstevel@tonic-gate 	wsp->walk_data = pevd;
26587c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
26597c478bd9Sstevel@tonic-gate }
26607c478bd9Sstevel@tonic-gate 
26617c478bd9Sstevel@tonic-gate int
26627c478bd9Sstevel@tonic-gate portev_walk_step(mdb_walk_state_t *wsp)
26637c478bd9Sstevel@tonic-gate {
26647c478bd9Sstevel@tonic-gate 	portev_walk_data_t	*pevd;
26657c478bd9Sstevel@tonic-gate 	struct port_kevent	ev;
26667c478bd9Sstevel@tonic-gate 	uintptr_t		evp;
26677c478bd9Sstevel@tonic-gate 
26687c478bd9Sstevel@tonic-gate 	pevd = (portev_walk_data_t *)wsp->walk_data;
26697c478bd9Sstevel@tonic-gate 
26707c478bd9Sstevel@tonic-gate 	if (pevd->pev_last == NULL)
26717c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
26727c478bd9Sstevel@tonic-gate 	if (pevd->pev_node == pevd->pev_last)
26737c478bd9Sstevel@tonic-gate 		pevd->pev_last = NULL;		/* last round */
26747c478bd9Sstevel@tonic-gate 
26757c478bd9Sstevel@tonic-gate 	evp = ((uintptr_t)(((char *)pevd->pev_node) - pevd->pev_offset));
26767c478bd9Sstevel@tonic-gate 	if (mdb_vread(&ev, sizeof (ev), evp) == -1) {
26777c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read port_kevent at %p", evp);
26787c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
26797c478bd9Sstevel@tonic-gate 	}
26807c478bd9Sstevel@tonic-gate 	pevd->pev_node = ev.portkev_node.list_next;
26817c478bd9Sstevel@tonic-gate 	return (wsp->walk_callback(evp, &ev, wsp->walk_cbdata));
26827c478bd9Sstevel@tonic-gate }
26837c478bd9Sstevel@tonic-gate 
26847c478bd9Sstevel@tonic-gate void
26857c478bd9Sstevel@tonic-gate portev_walk_fini(mdb_walk_state_t *wsp)
26867c478bd9Sstevel@tonic-gate {
26877c478bd9Sstevel@tonic-gate 	portev_walk_data_t *pevd = (portev_walk_data_t *)wsp->walk_data;
26887c478bd9Sstevel@tonic-gate 
26897c478bd9Sstevel@tonic-gate 	if (pevd != NULL)
26907c478bd9Sstevel@tonic-gate 		mdb_free(pevd, sizeof (portev_walk_data_t));
26917c478bd9Sstevel@tonic-gate }
26927c478bd9Sstevel@tonic-gate 
26937c478bd9Sstevel@tonic-gate typedef struct proc_walk_data {
26947c478bd9Sstevel@tonic-gate 	uintptr_t *pw_stack;
26957c478bd9Sstevel@tonic-gate 	int pw_depth;
26967c478bd9Sstevel@tonic-gate 	int pw_max;
26977c478bd9Sstevel@tonic-gate } proc_walk_data_t;
26987c478bd9Sstevel@tonic-gate 
26997c478bd9Sstevel@tonic-gate int
27007c478bd9Sstevel@tonic-gate proc_walk_init(mdb_walk_state_t *wsp)
27017c478bd9Sstevel@tonic-gate {
27027c478bd9Sstevel@tonic-gate 	GElf_Sym sym;
27037c478bd9Sstevel@tonic-gate 	proc_walk_data_t *pw;
27047c478bd9Sstevel@tonic-gate 
2705*892ad162SToomas Soome 	if (wsp->walk_addr == 0) {
27067c478bd9Sstevel@tonic-gate 		if (mdb_lookup_by_name("p0", &sym) == -1) {
27077c478bd9Sstevel@tonic-gate 			mdb_warn("failed to read 'practive'");
27087c478bd9Sstevel@tonic-gate 			return (WALK_ERR);
27097c478bd9Sstevel@tonic-gate 		}
27107c478bd9Sstevel@tonic-gate 		wsp->walk_addr = (uintptr_t)sym.st_value;
27117c478bd9Sstevel@tonic-gate 	}
27127c478bd9Sstevel@tonic-gate 
27137c478bd9Sstevel@tonic-gate 	pw = mdb_zalloc(sizeof (proc_walk_data_t), UM_SLEEP);
27147c478bd9Sstevel@tonic-gate 
27157c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&pw->pw_max, "nproc") == -1) {
27167c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read 'nproc'");
27177c478bd9Sstevel@tonic-gate 		mdb_free(pw, sizeof (pw));
27187c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
27197c478bd9Sstevel@tonic-gate 	}
27207c478bd9Sstevel@tonic-gate 
27217c478bd9Sstevel@tonic-gate 	pw->pw_stack = mdb_alloc(pw->pw_max * sizeof (uintptr_t), UM_SLEEP);
27227c478bd9Sstevel@tonic-gate 	wsp->walk_data = pw;
27237c478bd9Sstevel@tonic-gate 
27247c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
27257c478bd9Sstevel@tonic-gate }
27267c478bd9Sstevel@tonic-gate 
272775cebdd1SRyan Zezeski typedef struct mdb_walk_proc {
272875cebdd1SRyan Zezeski 	struct proc	*p_child;
272975cebdd1SRyan Zezeski 	struct proc	*p_sibling;
273075cebdd1SRyan Zezeski } mdb_walk_proc_t;
273175cebdd1SRyan Zezeski 
27327c478bd9Sstevel@tonic-gate int
27337c478bd9Sstevel@tonic-gate proc_walk_step(mdb_walk_state_t *wsp)
27347c478bd9Sstevel@tonic-gate {
27357c478bd9Sstevel@tonic-gate 	proc_walk_data_t *pw = wsp->walk_data;
27367c478bd9Sstevel@tonic-gate 	uintptr_t addr = wsp->walk_addr;
27377c478bd9Sstevel@tonic-gate 	uintptr_t cld, sib;
27387c478bd9Sstevel@tonic-gate 	int status;
273975cebdd1SRyan Zezeski 	mdb_walk_proc_t pr;
27407c478bd9Sstevel@tonic-gate 
274175cebdd1SRyan Zezeski 	if (mdb_ctf_vread(&pr, "proc_t", "mdb_walk_proc_t",
274275cebdd1SRyan Zezeski 	    addr, 0) == -1) {
27437c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read proc at %p", addr);
27447c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
27457c478bd9Sstevel@tonic-gate 	}
27467c478bd9Sstevel@tonic-gate 
27477c478bd9Sstevel@tonic-gate 	cld = (uintptr_t)pr.p_child;
27487c478bd9Sstevel@tonic-gate 	sib = (uintptr_t)pr.p_sibling;
27497c478bd9Sstevel@tonic-gate 
27507c478bd9Sstevel@tonic-gate 	if (pw->pw_depth > 0 && addr == pw->pw_stack[pw->pw_depth - 1]) {
27517c478bd9Sstevel@tonic-gate 		pw->pw_depth--;
27527c478bd9Sstevel@tonic-gate 		goto sib;
27537c478bd9Sstevel@tonic-gate 	}
27547c478bd9Sstevel@tonic-gate 
275575cebdd1SRyan Zezeski 	/*
275675cebdd1SRyan Zezeski 	 * Always pass NULL as the local copy pointer. Consumers
275775cebdd1SRyan Zezeski 	 * should use mdb_ctf_vread() to read their own minimal
275875cebdd1SRyan Zezeski 	 * version of proc_t. Thus minimizing the chance of breakage
275975cebdd1SRyan Zezeski 	 * with older crash dumps.
276075cebdd1SRyan Zezeski 	 */
276175cebdd1SRyan Zezeski 	status = wsp->walk_callback(addr, NULL, wsp->walk_cbdata);
27627c478bd9Sstevel@tonic-gate 
27637c478bd9Sstevel@tonic-gate 	if (status != WALK_NEXT)
27647c478bd9Sstevel@tonic-gate 		return (status);
27657c478bd9Sstevel@tonic-gate 
2766*892ad162SToomas Soome 	if ((wsp->walk_addr = cld) != 0) {
276775cebdd1SRyan Zezeski 		if (mdb_ctf_vread(&pr, "proc_t", "mdb_walk_proc_t",
276875cebdd1SRyan Zezeski 		    cld, 0) == -1) {
27697c478bd9Sstevel@tonic-gate 			mdb_warn("proc %p has invalid p_child %p; skipping\n",
27707c478bd9Sstevel@tonic-gate 			    addr, cld);
27717c478bd9Sstevel@tonic-gate 			goto sib;
27727c478bd9Sstevel@tonic-gate 		}
27737c478bd9Sstevel@tonic-gate 
27747c478bd9Sstevel@tonic-gate 		pw->pw_stack[pw->pw_depth++] = addr;
27757c478bd9Sstevel@tonic-gate 
27767c478bd9Sstevel@tonic-gate 		if (pw->pw_depth == pw->pw_max) {
27777c478bd9Sstevel@tonic-gate 			mdb_warn("depth %d exceeds max depth; try again\n",
27787c478bd9Sstevel@tonic-gate 			    pw->pw_depth);
27797c478bd9Sstevel@tonic-gate 			return (WALK_DONE);
27807c478bd9Sstevel@tonic-gate 		}
27817c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
27827c478bd9Sstevel@tonic-gate 	}
27837c478bd9Sstevel@tonic-gate 
27847c478bd9Sstevel@tonic-gate sib:
27857c478bd9Sstevel@tonic-gate 	/*
27867c478bd9Sstevel@tonic-gate 	 * We know that p0 has no siblings, and if another starting proc
27877c478bd9Sstevel@tonic-gate 	 * was given, we don't want to walk its siblings anyway.
27887c478bd9Sstevel@tonic-gate 	 */
27897c478bd9Sstevel@tonic-gate 	if (pw->pw_depth == 0)
27907c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
27917c478bd9Sstevel@tonic-gate 
2792*892ad162SToomas Soome 	if (sib != 0 && mdb_ctf_vread(&pr, "proc_t", "mdb_walk_proc_t",
279375cebdd1SRyan Zezeski 	    sib, 0) == -1) {
27947c478bd9Sstevel@tonic-gate 		mdb_warn("proc %p has invalid p_sibling %p; skipping\n",
27957c478bd9Sstevel@tonic-gate 		    addr, sib);
2796*892ad162SToomas Soome 		sib = 0;
27977c478bd9Sstevel@tonic-gate 	}
27987c478bd9Sstevel@tonic-gate 
2799*892ad162SToomas Soome 	if ((wsp->walk_addr = sib) == 0) {
28007c478bd9Sstevel@tonic-gate 		if (pw->pw_depth > 0) {
28017c478bd9Sstevel@tonic-gate 			wsp->walk_addr = pw->pw_stack[pw->pw_depth - 1];
28027c478bd9Sstevel@tonic-gate 			return (WALK_NEXT);
28037c478bd9Sstevel@tonic-gate 		}
28047c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
28057c478bd9Sstevel@tonic-gate 	}
28067c478bd9Sstevel@tonic-gate 
28077c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
28087c478bd9Sstevel@tonic-gate }
28097c478bd9Sstevel@tonic-gate 
28107c478bd9Sstevel@tonic-gate void
28117c478bd9Sstevel@tonic-gate proc_walk_fini(mdb_walk_state_t *wsp)
28127c478bd9Sstevel@tonic-gate {
28137c478bd9Sstevel@tonic-gate 	proc_walk_data_t *pw = wsp->walk_data;
28147c478bd9Sstevel@tonic-gate 
28157c478bd9Sstevel@tonic-gate 	mdb_free(pw->pw_stack, pw->pw_max * sizeof (uintptr_t));
28167c478bd9Sstevel@tonic-gate 	mdb_free(pw, sizeof (proc_walk_data_t));
28177c478bd9Sstevel@tonic-gate }
28187c478bd9Sstevel@tonic-gate 
28197c478bd9Sstevel@tonic-gate int
28207c478bd9Sstevel@tonic-gate task_walk_init(mdb_walk_state_t *wsp)
28217c478bd9Sstevel@tonic-gate {
28227c478bd9Sstevel@tonic-gate 	task_t task;
28237c478bd9Sstevel@tonic-gate 
28247c478bd9Sstevel@tonic-gate 	if (mdb_vread(&task, sizeof (task_t), wsp->walk_addr) == -1) {
28257c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read task at %p", wsp->walk_addr);
28267c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
28277c478bd9Sstevel@tonic-gate 	}
28287c478bd9Sstevel@tonic-gate 	wsp->walk_addr = (uintptr_t)task.tk_memb_list;
28297c478bd9Sstevel@tonic-gate 	wsp->walk_data = task.tk_memb_list;
28307c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
28317c478bd9Sstevel@tonic-gate }
28327c478bd9Sstevel@tonic-gate 
283375cebdd1SRyan Zezeski typedef struct mdb_task_proc {
283475cebdd1SRyan Zezeski 	struct proc	*p_tasknext;
283575cebdd1SRyan Zezeski } mdb_task_proc_t;
283675cebdd1SRyan Zezeski 
28377c478bd9Sstevel@tonic-gate int
28387c478bd9Sstevel@tonic-gate task_walk_step(mdb_walk_state_t *wsp)
28397c478bd9Sstevel@tonic-gate {
284075cebdd1SRyan Zezeski 	mdb_task_proc_t proc;
28417c478bd9Sstevel@tonic-gate 	int status;
28427c478bd9Sstevel@tonic-gate 
284375cebdd1SRyan Zezeski 	if (mdb_ctf_vread(&proc, "proc_t", "mdb_task_proc_t",
284475cebdd1SRyan Zezeski 	    wsp->walk_addr, 0) == -1) {
28457c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read proc at %p", wsp->walk_addr);
28467c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
28477c478bd9Sstevel@tonic-gate 	}
28487c478bd9Sstevel@tonic-gate 
28497c478bd9Sstevel@tonic-gate 	status = wsp->walk_callback(wsp->walk_addr, NULL, wsp->walk_cbdata);
28507c478bd9Sstevel@tonic-gate 
28517c478bd9Sstevel@tonic-gate 	if (proc.p_tasknext == wsp->walk_data)
28527c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
28537c478bd9Sstevel@tonic-gate 
28547c478bd9Sstevel@tonic-gate 	wsp->walk_addr = (uintptr_t)proc.p_tasknext;
28557c478bd9Sstevel@tonic-gate 	return (status);
28567c478bd9Sstevel@tonic-gate }
28577c478bd9Sstevel@tonic-gate 
28587c478bd9Sstevel@tonic-gate int
28597c478bd9Sstevel@tonic-gate project_walk_init(mdb_walk_state_t *wsp)
28607c478bd9Sstevel@tonic-gate {
2861*892ad162SToomas Soome 	if (wsp->walk_addr == 0) {
28627c478bd9Sstevel@tonic-gate 		if (mdb_readvar(&wsp->walk_addr, "proj0p") == -1) {
28637c478bd9Sstevel@tonic-gate 			mdb_warn("failed to read 'proj0p'");
28647c478bd9Sstevel@tonic-gate 			return (WALK_ERR);
28657c478bd9Sstevel@tonic-gate 		}
28667c478bd9Sstevel@tonic-gate 	}
28677c478bd9Sstevel@tonic-gate 	wsp->walk_data = (void *)wsp->walk_addr;
28687c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
28697c478bd9Sstevel@tonic-gate }
28707c478bd9Sstevel@tonic-gate 
28717c478bd9Sstevel@tonic-gate int
28727c478bd9Sstevel@tonic-gate project_walk_step(mdb_walk_state_t *wsp)
28737c478bd9Sstevel@tonic-gate {
28747c478bd9Sstevel@tonic-gate 	uintptr_t addr = wsp->walk_addr;
28757c478bd9Sstevel@tonic-gate 	kproject_t pj;
28767c478bd9Sstevel@tonic-gate 	int status;
28777c478bd9Sstevel@tonic-gate 
28787c478bd9Sstevel@tonic-gate 	if (mdb_vread(&pj, sizeof (kproject_t), addr) == -1) {
28797c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read project at %p", addr);
28807c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
28817c478bd9Sstevel@tonic-gate 	}
28827c478bd9Sstevel@tonic-gate 	status = wsp->walk_callback(addr, &pj, wsp->walk_cbdata);
28837c478bd9Sstevel@tonic-gate 	if (status != WALK_NEXT)
28847c478bd9Sstevel@tonic-gate 		return (status);
28857c478bd9Sstevel@tonic-gate 	wsp->walk_addr = (uintptr_t)pj.kpj_next;
28867c478bd9Sstevel@tonic-gate 	if ((void *)wsp->walk_addr == wsp->walk_data)
28877c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
28887c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
28897c478bd9Sstevel@tonic-gate }
28907c478bd9Sstevel@tonic-gate 
28917c478bd9Sstevel@tonic-gate static int
28927c478bd9Sstevel@tonic-gate generic_walk_step(mdb_walk_state_t *wsp)
28937c478bd9Sstevel@tonic-gate {
28947c478bd9Sstevel@tonic-gate 	return (wsp->walk_callback(wsp->walk_addr, wsp->walk_layer,
28957c478bd9Sstevel@tonic-gate 	    wsp->walk_cbdata));
28967c478bd9Sstevel@tonic-gate }
28977c478bd9Sstevel@tonic-gate 
28987c478bd9Sstevel@tonic-gate static int
28997c478bd9Sstevel@tonic-gate cpu_walk_cmp(const void *l, const void *r)
29007c478bd9Sstevel@tonic-gate {
29017c478bd9Sstevel@tonic-gate 	uintptr_t lhs = *((uintptr_t *)l);
29027c478bd9Sstevel@tonic-gate 	uintptr_t rhs = *((uintptr_t *)r);
29037c478bd9Sstevel@tonic-gate 	cpu_t lcpu, rcpu;
29047c478bd9Sstevel@tonic-gate 
29057c478bd9Sstevel@tonic-gate 	(void) mdb_vread(&lcpu, sizeof (lcpu), lhs);
29067c478bd9Sstevel@tonic-gate 	(void) mdb_vread(&rcpu, sizeof (rcpu), rhs);
29077c478bd9Sstevel@tonic-gate 
29087c478bd9Sstevel@tonic-gate 	if (lcpu.cpu_id < rcpu.cpu_id)
29097c478bd9Sstevel@tonic-gate 		return (-1);
29107c478bd9Sstevel@tonic-gate 
29117c478bd9Sstevel@tonic-gate 	if (lcpu.cpu_id > rcpu.cpu_id)
29127c478bd9Sstevel@tonic-gate 		return (1);
29137c478bd9Sstevel@tonic-gate 
29147c478bd9Sstevel@tonic-gate 	return (0);
29157c478bd9Sstevel@tonic-gate }
29167c478bd9Sstevel@tonic-gate 
29177c478bd9Sstevel@tonic-gate typedef struct cpu_walk {
29187c478bd9Sstevel@tonic-gate 	uintptr_t *cw_array;
29197c478bd9Sstevel@tonic-gate 	int cw_ndx;
29207c478bd9Sstevel@tonic-gate } cpu_walk_t;
29217c478bd9Sstevel@tonic-gate 
29227c478bd9Sstevel@tonic-gate int
29237c478bd9Sstevel@tonic-gate cpu_walk_init(mdb_walk_state_t *wsp)
29247c478bd9Sstevel@tonic-gate {
29257c478bd9Sstevel@tonic-gate 	cpu_walk_t *cw;
29267c478bd9Sstevel@tonic-gate 	int max_ncpus, i = 0;
29277c478bd9Sstevel@tonic-gate 	uintptr_t current, first;
29287c478bd9Sstevel@tonic-gate 	cpu_t cpu, panic_cpu;
29297c478bd9Sstevel@tonic-gate 	uintptr_t panicstr, addr;
29307c478bd9Sstevel@tonic-gate 	GElf_Sym sym;
29317c478bd9Sstevel@tonic-gate 
29327c478bd9Sstevel@tonic-gate 	cw = mdb_zalloc(sizeof (cpu_walk_t), UM_SLEEP | UM_GC);
29337c478bd9Sstevel@tonic-gate 
29347c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&max_ncpus, "max_ncpus") == -1) {
29357c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read 'max_ncpus'");
29367c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
29377c478bd9Sstevel@tonic-gate 	}
29387c478bd9Sstevel@tonic-gate 
29397c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&panicstr, "panicstr") == -1) {
29407c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read 'panicstr'");
29417c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
29427c478bd9Sstevel@tonic-gate 	}
29437c478bd9Sstevel@tonic-gate 
2944*892ad162SToomas Soome 	if (panicstr != 0) {
29457c478bd9Sstevel@tonic-gate 		if (mdb_lookup_by_name("panic_cpu", &sym) == -1) {
29467c478bd9Sstevel@tonic-gate 			mdb_warn("failed to find 'panic_cpu'");
29477c478bd9Sstevel@tonic-gate 			return (WALK_ERR);
29487c478bd9Sstevel@tonic-gate 		}
29497c478bd9Sstevel@tonic-gate 
29507c478bd9Sstevel@tonic-gate 		addr = (uintptr_t)sym.st_value;
29517c478bd9Sstevel@tonic-gate 
29527c478bd9Sstevel@tonic-gate 		if (mdb_vread(&panic_cpu, sizeof (cpu_t), addr) == -1) {
29537c478bd9Sstevel@tonic-gate 			mdb_warn("failed to read 'panic_cpu'");
29547c478bd9Sstevel@tonic-gate 			return (WALK_ERR);
29557c478bd9Sstevel@tonic-gate 		}
29567c478bd9Sstevel@tonic-gate 	}
29577c478bd9Sstevel@tonic-gate 
29587c478bd9Sstevel@tonic-gate 	/*
29597c478bd9Sstevel@tonic-gate 	 * Unfortunately, there is no platform-independent way to walk
29607c478bd9Sstevel@tonic-gate 	 * CPUs in ID order.  We therefore loop through in cpu_next order,
29617c478bd9Sstevel@tonic-gate 	 * building an array of CPU pointers which will subsequently be
29627c478bd9Sstevel@tonic-gate 	 * sorted.
29637c478bd9Sstevel@tonic-gate 	 */
29647c478bd9Sstevel@tonic-gate 	cw->cw_array =
29657c478bd9Sstevel@tonic-gate 	    mdb_zalloc((max_ncpus + 1) * sizeof (uintptr_t), UM_SLEEP | UM_GC);
29667c478bd9Sstevel@tonic-gate 
29677c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&first, "cpu_list") == -1) {
29687c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read 'cpu_list'");
29697c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
29707c478bd9Sstevel@tonic-gate 	}
29717c478bd9Sstevel@tonic-gate 
29727c478bd9Sstevel@tonic-gate 	current = first;
29737c478bd9Sstevel@tonic-gate 	do {
29747c478bd9Sstevel@tonic-gate 		if (mdb_vread(&cpu, sizeof (cpu), current) == -1) {
29757c478bd9Sstevel@tonic-gate 			mdb_warn("failed to read cpu at %p", current);
29767c478bd9Sstevel@tonic-gate 			return (WALK_ERR);
29777c478bd9Sstevel@tonic-gate 		}
29787c478bd9Sstevel@tonic-gate 
2979*892ad162SToomas Soome 		if (panicstr != 0 && panic_cpu.cpu_id == cpu.cpu_id) {
29807c478bd9Sstevel@tonic-gate 			cw->cw_array[i++] = addr;
29817c478bd9Sstevel@tonic-gate 		} else {
29827c478bd9Sstevel@tonic-gate 			cw->cw_array[i++] = current;
29837c478bd9Sstevel@tonic-gate 		}
29847c478bd9Sstevel@tonic-gate 	} while ((current = (uintptr_t)cpu.cpu_next) != first);
29857c478bd9Sstevel@tonic-gate 
29867c478bd9Sstevel@tonic-gate 	qsort(cw->cw_array, i, sizeof (uintptr_t), cpu_walk_cmp);
29877c478bd9Sstevel@tonic-gate 	wsp->walk_data = cw;
29887c478bd9Sstevel@tonic-gate 
29897c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
29907c478bd9Sstevel@tonic-gate }
29917c478bd9Sstevel@tonic-gate 
29927c478bd9Sstevel@tonic-gate int
29937c478bd9Sstevel@tonic-gate cpu_walk_step(mdb_walk_state_t *wsp)
29947c478bd9Sstevel@tonic-gate {
29957c478bd9Sstevel@tonic-gate 	cpu_walk_t *cw = wsp->walk_data;
29967c478bd9Sstevel@tonic-gate 	cpu_t cpu;
29977c478bd9Sstevel@tonic-gate 	uintptr_t addr = cw->cw_array[cw->cw_ndx++];
29987c478bd9Sstevel@tonic-gate 
2999*892ad162SToomas Soome 	if (addr == 0)
30007c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
30017c478bd9Sstevel@tonic-gate 
30027c478bd9Sstevel@tonic-gate 	if (mdb_vread(&cpu, sizeof (cpu), addr) == -1) {
30037c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read cpu at %p", addr);
30047c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
30057c478bd9Sstevel@tonic-gate 	}
30067c478bd9Sstevel@tonic-gate 
30077c478bd9Sstevel@tonic-gate 	return (wsp->walk_callback(addr, &cpu, wsp->walk_cbdata));
30087c478bd9Sstevel@tonic-gate }
30097c478bd9Sstevel@tonic-gate 
30107c478bd9Sstevel@tonic-gate typedef struct cpuinfo_data {
30117c478bd9Sstevel@tonic-gate 	intptr_t cid_cpu;
30127c478bd9Sstevel@tonic-gate 	uintptr_t **cid_ithr;
30137c478bd9Sstevel@tonic-gate 	char	cid_print_head;
30147c478bd9Sstevel@tonic-gate 	char	cid_print_thr;
30157c478bd9Sstevel@tonic-gate 	char	cid_print_ithr;
30167c478bd9Sstevel@tonic-gate 	char	cid_print_flags;
30177c478bd9Sstevel@tonic-gate } cpuinfo_data_t;
30187c478bd9Sstevel@tonic-gate 
30197c478bd9Sstevel@tonic-gate int
30207c478bd9Sstevel@tonic-gate cpuinfo_walk_ithread(uintptr_t addr, const kthread_t *thr, cpuinfo_data_t *cid)
30217c478bd9Sstevel@tonic-gate {
30227c478bd9Sstevel@tonic-gate 	cpu_t c;
30237c478bd9Sstevel@tonic-gate 	int id;
30247c478bd9Sstevel@tonic-gate 	uint8_t pil;
30257c478bd9Sstevel@tonic-gate 
30267c478bd9Sstevel@tonic-gate 	if (!(thr->t_flag & T_INTR_THREAD) || thr->t_state == TS_FREE)
30277c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
30287c478bd9Sstevel@tonic-gate 
30297c478bd9Sstevel@tonic-gate 	if (thr->t_bound_cpu == NULL) {
30307c478bd9Sstevel@tonic-gate 		mdb_warn("thr %p is intr thread w/out a CPU\n", addr);
30317c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
30327c478bd9Sstevel@tonic-gate 	}
30337c478bd9Sstevel@tonic-gate 
30347c478bd9Sstevel@tonic-gate 	(void) mdb_vread(&c, sizeof (c), (uintptr_t)thr->t_bound_cpu);
30357c478bd9Sstevel@tonic-gate 
30367c478bd9Sstevel@tonic-gate 	if ((id = c.cpu_id) >= NCPU) {
30377c478bd9Sstevel@tonic-gate 		mdb_warn("CPU %p has id (%d) greater than NCPU (%d)\n",
30387c478bd9Sstevel@tonic-gate 		    thr->t_bound_cpu, id, NCPU);
30397c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
30407c478bd9Sstevel@tonic-gate 	}
30417c478bd9Sstevel@tonic-gate 
30427c478bd9Sstevel@tonic-gate 	if ((pil = thr->t_pil) >= NINTR) {
30437c478bd9Sstevel@tonic-gate 		mdb_warn("thread %p has pil (%d) greater than %d\n",
30447c478bd9Sstevel@tonic-gate 		    addr, pil, NINTR);
30457c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
30467c478bd9Sstevel@tonic-gate 	}
30477c478bd9Sstevel@tonic-gate 
3048*892ad162SToomas Soome 	if (cid->cid_ithr[id][pil] != 0) {
30497c478bd9Sstevel@tonic-gate 		mdb_warn("CPU %d has multiple threads at pil %d (at least "
30507c478bd9Sstevel@tonic-gate 		    "%p and %p)\n", id, pil, addr, cid->cid_ithr[id][pil]);
30517c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
30527c478bd9Sstevel@tonic-gate 	}
30537c478bd9Sstevel@tonic-gate 
30547c478bd9Sstevel@tonic-gate 	cid->cid_ithr[id][pil] = addr;
30557c478bd9Sstevel@tonic-gate 
30567c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
30577c478bd9Sstevel@tonic-gate }
30587c478bd9Sstevel@tonic-gate 
30597c478bd9Sstevel@tonic-gate #define	CPUINFO_IDWIDTH		3
30607c478bd9Sstevel@tonic-gate #define	CPUINFO_FLAGWIDTH	9
30617c478bd9Sstevel@tonic-gate 
30627c478bd9Sstevel@tonic-gate #ifdef _LP64
3063f5533078Smishra #if defined(__amd64)
3064f5533078Smishra #define	CPUINFO_TWIDTH		16
3065f5533078Smishra #define	CPUINFO_CPUWIDTH	16
3066f5533078Smishra #else
30677c478bd9Sstevel@tonic-gate #define	CPUINFO_CPUWIDTH	11
30687c478bd9Sstevel@tonic-gate #define	CPUINFO_TWIDTH		11
3069f5533078Smishra #endif
30707c478bd9Sstevel@tonic-gate #else
30717c478bd9Sstevel@tonic-gate #define	CPUINFO_CPUWIDTH	8
30727c478bd9Sstevel@tonic-gate #define	CPUINFO_TWIDTH		8
30737c478bd9Sstevel@tonic-gate #endif
30747c478bd9Sstevel@tonic-gate 
30757c478bd9Sstevel@tonic-gate #define	CPUINFO_THRDELT		(CPUINFO_IDWIDTH + CPUINFO_CPUWIDTH + 9)
30767c478bd9Sstevel@tonic-gate #define	CPUINFO_FLAGDELT	(CPUINFO_IDWIDTH + CPUINFO_CPUWIDTH + 4)
30777c478bd9Sstevel@tonic-gate #define	CPUINFO_ITHRDELT	4
30787c478bd9Sstevel@tonic-gate 
30797c478bd9Sstevel@tonic-gate #define	CPUINFO_INDENT	mdb_printf("%*s", CPUINFO_THRDELT, \
30807c478bd9Sstevel@tonic-gate     flagline < nflaglines ? flagbuf[flagline++] : "")
30817c478bd9Sstevel@tonic-gate 
308275cebdd1SRyan Zezeski typedef struct mdb_cpuinfo_proc {
308375cebdd1SRyan Zezeski 	struct {
308475cebdd1SRyan Zezeski 		char		u_comm[MAXCOMLEN + 1];
308575cebdd1SRyan Zezeski 	} p_user;
308675cebdd1SRyan Zezeski } mdb_cpuinfo_proc_t;
308775cebdd1SRyan Zezeski 
30887c478bd9Sstevel@tonic-gate int
30897c478bd9Sstevel@tonic-gate cpuinfo_walk_cpu(uintptr_t addr, const cpu_t *cpu, cpuinfo_data_t *cid)
30907c478bd9Sstevel@tonic-gate {
30917c478bd9Sstevel@tonic-gate 	kthread_t t;
30927c478bd9Sstevel@tonic-gate 	disp_t disp;
309375cebdd1SRyan Zezeski 	mdb_cpuinfo_proc_t p;
30947c478bd9Sstevel@tonic-gate 	uintptr_t pinned;
30957c478bd9Sstevel@tonic-gate 	char **flagbuf;
30967c478bd9Sstevel@tonic-gate 	int nflaglines = 0, flagline = 0, bspl, rval = WALK_NEXT;
30977c478bd9Sstevel@tonic-gate 
30987c478bd9Sstevel@tonic-gate 	const char *flags[] = {
30997c478bd9Sstevel@tonic-gate 	    "RUNNING", "READY", "QUIESCED", "EXISTS",
31007c478bd9Sstevel@tonic-gate 	    "ENABLE", "OFFLINE", "POWEROFF", "FROZEN",
31017c478bd9Sstevel@tonic-gate 	    "SPARE", "FAULTED", NULL
31027c478bd9Sstevel@tonic-gate 	};
31037c478bd9Sstevel@tonic-gate 
31047c478bd9Sstevel@tonic-gate 	if (cid->cid_cpu != -1) {
31057c478bd9Sstevel@tonic-gate 		if (addr != cid->cid_cpu && cpu->cpu_id != cid->cid_cpu)
31067c478bd9Sstevel@tonic-gate 			return (WALK_NEXT);
31077c478bd9Sstevel@tonic-gate 
31087c478bd9Sstevel@tonic-gate 		/*
31097c478bd9Sstevel@tonic-gate 		 * Set cid_cpu to -1 to indicate that we found a matching CPU.
31107c478bd9Sstevel@tonic-gate 		 */
31117c478bd9Sstevel@tonic-gate 		cid->cid_cpu = -1;
31127c478bd9Sstevel@tonic-gate 		rval = WALK_DONE;
31137c478bd9Sstevel@tonic-gate 	}
31147c478bd9Sstevel@tonic-gate 
31157c478bd9Sstevel@tonic-gate 	if (cid->cid_print_head) {
31167c478bd9Sstevel@tonic-gate 		mdb_printf("%3s %-*s %3s %4s %4s %3s %4s %5s %-6s %-*s %s\n",
31177c478bd9Sstevel@tonic-gate 		    "ID", CPUINFO_CPUWIDTH, "ADDR", "FLG", "NRUN", "BSPL",
31187c478bd9Sstevel@tonic-gate 		    "PRI", "RNRN", "KRNRN", "SWITCH", CPUINFO_TWIDTH, "THREAD",
31197c478bd9Sstevel@tonic-gate 		    "PROC");
31207c478bd9Sstevel@tonic-gate 		cid->cid_print_head = FALSE;
31217c478bd9Sstevel@tonic-gate 	}
31227c478bd9Sstevel@tonic-gate 
31237c478bd9Sstevel@tonic-gate 	bspl = cpu->cpu_base_spl;
31247c478bd9Sstevel@tonic-gate 
31257c478bd9Sstevel@tonic-gate 	if (mdb_vread(&disp, sizeof (disp_t), (uintptr_t)cpu->cpu_disp) == -1) {
31267c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read disp_t at %p", cpu->cpu_disp);
31277c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
31287c478bd9Sstevel@tonic-gate 	}
31297c478bd9Sstevel@tonic-gate 
31307c478bd9Sstevel@tonic-gate 	mdb_printf("%3d %0*p %3x %4d %4d ",
31317c478bd9Sstevel@tonic-gate 	    cpu->cpu_id, CPUINFO_CPUWIDTH, addr, cpu->cpu_flags,
31327c478bd9Sstevel@tonic-gate 	    disp.disp_nrunnable, bspl);
31337c478bd9Sstevel@tonic-gate 
31347c478bd9Sstevel@tonic-gate 	if (mdb_vread(&t, sizeof (t), (uintptr_t)cpu->cpu_thread) != -1) {
31357c478bd9Sstevel@tonic-gate 		mdb_printf("%3d ", t.t_pri);
31367c478bd9Sstevel@tonic-gate 	} else {
31377c478bd9Sstevel@tonic-gate 		mdb_printf("%3s ", "-");
31387c478bd9Sstevel@tonic-gate 	}
31397c478bd9Sstevel@tonic-gate 
31407c478bd9Sstevel@tonic-gate 	mdb_printf("%4s %5s ", cpu->cpu_runrun ? "yes" : "no",
31417c478bd9Sstevel@tonic-gate 	    cpu->cpu_kprunrun ? "yes" : "no");
31427c478bd9Sstevel@tonic-gate 
31437c478bd9Sstevel@tonic-gate 	if (cpu->cpu_last_swtch) {
3144d3d50737SRafael Vanoni 		mdb_printf("t-%-4d ",
3145d3d50737SRafael Vanoni 		    (clock_t)mdb_get_lbolt() - cpu->cpu_last_swtch);
31467c478bd9Sstevel@tonic-gate 	} else {
31477c478bd9Sstevel@tonic-gate 		mdb_printf("%-6s ", "-");
31487c478bd9Sstevel@tonic-gate 	}
31497c478bd9Sstevel@tonic-gate 
31507c478bd9Sstevel@tonic-gate 	mdb_printf("%0*p", CPUINFO_TWIDTH, cpu->cpu_thread);
31517c478bd9Sstevel@tonic-gate 
31527c478bd9Sstevel@tonic-gate 	if (cpu->cpu_thread == cpu->cpu_idle_thread)
31537c478bd9Sstevel@tonic-gate 		mdb_printf(" (idle)\n");
31547c478bd9Sstevel@tonic-gate 	else if (cpu->cpu_thread == NULL)
31557c478bd9Sstevel@tonic-gate 		mdb_printf(" -\n");
31567c478bd9Sstevel@tonic-gate 	else {
315775cebdd1SRyan Zezeski 		if (mdb_ctf_vread(&p, "proc_t", "mdb_cpuinfo_proc_t",
315875cebdd1SRyan Zezeski 		    (uintptr_t)t.t_procp, 0) != -1) {
31597c478bd9Sstevel@tonic-gate 			mdb_printf(" %s\n", p.p_user.u_comm);
31607c478bd9Sstevel@tonic-gate 		} else {
31617c478bd9Sstevel@tonic-gate 			mdb_printf(" ?\n");
31627c478bd9Sstevel@tonic-gate 		}
31637c478bd9Sstevel@tonic-gate 	}
31647c478bd9Sstevel@tonic-gate 
31657c478bd9Sstevel@tonic-gate 	flagbuf = mdb_zalloc(sizeof (flags), UM_SLEEP | UM_GC);
31667c478bd9Sstevel@tonic-gate 
31677c478bd9Sstevel@tonic-gate 	if (cid->cid_print_flags) {
31687c478bd9Sstevel@tonic-gate 		int first = 1, i, j, k;
31697c478bd9Sstevel@tonic-gate 		char *s;
31707c478bd9Sstevel@tonic-gate 
31717c478bd9Sstevel@tonic-gate 		cid->cid_print_head = TRUE;
31727c478bd9Sstevel@tonic-gate 
31737c478bd9Sstevel@tonic-gate 		for (i = 1, j = 0; flags[j] != NULL; i <<= 1, j++) {
31747c478bd9Sstevel@tonic-gate 			if (!(cpu->cpu_flags & i))
31757c478bd9Sstevel@tonic-gate 				continue;
31767c478bd9Sstevel@tonic-gate 
31777c478bd9Sstevel@tonic-gate 			if (first) {
31787c478bd9Sstevel@tonic-gate 				s = mdb_alloc(CPUINFO_THRDELT + 1,
31797c478bd9Sstevel@tonic-gate 				    UM_GC | UM_SLEEP);
31807c478bd9Sstevel@tonic-gate 
31817c478bd9Sstevel@tonic-gate 				(void) mdb_snprintf(s, CPUINFO_THRDELT + 1,
31827c478bd9Sstevel@tonic-gate 				    "%*s|%*s", CPUINFO_FLAGDELT, "",
31837c478bd9Sstevel@tonic-gate 				    CPUINFO_THRDELT - 1 - CPUINFO_FLAGDELT, "");
31847c478bd9Sstevel@tonic-gate 				flagbuf[nflaglines++] = s;
31857c478bd9Sstevel@tonic-gate 			}
31867c478bd9Sstevel@tonic-gate 
31877c478bd9Sstevel@tonic-gate 			s = mdb_alloc(CPUINFO_THRDELT + 1, UM_GC | UM_SLEEP);
31887c478bd9Sstevel@tonic-gate 			(void) mdb_snprintf(s, CPUINFO_THRDELT + 1, "%*s%*s %s",
31897c478bd9Sstevel@tonic-gate 			    CPUINFO_IDWIDTH + CPUINFO_CPUWIDTH -
31907c478bd9Sstevel@tonic-gate 			    CPUINFO_FLAGWIDTH, "", CPUINFO_FLAGWIDTH, flags[j],
31917c478bd9Sstevel@tonic-gate 			    first ? "<--+" : "");
31927c478bd9Sstevel@tonic-gate 
31937c478bd9Sstevel@tonic-gate 			for (k = strlen(s); k < CPUINFO_THRDELT; k++)
31947c478bd9Sstevel@tonic-gate 				s[k] = ' ';
31957c478bd9Sstevel@tonic-gate 			s[k] = '\0';
31967c478bd9Sstevel@tonic-gate 
31977c478bd9Sstevel@tonic-gate 			flagbuf[nflaglines++] = s;
31987c478bd9Sstevel@tonic-gate 			first = 0;
31997c478bd9Sstevel@tonic-gate 		}
32007c478bd9Sstevel@tonic-gate 	}
32017c478bd9Sstevel@tonic-gate 
32027c478bd9Sstevel@tonic-gate 	if (cid->cid_print_ithr) {
32037c478bd9Sstevel@tonic-gate 		int i, found_one = FALSE;
32047c478bd9Sstevel@tonic-gate 		int print_thr = disp.disp_nrunnable && cid->cid_print_thr;
32057c478bd9Sstevel@tonic-gate 
32067c478bd9Sstevel@tonic-gate 		for (i = NINTR - 1; i >= 0; i--) {
32077c478bd9Sstevel@tonic-gate 			uintptr_t iaddr = cid->cid_ithr[cpu->cpu_id][i];
32087c478bd9Sstevel@tonic-gate 
3209*892ad162SToomas Soome 			if (iaddr == 0)
32107c478bd9Sstevel@tonic-gate 				continue;
32117c478bd9Sstevel@tonic-gate 
32127c478bd9Sstevel@tonic-gate 			if (!found_one) {
32137c478bd9Sstevel@tonic-gate 				found_one = TRUE;
32147c478bd9Sstevel@tonic-gate 
32157c478bd9Sstevel@tonic-gate 				CPUINFO_INDENT;
32167c478bd9Sstevel@tonic-gate 				mdb_printf("%c%*s|\n", print_thr ? '|' : ' ',
32177c478bd9Sstevel@tonic-gate 				    CPUINFO_ITHRDELT, "");
32187c478bd9Sstevel@tonic-gate 
32197c478bd9Sstevel@tonic-gate 				CPUINFO_INDENT;
32207c478bd9Sstevel@tonic-gate 				mdb_printf("%c%*s+--> %3s %s\n",
32217c478bd9Sstevel@tonic-gate 				    print_thr ? '|' : ' ', CPUINFO_ITHRDELT,
32227c478bd9Sstevel@tonic-gate 				    "", "PIL", "THREAD");
32237c478bd9Sstevel@tonic-gate 			}
32247c478bd9Sstevel@tonic-gate 
32257c478bd9Sstevel@tonic-gate 			if (mdb_vread(&t, sizeof (t), iaddr) == -1) {
32267c478bd9Sstevel@tonic-gate 				mdb_warn("failed to read kthread_t at %p",
32277c478bd9Sstevel@tonic-gate 				    iaddr);
32287c478bd9Sstevel@tonic-gate 				return (WALK_ERR);
32297c478bd9Sstevel@tonic-gate 			}
32307c478bd9Sstevel@tonic-gate 
32317c478bd9Sstevel@tonic-gate 			CPUINFO_INDENT;
32327c478bd9Sstevel@tonic-gate 			mdb_printf("%c%*s     %3d %0*p\n",
32337c478bd9Sstevel@tonic-gate 			    print_thr ? '|' : ' ', CPUINFO_ITHRDELT, "",
32347c478bd9Sstevel@tonic-gate 			    t.t_pil, CPUINFO_TWIDTH, iaddr);
32357c478bd9Sstevel@tonic-gate 
32367c478bd9Sstevel@tonic-gate 			pinned = (uintptr_t)t.t_intr;
32377c478bd9Sstevel@tonic-gate 		}
32387c478bd9Sstevel@tonic-gate 
3239*892ad162SToomas Soome 		if (found_one && pinned != 0) {
32407c478bd9Sstevel@tonic-gate 			cid->cid_print_head = TRUE;
32417c478bd9Sstevel@tonic-gate 			(void) strcpy(p.p_user.u_comm, "?");
32427c478bd9Sstevel@tonic-gate 
32437c478bd9Sstevel@tonic-gate 			if (mdb_vread(&t, sizeof (t),
32447c478bd9Sstevel@tonic-gate 			    (uintptr_t)pinned) == -1) {
32457c478bd9Sstevel@tonic-gate 				mdb_warn("failed to read kthread_t at %p",
32467c478bd9Sstevel@tonic-gate 				    pinned);
32477c478bd9Sstevel@tonic-gate 				return (WALK_ERR);
32487c478bd9Sstevel@tonic-gate 			}
324975cebdd1SRyan Zezeski 			if (mdb_ctf_vread(&p, "proc_t", "mdb_cpuinfo_proc_t",
325075cebdd1SRyan Zezeski 			    (uintptr_t)t.t_procp, 0) == -1) {
32517c478bd9Sstevel@tonic-gate 				mdb_warn("failed to read proc_t at %p",
32527c478bd9Sstevel@tonic-gate 				    t.t_procp);
32537c478bd9Sstevel@tonic-gate 				return (WALK_ERR);
32547c478bd9Sstevel@tonic-gate 			}
32557c478bd9Sstevel@tonic-gate 
32567c478bd9Sstevel@tonic-gate 			CPUINFO_INDENT;
32577c478bd9Sstevel@tonic-gate 			mdb_printf("%c%*s     %3s %0*p %s\n",
32587c478bd9Sstevel@tonic-gate 			    print_thr ? '|' : ' ', CPUINFO_ITHRDELT, "", "-",
32597c478bd9Sstevel@tonic-gate 			    CPUINFO_TWIDTH, pinned,
32607c478bd9Sstevel@tonic-gate 			    pinned == (uintptr_t)cpu->cpu_idle_thread ?
32617c478bd9Sstevel@tonic-gate 			    "(idle)" : p.p_user.u_comm);
32627c478bd9Sstevel@tonic-gate 		}
32637c478bd9Sstevel@tonic-gate 	}
32647c478bd9Sstevel@tonic-gate 
32657c478bd9Sstevel@tonic-gate 	if (disp.disp_nrunnable && cid->cid_print_thr) {
32667c478bd9Sstevel@tonic-gate 		dispq_t *dq;
32677c478bd9Sstevel@tonic-gate 
32687c478bd9Sstevel@tonic-gate 		int i, npri = disp.disp_npri;
32697c478bd9Sstevel@tonic-gate 
32707c478bd9Sstevel@tonic-gate 		dq = mdb_alloc(sizeof (dispq_t) * npri, UM_SLEEP | UM_GC);
32717c478bd9Sstevel@tonic-gate 
32727c478bd9Sstevel@tonic-gate 		if (mdb_vread(dq, sizeof (dispq_t) * npri,
32737c478bd9Sstevel@tonic-gate 		    (uintptr_t)disp.disp_q) == -1) {
32747c478bd9Sstevel@tonic-gate 			mdb_warn("failed to read dispq_t at %p", disp.disp_q);
32757c478bd9Sstevel@tonic-gate 			return (WALK_ERR);
32767c478bd9Sstevel@tonic-gate 		}
32777c478bd9Sstevel@tonic-gate 
32787c478bd9Sstevel@tonic-gate 		CPUINFO_INDENT;
32797c478bd9Sstevel@tonic-gate 		mdb_printf("|\n");
32807c478bd9Sstevel@tonic-gate 
32817c478bd9Sstevel@tonic-gate 		CPUINFO_INDENT;
32827c478bd9Sstevel@tonic-gate 		mdb_printf("+-->  %3s %-*s %s\n", "PRI",
32837c478bd9Sstevel@tonic-gate 		    CPUINFO_TWIDTH, "THREAD", "PROC");
32847c478bd9Sstevel@tonic-gate 
32857c478bd9Sstevel@tonic-gate 		for (i = npri - 1; i >= 0; i--) {
32867c478bd9Sstevel@tonic-gate 			uintptr_t taddr = (uintptr_t)dq[i].dq_first;
32877c478bd9Sstevel@tonic-gate 
3288*892ad162SToomas Soome 			while (taddr != 0) {
32897c478bd9Sstevel@tonic-gate 				if (mdb_vread(&t, sizeof (t), taddr) == -1) {
32907c478bd9Sstevel@tonic-gate 					mdb_warn("failed to read kthread_t "
32917c478bd9Sstevel@tonic-gate 					    "at %p", taddr);
32927c478bd9Sstevel@tonic-gate 					return (WALK_ERR);
32937c478bd9Sstevel@tonic-gate 				}
329475cebdd1SRyan Zezeski 				if (mdb_ctf_vread(&p, "proc_t",
329575cebdd1SRyan Zezeski 				    "mdb_cpuinfo_proc_t",
329675cebdd1SRyan Zezeski 				    (uintptr_t)t.t_procp, 0) == -1) {
32977c478bd9Sstevel@tonic-gate 					mdb_warn("failed to read proc_t at %p",
32987c478bd9Sstevel@tonic-gate 					    t.t_procp);
32997c478bd9Sstevel@tonic-gate 					return (WALK_ERR);
33007c478bd9Sstevel@tonic-gate 				}
33017c478bd9Sstevel@tonic-gate 
33027c478bd9Sstevel@tonic-gate 				CPUINFO_INDENT;
33037c478bd9Sstevel@tonic-gate 				mdb_printf("      %3d %0*p %s\n", t.t_pri,
33047c478bd9Sstevel@tonic-gate 				    CPUINFO_TWIDTH, taddr, p.p_user.u_comm);
33057c478bd9Sstevel@tonic-gate 
33067c478bd9Sstevel@tonic-gate 				taddr = (uintptr_t)t.t_link;
33077c478bd9Sstevel@tonic-gate 			}
33087c478bd9Sstevel@tonic-gate 		}
33097c478bd9Sstevel@tonic-gate 		cid->cid_print_head = TRUE;
33107c478bd9Sstevel@tonic-gate 	}
33117c478bd9Sstevel@tonic-gate 
33127c478bd9Sstevel@tonic-gate 	while (flagline < nflaglines)
33137c478bd9Sstevel@tonic-gate 		mdb_printf("%s\n", flagbuf[flagline++]);
33147c478bd9Sstevel@tonic-gate 
33157c478bd9Sstevel@tonic-gate 	if (cid->cid_print_head)
33167c478bd9Sstevel@tonic-gate 		mdb_printf("\n");
33177c478bd9Sstevel@tonic-gate 
33187c478bd9Sstevel@tonic-gate 	return (rval);
33197c478bd9Sstevel@tonic-gate }
33207c478bd9Sstevel@tonic-gate 
33217c478bd9Sstevel@tonic-gate int
33227c478bd9Sstevel@tonic-gate cpuinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
33237c478bd9Sstevel@tonic-gate {
33247c478bd9Sstevel@tonic-gate 	uint_t verbose = FALSE;
33257c478bd9Sstevel@tonic-gate 	cpuinfo_data_t cid;
33267c478bd9Sstevel@tonic-gate 
33277c478bd9Sstevel@tonic-gate 	cid.cid_print_ithr = FALSE;
33287c478bd9Sstevel@tonic-gate 	cid.cid_print_thr = FALSE;
33297c478bd9Sstevel@tonic-gate 	cid.cid_print_flags = FALSE;
33307c478bd9Sstevel@tonic-gate 	cid.cid_print_head = DCMD_HDRSPEC(flags) ? TRUE : FALSE;
33317c478bd9Sstevel@tonic-gate 	cid.cid_cpu = -1;
33327c478bd9Sstevel@tonic-gate 
33337c478bd9Sstevel@tonic-gate 	if (flags & DCMD_ADDRSPEC)
33347c478bd9Sstevel@tonic-gate 		cid.cid_cpu = addr;
33357c478bd9Sstevel@tonic-gate 
33367c478bd9Sstevel@tonic-gate 	if (mdb_getopts(argc, argv,
33377c478bd9Sstevel@tonic-gate 	    'v', MDB_OPT_SETBITS, TRUE, &verbose, NULL) != argc)
33387c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
33397c478bd9Sstevel@tonic-gate 
33407c478bd9Sstevel@tonic-gate 	if (verbose) {
33417c478bd9Sstevel@tonic-gate 		cid.cid_print_ithr = TRUE;
33427c478bd9Sstevel@tonic-gate 		cid.cid_print_thr = TRUE;
33437c478bd9Sstevel@tonic-gate 		cid.cid_print_flags = TRUE;
33447c478bd9Sstevel@tonic-gate 		cid.cid_print_head = TRUE;
33457c478bd9Sstevel@tonic-gate 	}
33467c478bd9Sstevel@tonic-gate 
33477c478bd9Sstevel@tonic-gate 	if (cid.cid_print_ithr) {
33487c478bd9Sstevel@tonic-gate 		int i;
33497c478bd9Sstevel@tonic-gate 
33507c478bd9Sstevel@tonic-gate 		cid.cid_ithr = mdb_alloc(sizeof (uintptr_t **)
33517c478bd9Sstevel@tonic-gate 		    * NCPU, UM_SLEEP | UM_GC);
33527c478bd9Sstevel@tonic-gate 
33537c478bd9Sstevel@tonic-gate 		for (i = 0; i < NCPU; i++)
33547c478bd9Sstevel@tonic-gate 			cid.cid_ithr[i] = mdb_zalloc(sizeof (uintptr_t *) *
33557c478bd9Sstevel@tonic-gate 			    NINTR, UM_SLEEP | UM_GC);
33567c478bd9Sstevel@tonic-gate 
33577c478bd9Sstevel@tonic-gate 		if (mdb_walk("thread", (mdb_walk_cb_t)cpuinfo_walk_ithread,
33587c478bd9Sstevel@tonic-gate 		    &cid) == -1) {
33597c478bd9Sstevel@tonic-gate 			mdb_warn("couldn't walk thread");
33607c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
33617c478bd9Sstevel@tonic-gate 		}
33627c478bd9Sstevel@tonic-gate 	}
33637c478bd9Sstevel@tonic-gate 
33647c478bd9Sstevel@tonic-gate 	if (mdb_walk("cpu", (mdb_walk_cb_t)cpuinfo_walk_cpu, &cid) == -1) {
33657c478bd9Sstevel@tonic-gate 		mdb_warn("can't walk cpus");
33667c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
33677c478bd9Sstevel@tonic-gate 	}
33687c478bd9Sstevel@tonic-gate 
33697c478bd9Sstevel@tonic-gate 	if (cid.cid_cpu != -1) {
33707c478bd9Sstevel@tonic-gate 		/*
33717c478bd9Sstevel@tonic-gate 		 * We didn't find this CPU when we walked through the CPUs
33727c478bd9Sstevel@tonic-gate 		 * (i.e. the address specified doesn't show up in the "cpu"
33737c478bd9Sstevel@tonic-gate 		 * walk).  However, the specified address may still correspond
33747c478bd9Sstevel@tonic-gate 		 * to a valid cpu_t (for example, if the specified address is
33757c478bd9Sstevel@tonic-gate 		 * the actual panicking cpu_t and not the cached panic_cpu).
33767c478bd9Sstevel@tonic-gate 		 * Point is:  even if we didn't find it, we still want to try
33777c478bd9Sstevel@tonic-gate 		 * to print the specified address as a cpu_t.
33787c478bd9Sstevel@tonic-gate 		 */
33797c478bd9Sstevel@tonic-gate 		cpu_t cpu;
33807c478bd9Sstevel@tonic-gate 
33817c478bd9Sstevel@tonic-gate 		if (mdb_vread(&cpu, sizeof (cpu), cid.cid_cpu) == -1) {
33827c478bd9Sstevel@tonic-gate 			mdb_warn("%p is neither a valid CPU ID nor a "
33837c478bd9Sstevel@tonic-gate 			    "valid cpu_t address\n", cid.cid_cpu);
33847c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
33857c478bd9Sstevel@tonic-gate 		}
33867c478bd9Sstevel@tonic-gate 
33877c478bd9Sstevel@tonic-gate 		(void) cpuinfo_walk_cpu(cid.cid_cpu, &cpu, &cid);
33887c478bd9Sstevel@tonic-gate 	}
33897c478bd9Sstevel@tonic-gate 
33907c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
33917c478bd9Sstevel@tonic-gate }
33927c478bd9Sstevel@tonic-gate 
33937c478bd9Sstevel@tonic-gate /*ARGSUSED*/
33947c478bd9Sstevel@tonic-gate int
33957c478bd9Sstevel@tonic-gate flipone(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
33967c478bd9Sstevel@tonic-gate {
33977c478bd9Sstevel@tonic-gate 	int i;
33987c478bd9Sstevel@tonic-gate 
33997c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC))
34007c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
34017c478bd9Sstevel@tonic-gate 
34027c478bd9Sstevel@tonic-gate 	for (i = 0; i < sizeof (addr) * NBBY; i++)
34037c478bd9Sstevel@tonic-gate 		mdb_printf("%p\n", addr ^ (1UL << i));
34047c478bd9Sstevel@tonic-gate 
34057c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
34067c478bd9Sstevel@tonic-gate }
34077c478bd9Sstevel@tonic-gate 
340875cebdd1SRyan Zezeski typedef struct mdb_as2proc_proc {
340975cebdd1SRyan Zezeski 	struct as *p_as;
341075cebdd1SRyan Zezeski } mdb_as2proc_proc_t;
341175cebdd1SRyan Zezeski 
341275cebdd1SRyan Zezeski /*ARGSUSED*/
34137c478bd9Sstevel@tonic-gate int
341475cebdd1SRyan Zezeski as2proc_walk(uintptr_t addr, const void *ignored, struct as **asp)
34157c478bd9Sstevel@tonic-gate {
341675cebdd1SRyan Zezeski 	mdb_as2proc_proc_t p;
341775cebdd1SRyan Zezeski 
341875cebdd1SRyan Zezeski 	mdb_ctf_vread(&p, "proc_t", "mdb_as2proc_proc_t", addr, 0);
341975cebdd1SRyan Zezeski 
342075cebdd1SRyan Zezeski 	if (p.p_as == *asp)
34217c478bd9Sstevel@tonic-gate 		mdb_printf("%p\n", addr);
34227c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
34237c478bd9Sstevel@tonic-gate }
34247c478bd9Sstevel@tonic-gate 
34257c478bd9Sstevel@tonic-gate /*ARGSUSED*/
34267c478bd9Sstevel@tonic-gate int
34277c478bd9Sstevel@tonic-gate as2proc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
34287c478bd9Sstevel@tonic-gate {
34297c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC) || argc != 0)
34307c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
34317c478bd9Sstevel@tonic-gate 
34327c478bd9Sstevel@tonic-gate 	if (mdb_walk("proc", (mdb_walk_cb_t)as2proc_walk, &addr) == -1) {
34337c478bd9Sstevel@tonic-gate 		mdb_warn("failed to walk proc");
34347c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
34357c478bd9Sstevel@tonic-gate 	}
34367c478bd9Sstevel@tonic-gate 
34377c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
34387c478bd9Sstevel@tonic-gate }
34397c478bd9Sstevel@tonic-gate 
344075cebdd1SRyan Zezeski typedef struct mdb_ptree_proc {
344175cebdd1SRyan Zezeski 	struct proc	*p_parent;
344275cebdd1SRyan Zezeski 	struct {
344375cebdd1SRyan Zezeski 		char		u_comm[MAXCOMLEN + 1];
344475cebdd1SRyan Zezeski 	} p_user;
344575cebdd1SRyan Zezeski } mdb_ptree_proc_t;
344675cebdd1SRyan Zezeski 
34477c478bd9Sstevel@tonic-gate /*ARGSUSED*/
34487c478bd9Sstevel@tonic-gate int
344975cebdd1SRyan Zezeski ptree_walk(uintptr_t addr, const void *ignored, void *data)
34507c478bd9Sstevel@tonic-gate {
345175cebdd1SRyan Zezeski 	mdb_ptree_proc_t proc;
345275cebdd1SRyan Zezeski 	mdb_ptree_proc_t parent;
34537c478bd9Sstevel@tonic-gate 	int ident = 0;
34547c478bd9Sstevel@tonic-gate 	uintptr_t paddr;
34557c478bd9Sstevel@tonic-gate 
345675cebdd1SRyan Zezeski 	mdb_ctf_vread(&proc, "proc_t", "mdb_ptree_proc_t", addr, 0);
345775cebdd1SRyan Zezeski 
3458*892ad162SToomas Soome 	for (paddr = (uintptr_t)proc.p_parent; paddr != 0; ident += 5) {
345975cebdd1SRyan Zezeski 		mdb_ctf_vread(&parent, "proc_t", "mdb_ptree_proc_t", paddr, 0);
34607c478bd9Sstevel@tonic-gate 		paddr = (uintptr_t)parent.p_parent;
34617c478bd9Sstevel@tonic-gate 	}
34627c478bd9Sstevel@tonic-gate 
34637c478bd9Sstevel@tonic-gate 	mdb_inc_indent(ident);
346475cebdd1SRyan Zezeski 	mdb_printf("%0?p  %s\n", addr, proc.p_user.u_comm);
34657c478bd9Sstevel@tonic-gate 	mdb_dec_indent(ident);
34667c478bd9Sstevel@tonic-gate 
34677c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
34687c478bd9Sstevel@tonic-gate }
34697c478bd9Sstevel@tonic-gate 
34707c478bd9Sstevel@tonic-gate void
34717c478bd9Sstevel@tonic-gate ptree_ancestors(uintptr_t addr, uintptr_t start)
34727c478bd9Sstevel@tonic-gate {
347375cebdd1SRyan Zezeski 	mdb_ptree_proc_t p;
34747c478bd9Sstevel@tonic-gate 
347575cebdd1SRyan Zezeski 	if (mdb_ctf_vread(&p, "proc_t", "mdb_ptree_proc_t", addr, 0) == -1) {
34767c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't read ancestor at %p", addr);
34777c478bd9Sstevel@tonic-gate 		return;
34787c478bd9Sstevel@tonic-gate 	}
34797c478bd9Sstevel@tonic-gate 
34807c478bd9Sstevel@tonic-gate 	if (p.p_parent != NULL)
34817c478bd9Sstevel@tonic-gate 		ptree_ancestors((uintptr_t)p.p_parent, start);
34827c478bd9Sstevel@tonic-gate 
34837c478bd9Sstevel@tonic-gate 	if (addr != start)
34847c478bd9Sstevel@tonic-gate 		(void) ptree_walk(addr, &p, NULL);
34857c478bd9Sstevel@tonic-gate }
34867c478bd9Sstevel@tonic-gate 
34877c478bd9Sstevel@tonic-gate /*ARGSUSED*/
34887c478bd9Sstevel@tonic-gate int
34897c478bd9Sstevel@tonic-gate ptree(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
34907c478bd9Sstevel@tonic-gate {
34917c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC))
3492*892ad162SToomas Soome 		addr = 0;
34937c478bd9Sstevel@tonic-gate 	else
34947c478bd9Sstevel@tonic-gate 		ptree_ancestors(addr, addr);
34957c478bd9Sstevel@tonic-gate 
34967c478bd9Sstevel@tonic-gate 	if (mdb_pwalk("proc", (mdb_walk_cb_t)ptree_walk, NULL, addr) == -1) {
34977c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't walk 'proc'");
34987c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
34997c478bd9Sstevel@tonic-gate 	}
35007c478bd9Sstevel@tonic-gate 
35017c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
35027c478bd9Sstevel@tonic-gate }
35037c478bd9Sstevel@tonic-gate 
350475cebdd1SRyan Zezeski typedef struct mdb_fd_proc {
350575cebdd1SRyan Zezeski 	struct {
350675cebdd1SRyan Zezeski 		struct {
350775cebdd1SRyan Zezeski 			int			fi_nfiles;
350875cebdd1SRyan Zezeski 			uf_entry_t *volatile	fi_list;
350975cebdd1SRyan Zezeski 		} u_finfo;
351075cebdd1SRyan Zezeski 	} p_user;
351175cebdd1SRyan Zezeski } mdb_fd_proc_t;
351275cebdd1SRyan Zezeski 
35137c478bd9Sstevel@tonic-gate /*ARGSUSED*/
35147c478bd9Sstevel@tonic-gate static int
35157c478bd9Sstevel@tonic-gate fd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
35167c478bd9Sstevel@tonic-gate {
35177c478bd9Sstevel@tonic-gate 	int fdnum;
35187c478bd9Sstevel@tonic-gate 	const mdb_arg_t *argp = &argv[0];
351975cebdd1SRyan Zezeski 	mdb_fd_proc_t p;
35207c478bd9Sstevel@tonic-gate 	uf_entry_t uf;
35217c478bd9Sstevel@tonic-gate 
35227c478bd9Sstevel@tonic-gate 	if ((flags & DCMD_ADDRSPEC) == 0) {
35237c478bd9Sstevel@tonic-gate 		mdb_warn("fd doesn't give global information\n");
35247c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
35257c478bd9Sstevel@tonic-gate 	}
35267c478bd9Sstevel@tonic-gate 	if (argc != 1)
35277c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
35287c478bd9Sstevel@tonic-gate 
35297c478bd9Sstevel@tonic-gate 	if (argp->a_type == MDB_TYPE_IMMEDIATE)
35307c478bd9Sstevel@tonic-gate 		fdnum = argp->a_un.a_val;
35317c478bd9Sstevel@tonic-gate 	else
35327c478bd9Sstevel@tonic-gate 		fdnum = mdb_strtoull(argp->a_un.a_str);
35337c478bd9Sstevel@tonic-gate 
353475cebdd1SRyan Zezeski 	if (mdb_ctf_vread(&p, "proc_t", "mdb_fd_proc_t", addr, 0) == -1) {
35357c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't read proc_t at %p", addr);
35367c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
35377c478bd9Sstevel@tonic-gate 	}
35387c478bd9Sstevel@tonic-gate 	if (fdnum > p.p_user.u_finfo.fi_nfiles) {
35397c478bd9Sstevel@tonic-gate 		mdb_warn("process %p only has %d files open.\n",
35407c478bd9Sstevel@tonic-gate 		    addr, p.p_user.u_finfo.fi_nfiles);
35417c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
35427c478bd9Sstevel@tonic-gate 	}
35437c478bd9Sstevel@tonic-gate 	if (mdb_vread(&uf, sizeof (uf_entry_t),
35447c478bd9Sstevel@tonic-gate 	    (uintptr_t)&p.p_user.u_finfo.fi_list[fdnum]) == -1) {
35457c478bd9Sstevel@tonic-gate 		mdb_warn("couldn't read uf_entry_t at %p",
35467c478bd9Sstevel@tonic-gate 		    &p.p_user.u_finfo.fi_list[fdnum]);
35477c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
35487c478bd9Sstevel@tonic-gate 	}
35497c478bd9Sstevel@tonic-gate 
35507c478bd9Sstevel@tonic-gate 	mdb_printf("%p\n", uf.uf_file);
35517c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
35527c478bd9Sstevel@tonic-gate }
35537c478bd9Sstevel@tonic-gate 
35547c478bd9Sstevel@tonic-gate /*ARGSUSED*/
35557c478bd9Sstevel@tonic-gate static int
35567c478bd9Sstevel@tonic-gate pid2proc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
35577c478bd9Sstevel@tonic-gate {
35587c478bd9Sstevel@tonic-gate 	pid_t pid = (pid_t)addr;
35597c478bd9Sstevel@tonic-gate 
35607c478bd9Sstevel@tonic-gate 	if (argc != 0)
35617c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
35627c478bd9Sstevel@tonic-gate 
356375cebdd1SRyan Zezeski 	if ((addr = mdb_pid2proc(pid, NULL)) == 0) {
35647c478bd9Sstevel@tonic-gate 		mdb_warn("PID 0t%d not found\n", pid);
35657c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
35667c478bd9Sstevel@tonic-gate 	}
35677c478bd9Sstevel@tonic-gate 
35687c478bd9Sstevel@tonic-gate 	mdb_printf("%p\n", addr);
35697c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
35707c478bd9Sstevel@tonic-gate }
35717c478bd9Sstevel@tonic-gate 
35727c478bd9Sstevel@tonic-gate static char *sysfile_cmd[] = {
35737c478bd9Sstevel@tonic-gate 	"exclude:",
35747c478bd9Sstevel@tonic-gate 	"include:",
35757c478bd9Sstevel@tonic-gate 	"forceload:",
35767c478bd9Sstevel@tonic-gate 	"rootdev:",
35777c478bd9Sstevel@tonic-gate 	"rootfs:",
35787c478bd9Sstevel@tonic-gate 	"swapdev:",
35797c478bd9Sstevel@tonic-gate 	"swapfs:",
35807c478bd9Sstevel@tonic-gate 	"moddir:",
35817c478bd9Sstevel@tonic-gate 	"set",
35827c478bd9Sstevel@tonic-gate 	"unknown",
35837c478bd9Sstevel@tonic-gate };
35847c478bd9Sstevel@tonic-gate 
35857c478bd9Sstevel@tonic-gate static char *sysfile_ops[] = { "", "=", "&", "|" };
35867c478bd9Sstevel@tonic-gate 
35877c478bd9Sstevel@tonic-gate /*ARGSUSED*/
35887c478bd9Sstevel@tonic-gate static int
35897c478bd9Sstevel@tonic-gate sysfile_vmem_seg(uintptr_t addr, const vmem_seg_t *vsp, void **target)
35907c478bd9Sstevel@tonic-gate {
35917c478bd9Sstevel@tonic-gate 	if (vsp->vs_type == VMEM_ALLOC && (void *)vsp->vs_start == *target) {
35927c478bd9Sstevel@tonic-gate 		*target = NULL;
35937c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
35947c478bd9Sstevel@tonic-gate 	}
35957c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
35967c478bd9Sstevel@tonic-gate }
35977c478bd9Sstevel@tonic-gate 
35987c478bd9Sstevel@tonic-gate /*ARGSUSED*/
35997c478bd9Sstevel@tonic-gate static int
36007c478bd9Sstevel@tonic-gate sysfile(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
36017c478bd9Sstevel@tonic-gate {
36027c478bd9Sstevel@tonic-gate 	struct sysparam *sysp, sys;
36037c478bd9Sstevel@tonic-gate 	char var[256];
36047c478bd9Sstevel@tonic-gate 	char modname[256];
36057c478bd9Sstevel@tonic-gate 	char val[256];
36067c478bd9Sstevel@tonic-gate 	char strval[256];
36077c478bd9Sstevel@tonic-gate 	vmem_t *mod_sysfile_arena;
36087c478bd9Sstevel@tonic-gate 	void *straddr;
36097c478bd9Sstevel@tonic-gate 
36107c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&sysp, "sysparam_hd") == -1) {
36117c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read sysparam_hd");
36127c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
36137c478bd9Sstevel@tonic-gate 	}
36147c478bd9Sstevel@tonic-gate 
36157c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&mod_sysfile_arena, "mod_sysfile_arena") == -1) {
36167c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read mod_sysfile_arena");
36177c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
36187c478bd9Sstevel@tonic-gate 	}
36197c478bd9Sstevel@tonic-gate 
36207c478bd9Sstevel@tonic-gate 	while (sysp != NULL) {
36217c478bd9Sstevel@tonic-gate 		var[0] = '\0';
36227c478bd9Sstevel@tonic-gate 		val[0] = '\0';
36237c478bd9Sstevel@tonic-gate 		modname[0] = '\0';
36247c478bd9Sstevel@tonic-gate 		if (mdb_vread(&sys, sizeof (sys), (uintptr_t)sysp) == -1) {
36257c478bd9Sstevel@tonic-gate 			mdb_warn("couldn't read sysparam %p", sysp);
36267c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
36277c478bd9Sstevel@tonic-gate 		}
36287c478bd9Sstevel@tonic-gate 		if (sys.sys_modnam != NULL &&
36297c478bd9Sstevel@tonic-gate 		    mdb_readstr(modname, 256,
36307c478bd9Sstevel@tonic-gate 		    (uintptr_t)sys.sys_modnam) == -1) {
36317c478bd9Sstevel@tonic-gate 			mdb_warn("couldn't read modname in %p", sysp);
36327c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
36337c478bd9Sstevel@tonic-gate 		}
36347c478bd9Sstevel@tonic-gate 		if (sys.sys_ptr != NULL &&
36357c478bd9Sstevel@tonic-gate 		    mdb_readstr(var, 256, (uintptr_t)sys.sys_ptr) == -1) {
36367c478bd9Sstevel@tonic-gate 			mdb_warn("couldn't read ptr in %p", sysp);
36377c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
36387c478bd9Sstevel@tonic-gate 		}
36397c478bd9Sstevel@tonic-gate 		if (sys.sys_op != SETOP_NONE) {
36407c478bd9Sstevel@tonic-gate 			/*
36417c478bd9Sstevel@tonic-gate 			 * Is this an int or a string?  We determine this
36427c478bd9Sstevel@tonic-gate 			 * by checking whether straddr is contained in
36437c478bd9Sstevel@tonic-gate 			 * mod_sysfile_arena.  If so, the walker will set
36447c478bd9Sstevel@tonic-gate 			 * straddr to NULL.
36457c478bd9Sstevel@tonic-gate 			 */
36467c478bd9Sstevel@tonic-gate 			straddr = (void *)(uintptr_t)sys.sys_info;
36477c478bd9Sstevel@tonic-gate 			if (sys.sys_op == SETOP_ASSIGN &&
36487c478bd9Sstevel@tonic-gate 			    sys.sys_info != 0 &&
36497c478bd9Sstevel@tonic-gate 			    mdb_pwalk("vmem_seg",
36507c478bd9Sstevel@tonic-gate 			    (mdb_walk_cb_t)sysfile_vmem_seg, &straddr,
36517c478bd9Sstevel@tonic-gate 			    (uintptr_t)mod_sysfile_arena) == 0 &&
36527c478bd9Sstevel@tonic-gate 			    straddr == NULL &&
36537c478bd9Sstevel@tonic-gate 			    mdb_readstr(strval, 256,
36547c478bd9Sstevel@tonic-gate 			    (uintptr_t)sys.sys_info) != -1) {
36557c478bd9Sstevel@tonic-gate 				(void) mdb_snprintf(val, sizeof (val), "\"%s\"",
36567c478bd9Sstevel@tonic-gate 				    strval);
36577c478bd9Sstevel@tonic-gate 			} else {
36587c478bd9Sstevel@tonic-gate 				(void) mdb_snprintf(val, sizeof (val),
36597c478bd9Sstevel@tonic-gate 				    "0x%llx [0t%llu]", sys.sys_info,
36607c478bd9Sstevel@tonic-gate 				    sys.sys_info);
36617c478bd9Sstevel@tonic-gate 			}
36627c478bd9Sstevel@tonic-gate 		}
36637c478bd9Sstevel@tonic-gate 		mdb_printf("%s %s%s%s%s%s\n", sysfile_cmd[sys.sys_type],
36647c478bd9Sstevel@tonic-gate 		    modname, modname[0] == '\0' ? "" : ":",
36657c478bd9Sstevel@tonic-gate 		    var, sysfile_ops[sys.sys_op], val);
36667c478bd9Sstevel@tonic-gate 
36677c478bd9Sstevel@tonic-gate 		sysp = sys.sys_next;
36687c478bd9Sstevel@tonic-gate 	}
36697c478bd9Sstevel@tonic-gate 
36707c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
36717c478bd9Sstevel@tonic-gate }
36727c478bd9Sstevel@tonic-gate 
36737c478bd9Sstevel@tonic-gate int
36747c478bd9Sstevel@tonic-gate didmatch(uintptr_t addr, const kthread_t *thr, kt_did_t *didp)
36757c478bd9Sstevel@tonic-gate {
36767c478bd9Sstevel@tonic-gate 
36777c478bd9Sstevel@tonic-gate 	if (*didp == thr->t_did) {
36787c478bd9Sstevel@tonic-gate 		mdb_printf("%p\n", addr);
36797c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
36807c478bd9Sstevel@tonic-gate 	} else
36817c478bd9Sstevel@tonic-gate 		return (WALK_NEXT);
36827c478bd9Sstevel@tonic-gate }
36837c478bd9Sstevel@tonic-gate 
36847c478bd9Sstevel@tonic-gate /*ARGSUSED*/
36857c478bd9Sstevel@tonic-gate int
36867c478bd9Sstevel@tonic-gate did2thread(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
36877c478bd9Sstevel@tonic-gate {
36887c478bd9Sstevel@tonic-gate 	const mdb_arg_t *argp = &argv[0];
36897c478bd9Sstevel@tonic-gate 	kt_did_t	did;
36907c478bd9Sstevel@tonic-gate 
36917c478bd9Sstevel@tonic-gate 	if (argc != 1)
36927c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
36937c478bd9Sstevel@tonic-gate 
36947c478bd9Sstevel@tonic-gate 	did = (kt_did_t)mdb_strtoull(argp->a_un.a_str);
36957c478bd9Sstevel@tonic-gate 
36967c478bd9Sstevel@tonic-gate 	if (mdb_walk("thread", (mdb_walk_cb_t)didmatch, (void *)&did) == -1) {
36977c478bd9Sstevel@tonic-gate 		mdb_warn("failed to walk thread");
36987c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
36997c478bd9Sstevel@tonic-gate 
37007c478bd9Sstevel@tonic-gate 	}
37017c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
37027c478bd9Sstevel@tonic-gate 
37037c478bd9Sstevel@tonic-gate }
37047c478bd9Sstevel@tonic-gate 
37057c478bd9Sstevel@tonic-gate static int
37067c478bd9Sstevel@tonic-gate errorq_walk_init(mdb_walk_state_t *wsp)
37077c478bd9Sstevel@tonic-gate {
3708*892ad162SToomas Soome 	if (wsp->walk_addr == 0 &&
37097c478bd9Sstevel@tonic-gate 	    mdb_readvar(&wsp->walk_addr, "errorq_list") == -1) {
37107c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read errorq_list");
37117c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
37127c478bd9Sstevel@tonic-gate 	}
37137c478bd9Sstevel@tonic-gate 
37147c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
37157c478bd9Sstevel@tonic-gate }
37167c478bd9Sstevel@tonic-gate 
37177c478bd9Sstevel@tonic-gate static int
37187c478bd9Sstevel@tonic-gate errorq_walk_step(mdb_walk_state_t *wsp)
37197c478bd9Sstevel@tonic-gate {
37207c478bd9Sstevel@tonic-gate 	uintptr_t addr = wsp->walk_addr;
37217c478bd9Sstevel@tonic-gate 	errorq_t eq;
37227c478bd9Sstevel@tonic-gate 
3723*892ad162SToomas Soome 	if (addr == 0)
37247c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
37257c478bd9Sstevel@tonic-gate 
37267c478bd9Sstevel@tonic-gate 	if (mdb_vread(&eq, sizeof (eq), addr) == -1) {
37277c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read errorq at %p", addr);
37287c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
37297c478bd9Sstevel@tonic-gate 	}
37307c478bd9Sstevel@tonic-gate 
37317c478bd9Sstevel@tonic-gate 	wsp->walk_addr = (uintptr_t)eq.eq_next;
37327c478bd9Sstevel@tonic-gate 	return (wsp->walk_callback(addr, &eq, wsp->walk_cbdata));
37337c478bd9Sstevel@tonic-gate }
37347c478bd9Sstevel@tonic-gate 
37357c478bd9Sstevel@tonic-gate typedef struct eqd_walk_data {
37367c478bd9Sstevel@tonic-gate 	uintptr_t *eqd_stack;
37377c478bd9Sstevel@tonic-gate 	void *eqd_buf;
37387c478bd9Sstevel@tonic-gate 	ulong_t eqd_qpos;
37397c478bd9Sstevel@tonic-gate 	ulong_t eqd_qlen;
37407c478bd9Sstevel@tonic-gate 	size_t eqd_size;
37417c478bd9Sstevel@tonic-gate } eqd_walk_data_t;
37427c478bd9Sstevel@tonic-gate 
37437c478bd9Sstevel@tonic-gate /*
37447c478bd9Sstevel@tonic-gate  * In order to walk the list of pending error queue elements, we push the
37457c478bd9Sstevel@tonic-gate  * addresses of the corresponding data buffers in to the eqd_stack array.
37467c478bd9Sstevel@tonic-gate  * The error lists are in reverse chronological order when iterating using
37477c478bd9Sstevel@tonic-gate  * eqe_prev, so we then pop things off the top in eqd_walk_step so that the
37487c478bd9Sstevel@tonic-gate  * walker client gets addresses in order from oldest error to newest error.
37497c478bd9Sstevel@tonic-gate  */
37507c478bd9Sstevel@tonic-gate static void
37517c478bd9Sstevel@tonic-gate eqd_push_list(eqd_walk_data_t *eqdp, uintptr_t addr)
37527c478bd9Sstevel@tonic-gate {
37537c478bd9Sstevel@tonic-gate 	errorq_elem_t eqe;
37547c478bd9Sstevel@tonic-gate 
3755*892ad162SToomas Soome 	while (addr != 0) {
37567c478bd9Sstevel@tonic-gate 		if (mdb_vread(&eqe, sizeof (eqe), addr) != sizeof (eqe)) {
37577c478bd9Sstevel@tonic-gate 			mdb_warn("failed to read errorq element at %p", addr);
37587c478bd9Sstevel@tonic-gate 			break;
37597c478bd9Sstevel@tonic-gate 		}
37607c478bd9Sstevel@tonic-gate 
37617c478bd9Sstevel@tonic-gate 		if (eqdp->eqd_qpos == eqdp->eqd_qlen) {
37627c478bd9Sstevel@tonic-gate 			mdb_warn("errorq is overfull -- more than %lu "
37637c478bd9Sstevel@tonic-gate 			    "elems found\n", eqdp->eqd_qlen);
37647c478bd9Sstevel@tonic-gate 			break;
37657c478bd9Sstevel@tonic-gate 		}
37667c478bd9Sstevel@tonic-gate 
37677c478bd9Sstevel@tonic-gate 		eqdp->eqd_stack[eqdp->eqd_qpos++] = (uintptr_t)eqe.eqe_data;
37687c478bd9Sstevel@tonic-gate 		addr = (uintptr_t)eqe.eqe_prev;
37697c478bd9Sstevel@tonic-gate 	}
37707c478bd9Sstevel@tonic-gate }
37717c478bd9Sstevel@tonic-gate 
37727c478bd9Sstevel@tonic-gate static int
37737c478bd9Sstevel@tonic-gate eqd_walk_init(mdb_walk_state_t *wsp)
37747c478bd9Sstevel@tonic-gate {
37757c478bd9Sstevel@tonic-gate 	eqd_walk_data_t *eqdp;
37767c478bd9Sstevel@tonic-gate 	errorq_elem_t eqe, *addr;
37777c478bd9Sstevel@tonic-gate 	errorq_t eq;
37787c478bd9Sstevel@tonic-gate 	ulong_t i;
37797c478bd9Sstevel@tonic-gate 
37807c478bd9Sstevel@tonic-gate 	if (mdb_vread(&eq, sizeof (eq), wsp->walk_addr) == -1) {
37817c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read errorq at %p", wsp->walk_addr);
37827c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
37837c478bd9Sstevel@tonic-gate 	}
37847c478bd9Sstevel@tonic-gate 
37857c478bd9Sstevel@tonic-gate 	if (eq.eq_ptail != NULL &&
37867c478bd9Sstevel@tonic-gate 	    mdb_vread(&eqe, sizeof (eqe), (uintptr_t)eq.eq_ptail) == -1) {
37877c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read errorq element at %p", eq.eq_ptail);
37887c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
37897c478bd9Sstevel@tonic-gate 	}
37907c478bd9Sstevel@tonic-gate 
37917c478bd9Sstevel@tonic-gate 	eqdp = mdb_alloc(sizeof (eqd_walk_data_t), UM_SLEEP);
37927c478bd9Sstevel@tonic-gate 	wsp->walk_data = eqdp;
37937c478bd9Sstevel@tonic-gate 
37947c478bd9Sstevel@tonic-gate 	eqdp->eqd_stack = mdb_zalloc(sizeof (uintptr_t) * eq.eq_qlen, UM_SLEEP);
37957c478bd9Sstevel@tonic-gate 	eqdp->eqd_buf = mdb_alloc(eq.eq_size, UM_SLEEP);
37967c478bd9Sstevel@tonic-gate 	eqdp->eqd_qlen = eq.eq_qlen;
37977c478bd9Sstevel@tonic-gate 	eqdp->eqd_qpos = 0;
37987c478bd9Sstevel@tonic-gate 	eqdp->eqd_size = eq.eq_size;
37997c478bd9Sstevel@tonic-gate 
38007c478bd9Sstevel@tonic-gate 	/*
38017c478bd9Sstevel@tonic-gate 	 * The newest elements in the queue are on the pending list, so we
38027c478bd9Sstevel@tonic-gate 	 * push those on to our stack first.
38037c478bd9Sstevel@tonic-gate 	 */
38047c478bd9Sstevel@tonic-gate 	eqd_push_list(eqdp, (uintptr_t)eq.eq_pend);
38057c478bd9Sstevel@tonic-gate 
38067c478bd9Sstevel@tonic-gate 	/*
38077c478bd9Sstevel@tonic-gate 	 * If eq_ptail is set, it may point to a subset of the errors on the
380875d94465SJosef 'Jeff' Sipek 	 * pending list in the event a atomic_cas_ptr() failed; if ptail's
380975d94465SJosef 'Jeff' Sipek 	 * data is already in our stack, NULL out eq_ptail and ignore it.
38107c478bd9Sstevel@tonic-gate 	 */
38117c478bd9Sstevel@tonic-gate 	if (eq.eq_ptail != NULL) {
38127c478bd9Sstevel@tonic-gate 		for (i = 0; i < eqdp->eqd_qpos; i++) {
38137c478bd9Sstevel@tonic-gate 			if (eqdp->eqd_stack[i] == (uintptr_t)eqe.eqe_data) {
38147c478bd9Sstevel@tonic-gate 				eq.eq_ptail = NULL;
38157c478bd9Sstevel@tonic-gate 				break;
38167c478bd9Sstevel@tonic-gate 			}
38177c478bd9Sstevel@tonic-gate 		}
38187c478bd9Sstevel@tonic-gate 	}
38197c478bd9Sstevel@tonic-gate 
38207c478bd9Sstevel@tonic-gate 	/*
38217c478bd9Sstevel@tonic-gate 	 * If eq_phead is set, it has the processing list in order from oldest
38227c478bd9Sstevel@tonic-gate 	 * to newest.  Use this to recompute eq_ptail as best we can and then
38237c478bd9Sstevel@tonic-gate 	 * we nicely fall into eqd_push_list() of eq_ptail below.
38247c478bd9Sstevel@tonic-gate 	 */
38257c478bd9Sstevel@tonic-gate 	for (addr = eq.eq_phead; addr != NULL && mdb_vread(&eqe, sizeof (eqe),
38267c478bd9Sstevel@tonic-gate 	    (uintptr_t)addr) == sizeof (eqe); addr = eqe.eqe_next)
38277c478bd9Sstevel@tonic-gate 		eq.eq_ptail = addr;
38287c478bd9Sstevel@tonic-gate 
38297c478bd9Sstevel@tonic-gate 	/*
38307c478bd9Sstevel@tonic-gate 	 * The oldest elements in the queue are on the processing list, subject
38317c478bd9Sstevel@tonic-gate 	 * to machinations in the if-clauses above.  Push any such elements.
38327c478bd9Sstevel@tonic-gate 	 */
38337c478bd9Sstevel@tonic-gate 	eqd_push_list(eqdp, (uintptr_t)eq.eq_ptail);
38347c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
38357c478bd9Sstevel@tonic-gate }
38367c478bd9Sstevel@tonic-gate 
38377c478bd9Sstevel@tonic-gate static int
38387c478bd9Sstevel@tonic-gate eqd_walk_step(mdb_walk_state_t *wsp)
38397c478bd9Sstevel@tonic-gate {
38407c478bd9Sstevel@tonic-gate 	eqd_walk_data_t *eqdp = wsp->walk_data;
38417c478bd9Sstevel@tonic-gate 	uintptr_t addr;
38427c478bd9Sstevel@tonic-gate 
38437c478bd9Sstevel@tonic-gate 	if (eqdp->eqd_qpos == 0)
38447c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
38457c478bd9Sstevel@tonic-gate 
38467c478bd9Sstevel@tonic-gate 	addr = eqdp->eqd_stack[--eqdp->eqd_qpos];
38477c478bd9Sstevel@tonic-gate 
38487c478bd9Sstevel@tonic-gate 	if (mdb_vread(eqdp->eqd_buf, eqdp->eqd_size, addr) != eqdp->eqd_size) {
38497c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read errorq data at %p", addr);
38507c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
38517c478bd9Sstevel@tonic-gate 	}
38527c478bd9Sstevel@tonic-gate 
38537c478bd9Sstevel@tonic-gate 	return (wsp->walk_callback(addr, eqdp->eqd_buf, wsp->walk_cbdata));
38547c478bd9Sstevel@tonic-gate }
38557c478bd9Sstevel@tonic-gate 
38567c478bd9Sstevel@tonic-gate static void
38577c478bd9Sstevel@tonic-gate eqd_walk_fini(mdb_walk_state_t *wsp)
38587c478bd9Sstevel@tonic-gate {
38597c478bd9Sstevel@tonic-gate 	eqd_walk_data_t *eqdp = wsp->walk_data;
38607c478bd9Sstevel@tonic-gate 
38617c478bd9Sstevel@tonic-gate 	mdb_free(eqdp->eqd_stack, sizeof (uintptr_t) * eqdp->eqd_qlen);
38627c478bd9Sstevel@tonic-gate 	mdb_free(eqdp->eqd_buf, eqdp->eqd_size);
38637c478bd9Sstevel@tonic-gate 	mdb_free(eqdp, sizeof (eqd_walk_data_t));
38647c478bd9Sstevel@tonic-gate }
38657c478bd9Sstevel@tonic-gate 
38667c478bd9Sstevel@tonic-gate #define	EQKSVAL(eqv, what) (eqv.eq_kstat.what.value.ui64)
38677c478bd9Sstevel@tonic-gate 
38687c478bd9Sstevel@tonic-gate static int
38697c478bd9Sstevel@tonic-gate errorq(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
38707c478bd9Sstevel@tonic-gate {
38717c478bd9Sstevel@tonic-gate 	int i;
38727c478bd9Sstevel@tonic-gate 	errorq_t eq;
38737c478bd9Sstevel@tonic-gate 	uint_t opt_v = FALSE;
38747c478bd9Sstevel@tonic-gate 
38757c478bd9Sstevel@tonic-gate 	if (!(flags & DCMD_ADDRSPEC)) {
38767c478bd9Sstevel@tonic-gate 		if (mdb_walk_dcmd("errorq", "errorq", argc, argv) == -1) {
38777c478bd9Sstevel@tonic-gate 			mdb_warn("can't walk 'errorq'");
38787c478bd9Sstevel@tonic-gate 			return (DCMD_ERR);
38797c478bd9Sstevel@tonic-gate 		}
38807c478bd9Sstevel@tonic-gate 		return (DCMD_OK);
38817c478bd9Sstevel@tonic-gate 	}
38827c478bd9Sstevel@tonic-gate 
38837c478bd9Sstevel@tonic-gate 	i = mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, TRUE, &opt_v, NULL);
38847c478bd9Sstevel@tonic-gate 	argc -= i;
38857c478bd9Sstevel@tonic-gate 	argv += i;
38867c478bd9Sstevel@tonic-gate 
38877c478bd9Sstevel@tonic-gate 	if (argc != 0)
38887c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
38897c478bd9Sstevel@tonic-gate 
38907c478bd9Sstevel@tonic-gate 	if (opt_v || DCMD_HDRSPEC(flags)) {
38917c478bd9Sstevel@tonic-gate 		mdb_printf("%<u>%-11s %-16s %1s %1s %1s ",
38927c478bd9Sstevel@tonic-gate 		    "ADDR", "NAME", "S", "V", "N");
38937c478bd9Sstevel@tonic-gate 		if (!opt_v) {
38947c478bd9Sstevel@tonic-gate 			mdb_printf("%7s %7s %7s%</u>\n",
38957c478bd9Sstevel@tonic-gate 			    "ACCEPT", "DROP", "LOG");
38967c478bd9Sstevel@tonic-gate 		} else {
38977c478bd9Sstevel@tonic-gate 			mdb_printf("%5s %6s %6s %3s %16s%</u>\n",
38987c478bd9Sstevel@tonic-gate 			    "KSTAT", "QLEN", "SIZE", "IPL", "FUNC");
38997c478bd9Sstevel@tonic-gate 		}
39007c478bd9Sstevel@tonic-gate 	}
39017c478bd9Sstevel@tonic-gate 
39027c478bd9Sstevel@tonic-gate 	if (mdb_vread(&eq, sizeof (eq), addr) != sizeof (eq)) {
39037c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read errorq at %p", addr);
39047c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
39057c478bd9Sstevel@tonic-gate 	}
39067c478bd9Sstevel@tonic-gate 
39077c478bd9Sstevel@tonic-gate 	mdb_printf("%-11p %-16s %c %c %c ", addr, eq.eq_name,
39087c478bd9Sstevel@tonic-gate 	    (eq.eq_flags & ERRORQ_ACTIVE) ? '+' : '-',
39097c478bd9Sstevel@tonic-gate 	    (eq.eq_flags & ERRORQ_VITAL) ? '!' : ' ',
39107c478bd9Sstevel@tonic-gate 	    (eq.eq_flags & ERRORQ_NVLIST) ? '*' : ' ');
39117c478bd9Sstevel@tonic-gate 
39127c478bd9Sstevel@tonic-gate 	if (!opt_v) {
39137c478bd9Sstevel@tonic-gate 		mdb_printf("%7llu %7llu %7llu\n",
39147c478bd9Sstevel@tonic-gate 		    EQKSVAL(eq, eqk_dispatched) + EQKSVAL(eq, eqk_committed),
39157c478bd9Sstevel@tonic-gate 		    EQKSVAL(eq, eqk_dropped) + EQKSVAL(eq, eqk_reserve_fail) +
39167c478bd9Sstevel@tonic-gate 		    EQKSVAL(eq, eqk_commit_fail), EQKSVAL(eq, eqk_logged));
39177c478bd9Sstevel@tonic-gate 	} else {
39187c478bd9Sstevel@tonic-gate 		mdb_printf("%5s %6lu %6lu %3u %a\n",
39197c478bd9Sstevel@tonic-gate 		    "  |  ", eq.eq_qlen, eq.eq_size, eq.eq_ipl, eq.eq_func);
39207c478bd9Sstevel@tonic-gate 		mdb_printf("%38s\n%41s"
39217c478bd9Sstevel@tonic-gate 		    "%12s %llu\n"
39227c478bd9Sstevel@tonic-gate 		    "%53s %llu\n"
39237c478bd9Sstevel@tonic-gate 		    "%53s %llu\n"
39247c478bd9Sstevel@tonic-gate 		    "%53s %llu\n"
39257c478bd9Sstevel@tonic-gate 		    "%53s %llu\n"
39267c478bd9Sstevel@tonic-gate 		    "%53s %llu\n"
39277c478bd9Sstevel@tonic-gate 		    "%53s %llu\n"
39287c478bd9Sstevel@tonic-gate 		    "%53s %llu\n\n",
39297c478bd9Sstevel@tonic-gate 		    "|", "+-> ",
39307c478bd9Sstevel@tonic-gate 		    "DISPATCHED",	EQKSVAL(eq, eqk_dispatched),
39317c478bd9Sstevel@tonic-gate 		    "DROPPED",		EQKSVAL(eq, eqk_dropped),
39327c478bd9Sstevel@tonic-gate 		    "LOGGED",		EQKSVAL(eq, eqk_logged),
39337c478bd9Sstevel@tonic-gate 		    "RESERVED",		EQKSVAL(eq, eqk_reserved),
39347c478bd9Sstevel@tonic-gate 		    "RESERVE FAIL",	EQKSVAL(eq, eqk_reserve_fail),
39357c478bd9Sstevel@tonic-gate 		    "COMMITTED",	EQKSVAL(eq, eqk_committed),
39367c478bd9Sstevel@tonic-gate 		    "COMMIT FAIL",	EQKSVAL(eq, eqk_commit_fail),
39377c478bd9Sstevel@tonic-gate 		    "CANCELLED",	EQKSVAL(eq, eqk_cancelled));
39387c478bd9Sstevel@tonic-gate 	}
39397c478bd9Sstevel@tonic-gate 
39407c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
39417c478bd9Sstevel@tonic-gate }
39427c478bd9Sstevel@tonic-gate 
39437c478bd9Sstevel@tonic-gate /*ARGSUSED*/
39447c478bd9Sstevel@tonic-gate static int
39457c478bd9Sstevel@tonic-gate panicinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
39467c478bd9Sstevel@tonic-gate {
39477c478bd9Sstevel@tonic-gate 	cpu_t panic_cpu;
39487c478bd9Sstevel@tonic-gate 	kthread_t *panic_thread;
394949795412Spetede 	void *buf;
39507c478bd9Sstevel@tonic-gate 	panic_data_t *pd;
39517c478bd9Sstevel@tonic-gate 	int i, n;
39527c478bd9Sstevel@tonic-gate 
39537c478bd9Sstevel@tonic-gate 	if (!mdb_prop_postmortem) {
39547c478bd9Sstevel@tonic-gate 		mdb_warn("panicinfo can only be run on a system "
39557c478bd9Sstevel@tonic-gate 		    "dump; see dumpadm(1M)\n");
39567c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
39577c478bd9Sstevel@tonic-gate 	}
39587c478bd9Sstevel@tonic-gate 
39597c478bd9Sstevel@tonic-gate 	if (flags & DCMD_ADDRSPEC || argc != 0)
39607c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
39617c478bd9Sstevel@tonic-gate 
39627c478bd9Sstevel@tonic-gate 	if (mdb_readsym(&panic_cpu, sizeof (cpu_t), "panic_cpu") == -1)
39637c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read 'panic_cpu'");
39647c478bd9Sstevel@tonic-gate 	else
39657c478bd9Sstevel@tonic-gate 		mdb_printf("%16s %?d\n", "cpu", panic_cpu.cpu_id);
39667c478bd9Sstevel@tonic-gate 
39677c478bd9Sstevel@tonic-gate 	if (mdb_readvar(&panic_thread, "panic_thread") == -1)
39687c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read 'panic_thread'");
39697c478bd9Sstevel@tonic-gate 	else
39707c478bd9Sstevel@tonic-gate 		mdb_printf("%16s %?p\n", "thread", panic_thread);
39717c478bd9Sstevel@tonic-gate 
397249795412Spetede 	buf = mdb_alloc(PANICBUFSIZE, UM_SLEEP);
397349795412Spetede 	pd = (panic_data_t *)buf;
39747c478bd9Sstevel@tonic-gate 
397549795412Spetede 	if (mdb_readsym(buf, PANICBUFSIZE, "panicbuf") == -1 ||
39767c478bd9Sstevel@tonic-gate 	    pd->pd_version != PANICBUFVERS) {
39777c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read 'panicbuf'");
397849795412Spetede 		mdb_free(buf, PANICBUFSIZE);
39797c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
39807c478bd9Sstevel@tonic-gate 	}
39817c478bd9Sstevel@tonic-gate 
398249795412Spetede 	mdb_printf("%16s %s\n", "message",  (char *)buf + pd->pd_msgoff);
39837c478bd9Sstevel@tonic-gate 
39847c478bd9Sstevel@tonic-gate 	n = (pd->pd_msgoff - (sizeof (panic_data_t) -
39857c478bd9Sstevel@tonic-gate 	    sizeof (panic_nv_t))) / sizeof (panic_nv_t);
39867c478bd9Sstevel@tonic-gate 
39877c478bd9Sstevel@tonic-gate 	for (i = 0; i < n; i++)
39887c478bd9Sstevel@tonic-gate 		mdb_printf("%16s %?llx\n",
39897c478bd9Sstevel@tonic-gate 		    pd->pd_nvdata[i].pnv_name, pd->pd_nvdata[i].pnv_value);
39907c478bd9Sstevel@tonic-gate 
399149795412Spetede 	mdb_free(buf, PANICBUFSIZE);
39927c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
39937c478bd9Sstevel@tonic-gate }
39947c478bd9Sstevel@tonic-gate 
3995d3d50737SRafael Vanoni /*
3996d3d50737SRafael Vanoni  * ::time dcmd, which will print a hires timestamp of when we entered the
3997d3d50737SRafael Vanoni  * debugger, or the lbolt value if used with the -l option.
3998d3d50737SRafael Vanoni  *
3999d3d50737SRafael Vanoni  */
4000d3d50737SRafael Vanoni /*ARGSUSED*/
4001d3d50737SRafael Vanoni static int
4002d3d50737SRafael Vanoni time(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
4003d3d50737SRafael Vanoni {
4004d7025c85SJonathan Adams 	uint_t opt_dec = FALSE;
4005d3d50737SRafael Vanoni 	uint_t opt_lbolt = FALSE;
4006d7025c85SJonathan Adams 	uint_t opt_hex = FALSE;
4007d7025c85SJonathan Adams 	const char *fmt;
4008d7025c85SJonathan Adams 	hrtime_t result;
4009d3d50737SRafael Vanoni 
4010d7025c85SJonathan Adams 	if (mdb_getopts(argc, argv,
4011d7025c85SJonathan Adams 	    'd', MDB_OPT_SETBITS, TRUE, &opt_dec,
4012d7025c85SJonathan Adams 	    'l', MDB_OPT_SETBITS, TRUE, &opt_lbolt,
4013d7025c85SJonathan Adams 	    'x', MDB_OPT_SETBITS, TRUE, &opt_hex,
4014d3d50737SRafael Vanoni 	    NULL) != argc)
4015d3d50737SRafael Vanoni 		return (DCMD_USAGE);
4016d3d50737SRafael Vanoni 
4017d7025c85SJonathan Adams 	if (opt_dec && opt_hex)
4018d7025c85SJonathan Adams 		return (DCMD_USAGE);
4019d7025c85SJonathan Adams 
4020d7025c85SJonathan Adams 	result = opt_lbolt ? mdb_get_lbolt() : mdb_gethrtime();
4021d7025c85SJonathan Adams 	fmt =
4022d7025c85SJonathan Adams 	    opt_hex ? "0x%llx\n" :
4023d7025c85SJonathan Adams 	    opt_dec ? "0t%lld\n" : "%#llr\n";
4024d3d50737SRafael Vanoni 
4025d7025c85SJonathan Adams 	mdb_printf(fmt, result);
4026d3d50737SRafael Vanoni 	return (DCMD_OK);
4027d3d50737SRafael Vanoni }
4028d3d50737SRafael Vanoni 
4029d3d50737SRafael Vanoni void
4030d3d50737SRafael Vanoni time_help(void)
4031d3d50737SRafael Vanoni {
4032d3d50737SRafael Vanoni 	mdb_printf("Prints the system time in nanoseconds.\n\n"
4033579a6895SRafael Vanoni 	    "::time will return the timestamp at which we dropped into, \n"
4034579a6895SRafael Vanoni 	    "if called from, kmdb(1); the core dump's high resolution \n"
4035579a6895SRafael Vanoni 	    "time if inspecting one; or the running hires time if we're \n"
4036579a6895SRafael Vanoni 	    "looking at a live system.\n\n"
4037d3d50737SRafael Vanoni 	    "Switches:\n"
4038d7025c85SJonathan Adams 	    "  -d   report times in decimal\n"
4039d7025c85SJonathan Adams 	    "  -l   prints the number of clock ticks since system boot\n"
4040d7025c85SJonathan Adams 	    "  -x   report times in hexadecimal\n");
4041d3d50737SRafael Vanoni }
4042d3d50737SRafael Vanoni 
40437c478bd9Sstevel@tonic-gate static const mdb_dcmd_t dcmds[] = {
40447c478bd9Sstevel@tonic-gate 
40457c478bd9Sstevel@tonic-gate 	/* from genunix.c */
40467c478bd9Sstevel@tonic-gate 	{ "as2proc", ":", "convert as to proc_t address", as2proc },
40477c478bd9Sstevel@tonic-gate 	{ "binding_hash_entry", ":", "print driver names hash table entry",
40487c478bd9Sstevel@tonic-gate 		binding_hash_entry },
404907247649SMadhavan Venkataraman 	{ "callout", "?[-r|n] [-s|l] [-xhB] [-t | -ab nsec [-dkD]]"
405087a18d3fSMadhavan Venkataraman 	    " [-C addr | -S seqid] [-f name|addr] [-p name| addr] [-T|L [-E]]"
405187a18d3fSMadhavan Venkataraman 	    " [-FivVA]",
405287a18d3fSMadhavan Venkataraman 	    "display callouts", callout, callout_help },
405387a18d3fSMadhavan Venkataraman 	{ "calloutid", "[-d|v] xid", "print callout by extended id",
405487a18d3fSMadhavan Venkataraman 	    calloutid, calloutid_help },
40557c478bd9Sstevel@tonic-gate 	{ "class", NULL, "print process scheduler classes", class },
40567c478bd9Sstevel@tonic-gate 	{ "cpuinfo", "?[-v]", "print CPUs and runnable threads", cpuinfo },
40577c478bd9Sstevel@tonic-gate 	{ "did2thread", "? kt_did", "find kernel thread for this id",
40587c478bd9Sstevel@tonic-gate 		did2thread },
40597c478bd9Sstevel@tonic-gate 	{ "errorq", "?[-v]", "display kernel error queues", errorq },
40607c478bd9Sstevel@tonic-gate 	{ "fd", ":[fd num]", "get a file pointer from an fd", fd },
40617c478bd9Sstevel@tonic-gate 	{ "flipone", ":", "the vik_rev_level 2 special", flipone },
40627c478bd9Sstevel@tonic-gate 	{ "lminfo", NULL, "print lock manager information", lminfo },
40637c478bd9Sstevel@tonic-gate 	{ "ndi_event_hdl", "?", "print ndi_event_hdl", ndi_event_hdl },
40647c478bd9Sstevel@tonic-gate 	{ "panicinfo", NULL, "print panic information", panicinfo },
40657c478bd9Sstevel@tonic-gate 	{ "pid2proc", "?", "convert PID to proc_t address", pid2proc },
40667c478bd9Sstevel@tonic-gate 	{ "project", NULL, "display kernel project(s)", project },
40677c478bd9Sstevel@tonic-gate 	{ "ps", "[-fltzTP]", "list processes (and associated thr,lwp)", ps },
40685b91507bSJoshua M. Clulow 	{ "pflags", NULL, "display various proc_t flags", pflags },
4069adb664e2Svb 	{ "pgrep", "[-x] [-n | -o] pattern",
4070adb664e2Svb 		"pattern match against all processes", pgrep },
40717c478bd9Sstevel@tonic-gate 	{ "ptree", NULL, "print process tree", ptree },
40727c478bd9Sstevel@tonic-gate 	{ "sysevent", "?[-sv]", "print sysevent pending or sent queue",
40737c478bd9Sstevel@tonic-gate 		sysevent},
40747c478bd9Sstevel@tonic-gate 	{ "sysevent_channel", "?", "print sysevent channel database",
40757c478bd9Sstevel@tonic-gate 		sysevent_channel},
40767c478bd9Sstevel@tonic-gate 	{ "sysevent_class_list", ":", "print sysevent class list",
40777c478bd9Sstevel@tonic-gate 		sysevent_class_list},
40787c478bd9Sstevel@tonic-gate 	{ "sysevent_subclass_list", ":",
40797c478bd9Sstevel@tonic-gate 		"print sysevent subclass list", sysevent_subclass_list},
40807c478bd9Sstevel@tonic-gate 	{ "system", NULL, "print contents of /etc/system file", sysfile },
40817c478bd9Sstevel@tonic-gate 	{ "task", NULL, "display kernel task(s)", task },
4082d7025c85SJonathan Adams 	{ "time", "[-dlx]", "display system time", time, time_help },
40837c478bd9Sstevel@tonic-gate 	{ "vnode2path", ":[-F]", "vnode address to pathname", vnode2path },
40847c478bd9Sstevel@tonic-gate 	{ "whereopen", ":", "given a vnode, dumps procs which have it open",
40857c478bd9Sstevel@tonic-gate 	    whereopen },
40867c478bd9Sstevel@tonic-gate 
40877c478bd9Sstevel@tonic-gate 	/* from bio.c */
40887c478bd9Sstevel@tonic-gate 	{ "bufpagefind", ":addr", "find page_t on buf_t list", bufpagefind },
40897c478bd9Sstevel@tonic-gate 
40904c06356bSdh 	/* from bitset.c */
40914c06356bSdh 	{ "bitset", ":", "display a bitset", bitset, bitset_help },
40924c06356bSdh 
40937c478bd9Sstevel@tonic-gate 	/* from contract.c */
40947c478bd9Sstevel@tonic-gate 	{ "contract", "?", "display a contract", cmd_contract },
40957c478bd9Sstevel@tonic-gate 	{ "ctevent", ":", "display a contract event", cmd_ctevent },
40967c478bd9Sstevel@tonic-gate 	{ "ctid", ":", "convert id to a contract pointer", cmd_ctid },
40977c478bd9Sstevel@tonic-gate 
40987c478bd9Sstevel@tonic-gate 	/* from cpupart.c */
4099f5533078Smishra 	{ "cpupart", "?[-v]", "print cpu partition info", cpupart },
41007c478bd9Sstevel@tonic-gate 
41010605fe78SGordon Ross 	/* from cred.c */
41020605fe78SGordon Ross 	{ "cred", ":[-v]", "display a credential", cmd_cred },
41030605fe78SGordon Ross 	{ "credgrp", ":[-v]", "display cred_t groups", cmd_credgrp },
41040605fe78SGordon Ross 	{ "credsid", ":[-v]", "display a credsid_t", cmd_credsid },
41050605fe78SGordon Ross 	{ "ksidlist", ":[-v]", "display a ksidlist_t", cmd_ksidlist },
41060605fe78SGordon Ross 
41077c478bd9Sstevel@tonic-gate 	/* from cyclic.c */
41087c478bd9Sstevel@tonic-gate 	{ "cyccover", NULL, "dump cyclic coverage information", cyccover },
41097c478bd9Sstevel@tonic-gate 	{ "cycid", "?", "dump a cyclic id", cycid },
41107c478bd9Sstevel@tonic-gate 	{ "cycinfo", "?", "dump cyc_cpu info", cycinfo },
41117c478bd9Sstevel@tonic-gate 	{ "cyclic", ":", "developer information", cyclic },
41127c478bd9Sstevel@tonic-gate 	{ "cyctrace", "?", "dump cyclic trace buffer", cyctrace },
41137c478bd9Sstevel@tonic-gate 
41144c06356bSdh 	/* from damap.c */
41154c06356bSdh 	{ "damap", ":", "display a damap_t", damap, damap_help },
41164c06356bSdh 
4117a288e5a9SJoshua M. Clulow 	/* from ddi_periodic.c */
4118a288e5a9SJoshua M. Clulow 	{ "ddi_periodic", "?[-v]", "dump ddi_periodic_impl_t info", dprinfo },
4119a288e5a9SJoshua M. Clulow 
41207c478bd9Sstevel@tonic-gate 	/* from devinfo.c */
41217c478bd9Sstevel@tonic-gate 	{ "devbindings", "?[-qs] [device-name | major-num]",
41227c478bd9Sstevel@tonic-gate 	    "print devinfo nodes bound to device-name or major-num",
41237c478bd9Sstevel@tonic-gate 	    devbindings, devinfo_help },
41247c478bd9Sstevel@tonic-gate 	{ "devinfo", ":[-qs]", "detailed devinfo of one node", devinfo,
41257c478bd9Sstevel@tonic-gate 	    devinfo_help },
41267c478bd9Sstevel@tonic-gate 	{ "devinfo_audit", ":[-v]", "devinfo configuration audit record",
41277c478bd9Sstevel@tonic-gate 	    devinfo_audit },
41287c478bd9Sstevel@tonic-gate 	{ "devinfo_audit_log", "?[-v]", "system wide devinfo configuration log",
41297c478bd9Sstevel@tonic-gate 	    devinfo_audit_log },
41307c478bd9Sstevel@tonic-gate 	{ "devinfo_audit_node", ":[-v]", "devinfo node configuration history",
41317c478bd9Sstevel@tonic-gate 	    devinfo_audit_node },
41327c478bd9Sstevel@tonic-gate 	{ "devinfo2driver", ":", "find driver name for this devinfo node",
41337c478bd9Sstevel@tonic-gate 	    devinfo2driver },
41347c478bd9Sstevel@tonic-gate 	{ "devnames", "?[-vm] [num]", "print devnames array", devnames },
41357c478bd9Sstevel@tonic-gate 	{ "dev2major", "?<dev_t>", "convert dev_t to a major number",
41367c478bd9Sstevel@tonic-gate 	    dev2major },
41377c478bd9Sstevel@tonic-gate 	{ "dev2minor", "?<dev_t>", "convert dev_t to a minor number",
41387c478bd9Sstevel@tonic-gate 	    dev2minor },
41397c478bd9Sstevel@tonic-gate 	{ "devt", "?<dev_t>", "display a dev_t's major and minor numbers",
41407c478bd9Sstevel@tonic-gate 	    devt },
41417c478bd9Sstevel@tonic-gate 	{ "major2name", "?<major-num>", "convert major number to dev name",
41427c478bd9Sstevel@tonic-gate 	    major2name },
41437c478bd9Sstevel@tonic-gate 	{ "minornodes", ":", "given a devinfo node, print its minor nodes",
41447c478bd9Sstevel@tonic-gate 	    minornodes },
41457c478bd9Sstevel@tonic-gate 	{ "modctl2devinfo", ":", "given a modctl, list its devinfos",
41467c478bd9Sstevel@tonic-gate 	    modctl2devinfo },
41477c478bd9Sstevel@tonic-gate 	{ "name2major", "<dev-name>", "convert dev name to major number",
41487c478bd9Sstevel@tonic-gate 	    name2major },
414920c06695SRobert Mustacchi 	{ "prtconf", "?[-vpc] [-d driver]", "print devinfo tree", prtconf,
415020c06695SRobert Mustacchi 	    prtconf_help },
41517c478bd9Sstevel@tonic-gate 	{ "softstate", ":<instance>", "retrieve soft-state pointer",
41527c478bd9Sstevel@tonic-gate 	    softstate },
41537c478bd9Sstevel@tonic-gate 	{ "devinfo_fm", ":", "devinfo fault managment configuration",
41547c478bd9Sstevel@tonic-gate 	    devinfo_fm },
41557c478bd9Sstevel@tonic-gate 	{ "devinfo_fmce", ":", "devinfo fault managment cache entry",
41567c478bd9Sstevel@tonic-gate 	    devinfo_fmce},
41577c478bd9Sstevel@tonic-gate 
41587c478bd9Sstevel@tonic-gate 	/* from findstack.c */
41597c478bd9Sstevel@tonic-gate 	{ "findstack", ":[-v]", "find kernel thread stack", findstack },
41607c478bd9Sstevel@tonic-gate 	{ "findstack_debug", NULL, "toggle findstack debugging",
41617c478bd9Sstevel@tonic-gate 		findstack_debug },
4162e6fc74c6SGreg Price 	{ "stacks", "?[-afiv] [-c func] [-C func] [-m module] [-M module] "
4163e6fc74c6SGreg Price 		"[-s sobj | -S sobj] [-t tstate | -T tstate]",
4164346799e8SJonathan W Adams 		"print unique kernel thread stacks",
4165346799e8SJonathan W Adams 		stacks, stacks_help },
41667c478bd9Sstevel@tonic-gate 
4167cbdcbd05SJonathan Adams 	/* from fm.c */
4168cbdcbd05SJonathan Adams 	{ "ereport", "[-v]", "print ereports logged in dump",
4169cbdcbd05SJonathan Adams 	    ereport },
4170cbdcbd05SJonathan Adams 
41714c06356bSdh 	/* from group.c */
41724c06356bSdh 	{ "group", "?[-q]", "display a group", group},
41734c06356bSdh 
4174cbdcbd05SJonathan Adams 	/* from hotplug.c */
4175cbdcbd05SJonathan Adams 	{ "hotplug", "?[-p]", "display a registered hotplug attachment",
4176cbdcbd05SJonathan Adams 	    hotplug, hotplug_help },
4177cbdcbd05SJonathan Adams 
41785febcb4aSScott Carter, SD IOSW 	/* from irm.c */
41795febcb4aSScott Carter, SD IOSW 	{ "irmpools", NULL, "display interrupt pools", irmpools_dcmd },
41805febcb4aSScott Carter, SD IOSW 	{ "irmreqs", NULL, "display interrupt requests in an interrupt pool",
41815febcb4aSScott Carter, SD IOSW 	    irmreqs_dcmd },
41825febcb4aSScott Carter, SD IOSW 	{ "irmreq", NULL, "display an interrupt request", irmreq_dcmd },
41835febcb4aSScott Carter, SD IOSW 
41847c478bd9Sstevel@tonic-gate 	/* from kgrep.c + genunix.c */
4185154eb83fSjwadams 	{ "kgrep", KGREP_USAGE, "search kernel as for a pointer", kgrep,
4186154eb83fSjwadams 		kgrep_help },
41877c478bd9Sstevel@tonic-gate 
41887c478bd9Sstevel@tonic-gate 	/* from kmem.c */
41897c478bd9Sstevel@tonic-gate 	{ "allocdby", ":", "given a thread, print its allocated buffers",
41907c478bd9Sstevel@tonic-gate 		allocdby },
41917c478bd9Sstevel@tonic-gate 	{ "bufctl", ":[-vh] [-a addr] [-c caller] [-e earliest] [-l latest] "
41927c478bd9Sstevel@tonic-gate 		"[-t thd]", "print or filter a bufctl", bufctl, bufctl_help },
41937c478bd9Sstevel@tonic-gate 	{ "freedby", ":", "given a thread, print its freed buffers", freedby },
41947c478bd9Sstevel@tonic-gate 	{ "kmalog", "?[ fail | slab ]",
41957c478bd9Sstevel@tonic-gate 	    "display kmem transaction log and stack traces", kmalog },
4196c92ff650Sek 	{ "kmastat", "[-kmg]", "kernel memory allocator stats",
4197c92ff650Sek 	    kmastat },
41987c478bd9Sstevel@tonic-gate 	{ "kmausers", "?[-ef] [cache ...]", "current medium and large users "
41997c478bd9Sstevel@tonic-gate 		"of the kmem allocator", kmausers, kmausers_help },
4200b5fca8f8Stomee 	{ "kmem_cache", "?[-n name]",
4201b5fca8f8Stomee 		"print kernel memory caches", kmem_cache, kmem_cache_help},
4202b5fca8f8Stomee 	{ "kmem_slabs", "?[-v] [-n cache] [-N cache] [-b maxbins] "
4203b5fca8f8Stomee 		"[-B minbinsize]", "display slab usage per kmem cache",
42043893cb7fStomee 		kmem_slabs, kmem_slabs_help },
42057c478bd9Sstevel@tonic-gate 	{ "kmem_debug", NULL, "toggle kmem dcmd/walk debugging", kmem_debug },
42067c478bd9Sstevel@tonic-gate 	{ "kmem_log", "?[-b]", "dump kmem transaction log", kmem_log },
42077c478bd9Sstevel@tonic-gate 	{ "kmem_verify", "?", "check integrity of kmem-managed memory",
42087c478bd9Sstevel@tonic-gate 		kmem_verify },
42097c478bd9Sstevel@tonic-gate 	{ "vmem", "?", "print a vmem_t", vmem },
42107c478bd9Sstevel@tonic-gate 	{ "vmem_seg", ":[-sv] [-c caller] [-e earliest] [-l latest] "
42117c478bd9Sstevel@tonic-gate 		"[-m minsize] [-M maxsize] [-t thread] [-T type]",
42127c478bd9Sstevel@tonic-gate 		"print or filter a vmem_seg", vmem_seg, vmem_seg_help },
42137c478bd9Sstevel@tonic-gate 	{ "whatthread", ":[-v]", "print threads whose stack contains the "
42147c478bd9Sstevel@tonic-gate 		"given address", whatthread },
42157c478bd9Sstevel@tonic-gate 
42167c478bd9Sstevel@tonic-gate 	/* from ldi.c */
42177c478bd9Sstevel@tonic-gate 	{ "ldi_handle", "?[-i]", "display a layered driver handle",
42187c478bd9Sstevel@tonic-gate 	    ldi_handle, ldi_handle_help },
42197c478bd9Sstevel@tonic-gate 	{ "ldi_ident", NULL, "display a layered driver identifier",
42207c478bd9Sstevel@tonic-gate 	    ldi_ident, ldi_ident_help },
42217c478bd9Sstevel@tonic-gate 
42227c478bd9Sstevel@tonic-gate 	/* from leaky.c + leaky_subr.c */
42237c478bd9Sstevel@tonic-gate 	{ "findleaks", FINDLEAKS_USAGE,
42247c478bd9Sstevel@tonic-gate 	    "search for potential kernel memory leaks", findleaks,
42257c478bd9Sstevel@tonic-gate 	    findleaks_help },
42267c478bd9Sstevel@tonic-gate 
42277c478bd9Sstevel@tonic-gate 	/* from lgrp.c */
42287c478bd9Sstevel@tonic-gate 	{ "lgrp", "?[-q] [-p | -Pih]", "display an lgrp", lgrp},
4229c6402783Sakolb 	{ "lgrp_set", "", "display bitmask of lgroups as a list", lgrp_set},
42307c478bd9Sstevel@tonic-gate 
42317c478bd9Sstevel@tonic-gate 	/* from log.c */
42327c478bd9Sstevel@tonic-gate 	{ "msgbuf", "?[-v]", "print most recent console messages", msgbuf },
42337c478bd9Sstevel@tonic-gate 
42344c06356bSdh 	/* from mdi.c */
42354c06356bSdh 	{ "mdipi", NULL, "given a path, dump mdi_pathinfo "
42364c06356bSdh 		"and detailed pi_prop list", mdipi },
42374c06356bSdh 	{ "mdiprops", NULL, "given a pi_prop, dump the pi_prop list",
42384c06356bSdh 		mdiprops },
42394c06356bSdh 	{ "mdiphci", NULL, "given a phci, dump mdi_phci and "
42404c06356bSdh 		"list all paths", mdiphci },
42414c06356bSdh 	{ "mdivhci", NULL, "given a vhci, dump mdi_vhci and list "
42424c06356bSdh 		"all phcis", mdivhci },
42434c06356bSdh 	{ "mdiclient_paths", NULL, "given a path, walk mdi_pathinfo "
42444c06356bSdh 		"client links", mdiclient_paths },
42454c06356bSdh 	{ "mdiphci_paths", NULL, "given a path, walk through mdi_pathinfo "
42464c06356bSdh 		"phci links", mdiphci_paths },
42474c06356bSdh 	{ "mdiphcis", NULL, "given a phci, walk through mdi_phci ph_next links",
42484c06356bSdh 		mdiphcis },
42494c06356bSdh 
42507c478bd9Sstevel@tonic-gate 	/* from memory.c */
4251cbdcbd05SJonathan Adams 	{ "addr2smap", ":[offset]", "translate address to smap", addr2smap },
42527c478bd9Sstevel@tonic-gate 	{ "memlist", "?[-iav]", "display a struct memlist", memlist },
4253cbdcbd05SJonathan Adams 	{ "memstat", NULL, "display memory usage summary", memstat },
4254cbdcbd05SJonathan Adams 	{ "page", "?", "display a summarized page_t", page },
4255cbdcbd05SJonathan Adams 	{ "pagelookup", "?[-v vp] [-o offset]",
4256cbdcbd05SJonathan Adams 		"find the page_t with the name {vp, offset}",
4257cbdcbd05SJonathan Adams 		pagelookup, pagelookup_help },
4258cbdcbd05SJonathan Adams 	{ "page_num2pp", ":", "find the page_t for a given page frame number",
4259cbdcbd05SJonathan Adams 		page_num2pp },
4260cbdcbd05SJonathan Adams 	{ "pmap", ":[-q]", "print process memory map", pmap },
4261cbdcbd05SJonathan Adams 	{ "seg", ":", "print address space segment", seg },
42627c478bd9Sstevel@tonic-gate 	{ "swapinfo", "?", "display a struct swapinfo", swapinfof },
4263cbdcbd05SJonathan Adams 	{ "vnode2smap", ":[offset]", "translate vnode to smap", vnode2smap },
42647c478bd9Sstevel@tonic-gate 
42657c478bd9Sstevel@tonic-gate 	/* from mmd.c */
42667c478bd9Sstevel@tonic-gate 	{ "multidata", ":[-sv]", "display a summarized multidata_t",
42677c478bd9Sstevel@tonic-gate 		multidata },
42687c478bd9Sstevel@tonic-gate 	{ "pattbl", ":", "display a summarized multidata attribute table",
42697c478bd9Sstevel@tonic-gate 		pattbl },
42707c478bd9Sstevel@tonic-gate 	{ "pattr2multidata", ":", "print multidata pointer from pattr_t",
42717c478bd9Sstevel@tonic-gate 		pattr2multidata },
42727c478bd9Sstevel@tonic-gate 	{ "pdesc2slab", ":", "print pdesc slab pointer from pdesc_t",
42737c478bd9Sstevel@tonic-gate 		pdesc2slab },
42747c478bd9Sstevel@tonic-gate 	{ "pdesc_verify", ":", "verify integrity of a pdesc_t", pdesc_verify },
42757c478bd9Sstevel@tonic-gate 	{ "slab2multidata", ":", "print multidata pointer from pdesc_slab_t",
42767c478bd9Sstevel@tonic-gate 		slab2multidata },
42777c478bd9Sstevel@tonic-gate 
42787c478bd9Sstevel@tonic-gate 	/* from modhash.c */
42797c478bd9Sstevel@tonic-gate 	{ "modhash", "?[-ceht] [-k key] [-v val] [-i index]",
42807c478bd9Sstevel@tonic-gate 		"display information about one or all mod_hash structures",
42817c478bd9Sstevel@tonic-gate 		modhash, modhash_help },
42827c478bd9Sstevel@tonic-gate 	{ "modent", ":[-k | -v | -t type]",
42837c478bd9Sstevel@tonic-gate 		"display information about a mod_hash_entry", modent,
42847c478bd9Sstevel@tonic-gate 		modent_help },
42857c478bd9Sstevel@tonic-gate 
42867c478bd9Sstevel@tonic-gate 	/* from net.c */
42874eaa4710SRishi Srivatsavai 	{ "dladm", "?<sub-command> [flags]", "show data link information",
42884eaa4710SRishi Srivatsavai 		dladm, dladm_help },
42897c478bd9Sstevel@tonic-gate 	{ "mi", ":[-p] [-d | -m]", "filter and display MI object or payload",
42907c478bd9Sstevel@tonic-gate 		mi },
4291d5b6ed4bSVasumathi Sundaram - Sun Microsystems 	{ "netstat", "[-arv] [-f inet | inet6 | unix] [-P tcp | udp | icmp]",
42927c478bd9Sstevel@tonic-gate 		"show network statistics", netstat },
42937c478bd9Sstevel@tonic-gate 	{ "sonode", "?[-f inet | inet6 | unix | #] "
42947c478bd9Sstevel@tonic-gate 		"[-t stream | dgram | raw | #] [-p #]",
42957c478bd9Sstevel@tonic-gate 		"filter and display sonode", sonode },
42967c478bd9Sstevel@tonic-gate 
4297f4b3ec61Sdh 	/* from netstack.c */
4298f4b3ec61Sdh 	{ "netstack", "", "show stack instances", netstack },
4299589efa95SRobert Mustacchi 	{ "netstackid2netstack", ":",
4300589efa95SRobert Mustacchi 		"translate a netstack id to its netstack_t",
4301589efa95SRobert Mustacchi 		netstackid2netstack },
4302f4b3ec61Sdh 
43037c478bd9Sstevel@tonic-gate 	/* from nvpair.c */
43047c478bd9Sstevel@tonic-gate 	{ NVPAIR_DCMD_NAME, NVPAIR_DCMD_USAGE, NVPAIR_DCMD_DESCR,
43057c478bd9Sstevel@tonic-gate 		nvpair_print },
4306fa9e4066Sahrens 	{ NVLIST_DCMD_NAME, NVLIST_DCMD_USAGE, NVLIST_DCMD_DESCR,
43078a40a695Sgavinm 		print_nvlist },
43087c478bd9Sstevel@tonic-gate 
4309fb2f18f8Sesaxe 	/* from pg.c */
4310fb2f18f8Sesaxe 	{ "pg", "?[-q]", "display a pg", pg},
4311fb2f18f8Sesaxe 
43127c478bd9Sstevel@tonic-gate 	/* from rctl.c */
43137c478bd9Sstevel@tonic-gate 	{ "rctl_dict", "?", "print systemwide default rctl definitions",
43147c478bd9Sstevel@tonic-gate 		rctl_dict },
43157c478bd9Sstevel@tonic-gate 	{ "rctl_list", ":[handle]", "print rctls for the given proc",
43167c478bd9Sstevel@tonic-gate 		rctl_list },
43177c478bd9Sstevel@tonic-gate 	{ "rctl", ":[handle]", "print a rctl_t, only if it matches the handle",
43187c478bd9Sstevel@tonic-gate 		rctl },
43197c478bd9Sstevel@tonic-gate 	{ "rctl_validate", ":[-v] [-n #]", "test resource control value "
43207c478bd9Sstevel@tonic-gate 		"sequence", rctl_validate },
43217c478bd9Sstevel@tonic-gate 
43227c478bd9Sstevel@tonic-gate 	/* from sobj.c */
43237c478bd9Sstevel@tonic-gate 	{ "rwlock", ":", "dump out a readers/writer lock", rwlock },
43247c478bd9Sstevel@tonic-gate 	{ "mutex", ":[-f]", "dump out an adaptive or spin mutex", mutex,
43257c478bd9Sstevel@tonic-gate 		mutex_help },
43267c478bd9Sstevel@tonic-gate 	{ "sobj2ts", ":", "perform turnstile lookup on synch object", sobj2ts },
43277c478bd9Sstevel@tonic-gate 	{ "wchaninfo", "?[-v]", "dump condition variable", wchaninfo },
43287c478bd9Sstevel@tonic-gate 	{ "turnstile", "?", "display a turnstile", turnstile },
43297c478bd9Sstevel@tonic-gate 
43307c478bd9Sstevel@tonic-gate 	/* from stream.c */
43317c478bd9Sstevel@tonic-gate 	{ "mblk", ":[-q|v] [-f|F flag] [-t|T type] [-l|L|B len] [-d dbaddr]",
43327c478bd9Sstevel@tonic-gate 		"print an mblk", mblk_prt, mblk_help },
43337c478bd9Sstevel@tonic-gate 	{ "mblk_verify", "?", "verify integrity of an mblk", mblk_verify },
43347c478bd9Sstevel@tonic-gate 	{ "mblk2dblk", ":", "convert mblk_t address to dblk_t address",
43357c478bd9Sstevel@tonic-gate 		mblk2dblk },
43367c478bd9Sstevel@tonic-gate 	{ "q2otherq", ":", "print peer queue for a given queue", q2otherq },
43377c478bd9Sstevel@tonic-gate 	{ "q2rdq", ":", "print read queue for a given queue", q2rdq },
43387c478bd9Sstevel@tonic-gate 	{ "q2syncq", ":", "print syncq for a given queue", q2syncq },
43397c478bd9Sstevel@tonic-gate 	{ "q2stream", ":", "print stream pointer for a given queue", q2stream },
43407c478bd9Sstevel@tonic-gate 	{ "q2wrq", ":", "print write queue for a given queue", q2wrq },
43417c478bd9Sstevel@tonic-gate 	{ "queue", ":[-q|v] [-m mod] [-f flag] [-F flag] [-s syncq_addr]",
43427c478bd9Sstevel@tonic-gate 		"filter and display STREAM queue", queue, queue_help },
43437c478bd9Sstevel@tonic-gate 	{ "stdata", ":[-q|v] [-f flag] [-F flag]",
43447c478bd9Sstevel@tonic-gate 		"filter and display STREAM head", stdata, stdata_help },
43457c478bd9Sstevel@tonic-gate 	{ "str2mate", ":", "print mate of this stream", str2mate },
43467c478bd9Sstevel@tonic-gate 	{ "str2wrq", ":", "print write queue of this stream", str2wrq },
43477c478bd9Sstevel@tonic-gate 	{ "stream", ":", "display STREAM", stream },
43487c478bd9Sstevel@tonic-gate 	{ "strftevent", ":", "print STREAMS flow trace event", strftevent },
43497c478bd9Sstevel@tonic-gate 	{ "syncq", ":[-q|v] [-f flag] [-F flag] [-t type] [-T type]",
43507c478bd9Sstevel@tonic-gate 		"filter and display STREAM sync queue", syncq, syncq_help },
43517c478bd9Sstevel@tonic-gate 	{ "syncq2q", ":", "print queue for a given syncq", syncq2q },
43527c478bd9Sstevel@tonic-gate 
4353e0ad97e3SJonathan Adams 	/* from taskq.c */
4354e0ad97e3SJonathan Adams 	{ "taskq", ":[-atT] [-m min_maxq] [-n name]",
4355e0ad97e3SJonathan Adams 	    "display a taskq", taskq, taskq_help },
4356e0ad97e3SJonathan Adams 	{ "taskq_entry", ":", "display a taskq_ent_t", taskq_ent },
4357e0ad97e3SJonathan Adams 
43587c478bd9Sstevel@tonic-gate 	/* from thread.c */
43597c478bd9Sstevel@tonic-gate 	{ "thread", "?[-bdfimps]", "display a summarized kthread_t", thread,
43607c478bd9Sstevel@tonic-gate 		thread_help },
4361ab4a9bebSjohnlev 	{ "threadlist", "?[-t] [-v [count]]",
43627c478bd9Sstevel@tonic-gate 		"display threads and associated C stack traces", threadlist,
43637c478bd9Sstevel@tonic-gate 		threadlist_help },
4364bff31d89SPhilippe Jung 	{ "stackinfo", "?[-h|-a]", "display kthread_t stack usage", stackinfo,
4365bff31d89SPhilippe Jung 		stackinfo_help },
43667c478bd9Sstevel@tonic-gate 
43677c478bd9Sstevel@tonic-gate 	/* from tsd.c */
43687c478bd9Sstevel@tonic-gate 	{ "tsd", ":-k key", "print tsd[key-1] for this thread", ttotsd },
43697c478bd9Sstevel@tonic-gate 	{ "tsdtot", ":", "find thread with this tsd", tsdtot },
43707c478bd9Sstevel@tonic-gate 
43717c478bd9Sstevel@tonic-gate 	/*
43727c478bd9Sstevel@tonic-gate 	 * typegraph does not work under kmdb, as it requires too much memory
43737c478bd9Sstevel@tonic-gate 	 * for its internal data structures.
43747c478bd9Sstevel@tonic-gate 	 */
43757c478bd9Sstevel@tonic-gate #ifndef _KMDB
43767c478bd9Sstevel@tonic-gate 	/* from typegraph.c */
43777c478bd9Sstevel@tonic-gate 	{ "findlocks", ":", "find locks held by specified thread", findlocks },
43787c478bd9Sstevel@tonic-gate 	{ "findfalse", "?[-v]", "find potentially falsely shared structures",
43797c478bd9Sstevel@tonic-gate 		findfalse },
43807c478bd9Sstevel@tonic-gate 	{ "typegraph", NULL, "build type graph", typegraph },
43817c478bd9Sstevel@tonic-gate 	{ "istype", ":type", "manually set object type", istype },
43827c478bd9Sstevel@tonic-gate 	{ "notype", ":", "manually clear object type", notype },
43837c478bd9Sstevel@tonic-gate 	{ "whattype", ":", "determine object type", whattype },
43847c478bd9Sstevel@tonic-gate #endif
43857c478bd9Sstevel@tonic-gate 
43867c478bd9Sstevel@tonic-gate 	/* from vfs.c */
43877c478bd9Sstevel@tonic-gate 	{ "fsinfo", "?[-v]", "print mounted filesystems", fsinfo },
43887c478bd9Sstevel@tonic-gate 	{ "pfiles", ":[-fp]", "print process file information", pfiles,
43897c478bd9Sstevel@tonic-gate 		pfiles_help },
43907c478bd9Sstevel@tonic-gate 
43914c06356bSdh 	/* from zone.c */
4392589efa95SRobert Mustacchi 	{ "zid2zone", ":", "find the zone_t with the given zone id",
4393589efa95SRobert Mustacchi 		zid2zone },
4394a19609f8Sjv 	{ "zone", "?[-r [-v]]", "display kernel zone(s)", zoneprt },
43954c06356bSdh 	{ "zsd", ":[-v] [zsd_key]", "display zone-specific-data entries for "
43964c06356bSdh 	    "selected zones", zsd },
439770ab954aSramat 
43982a12f85aSJeremy Jones #ifndef _KMDB
43992a12f85aSJeremy Jones 	{ "gcore", NULL, "generate a user core for the given process",
44002a12f85aSJeremy Jones 	    gcore_dcmd },
44012a12f85aSJeremy Jones #endif
44022a12f85aSJeremy Jones 
44037c478bd9Sstevel@tonic-gate 	{ NULL }
44047c478bd9Sstevel@tonic-gate };
44057c478bd9Sstevel@tonic-gate 
44067c478bd9Sstevel@tonic-gate static const mdb_walker_t walkers[] = {
44077c478bd9Sstevel@tonic-gate 
44087c478bd9Sstevel@tonic-gate 	/* from genunix.c */
440987a18d3fSMadhavan Venkataraman 	{ "callouts_bytime", "walk callouts by list chain (expiration time)",
441087a18d3fSMadhavan Venkataraman 		callout_walk_init, callout_walk_step, callout_walk_fini,
441187a18d3fSMadhavan Venkataraman 		(void *)CALLOUT_WALK_BYLIST },
441287a18d3fSMadhavan Venkataraman 	{ "callouts_byid", "walk callouts by id hash chain",
441387a18d3fSMadhavan Venkataraman 		callout_walk_init, callout_walk_step, callout_walk_fini,
441487a18d3fSMadhavan Venkataraman 		(void *)CALLOUT_WALK_BYID },
441587a18d3fSMadhavan Venkataraman 	{ "callout_list", "walk a callout list", callout_list_walk_init,
441687a18d3fSMadhavan Venkataraman 		callout_list_walk_step, callout_list_walk_fini },
441787a18d3fSMadhavan Venkataraman 	{ "callout_table", "walk callout table array", callout_table_walk_init,
441887a18d3fSMadhavan Venkataraman 		callout_table_walk_step, callout_table_walk_fini },
44197c478bd9Sstevel@tonic-gate 	{ "cpu", "walk cpu structures", cpu_walk_init, cpu_walk_step },
442039f030b8SPatrick Mooney 	{ "dnlc", "walk dnlc entries",
442139f030b8SPatrick Mooney 		dnlc_walk_init, dnlc_walk_step, dnlc_walk_fini },
44229dd0f810Scindi 	{ "ereportq_dump", "walk list of ereports in dump error queue",
44239dd0f810Scindi 		ereportq_dump_walk_init, ereportq_dump_walk_step, NULL },
44249dd0f810Scindi 	{ "ereportq_pend", "walk list of ereports in pending error queue",
44259dd0f810Scindi 		ereportq_pend_walk_init, ereportq_pend_walk_step, NULL },
44267c478bd9Sstevel@tonic-gate 	{ "errorq", "walk list of system error queues",
44277c478bd9Sstevel@tonic-gate 		errorq_walk_init, errorq_walk_step, NULL },
44287c478bd9Sstevel@tonic-gate 	{ "errorq_data", "walk pending error queue data buffers",
44297c478bd9Sstevel@tonic-gate 		eqd_walk_init, eqd_walk_step, eqd_walk_fini },
44307c478bd9Sstevel@tonic-gate 	{ "allfile", "given a proc pointer, list all file pointers",
44317c478bd9Sstevel@tonic-gate 		file_walk_init, allfile_walk_step, file_walk_fini },
44327c478bd9Sstevel@tonic-gate 	{ "file", "given a proc pointer, list of open file pointers",
44337c478bd9Sstevel@tonic-gate 		file_walk_init, file_walk_step, file_walk_fini },
44347c478bd9Sstevel@tonic-gate 	{ "lock_descriptor", "walk lock_descriptor_t structures",
44357c478bd9Sstevel@tonic-gate 		ld_walk_init, ld_walk_step, NULL },
44367c478bd9Sstevel@tonic-gate 	{ "lock_graph", "walk lock graph",
44377c478bd9Sstevel@tonic-gate 		lg_walk_init, lg_walk_step, NULL },
44387c478bd9Sstevel@tonic-gate 	{ "port", "given a proc pointer, list of created event ports",
44397c478bd9Sstevel@tonic-gate 		port_walk_init, port_walk_step, NULL },
44407c478bd9Sstevel@tonic-gate 	{ "portev", "given a port pointer, list of events in the queue",
44417c478bd9Sstevel@tonic-gate 		portev_walk_init, portev_walk_step, portev_walk_fini },
44427c478bd9Sstevel@tonic-gate 	{ "proc", "list of active proc_t structures",
44437c478bd9Sstevel@tonic-gate 		proc_walk_init, proc_walk_step, proc_walk_fini },
44447c478bd9Sstevel@tonic-gate 	{ "projects", "walk a list of kernel projects",
44457c478bd9Sstevel@tonic-gate 		project_walk_init, project_walk_step, NULL },
44467c478bd9Sstevel@tonic-gate 	{ "sysevent_pend", "walk sysevent pending queue",
44477c478bd9Sstevel@tonic-gate 		sysevent_pend_walk_init, sysevent_walk_step,
44487c478bd9Sstevel@tonic-gate 		sysevent_walk_fini},
44497c478bd9Sstevel@tonic-gate 	{ "sysevent_sent", "walk sysevent sent queue", sysevent_sent_walk_init,
44507c478bd9Sstevel@tonic-gate 		sysevent_walk_step, sysevent_walk_fini},
44517c478bd9Sstevel@tonic-gate 	{ "sysevent_channel", "walk sysevent channel subscriptions",
44527c478bd9Sstevel@tonic-gate 		sysevent_channel_walk_init, sysevent_channel_walk_step,
44537c478bd9Sstevel@tonic-gate 		sysevent_channel_walk_fini},
44547c478bd9Sstevel@tonic-gate 	{ "sysevent_class_list", "walk sysevent subscription's class list",
44557c478bd9Sstevel@tonic-gate 		sysevent_class_list_walk_init, sysevent_class_list_walk_step,
44567c478bd9Sstevel@tonic-gate 		sysevent_class_list_walk_fini},
44577c478bd9Sstevel@tonic-gate 	{ "sysevent_subclass_list",
44587c478bd9Sstevel@tonic-gate 		"walk sysevent subscription's subclass list",
44597c478bd9Sstevel@tonic-gate 		sysevent_subclass_list_walk_init,
44607c478bd9Sstevel@tonic-gate 		sysevent_subclass_list_walk_step,
44617c478bd9Sstevel@tonic-gate 		sysevent_subclass_list_walk_fini},
44627c478bd9Sstevel@tonic-gate 	{ "task", "given a task pointer, walk its processes",
44637c478bd9Sstevel@tonic-gate 		task_walk_init, task_walk_step, NULL },
44647c478bd9Sstevel@tonic-gate 
4465fa9e4066Sahrens 	/* from avl.c */
4466fa9e4066Sahrens 	{ AVL_WALK_NAME, AVL_WALK_DESC,
4467fa9e4066Sahrens 		avl_walk_init, avl_walk_step, avl_walk_fini },
4468fa9e4066Sahrens 
44697c478bd9Sstevel@tonic-gate 	/* from bio.c */
44707c478bd9Sstevel@tonic-gate 	{ "buf", "walk the bio buf hash",
44717c478bd9Sstevel@tonic-gate 		buf_walk_init, buf_walk_step, buf_walk_fini },
44727c478bd9Sstevel@tonic-gate 
44737c478bd9Sstevel@tonic-gate 	/* from contract.c */
44747c478bd9Sstevel@tonic-gate 	{ "contract", "walk all contracts, or those of the specified type",
44757c478bd9Sstevel@tonic-gate 		ct_walk_init, generic_walk_step, NULL },
44767c478bd9Sstevel@tonic-gate 	{ "ct_event", "walk events on a contract event queue",
44777c478bd9Sstevel@tonic-gate 		ct_event_walk_init, generic_walk_step, NULL },
44787c478bd9Sstevel@tonic-gate 	{ "ct_listener", "walk contract event queue listeners",
44797c478bd9Sstevel@tonic-gate 		ct_listener_walk_init, generic_walk_step, NULL },
44807c478bd9Sstevel@tonic-gate 
44817c478bd9Sstevel@tonic-gate 	/* from cpupart.c */
44827c478bd9Sstevel@tonic-gate 	{ "cpupart_cpulist", "given an cpupart_t, walk cpus in partition",
44837c478bd9Sstevel@tonic-gate 		cpupart_cpulist_walk_init, cpupart_cpulist_walk_step,
44847c478bd9Sstevel@tonic-gate 		NULL },
44857c478bd9Sstevel@tonic-gate 	{ "cpupart_walk", "walk the set of cpu partitions",
44867c478bd9Sstevel@tonic-gate 		cpupart_walk_init, cpupart_walk_step, NULL },
44877c478bd9Sstevel@tonic-gate 
44887c478bd9Sstevel@tonic-gate 	/* from ctxop.c */
44897c478bd9Sstevel@tonic-gate 	{ "ctxop", "walk list of context ops on a thread",
44907c478bd9Sstevel@tonic-gate 		ctxop_walk_init, ctxop_walk_step, ctxop_walk_fini },
44917c478bd9Sstevel@tonic-gate 
44927c478bd9Sstevel@tonic-gate 	/* from cyclic.c */
44937c478bd9Sstevel@tonic-gate 	{ "cyccpu", "walk per-CPU cyc_cpu structures",
44947c478bd9Sstevel@tonic-gate 		cyccpu_walk_init, cyccpu_walk_step, NULL },
44957c478bd9Sstevel@tonic-gate 	{ "cycomni", "for an omnipresent cyclic, walk cyc_omni_cpu list",
44967c478bd9Sstevel@tonic-gate 		cycomni_walk_init, cycomni_walk_step, NULL },
44977c478bd9Sstevel@tonic-gate 	{ "cyctrace", "walk cyclic trace buffer",
44987c478bd9Sstevel@tonic-gate 		cyctrace_walk_init, cyctrace_walk_step, cyctrace_walk_fini },
44997c478bd9Sstevel@tonic-gate 
45007c478bd9Sstevel@tonic-gate 	/* from devinfo.c */
45017c478bd9Sstevel@tonic-gate 	{ "binding_hash", "walk all entries in binding hash table",
45027c478bd9Sstevel@tonic-gate 		binding_hash_walk_init, binding_hash_walk_step, NULL },
45037c478bd9Sstevel@tonic-gate 	{ "devinfo", "walk devinfo tree or subtree",
45047c478bd9Sstevel@tonic-gate 		devinfo_walk_init, devinfo_walk_step, devinfo_walk_fini },
45057c478bd9Sstevel@tonic-gate 	{ "devinfo_audit_log", "walk devinfo audit system-wide log",
45067c478bd9Sstevel@tonic-gate 		devinfo_audit_log_walk_init, devinfo_audit_log_walk_step,
45077c478bd9Sstevel@tonic-gate 		devinfo_audit_log_walk_fini},
45087c478bd9Sstevel@tonic-gate 	{ "devinfo_audit_node", "walk per-devinfo audit history",
45097c478bd9Sstevel@tonic-gate 		devinfo_audit_node_walk_init, devinfo_audit_node_walk_step,
45107c478bd9Sstevel@tonic-gate 		devinfo_audit_node_walk_fini},
45117c478bd9Sstevel@tonic-gate 	{ "devinfo_children", "walk children of devinfo node",
45127c478bd9Sstevel@tonic-gate 		devinfo_children_walk_init, devinfo_children_walk_step,
45137c478bd9Sstevel@tonic-gate 		devinfo_children_walk_fini },
45147c478bd9Sstevel@tonic-gate 	{ "devinfo_parents", "walk ancestors of devinfo node",
45157c478bd9Sstevel@tonic-gate 		devinfo_parents_walk_init, devinfo_parents_walk_step,
45167c478bd9Sstevel@tonic-gate 		devinfo_parents_walk_fini },
45177c478bd9Sstevel@tonic-gate 	{ "devinfo_siblings", "walk siblings of devinfo node",
45187c478bd9Sstevel@tonic-gate 		devinfo_siblings_walk_init, devinfo_siblings_walk_step, NULL },
45197c478bd9Sstevel@tonic-gate 	{ "devi_next", "walk devinfo list",
45207c478bd9Sstevel@tonic-gate 		NULL, devi_next_walk_step, NULL },
45217c478bd9Sstevel@tonic-gate 	{ "devnames", "walk devnames array",
45227c478bd9Sstevel@tonic-gate 		devnames_walk_init, devnames_walk_step, devnames_walk_fini },
45237c478bd9Sstevel@tonic-gate 	{ "minornode", "given a devinfo node, walk minor nodes",
45247c478bd9Sstevel@tonic-gate 		minornode_walk_init, minornode_walk_step, NULL },
45257c478bd9Sstevel@tonic-gate 	{ "softstate",
45267c478bd9Sstevel@tonic-gate 		"given an i_ddi_soft_state*, list all in-use driver stateps",
45277c478bd9Sstevel@tonic-gate 		soft_state_walk_init, soft_state_walk_step,
45287c478bd9Sstevel@tonic-gate 		NULL, NULL },
45297c478bd9Sstevel@tonic-gate 	{ "softstate_all",
45307c478bd9Sstevel@tonic-gate 		"given an i_ddi_soft_state*, list all driver stateps",
45317c478bd9Sstevel@tonic-gate 		soft_state_walk_init, soft_state_all_walk_step,
45327c478bd9Sstevel@tonic-gate 		NULL, NULL },
45337c478bd9Sstevel@tonic-gate 	{ "devinfo_fmc",
45347c478bd9Sstevel@tonic-gate 		"walk a fault management handle cache active list",
45357c478bd9Sstevel@tonic-gate 		devinfo_fmc_walk_init, devinfo_fmc_walk_step, NULL },
45367c478bd9Sstevel@tonic-gate 
45374c06356bSdh 	/* from group.c */
45384c06356bSdh 	{ "group", "walk all elements of a group",
45394c06356bSdh 		group_walk_init, group_walk_step, NULL },
45404c06356bSdh 
45415febcb4aSScott Carter, SD IOSW 	/* from irm.c */
45425febcb4aSScott Carter, SD IOSW 	{ "irmpools", "walk global list of interrupt pools",
45435febcb4aSScott Carter, SD IOSW 	    irmpools_walk_init, list_walk_step, list_walk_fini },
45445febcb4aSScott Carter, SD IOSW 	{ "irmreqs", "walk list of interrupt requests in an interrupt pool",
45455febcb4aSScott Carter, SD IOSW 	    irmreqs_walk_init, list_walk_step, list_walk_fini },
45465febcb4aSScott Carter, SD IOSW 
45477c478bd9Sstevel@tonic-gate 	/* from kmem.c */
45487c478bd9Sstevel@tonic-gate 	{ "allocdby", "given a thread, walk its allocated bufctls",
45497c478bd9Sstevel@tonic-gate 		allocdby_walk_init, allocdby_walk_step, allocdby_walk_fini },
45507c478bd9Sstevel@tonic-gate 	{ "bufctl", "walk a kmem cache's bufctls",
45517c478bd9Sstevel@tonic-gate 		bufctl_walk_init, kmem_walk_step, kmem_walk_fini },
45527c478bd9Sstevel@tonic-gate 	{ "bufctl_history", "walk the available history of a bufctl",
45537c478bd9Sstevel@tonic-gate 		bufctl_history_walk_init, bufctl_history_walk_step,
45547c478bd9Sstevel@tonic-gate 		bufctl_history_walk_fini },
45557c478bd9Sstevel@tonic-gate 	{ "freedby", "given a thread, walk its freed bufctls",
45567c478bd9Sstevel@tonic-gate 		freedby_walk_init, allocdby_walk_step, allocdby_walk_fini },
45577c478bd9Sstevel@tonic-gate 	{ "freectl", "walk a kmem cache's free bufctls",
45587c478bd9Sstevel@tonic-gate 		freectl_walk_init, kmem_walk_step, kmem_walk_fini },
45597c478bd9Sstevel@tonic-gate 	{ "freectl_constructed", "walk a kmem cache's constructed free bufctls",
45607c478bd9Sstevel@tonic-gate 		freectl_constructed_walk_init, kmem_walk_step, kmem_walk_fini },
45617c478bd9Sstevel@tonic-gate 	{ "freemem", "walk a kmem cache's free memory",
45627c478bd9Sstevel@tonic-gate 		freemem_walk_init, kmem_walk_step, kmem_walk_fini },
45637c478bd9Sstevel@tonic-gate 	{ "freemem_constructed", "walk a kmem cache's constructed free memory",
45647c478bd9Sstevel@tonic-gate 		freemem_constructed_walk_init, kmem_walk_step, kmem_walk_fini },
45657c478bd9Sstevel@tonic-gate 	{ "kmem", "walk a kmem cache",
45667c478bd9Sstevel@tonic-gate 		kmem_walk_init, kmem_walk_step, kmem_walk_fini },
45677c478bd9Sstevel@tonic-gate 	{ "kmem_cpu_cache", "given a kmem cache, walk its per-CPU caches",
45687c478bd9Sstevel@tonic-gate 		kmem_cpu_cache_walk_init, kmem_cpu_cache_walk_step, NULL },
45697c478bd9Sstevel@tonic-gate 	{ "kmem_hash", "given a kmem cache, walk its allocated hash table",
45707c478bd9Sstevel@tonic-gate 		kmem_hash_walk_init, kmem_hash_walk_step, kmem_hash_walk_fini },
45717c478bd9Sstevel@tonic-gate 	{ "kmem_log", "walk the kmem transaction log",
45727c478bd9Sstevel@tonic-gate 		kmem_log_walk_init, kmem_log_walk_step, kmem_log_walk_fini },
45737c478bd9Sstevel@tonic-gate 	{ "kmem_slab", "given a kmem cache, walk its slabs",
4574b5fca8f8Stomee 		kmem_slab_walk_init, combined_walk_step, combined_walk_fini },
45757c478bd9Sstevel@tonic-gate 	{ "kmem_slab_partial",
45767c478bd9Sstevel@tonic-gate 	    "given a kmem cache, walk its partially allocated slabs (min 1)",
4577b5fca8f8Stomee 		kmem_slab_walk_partial_init, combined_walk_step,
4578b5fca8f8Stomee 		combined_walk_fini },
45797c478bd9Sstevel@tonic-gate 	{ "vmem", "walk vmem structures in pre-fix, depth-first order",
45807c478bd9Sstevel@tonic-gate 		vmem_walk_init, vmem_walk_step, vmem_walk_fini },
45817c478bd9Sstevel@tonic-gate 	{ "vmem_alloc", "given a vmem_t, walk its allocated vmem_segs",
45827c478bd9Sstevel@tonic-gate 		vmem_alloc_walk_init, vmem_seg_walk_step, vmem_seg_walk_fini },
45837c478bd9Sstevel@tonic-gate 	{ "vmem_free", "given a vmem_t, walk its free vmem_segs",
45847c478bd9Sstevel@tonic-gate 		vmem_free_walk_init, vmem_seg_walk_step, vmem_seg_walk_fini },
45857c478bd9Sstevel@tonic-gate 	{ "vmem_postfix", "walk vmem structures in post-fix, depth-first order",
45867c478bd9Sstevel@tonic-gate 		vmem_walk_init, vmem_postfix_walk_step, vmem_walk_fini },
45877c478bd9Sstevel@tonic-gate 	{ "vmem_seg", "given a vmem_t, walk all of its vmem_segs",
45887c478bd9Sstevel@tonic-gate 		vmem_seg_walk_init, vmem_seg_walk_step, vmem_seg_walk_fini },
45897c478bd9Sstevel@tonic-gate 	{ "vmem_span", "given a vmem_t, walk its spanning vmem_segs",
45907c478bd9Sstevel@tonic-gate 		vmem_span_walk_init, vmem_seg_walk_step, vmem_seg_walk_fini },
45917c478bd9Sstevel@tonic-gate 
45927c478bd9Sstevel@tonic-gate 	/* from ldi.c */
45937c478bd9Sstevel@tonic-gate 	{ "ldi_handle", "walk the layered driver handle hash",
45947c478bd9Sstevel@tonic-gate 		ldi_handle_walk_init, ldi_handle_walk_step, NULL },
45957c478bd9Sstevel@tonic-gate 	{ "ldi_ident", "walk the layered driver identifier hash",
45967c478bd9Sstevel@tonic-gate 		ldi_ident_walk_init, ldi_ident_walk_step, NULL },
45977c478bd9Sstevel@tonic-gate 
45987c478bd9Sstevel@tonic-gate 	/* from leaky.c + leaky_subr.c */
45997c478bd9Sstevel@tonic-gate 	{ "leak", "given a leaked bufctl or vmem_seg, find leaks w/ same "
46007c478bd9Sstevel@tonic-gate 	    "stack trace",
46017c478bd9Sstevel@tonic-gate 		leaky_walk_init, leaky_walk_step, leaky_walk_fini },
46027c478bd9Sstevel@tonic-gate 	{ "leakbuf", "given a leaked bufctl or vmem_seg, walk buffers for "
46037c478bd9Sstevel@tonic-gate 	    "leaks w/ same stack trace",
46047c478bd9Sstevel@tonic-gate 		leaky_walk_init, leaky_buf_walk_step, leaky_walk_fini },
46057c478bd9Sstevel@tonic-gate 
46067c478bd9Sstevel@tonic-gate 	/* from lgrp.c */
4607c6402783Sakolb 	{ "lgrp_cpulist", "walk CPUs in a given lgroup",
4608c6402783Sakolb 		lgrp_cpulist_walk_init, lgrp_cpulist_walk_step, NULL },
4609c6402783Sakolb 	{ "lgrptbl", "walk lgroup table",
46107c478bd9Sstevel@tonic-gate 		lgrp_walk_init, lgrp_walk_step, NULL },
4611c6402783Sakolb 	{ "lgrp_parents", "walk up lgroup lineage from given lgroup",
4612c6402783Sakolb 		lgrp_parents_walk_init, lgrp_parents_walk_step, NULL },
4613c6402783Sakolb 	{ "lgrp_rsrc_mem", "walk lgroup memory resources of given lgroup",
4614c6402783Sakolb 		lgrp_rsrc_mem_walk_init, lgrp_set_walk_step, NULL },
4615c6402783Sakolb 	{ "lgrp_rsrc_cpu", "walk lgroup CPU resources of given lgroup",
4616c6402783Sakolb 		lgrp_rsrc_cpu_walk_init, lgrp_set_walk_step, NULL },
46177c478bd9Sstevel@tonic-gate 
46187c478bd9Sstevel@tonic-gate 	/* from list.c */
4619fa9e4066Sahrens 	{ LIST_WALK_NAME, LIST_WALK_DESC,
46207c478bd9Sstevel@tonic-gate 		list_walk_init, list_walk_step, list_walk_fini },
46217c478bd9Sstevel@tonic-gate 
46224c06356bSdh 	/* from mdi.c */
46234c06356bSdh 	{ "mdipi_client_list", "Walker for mdi_pathinfo pi_client_link",
46244c06356bSdh 		mdi_pi_client_link_walk_init,
46254c06356bSdh 		mdi_pi_client_link_walk_step,
46264c06356bSdh 		mdi_pi_client_link_walk_fini },
46274c06356bSdh 	{ "mdipi_phci_list", "Walker for mdi_pathinfo pi_phci_link",
46284c06356bSdh 		mdi_pi_phci_link_walk_init,
46294c06356bSdh 		mdi_pi_phci_link_walk_step,
46304c06356bSdh 		mdi_pi_phci_link_walk_fini },
46314c06356bSdh 	{ "mdiphci_list", "Walker for mdi_phci ph_next link",
46324c06356bSdh 		mdi_phci_ph_next_walk_init,
46334c06356bSdh 		mdi_phci_ph_next_walk_step,
46344c06356bSdh 		mdi_phci_ph_next_walk_fini },
46354c06356bSdh 
46367c478bd9Sstevel@tonic-gate 	/* from memory.c */
4637d20abfaaSPavel Tatashin 	{ "allpages", "walk all pages, including free pages",
4638d20abfaaSPavel Tatashin 		allpages_walk_init, allpages_walk_step, allpages_walk_fini },
463964a3d88bSJonathan Adams 	{ "anon", "given an amp, list allocated anon structures",
464064a3d88bSJonathan Adams 		anon_walk_init, anon_walk_step, anon_walk_fini,
464164a3d88bSJonathan Adams 		ANON_WALK_ALLOC },
464264a3d88bSJonathan Adams 	{ "anon_all", "given an amp, list contents of all anon slots",
464364a3d88bSJonathan Adams 		anon_walk_init, anon_walk_step, anon_walk_fini,
464464a3d88bSJonathan Adams 		ANON_WALK_ALL },
46457c478bd9Sstevel@tonic-gate 	{ "memlist", "walk specified memlist",
46467c478bd9Sstevel@tonic-gate 		NULL, memlist_walk_step, NULL },
4647cbdcbd05SJonathan Adams 	{ "page", "walk all pages, or those from the specified vnode",
4648cbdcbd05SJonathan Adams 		page_walk_init, page_walk_step, page_walk_fini },
4649cbdcbd05SJonathan Adams 	{ "seg", "given an as, list of segments",
4650cbdcbd05SJonathan Adams 		seg_walk_init, avl_walk_step, avl_walk_fini },
465164a3d88bSJonathan Adams 	{ "segvn_anon",
465264a3d88bSJonathan Adams 		"given a struct segvn_data, list allocated anon structures",
465364a3d88bSJonathan Adams 		segvn_anon_walk_init, anon_walk_step, anon_walk_fini,
465464a3d88bSJonathan Adams 		ANON_WALK_ALLOC },
465564a3d88bSJonathan Adams 	{ "segvn_anon_all",
465664a3d88bSJonathan Adams 		"given a struct segvn_data, list contents of all anon slots",
465764a3d88bSJonathan Adams 		segvn_anon_walk_init, anon_walk_step, anon_walk_fini,
465864a3d88bSJonathan Adams 		ANON_WALK_ALL },
465964a3d88bSJonathan Adams 	{ "segvn_pages",
466064a3d88bSJonathan Adams 		"given a struct segvn_data, list resident pages in "
466164a3d88bSJonathan Adams 		"offset order",
466264a3d88bSJonathan Adams 		segvn_pages_walk_init, segvn_pages_walk_step,
466364a3d88bSJonathan Adams 		segvn_pages_walk_fini, SEGVN_PAGES_RESIDENT },
466464a3d88bSJonathan Adams 	{ "segvn_pages_all",
466564a3d88bSJonathan Adams 		"for each offset in a struct segvn_data, give page_t pointer "
466664a3d88bSJonathan Adams 		"(if resident), or NULL.",
466764a3d88bSJonathan Adams 		segvn_pages_walk_init, segvn_pages_walk_step,
466864a3d88bSJonathan Adams 		segvn_pages_walk_fini, SEGVN_PAGES_ALL },
46697c478bd9Sstevel@tonic-gate 	{ "swapinfo", "walk swapinfo structures",
46707c478bd9Sstevel@tonic-gate 		swap_walk_init, swap_walk_step, NULL },
46717c478bd9Sstevel@tonic-gate 
46727c478bd9Sstevel@tonic-gate 	/* from mmd.c */
46737c478bd9Sstevel@tonic-gate 	{ "pattr", "walk pattr_t structures", pattr_walk_init,
46747c478bd9Sstevel@tonic-gate 		mmdq_walk_step, mmdq_walk_fini },
46757c478bd9Sstevel@tonic-gate 	{ "pdesc", "walk pdesc_t structures",
46767c478bd9Sstevel@tonic-gate 		pdesc_walk_init, mmdq_walk_step, mmdq_walk_fini },
46777c478bd9Sstevel@tonic-gate 	{ "pdesc_slab", "walk pdesc_slab_t structures",
46787c478bd9Sstevel@tonic-gate 		pdesc_slab_walk_init, mmdq_walk_step, mmdq_walk_fini },
46797c478bd9Sstevel@tonic-gate 
46807c478bd9Sstevel@tonic-gate 	/* from modhash.c */
46817c478bd9Sstevel@tonic-gate 	{ "modhash", "walk list of mod_hash structures", modhash_walk_init,
46827c478bd9Sstevel@tonic-gate 		modhash_walk_step, NULL },
46837c478bd9Sstevel@tonic-gate 	{ "modent", "walk list of entries in a given mod_hash",
46847c478bd9Sstevel@tonic-gate 		modent_walk_init, modent_walk_step, modent_walk_fini },
46857c478bd9Sstevel@tonic-gate 	{ "modchain", "walk list of entries in a given mod_hash_entry",
46867c478bd9Sstevel@tonic-gate 		NULL, modchain_walk_step, NULL },
46877c478bd9Sstevel@tonic-gate 
46887c478bd9Sstevel@tonic-gate 	/* from net.c */
4689f4b3ec61Sdh 	{ "icmp", "walk ICMP control structures using MI for all stacks",
4690f4b3ec61Sdh 		mi_payload_walk_init, mi_payload_walk_step, NULL,
4691f4b3ec61Sdh 		&mi_icmp_arg },
46927c478bd9Sstevel@tonic-gate 	{ "mi", "given a MI_O, walk the MI",
46937c478bd9Sstevel@tonic-gate 		mi_walk_init, mi_walk_step, mi_walk_fini, NULL },
46947c478bd9Sstevel@tonic-gate 	{ "sonode", "given a sonode, walk its children",
46957c478bd9Sstevel@tonic-gate 		sonode_walk_init, sonode_walk_step, sonode_walk_fini, NULL },
4696f4b3ec61Sdh 	{ "icmp_stacks", "walk all the icmp_stack_t",
4697f4b3ec61Sdh 		icmp_stacks_walk_init, icmp_stacks_walk_step, NULL },
4698f4b3ec61Sdh 	{ "tcp_stacks", "walk all the tcp_stack_t",
4699f4b3ec61Sdh 		tcp_stacks_walk_init, tcp_stacks_walk_step, NULL },
4700f4b3ec61Sdh 	{ "udp_stacks", "walk all the udp_stack_t",
4701f4b3ec61Sdh 		udp_stacks_walk_init, udp_stacks_walk_step, NULL },
4702f4b3ec61Sdh 
47034c06356bSdh 	/* from netstack.c */
47044c06356bSdh 	{ "netstack", "walk a list of kernel netstacks",
47054c06356bSdh 		netstack_walk_init, netstack_walk_step, NULL },
47064c06356bSdh 
47077c478bd9Sstevel@tonic-gate 	/* from nvpair.c */
47087c478bd9Sstevel@tonic-gate 	{ NVPAIR_WALKER_NAME, NVPAIR_WALKER_DESCR,
47097c478bd9Sstevel@tonic-gate 		nvpair_walk_init, nvpair_walk_step, NULL },
47107c478bd9Sstevel@tonic-gate 
47117c478bd9Sstevel@tonic-gate 	/* from rctl.c */
47127c478bd9Sstevel@tonic-gate 	{ "rctl_dict_list", "walk all rctl_dict_entry_t's from rctl_lists",
47137c478bd9Sstevel@tonic-gate 		rctl_dict_walk_init, rctl_dict_walk_step, NULL },
47147c478bd9Sstevel@tonic-gate 	{ "rctl_set", "given a rctl_set, walk all rctls", rctl_set_walk_init,
47157c478bd9Sstevel@tonic-gate 		rctl_set_walk_step, NULL },
47167c478bd9Sstevel@tonic-gate 	{ "rctl_val", "given a rctl_t, walk all rctl_val entries associated",
47177c478bd9Sstevel@tonic-gate 		rctl_val_walk_init, rctl_val_walk_step },
47187c478bd9Sstevel@tonic-gate 
47197c478bd9Sstevel@tonic-gate 	/* from sobj.c */
47207c478bd9Sstevel@tonic-gate 	{ "blocked", "walk threads blocked on a given sobj",
47217c478bd9Sstevel@tonic-gate 		blocked_walk_init, blocked_walk_step, NULL },
47227c478bd9Sstevel@tonic-gate 	{ "wchan", "given a wchan, list of blocked threads",
47237c478bd9Sstevel@tonic-gate 		wchan_walk_init, wchan_walk_step, wchan_walk_fini },
47247c478bd9Sstevel@tonic-gate 
47257c478bd9Sstevel@tonic-gate 	/* from stream.c */
47267c478bd9Sstevel@tonic-gate 	{ "b_cont", "walk mblk_t list using b_cont",
47277c478bd9Sstevel@tonic-gate 		mblk_walk_init, b_cont_step, mblk_walk_fini },
47287c478bd9Sstevel@tonic-gate 	{ "b_next", "walk mblk_t list using b_next",
47297c478bd9Sstevel@tonic-gate 		mblk_walk_init, b_next_step, mblk_walk_fini },
47307c478bd9Sstevel@tonic-gate 	{ "qlink", "walk queue_t list using q_link",
47317c478bd9Sstevel@tonic-gate 		queue_walk_init, queue_link_step, queue_walk_fini },
47327c478bd9Sstevel@tonic-gate 	{ "qnext", "walk queue_t list using q_next",
47337c478bd9Sstevel@tonic-gate 		queue_walk_init, queue_next_step, queue_walk_fini },
47347c478bd9Sstevel@tonic-gate 	{ "strftblk", "given a dblk_t, walk STREAMS flow trace event list",
47357c478bd9Sstevel@tonic-gate 		strftblk_walk_init, strftblk_step, strftblk_walk_fini },
47367c478bd9Sstevel@tonic-gate 	{ "readq", "walk read queue side of stdata",
47377c478bd9Sstevel@tonic-gate 		str_walk_init, strr_walk_step, str_walk_fini },
47387c478bd9Sstevel@tonic-gate 	{ "writeq", "walk write queue side of stdata",
47397c478bd9Sstevel@tonic-gate 		str_walk_init, strw_walk_step, str_walk_fini },
47407c478bd9Sstevel@tonic-gate 
4741e0ad97e3SJonathan Adams 	/* from taskq.c */
4742e0ad97e3SJonathan Adams 	{ "taskq_thread", "given a taskq_t, list all of its threads",
4743e0ad97e3SJonathan Adams 		taskq_thread_walk_init,
4744e0ad97e3SJonathan Adams 		taskq_thread_walk_step,
4745e0ad97e3SJonathan Adams 		taskq_thread_walk_fini },
4746e0ad97e3SJonathan Adams 	{ "taskq_entry", "given a taskq_t*, list all taskq_ent_t in the list",
4747e0ad97e3SJonathan Adams 		taskq_ent_walk_init, taskq_ent_walk_step, NULL },
4748e0ad97e3SJonathan Adams 
47497c478bd9Sstevel@tonic-gate 	/* from thread.c */
47507c478bd9Sstevel@tonic-gate 	{ "deathrow", "walk threads on both lwp_ and thread_deathrow",
47517c478bd9Sstevel@tonic-gate 		deathrow_walk_init, deathrow_walk_step, NULL },
47527c478bd9Sstevel@tonic-gate 	{ "cpu_dispq", "given a cpu_t, walk threads in dispatcher queues",
47537c478bd9Sstevel@tonic-gate 		cpu_dispq_walk_init, dispq_walk_step, dispq_walk_fini },
47547c478bd9Sstevel@tonic-gate 	{ "cpupart_dispq",
47557c478bd9Sstevel@tonic-gate 		"given a cpupart_t, walk threads in dispatcher queues",
47567c478bd9Sstevel@tonic-gate 		cpupart_dispq_walk_init, dispq_walk_step, dispq_walk_fini },
47577c478bd9Sstevel@tonic-gate 	{ "lwp_deathrow", "walk lwp_deathrow",
47587c478bd9Sstevel@tonic-gate 		lwp_deathrow_walk_init, deathrow_walk_step, NULL },
47597c478bd9Sstevel@tonic-gate 	{ "thread", "global or per-process kthread_t structures",
47607c478bd9Sstevel@tonic-gate 		thread_walk_init, thread_walk_step, thread_walk_fini },
47617c478bd9Sstevel@tonic-gate 	{ "thread_deathrow", "walk threads on thread_deathrow",
47627c478bd9Sstevel@tonic-gate 		thread_deathrow_walk_init, deathrow_walk_step, NULL },
47637c478bd9Sstevel@tonic-gate 
47647c478bd9Sstevel@tonic-gate 	/* from tsd.c */
47657c478bd9Sstevel@tonic-gate 	{ "tsd", "walk list of thread-specific data",
47667c478bd9Sstevel@tonic-gate 		tsd_walk_init, tsd_walk_step, tsd_walk_fini },
47677c478bd9Sstevel@tonic-gate 
476845916cd2Sjpk 	/* from tsol.c */
476945916cd2Sjpk 	{ "tnrh", "walk remote host cache structures",
477045916cd2Sjpk 	    tnrh_walk_init, tnrh_walk_step, tnrh_walk_fini },
477145916cd2Sjpk 	{ "tnrhtp", "walk remote host template structures",
477245916cd2Sjpk 	    tnrhtp_walk_init, tnrhtp_walk_step, tnrhtp_walk_fini },
477345916cd2Sjpk 
47747c478bd9Sstevel@tonic-gate 	/*
47757c478bd9Sstevel@tonic-gate 	 * typegraph does not work under kmdb, as it requires too much memory
47767c478bd9Sstevel@tonic-gate 	 * for its internal data structures.
47777c478bd9Sstevel@tonic-gate 	 */
47787c478bd9Sstevel@tonic-gate #ifndef _KMDB
47797c478bd9Sstevel@tonic-gate 	/* from typegraph.c */
47807c478bd9Sstevel@tonic-gate 	{ "typeconflict", "walk buffers with conflicting type inferences",
47817c478bd9Sstevel@tonic-gate 		typegraph_walk_init, typeconflict_walk_step },
47827c478bd9Sstevel@tonic-gate 	{ "typeunknown", "walk buffers with unknown types",
47837c478bd9Sstevel@tonic-gate 		typegraph_walk_init, typeunknown_walk_step },
47847c478bd9Sstevel@tonic-gate #endif
47857c478bd9Sstevel@tonic-gate 
47867c478bd9Sstevel@tonic-gate 	/* from vfs.c */
47877c478bd9Sstevel@tonic-gate 	{ "vfs", "walk file system list",
47887c478bd9Sstevel@tonic-gate 		vfs_walk_init, vfs_walk_step },
478970ab954aSramat 
47904c06356bSdh 	/* from zone.c */
47914c06356bSdh 	{ "zone", "walk a list of kernel zones",
47924c06356bSdh 		zone_walk_init, zone_walk_step, NULL },
47934c06356bSdh 	{ "zsd", "walk list of zsd entries for a zone",
47944c06356bSdh 		zsd_walk_init, zsd_walk_step, NULL },
4795f4b3ec61Sdh 
47967c478bd9Sstevel@tonic-gate 	{ NULL }
47977c478bd9Sstevel@tonic-gate };
47987c478bd9Sstevel@tonic-gate 
47997c478bd9Sstevel@tonic-gate static const mdb_modinfo_t modinfo = { MDB_API_VERSION, dcmds, walkers };
48007c478bd9Sstevel@tonic-gate 
4801346799e8SJonathan W Adams /*ARGSUSED*/
4802346799e8SJonathan W Adams static void
4803346799e8SJonathan W Adams genunix_statechange_cb(void *ignored)
4804346799e8SJonathan W Adams {
4805346799e8SJonathan W Adams 	/*
4806346799e8SJonathan W Adams 	 * Force ::findleaks and ::stacks to let go any cached state.
4807346799e8SJonathan W Adams 	 */
4808346799e8SJonathan W Adams 	leaky_cleanup(1);
4809346799e8SJonathan W Adams 	stacks_cleanup(1);
4810346799e8SJonathan W Adams 
4811346799e8SJonathan W Adams 	kmem_statechange();	/* notify kmem */
4812346799e8SJonathan W Adams }
4813346799e8SJonathan W Adams 
48147c478bd9Sstevel@tonic-gate const mdb_modinfo_t *
48157c478bd9Sstevel@tonic-gate _mdb_init(void)
48167c478bd9Sstevel@tonic-gate {
48177c478bd9Sstevel@tonic-gate 	kmem_init();
48187c478bd9Sstevel@tonic-gate 
4819346799e8SJonathan W Adams 	(void) mdb_callback_add(MDB_CALLBACK_STCHG,
4820346799e8SJonathan W Adams 	    genunix_statechange_cb, NULL);
4821346799e8SJonathan W Adams 
48222a12f85aSJeremy Jones #ifndef _KMDB
48232a12f85aSJeremy Jones 	gcore_init();
48242a12f85aSJeremy Jones #endif
48252a12f85aSJeremy Jones 
48267c478bd9Sstevel@tonic-gate 	return (&modinfo);
48277c478bd9Sstevel@tonic-gate }
48287c478bd9Sstevel@tonic-gate 
48297c478bd9Sstevel@tonic-gate void
48307c478bd9Sstevel@tonic-gate _mdb_fini(void)
48317c478bd9Sstevel@tonic-gate {
48327c478bd9Sstevel@tonic-gate 	leaky_cleanup(1);
4833346799e8SJonathan W Adams 	stacks_cleanup(1);
48347c478bd9Sstevel@tonic-gate }
4835