genunix.c revision cbdcbd056f15c9c9fd82d5543b3a502677c4d391
1N/A * The contents of this file are subject to the terms of the 1N/A * Common Development and Distribution License (the "License"). 1N/A * You may not use this file except in compliance with the License. 1N/A * See the License for the specific language governing permissions 1N/A * and limitations under the License. 1N/A * When distributing Covered Code, include this CDDL HEADER in each 1N/A * If applicable, add the following below this CDDL HEADER, with the 1N/A * fields enclosed by brackets "[]" replaced with your own identifying 1N/A * information: Portions Copyright [yyyy] [name of copyright owner] 1N/A * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 1N/A * Use is subject to license terms. 1N/A * Surely this is defined somewhere... 1N/A default:
return (
'?');
1N/A "S",
"PID",
"PPID",
"PGID",
"SID");
1N/A "UID",
"FLAGS",
"ADDR",
"NAME");
1N/A * kmdb doesn't have access to the reg* functions, so we fall back 1N/A * -n and -o are mutually exclusive. 1N/A "ADDR",
"TASKID",
"PROJID",
"ZONEID",
"REFCNT",
"FLAGS");
"ADDR",
"PROJID",
"ZONEID",
"REFCNT");
/* walk callouts themselves, either by list or id hash. */ mdb_warn(
"callout doesn't support global walk");
/* the walker arg switches between walking by list (0) and walking by id (1). */ * walker for callout lists. This is different from hashes and callouts. * Thankfully, it's also simpler. mdb_warn(
"callout list doesn't support global walk");
mdb_warn(
"failed to read 'callout_table'");
mdb_warn(
"failed to get callout_table array size");
mdb_warn(
"failed to read id_hash at %p",
mdb_warn(
"failed to read cl_hash at %p",
/* callout flags, in no particular order */ /* show real and normal, short and long, expired and unexpired. */ /* private callout data for callback functions */ int seqid;
/* cpu seqid, or -1 */ int ndx;
/* table index. */ /* this callback does the actual callback itself (finally). */ * The callout must have been reallocated. No point in * The callout must have been freed. No point in /* it is possible we don't have the exp time or flags */ /* we have to fetch the expire time ourselves. */ /* free callouts can't use list pointer. */ /* tricky part, since both HIRES and ABS can be set */ /* both flags are set, only skip "regular" ones */ /* individual flags, or no flags */ * We need to print the headers. If walking by id, then * the list header isn't printed, so we must include "XHAL",
"XID",
"FUNC(ARG)");
"PREVID",
"NEXTID",
"PREVL",
"NEXTL");
"DONE",
"UTOS",
"THREAD");
/* this callback is for callout list handling. idhash is done by callout_t_cb */ * The callout list must have been reallocated. No point in * The callout list must have been freed. No point in /* FOUR cases, each different, !A!B, !AB, A!B, AB */ /* both flags are set, only skip "regular" ones */ /* don't be redundant again */ /* yet another layer as we walk the actual callouts via list. */ /* free list structures do not have valid callouts off of them. */ * walk callouts using yet another callback routine. * we use callouts_bytime because id hash is handled via * the callout_t_cb callback. /* this callback handles the details of callout table walking. */ mdb_printf(
"%<u>%-3s %-1s %-?s %-?s %-?s %-?s%</u>",
"SEQ",
"T",
"FREE",
"LFREE",
"CYCLIC",
"HEAP");
"HEAPNUM",
"HEAPMAX",
"TASKQ",
"EXPQ",
/* walk the list hash table */ mdb_warn(
"cannot walk callout free list at %p",
/* first print the expired list. */ /* walk list with callback routine. */ /* walk the id hash table. */ mdb_warn(
"cannot walk callout id free list" * walk callouts directly by id. For id * chain, the callout list is just a header, * so there's no need to walk it. * initialize some common info for both callout dcmds. /* we need a couple of things */ mdb_warn(
"failed to read 'callout_table'");
/* need to get now in nsecs. Approximate with hrtime vars */ mdb_warn(
"Could not determine current system time");
mdb_warn(
"failed to read 'callout_table_bits'");
mdb_warn(
"failed to read 'nsec_per_tick'");
* dcmd to print callouts. Optional addr limits to specific table. * Parses lots of options that get passed to callbacks for walkers. * Has it's own help function. /* getopts doesn't help much with stuff like this */ /* initialize from kernel variables */ /* do some option post-processing */ /* avoid null outputs. */ mdb_printf(
"-t and -a|b are mutually exclusive\n");
mdb_printf(
"value for -a must be earlier than the value" /* don't pass "dot" if no addr. */ * a callout table was specified. Ignore -r|n option /* -F = free callouts, -FL = free lists */ /* walk table, using specialized callback routine. */ * Given an extended callout id, dump its information. /* initialize from kernel variables */ /* we must massage the environment so that the macros will play nice */ mdb_printf(
"calloutid does not accept explicit address.\n");
"SEQ",
"T",
"XL",
"XID",
"IDHASH");
/* get our table. Note this relies on the types being correct */ mdb_warn(
"failed to read id_hash at %p",
/* callout at beginning of hash chain */ mdb_printf(
"id hash chain for this xid is empty\n");
mdb_printf(
"id hash chain for this xid is empty\n");
/* use the walker, luke */ "Given a callout table address, display callouts from table.\n" "Without an address, display callouts from all tables.\n" " -r|n : limit display to (r)ealtime or (n)ormal type callouts\n" " -s|l : limit display to (s)hort-term ids or (l)ong-term ids\n" " -x : limit display to callouts which are executing\n" " -h : limit display to callouts based on hrestime\n" " -B : limit display to callouts based on absolute time\n" " -t|a|b nsec: limit display to callouts that expire a(t) time," " (a)fter time,\n or (b)efore time. Use -a and -b together " " to specify a range.\n For \"now\", use -d[t|a|b] 0.\n" " -d : interpret time option to -t|a|b as delta from current time\n" " -k : use ticks instead of nanoseconds as arguments to" " -t|a|b. Note that\n ticks are less accurate and may not" " match other tick times (ie: lbolt).\n" " -D : display exiration time as delta from current time\n" " -S seqid : limit display to callouts for this cpu sequence id\n" " -C addr : limit display to callouts for this cpu pointer\n" " -f name|addr : limit display to callouts with this function\n" " -p name|addr : limit display to callouts functions with this" " -T : display the callout table itself, instead of callouts\n" " -L : display callout lists instead of callouts\n" " -E : with -T or L, display empty data structures.\n" " -i : traverse callouts by id hash instead of list hash\n" " -F : walk free callout list (free list with -i) instead\n" " -v : display more info for each item\n" " -V : show details of each level of info as it is traversed\n" " -A : show only addresses. Useful for pipelines.\n");
"Given an extended callout id, display the callout infomation.\n" " -d : do not dereference callout, just decode the id.\n" " -v : verbose display more info about the callout\n");
mdb_warn(
"failed to find symbol sclass\n");
mdb_printf(
"%<u>%4s %-10s %-24s %-24s%</u>\n",
"SLOT",
"NAME",
"INIT FCN",
"CLASS FCN");
#
define FSNAMELEN 32 /* Max len of FS name we read from vnodeops */ mdb_warn(
"expected explicit vnode_t address before ::\n");
mdb_warn(
"couldn't read lock_descriptor_t at %p\n",
mdb_warn(
"failed to find symbol 'lock_graph'\n");
* We can't use ::walk lock_descriptor directly, because the head of each graph * is really a dummy lock. Rather than trying to dynamically determine if this * is a dummy node or not, we just filter out the initial element of the * The space available for the path corresponding to the locked vnode depends * on whether we are printing 32- or 64-bit addresses. mdb_printf(
"%<u>%-?s %2s %4s %6s %-16s %-?s %s%</u>\n",
"ADDR",
"TP",
"FLAG",
"PID",
"COMM",
"VNODE",
"PATH");
"-------------------------",
"%-25s " },
{
" buf",
" size",
"------",
"%6u " },
{
" buf",
"in use",
"------",
"%6u " },
{
" buf",
" total",
"------",
"%6u " },
{
" memory",
" in use",
"----------",
"%9u%c " },
{
" alloc",
" succeed",
"---------",
"%9u " },
{
"alloc",
" fail",
"-----",
"%5u " },
"-------------------------",
"%-*s " },
{
" memory",
" in use",
"----------",
"%9llu%c " },
{
" memory",
" total",
"-----------",
"%10llu%c " },
{
" memory",
" import",
"----------",
"%9llu%c " },
{
" alloc",
" succeed",
"---------",
"%9llu " },
{
"alloc",
" fail",
"-----",
"%5llu " },
17 -
len,
"",
"",
"",
"",
* Our ::kgrep callback scans the entire kernel VA space (kas). kas is made * up of a set of 'struct seg's. We could just scan each seg en masse, but * unfortunately, a few of the segs are both large and sparse, so we could * spend quite a bit of time scanning VAs which have no backing pages. * So for the few very sparse segs, we skip the segment itself, and scan * the allocated vmem_segs in the vmem arena which manages that part of kas. * Currently, we do this for: * kvseg_core heap_core_arena * In addition, we skip the segkpm segment in its entirety, since it is very * sparse, and contains no new kernel data. * skip large page heap address range - it is scanned by walking * allocated vmem_segs in the heap_lp_arena mdb_warn(
"kgrep can only be run on a system " "dump or under kmdb; see dumpadm(1M)\n");
mdb_warn(
"failed to locate 'kas' symbol\n");
mdb_warn(
"failed to locate 'kvseg' symbol\n");
mdb_warn(
"failed to locate 'kvseg32' symbol\n");
mdb_warn(
"failed to locate 'kvseg_core' symbol\n");
mdb_warn(
"failed to locate 'segkpm_ops' symbol\n");
mdb_warn(
"failed to read 'heap_lp_base'\n");
mdb_warn(
"failed to read 'heap_lp_end'\n");
mdb_warn(
"failed to walk kas segments");
mdb_warn(
"file walk doesn't support global walks\n");
mdb_warn(
"failed to read file array at %p",
mdb_warn(
"port walk doesn't support global walks\n");
mdb_warn(
"portev walk doesn't support global walks\n");
mdb_warn(
"input address (%p) does not point to an event port",
mdb_warn(
"proc %p has invalid p_child %p; skipping\n",
mdb_warn(
"depth %d exceeds max depth; try again\n",
* We know that p0 has no siblings, and if another starting proc * was given, we don't want to walk its siblings anyway. mdb_warn(
"proc %p has invalid p_sibling %p; skipping\n",
* Unfortunately, there is no platform-independent way to walk * CPUs in ID order. We therefore loop through in cpu_next order, * building an array of CPU pointers which will subsequently be mdb_warn(
"CPU %p has id (%d) greater than NCPU (%d)\n",
mdb_warn(
"thread %p has pil (%d) greater than %d\n",
mdb_warn(
"CPU %d has multiple threads at pil %d (at least " "RUNNING",
"READY",
"QUIESCED",
"EXISTS",
"ENABLE",
"OFFLINE",
"POWEROFF",
"FROZEN",
* Set cid_cpu to -1 to indicate that we found a matching CPU. mdb_printf(
"%3s %-*s %3s %4s %4s %3s %4s %5s %-6s %-*s %s\n",
for (i =
1, j = 0;
flags[j] !=
NULL; i <<=
1, j++) {
for (i =
NINTR -
1; i >= 0; i--) {
mdb_warn(
"failed to read kthread_t at %p",
mdb_warn(
"failed to read kthread_t at %p",
for (i =
npri -
1; i >= 0; i--) {
for (i = 0; i <
NCPU; i++)
* We didn't find this CPU when we walked through the CPUs * (i.e. the address specified doesn't show up in the "cpu" * walk). However, the specified address may still correspond * to a valid cpu_t (for example, if the specified address is * the actual panicking cpu_t and not the cached panic_cpu). * Point is: even if we didn't find it, we still want to try * to print the specified address as a cpu_t. mdb_warn(
"%p is neither a valid CPU ID nor a " for (i = 0; i <
sizeof (
addr) *
NBBY; i++)
mdb_warn(
"fd doesn't give global information\n");
mdb_warn(
"process %p only has %d files open.\n",
mdb_warn(
"couldn't read uf_entry_t at %p",
mdb_warn(
"failed to read mod_sysfile_arena");
* Is this an int or a string? We determine this * by checking whether straddr is contained in * mod_sysfile_arena. If so, the walker will set * In order to walk the list of pending error queue elements, we push the * addresses of the corresponding data buffers in to the eqd_stack array. * The error lists are in reverse chronological order when iterating using * eqe_prev, so we then pop things off the top in eqd_walk_step so that the * walker client gets addresses in order from oldest error to newest error. mdb_warn(
"errorq is overfull -- more than %lu " * The newest elements in the queue are on the pending list, so we * push those on to our stack first. * If eq_ptail is set, it may point to a subset of the errors on the * pending list in the event a casptr() failed; if ptail's data is * already in our stack, NULL out eq_ptail and ignore it. * If eq_phead is set, it has the processing list in order from oldest * to newest. Use this to recompute eq_ptail as best we can and then * we nicely fall into eqd_push_list() of eq_ptail below. * The oldest elements in the queue are on the processing list, subject * to machinations in the if-clauses above. Push any such elements. "ADDR",
"NAME",
"S",
"V",
"N");
"ACCEPT",
"DROP",
"LOG");
"KSTAT",
"QLEN",
"SIZE",
"IPL",
"FUNC");
mdb_warn(
"panicinfo can only be run on a system " "dump; see dumpadm(1M)\n");
mdb_warn(
"failed to read 'panic_thread'");
* ::time dcmd, which will print a hires timestamp of when we entered the * debugger, or the lbolt value if used with the -l option. mdb_printf(
"Prints the system time in nanoseconds.\n\n" "::time will return the timestamp at which we dropped into, \n" "if called from, kmdb(1); the core dump's high resolution \n" "time if inspecting one; or the running hires time if we're \n" "looking at a live system.\n\n" " -l prints the number of clock ticks since system boot\n");
{
"as2proc",
":",
"convert as to proc_t address",
as2proc },
{
"binding_hash_entry",
":",
"print driver names hash table entry",
{
"callout",
"?[-r|n] [-s|l] [-xhB] [-t | -ab nsec [-dkD]]" " [-C addr | -S seqid] [-f name|addr] [-p name| addr] [-T|L [-E]]" {
"calloutid",
"[-d|v] xid",
"print callout by extended id",
{
"class",
NULL,
"print process scheduler classes",
class },
{
"cpuinfo",
"?[-v]",
"print CPUs and runnable threads",
cpuinfo },
{
"did2thread",
"? kt_did",
"find kernel thread for this id",
{
"errorq",
"?[-v]",
"display kernel error queues",
errorq },
{
"fd",
":[fd num]",
"get a file pointer from an fd",
fd },
{
"flipone",
":",
"the vik_rev_level 2 special",
flipone },
{
"lminfo",
NULL,
"print lock manager information",
lminfo },
{
"pid2proc",
"?",
"convert PID to proc_t address",
pid2proc },
{
"project",
NULL,
"display kernel project(s)",
project },
{
"ps",
"[-fltzTP]",
"list processes (and associated thr,lwp)",
ps },
{
"pgrep",
"[-x] [-n | -o] pattern",
"pattern match against all processes",
pgrep },
{
"ptree",
NULL,
"print process tree",
ptree },
{
"sysevent",
"?[-sv]",
"print sysevent pending or sent queue",
{
"sysevent_channel",
"?",
"print sysevent channel database",
{
"sysevent_class_list",
":",
"print sysevent class list",
{
"sysevent_subclass_list",
":",
{
"task",
NULL,
"display kernel task(s)",
task },
{
"vnode2path",
":[-F]",
"vnode address to pathname",
vnode2path },
{
"whereopen",
":",
"given a vnode, dumps procs which have it open",
{
"bufpagefind",
":addr",
"find page_t on buf_t list",
bufpagefind },
{
"ctevent",
":",
"display a contract event",
cmd_ctevent },
{
"ctid",
":",
"convert id to a contract pointer",
cmd_ctid },
{
"cpupart",
"?[-v]",
"print cpu partition info",
cpupart },
{
"cyccover",
NULL,
"dump cyclic coverage information",
cyccover },
{
"cycid",
"?",
"dump a cyclic id",
cycid },
{
"cycinfo",
"?",
"dump cyc_cpu info",
cycinfo },
{
"cyclic",
":",
"developer information",
cyclic },
{
"cyctrace",
"?",
"dump cyclic trace buffer",
cyctrace },
{
"devbindings",
"?[-qs] [device-name | major-num]",
"print devinfo nodes bound to device-name or major-num",
{
"devinfo",
":[-qs]",
"detailed devinfo of one node",
devinfo,
{
"devinfo_audit",
":[-v]",
"devinfo configuration audit record",
{
"devinfo_audit_log",
"?[-v]",
"system wide devinfo configuration log",
{
"devinfo_audit_node",
":[-v]",
"devinfo node configuration history",
{
"devinfo2driver",
":",
"find driver name for this devinfo node",
{
"devnames",
"?[-vm] [num]",
"print devnames array",
devnames },
{
"dev2major",
"?<dev_t>",
"convert dev_t to a major number",
{
"dev2minor",
"?<dev_t>",
"convert dev_t to a minor number",
{
"devt",
"?<dev_t>",
"display a dev_t's major and minor numbers",
{
"major2name",
"?<major-num>",
"convert major number to dev name",
{
"minornodes",
":",
"given a devinfo node, print its minor nodes",
{
"modctl2devinfo",
":",
"given a modctl, list its devinfos",
{
"name2major",
"<dev-name>",
"convert dev name to major number",
{
"softstate",
":<instance>",
"retrieve soft-state pointer",
{
"devinfo_fm",
":",
"devinfo fault managment configuration",
{
"devinfo_fmce",
":",
"devinfo fault managment cache entry",
{
"findstack",
":[-v]",
"find kernel thread stack",
findstack },
{
"findstack_debug",
NULL,
"toggle findstack debugging",
{
"stacks",
"?[-afiv] [-c func] [-C func] [-m module] [-M module] " "[-s sobj | -S sobj] [-t tstate | -T tstate]",
"print unique kernel thread stacks",
{
"ereport",
"[-v]",
"print ereports logged in dump",
{
"group",
"?[-q]",
"display a group",
group},
{
"hotplug",
"?[-p]",
"display a registered hotplug attachment",
{
"irmreqs",
NULL,
"display interrupt requests in an interrupt pool",
{
"allocdby",
":",
"given a thread, print its allocated buffers",
{
"bufctl",
":[-vh] [-a addr] [-c caller] [-e earliest] [-l latest] " {
"freedby",
":",
"given a thread, print its freed buffers",
freedby },
{
"kmalog",
"?[ fail | slab ]",
"display kmem transaction log and stack traces",
kmalog },
{
"kmastat",
"[-kmg]",
"kernel memory allocator stats",
{
"kmausers",
"?[-ef] [cache ...]",
"current medium and large users " {
"kmem_cache",
"?[-n name]",
{
"kmem_slabs",
"?[-v] [-n cache] [-N cache] [-b maxbins] " "[-B minbinsize]",
"display slab usage per kmem cache",
{
"kmem_log",
"?[-b]",
"dump kmem transaction log",
kmem_log },
{
"kmem_verify",
"?",
"check integrity of kmem-managed memory",
{
"vmem",
"?",
"print a vmem_t",
vmem },
{
"vmem_seg",
":[-sv] [-c caller] [-e earliest] [-l latest] " "[-m minsize] [-M maxsize] [-t thread] [-T type]",
{
"whatthread",
":[-v]",
"print threads whose stack contains the " {
"ldi_handle",
"?[-i]",
"display a layered driver handle",
{
"ldi_ident",
NULL,
"display a layered driver identifier",
"search for potential kernel memory leaks",
findleaks,
{
"lgrp",
"?[-q] [-p | -Pih]",
"display an lgrp",
lgrp},
{
"lgrp_set",
"",
"display bitmask of lgroups as a list",
lgrp_set},
{
"msgbuf",
"?[-v]",
"print most recent console messages",
msgbuf },
{
"mdipi",
NULL,
"given a path, dump mdi_pathinfo " "and detailed pi_prop list",
mdipi },
{
"mdiprops",
NULL,
"given a pi_prop, dump the pi_prop list",
{
"mdiphci",
NULL,
"given a phci, dump mdi_phci and " {
"mdivhci",
NULL,
"given a vhci, dump mdi_vhci and list " {
"mdiclient_paths",
NULL,
"given a path, walk mdi_pathinfo " {
"mdiphci_paths",
NULL,
"given a path, walk through mdi_pathinfo " {
"mdiphcis",
NULL,
"given a phci, walk through mdi_phci ph_next links",
{
"addr2smap",
":[offset]",
"translate address to smap",
addr2smap },
{
"memlist",
"?[-iav]",
"display a struct memlist",
memlist },
{
"memstat",
NULL,
"display memory usage summary",
memstat },
{
"page",
"?",
"display a summarized page_t",
page },
{
"pagelookup",
"?[-v vp] [-o offset]",
"find the page_t with the name {vp, offset}",
{
"page_num2pp",
":",
"find the page_t for a given page frame number",
{
"pmap",
":[-q]",
"print process memory map",
pmap },
{
"seg",
":",
"print address space segment",
seg },
{
"swapinfo",
"?",
"display a struct swapinfo",
swapinfof },
{
"vnode2smap",
":[offset]",
"translate vnode to smap",
vnode2smap },
{
"multidata",
":[-sv]",
"display a summarized multidata_t",
{
"pattbl",
":",
"display a summarized multidata attribute table",
{
"pattr2multidata",
":",
"print multidata pointer from pattr_t",
{
"pdesc2slab",
":",
"print pdesc slab pointer from pdesc_t",
{
"pdesc_verify",
":",
"verify integrity of a pdesc_t",
pdesc_verify },
{
"slab2multidata",
":",
"print multidata pointer from pdesc_slab_t",
{
"modhash",
"?[-ceht] [-k key] [-v val] [-i index]",
"display information about one or all mod_hash structures",
{
"modent",
":[-k | -v | -t type]",
"display information about a mod_hash_entry",
modent,
{
"dladm",
"?<sub-command> [flags]",
"show data link information",
{
"mi",
":[-p] [-d | -m]",
"filter and display MI object or payload",
{
"netstat",
"[-arv] [-f inet | inet6 | unix] [-P tcp | udp | icmp]",
"show network statistics",
netstat },
{
"sonode",
"?[-f inet | inet6 | unix | #] " "[-t stream | dgram | raw | #] [-p #]",
"filter and display sonode",
sonode },
{
"netstack",
"",
"show stack instances",
netstack },
{
"pg",
"?[-q]",
"display a pg",
pg},
{
"rctl_dict",
"?",
"print systemwide default rctl definitions",
{
"rctl_list",
":[handle]",
"print rctls for the given proc",
{
"rctl",
":[handle]",
"print a rctl_t, only if it matches the handle",
{
"rctl_validate",
":[-v] [-n #]",
"test resource control value " {
"mutex",
":[-f]",
"dump out an adaptive or spin mutex",
mutex,
{
"sobj2ts",
":",
"perform turnstile lookup on synch object",
sobj2ts },
{
"wchaninfo",
"?[-v]",
"dump condition variable",
wchaninfo },
{
"turnstile",
"?",
"display a turnstile",
turnstile },
{
"mblk",
":[-q|v] [-f|F flag] [-t|T type] [-l|L|B len] [-d dbaddr]",
{
"mblk_verify",
"?",
"verify integrity of an mblk",
mblk_verify },
{
"mblk2dblk",
":",
"convert mblk_t address to dblk_t address",
{
"q2otherq",
":",
"print peer queue for a given queue",
q2otherq },
{
"q2rdq",
":",
"print read queue for a given queue",
q2rdq },
{
"q2syncq",
":",
"print syncq for a given queue",
q2syncq },
{
"q2stream",
":",
"print stream pointer for a given queue",
q2stream },
{
"q2wrq",
":",
"print write queue for a given queue",
q2wrq },
{
"queue",
":[-q|v] [-m mod] [-f flag] [-F flag] [-s syncq_addr]",
{
"stdata",
":[-q|v] [-f flag] [-F flag]",
{
"str2mate",
":",
"print mate of this stream",
str2mate },
{
"str2wrq",
":",
"print write queue of this stream",
str2wrq },
{
"stream",
":",
"display STREAM",
stream },
{
"strftevent",
":",
"print STREAMS flow trace event",
strftevent },
{
"syncq",
":[-q|v] [-f flag] [-F flag] [-t type] [-T type]",
{
"syncq2q",
":",
"print queue for a given syncq",
syncq2q },
{
"taskq",
":[-atT] [-m min_maxq] [-n name]",
{
"taskq_entry",
":",
"display a taskq_ent_t",
taskq_ent },
{
"thread",
"?[-bdfimps]",
"display a summarized kthread_t",
thread,
{
"threadlist",
"?[-t] [-v [count]]",
"display threads and associated C stack traces",
threadlist,
{
"stackinfo",
"?[-h|-a]",
"display kthread_t stack usage",
stackinfo,
{
"tsd",
":-k key",
"print tsd[key-1] for this thread",
ttotsd },
{
"tsdtot",
":",
"find thread with this tsd",
tsdtot },
* typegraph does not work under kmdb, as it requires too much memory * for its internal data structures. {
"findlocks",
":",
"find locks held by specified thread",
findlocks },
{
"findfalse",
"?[-v]",
"find potentially falsely shared structures",
{
"istype",
":type",
"manually set object type",
istype },
{
"notype",
":",
"manually clear object type",
notype },
{
"whattype",
":",
"determine object type",
whattype },
{
"fsinfo",
"?[-v]",
"print mounted filesystems",
fsinfo },
{
"pfiles",
":[-fp]",
"print process file information",
pfiles,
{
"zone",
"?",
"display kernel zone(s)",
zoneprt },
{
"zsd",
":[-v] [zsd_key]",
"display zone-specific-data entries for " {
"callouts_bytime",
"walk callouts by list chain (expiration time)",
{
"callouts_byid",
"walk callouts by id hash chain",
{
"ereportq_dump",
"walk list of ereports in dump error queue",
{
"ereportq_pend",
"walk list of ereports in pending error queue",
{
"errorq",
"walk list of system error queues",
{
"errorq_data",
"walk pending error queue data buffers",
{
"allfile",
"given a proc pointer, list all file pointers",
{
"file",
"given a proc pointer, list of open file pointers",
{
"lock_descriptor",
"walk lock_descriptor_t structures",
{
"lock_graph",
"walk lock graph",
{
"port",
"given a proc pointer, list of created event ports",
{
"portev",
"given a port pointer, list of events in the queue",
{
"proc",
"list of active proc_t structures",
{
"projects",
"walk a list of kernel projects",
{
"sysevent_pend",
"walk sysevent pending queue",
{
"sysevent_channel",
"walk sysevent channel subscriptions",
{
"sysevent_class_list",
"walk sysevent subscription's class list",
{
"sysevent_subclass_list",
"walk sysevent subscription's subclass list",
{
"task",
"given a task pointer, walk its processes",
{
"buf",
"walk the bio buf hash",
{
"contract",
"walk all contracts, or those of the specified type",
{
"ct_event",
"walk events on a contract event queue",
{
"ct_listener",
"walk contract event queue listeners",
{
"cpupart_cpulist",
"given an cpupart_t, walk cpus in partition",
{
"cpupart_walk",
"walk the set of cpu partitions",
{
"ctxop",
"walk list of context ops on a thread",
{
"cyccpu",
"walk per-CPU cyc_cpu structures",
{
"cycomni",
"for an omnipresent cyclic, walk cyc_omni_cpu list",
{
"cyctrace",
"walk cyclic trace buffer",
{
"binding_hash",
"walk all entries in binding hash table",
{
"devinfo",
"walk devinfo tree or subtree",
{
"devinfo_audit_log",
"walk devinfo audit system-wide log",
{
"devinfo_audit_node",
"walk per-devinfo audit history",
{
"devinfo_children",
"walk children of devinfo node",
{
"devinfo_parents",
"walk ancestors of devinfo node",
{
"devinfo_siblings",
"walk siblings of devinfo node",
{
"devi_next",
"walk devinfo list",
{
"devnames",
"walk devnames array",
{
"minornode",
"given a devinfo node, walk minor nodes",
"given an i_ddi_soft_state*, list all in-use driver stateps",
"given an i_ddi_soft_state*, list all driver stateps",
"walk a fault management handle cache active list",
{
"group",
"walk all elements of a group",
{
"irmpools",
"walk global list of interrupt pools",
{
"irmreqs",
"walk list of interrupt requests in an interrupt pool",
{
"allocdby",
"given a thread, walk its allocated bufctls",
{
"bufctl",
"walk a kmem cache's bufctls",
{
"bufctl_history",
"walk the available history of a bufctl",
{
"freedby",
"given a thread, walk its freed bufctls",
{
"freectl",
"walk a kmem cache's free bufctls",
{
"freectl_constructed",
"walk a kmem cache's constructed free bufctls",
{
"freemem",
"walk a kmem cache's free memory",
{
"freemem_constructed",
"walk a kmem cache's constructed free memory",
{
"kmem",
"walk a kmem cache",
{
"kmem_cpu_cache",
"given a kmem cache, walk its per-CPU caches",
{
"kmem_hash",
"given a kmem cache, walk its allocated hash table",
{
"kmem_log",
"walk the kmem transaction log",
{
"kmem_slab",
"given a kmem cache, walk its slabs",
"given a kmem cache, walk its partially allocated slabs (min 1)",
{
"vmem",
"walk vmem structures in pre-fix, depth-first order",
{
"vmem_alloc",
"given a vmem_t, walk its allocated vmem_segs",
{
"vmem_free",
"given a vmem_t, walk its free vmem_segs",
{
"vmem_postfix",
"walk vmem structures in post-fix, depth-first order",
{
"vmem_seg",
"given a vmem_t, walk all of its vmem_segs",
{
"vmem_span",
"given a vmem_t, walk its spanning vmem_segs",
{
"ldi_handle",
"walk the layered driver handle hash",
{
"ldi_ident",
"walk the layered driver identifier hash",
{
"leak",
"given a leaked bufctl or vmem_seg, find leaks w/ same " {
"leakbuf",
"given a leaked bufctl or vmem_seg, walk buffers for " "leaks w/ same stack trace",
{
"lgrp_cpulist",
"walk CPUs in a given lgroup",
{
"lgrptbl",
"walk lgroup table",
{
"lgrp_parents",
"walk up lgroup lineage from given lgroup",
{
"lgrp_rsrc_mem",
"walk lgroup memory resources of given lgroup",
{
"lgrp_rsrc_cpu",
"walk lgroup CPU resources of given lgroup",
{
"mdipi_client_list",
"Walker for mdi_pathinfo pi_client_link",
{
"mdipi_phci_list",
"Walker for mdi_pathinfo pi_phci_link",
{
"mdiphci_list",
"Walker for mdi_phci ph_next link",
{
"allpages",
"walk all pages, including free pages",
{
"anon",
"given an amp, list of anon structures",
{
"memlist",
"walk specified memlist",
{
"page",
"walk all pages, or those from the specified vnode",
{
"seg",
"given an as, list of segments",
{
"swapinfo",
"walk swapinfo structures",
{
"pdesc",
"walk pdesc_t structures",
{
"pdesc_slab",
"walk pdesc_slab_t structures",
{
"modent",
"walk list of entries in a given mod_hash",
{
"modchain",
"walk list of entries in a given mod_hash_entry",
{
"icmp",
"walk ICMP control structures using MI for all stacks",
{
"mi",
"given a MI_O, walk the MI",
{
"sonode",
"given a sonode, walk its children",
{
"icmp_stacks",
"walk all the icmp_stack_t",
{
"tcp_stacks",
"walk all the tcp_stack_t",
{
"udp_stacks",
"walk all the udp_stack_t",
{
"netstack",
"walk a list of kernel netstacks",
{
"rctl_dict_list",
"walk all rctl_dict_entry_t's from rctl_lists",
{
"rctl_val",
"given a rctl_t, walk all rctl_val entries associated",
{
"blocked",
"walk threads blocked on a given sobj",
{
"wchan",
"given a wchan, list of blocked threads",
{
"b_cont",
"walk mblk_t list using b_cont",
{
"b_next",
"walk mblk_t list using b_next",
{
"qlink",
"walk queue_t list using q_link",
{
"qnext",
"walk queue_t list using q_next",
{
"strftblk",
"given a dblk_t, walk STREAMS flow trace event list",
{
"readq",
"walk read queue side of stdata",
{
"writeq",
"walk write queue side of stdata",
{
"taskq_thread",
"given a taskq_t, list all of its threads",
{
"taskq_entry",
"given a taskq_t*, list all taskq_ent_t in the list",
{
"deathrow",
"walk threads on both lwp_ and thread_deathrow",
{
"cpu_dispq",
"given a cpu_t, walk threads in dispatcher queues",
"given a cpupart_t, walk threads in dispatcher queues",
{
"lwp_deathrow",
"walk lwp_deathrow",
{
"thread",
"global or per-process kthread_t structures",
{
"thread_deathrow",
"walk threads on thread_deathrow",
{
"tsd",
"walk list of thread-specific data",
{
"tnrh",
"walk remote host cache structures",
{
"tnrhtp",
"walk remote host template structures",
* typegraph does not work under kmdb, as it requires too much memory * for its internal data structures. {
"typeconflict",
"walk buffers with conflicting type inferences",
{
"typeunknown",
"walk buffers with unknown types",
{
"vfs",
"walk file system list",
{
"zone",
"walk a list of kernel zones",
{
"zsd",
"walk list of zsd entries for a zone",
* Force ::findleaks and ::stacks to let go any cached state.