1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
23 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright 2019 Joyent, Inc.
25 * Copyright (c) 2013 by Delphix. All rights reserved.
26 * Copyright 2022 Garrett D'Amore
27 * Copyright 2023 RackTop Systems, Inc.
28 * Copyright 2025 Oxide Computer Company
29 */
30
31 #include <mdb/mdb_param.h>
32 #include <mdb/mdb_modapi.h>
33 #include <mdb/mdb_ks.h>
34 #include <mdb/mdb_ctf.h>
35
36 #include <sys/types.h>
37 #include <sys/thread.h>
38 #include <sys/session.h>
39 #include <sys/user.h>
40 #include <sys/proc.h>
41 #include <sys/var.h>
42 #include <sys/t_lock.h>
43 #include <sys/callo.h>
44 #include <sys/priocntl.h>
45 #include <sys/class.h>
46 #include <sys/regset.h>
47 #include <sys/stack.h>
48 #include <sys/cpuvar.h>
49 #include <sys/vnode.h>
50 #include <sys/vfs.h>
51 #include <sys/flock_impl.h>
52 #include <sys/kmem_impl.h>
53 #include <sys/vmem_impl.h>
54 #include <sys/kstat.h>
55 #include <sys/dditypes.h>
56 #include <sys/ddi_impldefs.h>
57 #include <sys/sysmacros.h>
58 #include <sys/sysconf.h>
59 #include <sys/task.h>
60 #include <sys/project.h>
61 #include <sys/errorq_impl.h>
62 #include <sys/cred_impl.h>
63 #include <sys/zone.h>
64 #include <sys/panic.h>
65 #include <regex.h>
66 #include <sys/port_impl.h>
67 #include <sys/contract/process_impl.h>
68
69 #include "avl.h"
70 #include "bio.h"
71 #include "bitset.h"
72 #include "combined.h"
73 #include "contract.h"
74 #include "cpupart_mdb.h"
75 #include "cred.h"
76 #include "ctxop.h"
77 #include "cyclic.h"
78 #include "damap.h"
79 #include "ddi_periodic.h"
80 #include "devinfo.h"
81 #include "dnlc.h"
82 #include "findstack.h"
83 #include "fm.h"
84 #include "gcore.h"
85 #include "group.h"
86 #include "irm.h"
87 #include "kgrep.h"
88 #include "kmem.h"
89 #include "ldi.h"
90 #include "leaky.h"
91 #include "lgrp.h"
92 #include "list.h"
93 #include "log.h"
94 #include "mdi.h"
95 #include "memory.h"
96 #include "modhash.h"
97 #include "ndievents.h"
98 #include "net.h"
99 #include "netstack.h"
100 #include "nvpair.h"
101 #include "pci.h"
102 #include "pg.h"
103 #include "rctl.h"
104 #include "sobj.h"
105 #include "streams.h"
106 #include "sysevent.h"
107 #include "taskq.h"
108 #include "thread.h"
109 #include "tsd.h"
110 #include "tsol.h"
111 #include "typegraph.h"
112 #include "vfs.h"
113 #include "zone.h"
114 #include "hotplug.h"
115
116 /*
117 * Surely this is defined somewhere...
118 */
119 #define NINTR 16
120
121 #define KILOS 10
122 #define MEGS 20
123 #define GIGS 30
124
125 #ifndef STACK_BIAS
126 #define STACK_BIAS 0
127 #endif
128
129 static char
pstat2ch(uchar_t state)130 pstat2ch(uchar_t state)
131 {
132 switch (state) {
133 case SSLEEP: return ('S');
134 case SRUN: return ('R');
135 case SZOMB: return ('Z');
136 case SIDL: return ('I');
137 case SONPROC: return ('O');
138 case SSTOP: return ('T');
139 case SWAIT: return ('W');
140 default: return ('?');
141 }
142 }
143
144 #define PS_PRTTHREADS 0x1
145 #define PS_PRTLWPS 0x2
146 #define PS_PSARGS 0x4
147 #define PS_TASKS 0x8
148 #define PS_PROJECTS 0x10
149 #define PS_ZONES 0x20
150 #define PS_SERVICES 0x40
151
152 static int
ps_threadprint(uintptr_t addr,const void * data,void * private)153 ps_threadprint(uintptr_t addr, const void *data, void *private)
154 {
155 const kthread_t *t = (const kthread_t *)data;
156 uint_t prt_flags = *((uint_t *)private);
157
158 static const mdb_bitmask_t t_state_bits[] = {
159 { "TS_FREE", UINT_MAX, TS_FREE },
160 { "TS_SLEEP", TS_SLEEP, TS_SLEEP },
161 { "TS_RUN", TS_RUN, TS_RUN },
162 { "TS_ONPROC", TS_ONPROC, TS_ONPROC },
163 { "TS_ZOMB", TS_ZOMB, TS_ZOMB },
164 { "TS_STOPPED", TS_STOPPED, TS_STOPPED },
165 { "TS_WAIT", TS_WAIT, TS_WAIT },
166 { NULL, 0, 0 }
167 };
168
169 if (prt_flags & PS_PRTTHREADS)
170 mdb_printf("\tT %?a <%b>\n", addr, t->t_state, t_state_bits);
171
172 if (prt_flags & PS_PRTLWPS) {
173 char desc[128] = "";
174
175 (void) thread_getdesc(addr, B_FALSE, desc, sizeof (desc));
176
177 mdb_printf("\tL %?a ID: %s\n", t->t_lwp, desc);
178 }
179
180 return (WALK_NEXT);
181 }
182
183 typedef struct mdb_pflags_proc {
184 struct pid *p_pidp;
185 ushort_t p_pidflag;
186 uint_t p_proc_flag;
187 uint_t p_flag;
188 } mdb_pflags_proc_t;
189
190 static int
pflags(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)191 pflags(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
192 {
193 mdb_pflags_proc_t pr;
194 struct pid pid;
195
196 static const mdb_bitmask_t p_flag_bits[] = {
197 { "SSYS", SSYS, SSYS },
198 { "SEXITING", SEXITING, SEXITING },
199 { "SITBUSY", SITBUSY, SITBUSY },
200 { "SFORKING", SFORKING, SFORKING },
201 { "SWATCHOK", SWATCHOK, SWATCHOK },
202 { "SKILLED", SKILLED, SKILLED },
203 { "SSCONT", SSCONT, SSCONT },
204 { "SZONETOP", SZONETOP, SZONETOP },
205 { "SEXTKILLED", SEXTKILLED, SEXTKILLED },
206 { "SUGID", SUGID, SUGID },
207 { "SEXECED", SEXECED, SEXECED },
208 { "SJCTL", SJCTL, SJCTL },
209 { "SNOWAIT", SNOWAIT, SNOWAIT },
210 { "SVFORK", SVFORK, SVFORK },
211 { "SVFWAIT", SVFWAIT, SVFWAIT },
212 { "SEXITLWPS", SEXITLWPS, SEXITLWPS },
213 { "SHOLDFORK", SHOLDFORK, SHOLDFORK },
214 { "SHOLDFORK1", SHOLDFORK1, SHOLDFORK1 },
215 { "SCOREDUMP", SCOREDUMP, SCOREDUMP },
216 { "SMSACCT", SMSACCT, SMSACCT },
217 { "SLWPWRAP", SLWPWRAP, SLWPWRAP },
218 { "SAUTOLPG", SAUTOLPG, SAUTOLPG },
219 { "SNOCD", SNOCD, SNOCD },
220 { "SHOLDWATCH", SHOLDWATCH, SHOLDWATCH },
221 { "SMSFORK", SMSFORK, SMSFORK },
222 { "SDOCORE", SDOCORE, SDOCORE },
223 { NULL, 0, 0 }
224 };
225
226 static const mdb_bitmask_t p_pidflag_bits[] = {
227 { "CLDPEND", CLDPEND, CLDPEND },
228 { "CLDCONT", CLDCONT, CLDCONT },
229 { "CLDNOSIGCHLD", CLDNOSIGCHLD, CLDNOSIGCHLD },
230 { "CLDWAITPID", CLDWAITPID, CLDWAITPID },
231 { NULL, 0, 0 }
232 };
233
234 static const mdb_bitmask_t p_proc_flag_bits[] = {
235 { "P_PR_TRACE", P_PR_TRACE, P_PR_TRACE },
236 { "P_PR_PTRACE", P_PR_PTRACE, P_PR_PTRACE },
237 { "P_PR_FORK", P_PR_FORK, P_PR_FORK },
238 { "P_PR_LOCK", P_PR_LOCK, P_PR_LOCK },
239 { "P_PR_ASYNC", P_PR_ASYNC, P_PR_ASYNC },
240 { "P_PR_EXEC", P_PR_EXEC, P_PR_EXEC },
241 { "P_PR_BPTADJ", P_PR_BPTADJ, P_PR_BPTADJ },
242 { "P_PR_RUNLCL", P_PR_RUNLCL, P_PR_RUNLCL },
243 { "P_PR_KILLCL", P_PR_KILLCL, P_PR_KILLCL },
244 { NULL, 0, 0 }
245 };
246
247 if (!(flags & DCMD_ADDRSPEC)) {
248 if (mdb_walk_dcmd("proc", "pflags", argc, argv) == -1) {
249 mdb_warn("can't walk 'proc'");
250 return (DCMD_ERR);
251 }
252 return (DCMD_OK);
253 }
254
255 if (mdb_ctf_vread(&pr, "proc_t", "mdb_pflags_proc_t", addr, 0) == -1 ||
256 mdb_vread(&pid, sizeof (pid), (uintptr_t)pr.p_pidp) == -1) {
257 mdb_warn("cannot read proc_t or pid");
258 return (DCMD_ERR);
259 }
260
261 mdb_printf("%p [pid %d]:\n", addr, pid.pid_id);
262 mdb_printf("\tp_flag: %08x <%b>\n", pr.p_flag, pr.p_flag,
263 p_flag_bits);
264 mdb_printf("\tp_pidflag: %08x <%b>\n", pr.p_pidflag, pr.p_pidflag,
265 p_pidflag_bits);
266 mdb_printf("\tp_proc_flag: %08x <%b>\n", pr.p_proc_flag, pr.p_proc_flag,
267 p_proc_flag_bits);
268
269 return (DCMD_OK);
270 }
271
272 typedef struct mdb_ps_proc {
273 char p_stat;
274 struct pid *p_pidp;
275 struct pid *p_pgidp;
276 struct cred *p_cred;
277 struct sess *p_sessp;
278 struct task *p_task;
279 struct zone *p_zone;
280 struct cont_process *p_ct_process;
281 pid_t p_ppid;
282 uint_t p_flag;
283 struct {
284 char u_comm[MAXCOMLEN + 1];
285 char u_psargs[PSARGSZ];
286 } p_user;
287 } mdb_ps_proc_t;
288
289 /*
290 * A reasonable enough limit. Note that we purposefully let this column over-run
291 * if needed.
292 */
293 #define FMRI_LEN (128)
294
295 int
ps(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)296 ps(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
297 {
298 uint_t prt_flags = 0;
299 mdb_ps_proc_t pr;
300 struct pid pid, pgid, sid;
301 sess_t session;
302 cred_t cred;
303 task_t tk;
304 kproject_t pj;
305 zone_t zn;
306 struct cont_process cp;
307 char fmri[FMRI_LEN] = "";
308
309 if (!(flags & DCMD_ADDRSPEC)) {
310 if (mdb_walk_dcmd("proc", "ps", argc, argv) == -1) {
311 mdb_warn("can't walk 'proc'");
312 return (DCMD_ERR);
313 }
314 return (DCMD_OK);
315 }
316
317 if (mdb_getopts(argc, argv,
318 'f', MDB_OPT_SETBITS, PS_PSARGS, &prt_flags,
319 'l', MDB_OPT_SETBITS, PS_PRTLWPS, &prt_flags,
320 's', MDB_OPT_SETBITS, PS_SERVICES, &prt_flags,
321 'T', MDB_OPT_SETBITS, PS_TASKS, &prt_flags,
322 'P', MDB_OPT_SETBITS, PS_PROJECTS, &prt_flags,
323 'z', MDB_OPT_SETBITS, PS_ZONES, &prt_flags,
324 't', MDB_OPT_SETBITS, PS_PRTTHREADS, &prt_flags, NULL) != argc)
325 return (DCMD_USAGE);
326
327 if (DCMD_HDRSPEC(flags)) {
328 mdb_printf("%<u>%-1s %-6s %-6s %-6s %-6s ",
329 "S", "PID", "PPID", "PGID", "SID");
330 if (prt_flags & PS_TASKS)
331 mdb_printf("%-5s ", "TASK");
332 if (prt_flags & PS_PROJECTS)
333 mdb_printf("%-5s ", "PROJ");
334 if (prt_flags & PS_ZONES)
335 mdb_printf("%-5s ", "ZONE");
336 if (prt_flags & PS_SERVICES)
337 mdb_printf("%-40s ", "SERVICE");
338 mdb_printf("%-6s %-10s %-?s %-s%</u>\n",
339 "UID", "FLAGS", "ADDR", "NAME");
340 }
341
342 if (mdb_ctf_vread(&pr, "proc_t", "mdb_ps_proc_t", addr, 0) == -1)
343 return (DCMD_ERR);
344
345 mdb_vread(&pid, sizeof (pid), (uintptr_t)pr.p_pidp);
346 mdb_vread(&pgid, sizeof (pgid), (uintptr_t)pr.p_pgidp);
347 mdb_vread(&cred, sizeof (cred), (uintptr_t)pr.p_cred);
348 mdb_vread(&session, sizeof (session), (uintptr_t)pr.p_sessp);
349 mdb_vread(&sid, sizeof (sid), (uintptr_t)session.s_sidp);
350 if (prt_flags & (PS_TASKS | PS_PROJECTS))
351 mdb_vread(&tk, sizeof (tk), (uintptr_t)pr.p_task);
352 if (prt_flags & PS_PROJECTS)
353 mdb_vread(&pj, sizeof (pj), (uintptr_t)tk.tk_proj);
354 if (prt_flags & PS_ZONES)
355 mdb_vread(&zn, sizeof (zn), (uintptr_t)pr.p_zone);
356 if ((prt_flags & PS_SERVICES) && pr.p_ct_process != NULL) {
357 mdb_vread(&cp, sizeof (cp), (uintptr_t)pr.p_ct_process);
358
359 if (mdb_read_refstr((uintptr_t)cp.conp_svc_fmri, fmri,
360 sizeof (fmri)) <= 0)
361 (void) strlcpy(fmri, "?", sizeof (fmri));
362
363 /* Strip any standard prefix and suffix. */
364 if (strncmp(fmri, "svc:/", sizeof ("svc:/") - 1) == 0) {
365 char *i = fmri;
366 char *j = fmri + sizeof ("svc:/") - 1;
367 for (; *j != '\0'; i++, j++) {
368 if (strcmp(j, ":default") == 0)
369 break;
370 *i = *j;
371 }
372
373 *i = '\0';
374 }
375 }
376
377 mdb_printf("%-c %-6d %-6d %-6d %-6d ",
378 pstat2ch(pr.p_stat), pid.pid_id, pr.p_ppid, pgid.pid_id,
379 sid.pid_id);
380 if (prt_flags & PS_TASKS)
381 mdb_printf("%-5d ", tk.tk_tkid);
382 if (prt_flags & PS_PROJECTS)
383 mdb_printf("%-5d ", pj.kpj_id);
384 if (prt_flags & PS_ZONES)
385 mdb_printf("%-5d ", zn.zone_id);
386 if (prt_flags & PS_SERVICES)
387 mdb_printf("%-40s ", fmri);
388 mdb_printf("%-6d 0x%08x %0?p %-s\n",
389 cred.cr_uid, pr.p_flag, addr,
390 (prt_flags & PS_PSARGS) ? pr.p_user.u_psargs : pr.p_user.u_comm);
391
392 if (prt_flags & ~PS_PSARGS)
393 (void) mdb_pwalk("thread", ps_threadprint, &prt_flags, addr);
394
395 return (DCMD_OK);
396 }
397
398 static void
ps_help(void)399 ps_help(void)
400 {
401 mdb_printf("Display processes.\n\n"
402 "Options:\n"
403 " -f\tDisplay command arguments\n"
404 " -l\tDisplay LWPs\n"
405 " -T\tDisplay tasks\n"
406 " -P\tDisplay projects\n"
407 " -s\tDisplay SMF FMRI\n"
408 " -z\tDisplay zones\n"
409 " -t\tDisplay threads\n\n");
410
411 mdb_printf("The resulting output is a table of the processes on the "
412 "system. The\n"
413 "columns in the output consist of a combination of the "
414 "following fields:\n\n");
415 mdb_printf("S\tProcess state. Possible states are:\n"
416 "\tS\tSleeping (SSLEEP)\n"
417 "\tR\tRunnable (SRUN)\n"
418 "\tZ\tZombie (SZOMB)\n"
419 "\tI\tIdle (SIDL)\n"
420 "\tO\tOn Cpu (SONPROC)\n"
421 "\tT\tStopped (SSTOP)\n"
422 "\tW\tWaiting (SWAIT)\n");
423
424 mdb_printf("PID\tProcess id.\n");
425 mdb_printf("PPID\tParent process id.\n");
426 mdb_printf("PGID\tProcess group id.\n");
427 mdb_printf("SID\tProcess id of the session leader.\n");
428 mdb_printf("TASK\tThe task id of the process.\n");
429 mdb_printf("PROJ\tThe project id of the process.\n");
430 mdb_printf("ZONE\tThe zone id of the process.\n");
431 mdb_printf("SERVICE The SMF service FMRI of the process.\n");
432 mdb_printf("UID\tThe user id of the process.\n");
433 mdb_printf("FLAGS\tThe process flags (see ::pflags).\n");
434 mdb_printf("ADDR\tThe kernel address of the proc_t structure of the "
435 "process\n");
436 mdb_printf("NAME\tThe name (p_user.u_comm field) of the process. If "
437 "the -f flag\n"
438 "\tis specified, the arguments of the process are displayed.\n");
439 }
440
441 #define PG_NEWEST 0x0001
442 #define PG_OLDEST 0x0002
443 #define PG_PIPE_OUT 0x0004
444 #define PG_EXACT_MATCH 0x0008
445
446 typedef struct pgrep_data {
447 uint_t pg_flags;
448 uint_t pg_psflags;
449 uintptr_t pg_xaddr;
450 hrtime_t pg_xstart;
451 const char *pg_pat;
452 #ifndef _KMDB
453 regex_t pg_reg;
454 #endif
455 } pgrep_data_t;
456
457 typedef struct mdb_pgrep_proc {
458 struct {
459 timestruc_t u_start;
460 char u_comm[MAXCOMLEN + 1];
461 } p_user;
462 } mdb_pgrep_proc_t;
463
464 /*ARGSUSED*/
465 static int
pgrep_cb(uintptr_t addr,const void * ignored,void * data)466 pgrep_cb(uintptr_t addr, const void *ignored, void *data)
467 {
468 mdb_pgrep_proc_t p;
469 pgrep_data_t *pgp = data;
470 #ifndef _KMDB
471 regmatch_t pmatch;
472 #endif
473
474 if (mdb_ctf_vread(&p, "proc_t", "mdb_pgrep_proc_t", addr, 0) == -1)
475 return (WALK_ERR);
476
477 /*
478 * kmdb doesn't have access to the reg* functions, so we fall back
479 * to strstr/strcmp.
480 */
481 #ifdef _KMDB
482 if ((pgp->pg_flags & PG_EXACT_MATCH) ?
483 (strcmp(p.p_user.u_comm, pgp->pg_pat) != 0) :
484 (strstr(p.p_user.u_comm, pgp->pg_pat) == NULL))
485 return (WALK_NEXT);
486 #else
487 if (regexec(&pgp->pg_reg, p.p_user.u_comm, 1, &pmatch, 0) != 0)
488 return (WALK_NEXT);
489
490 if ((pgp->pg_flags & PG_EXACT_MATCH) &&
491 (pmatch.rm_so != 0 || p.p_user.u_comm[pmatch.rm_eo] != '\0'))
492 return (WALK_NEXT);
493 #endif
494
495 if (pgp->pg_flags & (PG_NEWEST | PG_OLDEST)) {
496 hrtime_t start;
497
498 start = (hrtime_t)p.p_user.u_start.tv_sec * NANOSEC +
499 p.p_user.u_start.tv_nsec;
500
501 if (pgp->pg_flags & PG_NEWEST) {
502 if (pgp->pg_xaddr == 0 || start > pgp->pg_xstart) {
503 pgp->pg_xaddr = addr;
504 pgp->pg_xstart = start;
505 }
506 } else {
507 if (pgp->pg_xaddr == 0 || start < pgp->pg_xstart) {
508 pgp->pg_xaddr = addr;
509 pgp->pg_xstart = start;
510 }
511 }
512
513 } else if (pgp->pg_flags & PG_PIPE_OUT) {
514 mdb_printf("%p\n", addr);
515
516 } else {
517 if (mdb_call_dcmd("ps", addr, pgp->pg_psflags, 0, NULL) != 0) {
518 mdb_warn("can't invoke 'ps'");
519 return (WALK_DONE);
520 }
521 pgp->pg_psflags &= ~DCMD_LOOPFIRST;
522 }
523
524 return (WALK_NEXT);
525 }
526
527 /*ARGSUSED*/
528 int
pgrep(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)529 pgrep(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
530 {
531 pgrep_data_t pg;
532 int i;
533 #ifndef _KMDB
534 int err;
535 #endif
536
537 if (flags & DCMD_ADDRSPEC)
538 return (DCMD_USAGE);
539
540 pg.pg_flags = 0;
541 pg.pg_xaddr = 0;
542
543 i = mdb_getopts(argc, argv,
544 'n', MDB_OPT_SETBITS, PG_NEWEST, &pg.pg_flags,
545 'o', MDB_OPT_SETBITS, PG_OLDEST, &pg.pg_flags,
546 'x', MDB_OPT_SETBITS, PG_EXACT_MATCH, &pg.pg_flags,
547 NULL);
548
549 argc -= i;
550 argv += i;
551
552 if (argc != 1)
553 return (DCMD_USAGE);
554
555 /*
556 * -n and -o are mutually exclusive.
557 */
558 if ((pg.pg_flags & PG_NEWEST) && (pg.pg_flags & PG_OLDEST))
559 return (DCMD_USAGE);
560
561 if (argv->a_type != MDB_TYPE_STRING)
562 return (DCMD_USAGE);
563
564 if (flags & DCMD_PIPE_OUT)
565 pg.pg_flags |= PG_PIPE_OUT;
566
567 pg.pg_pat = argv->a_un.a_str;
568 if (DCMD_HDRSPEC(flags))
569 pg.pg_psflags = DCMD_ADDRSPEC | DCMD_LOOP | DCMD_LOOPFIRST;
570 else
571 pg.pg_psflags = DCMD_ADDRSPEC | DCMD_LOOP;
572
573 #ifndef _KMDB
574 if ((err = regcomp(&pg.pg_reg, pg.pg_pat, REG_EXTENDED)) != 0) {
575 size_t nbytes;
576 char *buf;
577
578 nbytes = regerror(err, &pg.pg_reg, NULL, 0);
579 buf = mdb_alloc(nbytes + 1, UM_SLEEP | UM_GC);
580 (void) regerror(err, &pg.pg_reg, buf, nbytes);
581 mdb_warn("%s\n", buf);
582
583 return (DCMD_ERR);
584 }
585 #endif
586
587 if (mdb_walk("proc", pgrep_cb, &pg) != 0) {
588 mdb_warn("can't walk 'proc'");
589 return (DCMD_ERR);
590 }
591
592 if (pg.pg_xaddr != 0 && (pg.pg_flags & (PG_NEWEST | PG_OLDEST))) {
593 if (pg.pg_flags & PG_PIPE_OUT) {
594 mdb_printf("%p\n", pg.pg_xaddr);
595 } else {
596 if (mdb_call_dcmd("ps", pg.pg_xaddr, pg.pg_psflags,
597 0, NULL) != 0) {
598 mdb_warn("can't invoke 'ps'");
599 return (DCMD_ERR);
600 }
601 }
602 }
603
604 return (DCMD_OK);
605 }
606
607 int
task(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)608 task(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
609 {
610 task_t tk;
611 kproject_t pj;
612
613 if (!(flags & DCMD_ADDRSPEC)) {
614 if (mdb_walk_dcmd("task_cache", "task", argc, argv) == -1) {
615 mdb_warn("can't walk task_cache");
616 return (DCMD_ERR);
617 }
618 return (DCMD_OK);
619 }
620 if (DCMD_HDRSPEC(flags)) {
621 mdb_printf("%<u>%?s %6s %6s %6s %6s %10s%</u>\n",
622 "ADDR", "TASKID", "PROJID", "ZONEID", "REFCNT", "FLAGS");
623 }
624 if (mdb_vread(&tk, sizeof (task_t), addr) == -1) {
625 mdb_warn("can't read task_t structure at %p", addr);
626 return (DCMD_ERR);
627 }
628 if (mdb_vread(&pj, sizeof (kproject_t), (uintptr_t)tk.tk_proj) == -1) {
629 mdb_warn("can't read project_t structure at %p", addr);
630 return (DCMD_ERR);
631 }
632 mdb_printf("%0?p %6d %6d %6d %6u 0x%08x\n",
633 addr, tk.tk_tkid, pj.kpj_id, pj.kpj_zoneid, tk.tk_hold_count,
634 tk.tk_flags);
635 return (DCMD_OK);
636 }
637
638 int
project(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)639 project(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
640 {
641 kproject_t pj;
642
643 if (!(flags & DCMD_ADDRSPEC)) {
644 if (mdb_walk_dcmd("projects", "project", argc, argv) == -1) {
645 mdb_warn("can't walk projects");
646 return (DCMD_ERR);
647 }
648 return (DCMD_OK);
649 }
650 if (DCMD_HDRSPEC(flags)) {
651 mdb_printf("%<u>%?s %6s %6s %6s%</u>\n",
652 "ADDR", "PROJID", "ZONEID", "REFCNT");
653 }
654 if (mdb_vread(&pj, sizeof (kproject_t), addr) == -1) {
655 mdb_warn("can't read kproject_t structure at %p", addr);
656 return (DCMD_ERR);
657 }
658 mdb_printf("%0?p %6d %6d %6u\n", addr, pj.kpj_id, pj.kpj_zoneid,
659 pj.kpj_count);
660 return (DCMD_OK);
661 }
662
663 /* walk callouts themselves, either by list or id hash. */
664 int
callout_walk_init(mdb_walk_state_t * wsp)665 callout_walk_init(mdb_walk_state_t *wsp)
666 {
667 if (wsp->walk_addr == 0) {
668 mdb_warn("callout doesn't support global walk");
669 return (WALK_ERR);
670 }
671 wsp->walk_data = mdb_alloc(sizeof (callout_t), UM_SLEEP);
672 return (WALK_NEXT);
673 }
674
675 #define CALLOUT_WALK_BYLIST 0
676 #define CALLOUT_WALK_BYID 1
677
678 /* the walker arg switches between walking by list (0) and walking by id (1). */
679 int
callout_walk_step(mdb_walk_state_t * wsp)680 callout_walk_step(mdb_walk_state_t *wsp)
681 {
682 int retval;
683
684 if (wsp->walk_addr == 0) {
685 return (WALK_DONE);
686 }
687 if (mdb_vread(wsp->walk_data, sizeof (callout_t),
688 wsp->walk_addr) == -1) {
689 mdb_warn("failed to read callout at %p", wsp->walk_addr);
690 return (WALK_DONE);
691 }
692 retval = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
693 wsp->walk_cbdata);
694
695 if ((ulong_t)wsp->walk_arg == CALLOUT_WALK_BYID) {
696 wsp->walk_addr =
697 (uintptr_t)(((callout_t *)wsp->walk_data)->c_idnext);
698 } else {
699 wsp->walk_addr =
700 (uintptr_t)(((callout_t *)wsp->walk_data)->c_clnext);
701 }
702
703 return (retval);
704 }
705
706 void
callout_walk_fini(mdb_walk_state_t * wsp)707 callout_walk_fini(mdb_walk_state_t *wsp)
708 {
709 mdb_free(wsp->walk_data, sizeof (callout_t));
710 }
711
712 /*
713 * walker for callout lists. This is different from hashes and callouts.
714 * Thankfully, it's also simpler.
715 */
716 int
callout_list_walk_init(mdb_walk_state_t * wsp)717 callout_list_walk_init(mdb_walk_state_t *wsp)
718 {
719 if (wsp->walk_addr == 0) {
720 mdb_warn("callout list doesn't support global walk");
721 return (WALK_ERR);
722 }
723 wsp->walk_data = mdb_alloc(sizeof (callout_list_t), UM_SLEEP);
724 return (WALK_NEXT);
725 }
726
727 int
callout_list_walk_step(mdb_walk_state_t * wsp)728 callout_list_walk_step(mdb_walk_state_t *wsp)
729 {
730 int retval;
731
732 if (wsp->walk_addr == 0) {
733 return (WALK_DONE);
734 }
735 if (mdb_vread(wsp->walk_data, sizeof (callout_list_t),
736 wsp->walk_addr) != sizeof (callout_list_t)) {
737 mdb_warn("failed to read callout_list at %p", wsp->walk_addr);
738 return (WALK_ERR);
739 }
740 retval = wsp->walk_callback(wsp->walk_addr, wsp->walk_data,
741 wsp->walk_cbdata);
742
743 wsp->walk_addr = (uintptr_t)
744 (((callout_list_t *)wsp->walk_data)->cl_next);
745
746 return (retval);
747 }
748
749 void
callout_list_walk_fini(mdb_walk_state_t * wsp)750 callout_list_walk_fini(mdb_walk_state_t *wsp)
751 {
752 mdb_free(wsp->walk_data, sizeof (callout_list_t));
753 }
754
755 /* routines/structs to walk callout table(s) */
756 typedef struct cot_data {
757 callout_table_t *ct0;
758 callout_table_t ct;
759 callout_hash_t cot_idhash[CALLOUT_BUCKETS];
760 callout_hash_t cot_clhash[CALLOUT_BUCKETS];
761 kstat_named_t ct_kstat_data[CALLOUT_NUM_STATS];
762 int cotndx;
763 int cotsize;
764 } cot_data_t;
765
766 int
callout_table_walk_init(mdb_walk_state_t * wsp)767 callout_table_walk_init(mdb_walk_state_t *wsp)
768 {
769 int max_ncpus;
770 cot_data_t *cot_walk_data;
771
772 cot_walk_data = mdb_alloc(sizeof (cot_data_t), UM_SLEEP);
773
774 if (wsp->walk_addr == 0) {
775 if (mdb_readvar(&cot_walk_data->ct0, "callout_table") == -1) {
776 mdb_warn("failed to read 'callout_table'");
777 return (WALK_ERR);
778 }
779 if (mdb_readvar(&max_ncpus, "max_ncpus") == -1) {
780 mdb_warn("failed to get callout_table array size");
781 return (WALK_ERR);
782 }
783 cot_walk_data->cotsize = CALLOUT_NTYPES * max_ncpus;
784 wsp->walk_addr = (uintptr_t)cot_walk_data->ct0;
785 } else {
786 /* not a global walk */
787 cot_walk_data->cotsize = 1;
788 }
789
790 cot_walk_data->cotndx = 0;
791 wsp->walk_data = cot_walk_data;
792
793 return (WALK_NEXT);
794 }
795
796 int
callout_table_walk_step(mdb_walk_state_t * wsp)797 callout_table_walk_step(mdb_walk_state_t *wsp)
798 {
799 int retval;
800 cot_data_t *cotwd = (cot_data_t *)wsp->walk_data;
801 size_t size;
802
803 if (cotwd->cotndx >= cotwd->cotsize) {
804 return (WALK_DONE);
805 }
806 if (mdb_vread(&(cotwd->ct), sizeof (callout_table_t),
807 wsp->walk_addr) != sizeof (callout_table_t)) {
808 mdb_warn("failed to read callout_table at %p", wsp->walk_addr);
809 return (WALK_ERR);
810 }
811
812 size = sizeof (callout_hash_t) * CALLOUT_BUCKETS;
813 if (cotwd->ct.ct_idhash != NULL) {
814 if (mdb_vread(cotwd->cot_idhash, size,
815 (uintptr_t)(cotwd->ct.ct_idhash)) != size) {
816 mdb_warn("failed to read id_hash at %p",
817 cotwd->ct.ct_idhash);
818 return (WALK_ERR);
819 }
820 }
821 if (cotwd->ct.ct_clhash != NULL) {
822 if (mdb_vread(&(cotwd->cot_clhash), size,
823 (uintptr_t)cotwd->ct.ct_clhash) == -1) {
824 mdb_warn("failed to read cl_hash at %p",
825 cotwd->ct.ct_clhash);
826 return (WALK_ERR);
827 }
828 }
829 size = sizeof (kstat_named_t) * CALLOUT_NUM_STATS;
830 if (cotwd->ct.ct_kstat_data != NULL) {
831 if (mdb_vread(&(cotwd->ct_kstat_data), size,
832 (uintptr_t)cotwd->ct.ct_kstat_data) == -1) {
833 mdb_warn("failed to read kstats at %p",
834 cotwd->ct.ct_kstat_data);
835 return (WALK_ERR);
836 }
837 }
838 retval = wsp->walk_callback(wsp->walk_addr, (void *)cotwd,
839 wsp->walk_cbdata);
840
841 cotwd->cotndx++;
842 if (cotwd->cotndx >= cotwd->cotsize) {
843 return (WALK_DONE);
844 }
845 wsp->walk_addr = (uintptr_t)((char *)wsp->walk_addr +
846 sizeof (callout_table_t));
847
848 return (retval);
849 }
850
851 void
callout_table_walk_fini(mdb_walk_state_t * wsp)852 callout_table_walk_fini(mdb_walk_state_t *wsp)
853 {
854 mdb_free(wsp->walk_data, sizeof (cot_data_t));
855 }
856
857 static const char *co_typenames[] = { "R", "N" };
858
859 #define CO_PLAIN_ID(xid) ((xid) & CALLOUT_ID_MASK)
860
861 #define TABLE_TO_SEQID(x) ((x) >> CALLOUT_TYPE_BITS)
862
863 /* callout flags, in no particular order */
864 #define COF_REAL 0x00000001
865 #define COF_NORM 0x00000002
866 #define COF_LONG 0x00000004
867 #define COF_SHORT 0x00000008
868 #define COF_EMPTY 0x00000010
869 #define COF_TIME 0x00000020
870 #define COF_BEFORE 0x00000040
871 #define COF_AFTER 0x00000080
872 #define COF_SEQID 0x00000100
873 #define COF_FUNC 0x00000200
874 #define COF_ADDR 0x00000400
875 #define COF_EXEC 0x00000800
876 #define COF_HIRES 0x00001000
877 #define COF_ABS 0x00002000
878 #define COF_TABLE 0x00004000
879 #define COF_BYIDH 0x00008000
880 #define COF_FREE 0x00010000
881 #define COF_LIST 0x00020000
882 #define COF_EXPREL 0x00040000
883 #define COF_HDR 0x00080000
884 #define COF_VERBOSE 0x00100000
885 #define COF_LONGLIST 0x00200000
886 #define COF_THDR 0x00400000
887 #define COF_LHDR 0x00800000
888 #define COF_CHDR 0x01000000
889 #define COF_PARAM 0x02000000
890 #define COF_DECODE 0x04000000
891 #define COF_HEAP 0x08000000
892 #define COF_QUEUE 0x10000000
893
894 /* show real and normal, short and long, expired and unexpired. */
895 #define COF_DEFAULT (COF_REAL | COF_NORM | COF_LONG | COF_SHORT)
896
897 #define COF_LIST_FLAGS \
898 (CALLOUT_LIST_FLAG_HRESTIME | CALLOUT_LIST_FLAG_ABSOLUTE)
899
900 /* private callout data for callback functions */
901 typedef struct callout_data {
902 uint_t flags; /* COF_* */
903 cpu_t *cpu; /* cpu pointer if given */
904 int seqid; /* cpu seqid, or -1 */
905 hrtime_t time; /* expiration time value */
906 hrtime_t atime; /* expiration before value */
907 hrtime_t btime; /* expiration after value */
908 uintptr_t funcaddr; /* function address or NULL */
909 uintptr_t param; /* parameter to function or NULL */
910 hrtime_t now; /* current system time */
911 int nsec_per_tick; /* for conversions */
912 ulong_t ctbits; /* for decoding xid */
913 callout_table_t *co_table; /* top of callout table array */
914 int ndx; /* table index. */
915 int bucket; /* which list/id bucket are we in */
916 hrtime_t exp; /* expire time */
917 int list_flags; /* copy of cl_flags */
918 } callout_data_t;
919
920 /* this callback does the actual callback itself (finally). */
921 /*ARGSUSED*/
922 static int
callouts_cb(uintptr_t addr,const void * data,void * priv)923 callouts_cb(uintptr_t addr, const void *data, void *priv)
924 {
925 callout_data_t *coargs = (callout_data_t *)priv;
926 callout_t *co = (callout_t *)data;
927 int tableid, list_flags;
928 callout_id_t coid;
929
930 if ((coargs == NULL) || (co == NULL)) {
931 return (WALK_ERR);
932 }
933
934 if ((coargs->flags & COF_FREE) && !(co->c_xid & CALLOUT_ID_FREE)) {
935 /*
936 * The callout must have been reallocated. No point in
937 * walking any more.
938 */
939 return (WALK_DONE);
940 }
941 if (!(coargs->flags & COF_FREE) && (co->c_xid & CALLOUT_ID_FREE)) {
942 /*
943 * The callout must have been freed. No point in
944 * walking any more.
945 */
946 return (WALK_DONE);
947 }
948 if ((coargs->flags & COF_FUNC) &&
949 (coargs->funcaddr != (uintptr_t)co->c_func)) {
950 return (WALK_NEXT);
951 }
952 if ((coargs->flags & COF_PARAM) &&
953 (coargs->param != (uintptr_t)co->c_arg)) {
954 return (WALK_NEXT);
955 }
956 if (!(coargs->flags & COF_LONG) && (co->c_xid & CALLOUT_LONGTERM)) {
957 return (WALK_NEXT);
958 }
959 if (!(coargs->flags & COF_SHORT) && !(co->c_xid & CALLOUT_LONGTERM)) {
960 return (WALK_NEXT);
961 }
962 if ((coargs->flags & COF_EXEC) && !(co->c_xid & CALLOUT_EXECUTING)) {
963 return (WALK_NEXT);
964 }
965 /* it is possible we don't have the exp time or flags */
966 if (coargs->flags & COF_BYIDH) {
967 if (!(coargs->flags & COF_FREE)) {
968 /* we have to fetch the expire time ourselves. */
969 if (mdb_vread(&coargs->exp, sizeof (hrtime_t),
970 (uintptr_t)co->c_list + offsetof(callout_list_t,
971 cl_expiration)) == -1) {
972 mdb_warn("failed to read expiration "
973 "time from %p", co->c_list);
974 coargs->exp = 0;
975 }
976 /* and flags. */
977 if (mdb_vread(&coargs->list_flags, sizeof (int),
978 (uintptr_t)co->c_list + offsetof(callout_list_t,
979 cl_flags)) == -1) {
980 mdb_warn("failed to read list flags"
981 "from %p", co->c_list);
982 coargs->list_flags = 0;
983 }
984 } else {
985 /* free callouts can't use list pointer. */
986 coargs->exp = 0;
987 coargs->list_flags = 0;
988 }
989 if (coargs->exp != 0) {
990 if ((coargs->flags & COF_TIME) &&
991 (coargs->exp != coargs->time)) {
992 return (WALK_NEXT);
993 }
994 if ((coargs->flags & COF_BEFORE) &&
995 (coargs->exp > coargs->btime)) {
996 return (WALK_NEXT);
997 }
998 if ((coargs->flags & COF_AFTER) &&
999 (coargs->exp < coargs->atime)) {
1000 return (WALK_NEXT);
1001 }
1002 }
1003 /* tricky part, since both HIRES and ABS can be set */
1004 list_flags = coargs->list_flags;
1005 if ((coargs->flags & COF_HIRES) && (coargs->flags & COF_ABS)) {
1006 /* both flags are set, only skip "regular" ones */
1007 if (! (list_flags & COF_LIST_FLAGS)) {
1008 return (WALK_NEXT);
1009 }
1010 } else {
1011 /* individual flags, or no flags */
1012 if ((coargs->flags & COF_HIRES) &&
1013 !(list_flags & CALLOUT_LIST_FLAG_HRESTIME)) {
1014 return (WALK_NEXT);
1015 }
1016 if ((coargs->flags & COF_ABS) &&
1017 !(list_flags & CALLOUT_LIST_FLAG_ABSOLUTE)) {
1018 return (WALK_NEXT);
1019 }
1020 }
1021 /*
1022 * We do the checks for COF_HEAP and COF_QUEUE here only if we
1023 * are traversing BYIDH. If the traversal is by callout list,
1024 * we do this check in callout_list_cb() to be more
1025 * efficient.
1026 */
1027 if ((coargs->flags & COF_HEAP) &&
1028 !(list_flags & CALLOUT_LIST_FLAG_HEAPED)) {
1029 return (WALK_NEXT);
1030 }
1031
1032 if ((coargs->flags & COF_QUEUE) &&
1033 !(list_flags & CALLOUT_LIST_FLAG_QUEUED)) {
1034 return (WALK_NEXT);
1035 }
1036 }
1037
1038 #define callout_table_mask ((1 << coargs->ctbits) - 1)
1039 tableid = CALLOUT_ID_TO_TABLE(co->c_xid);
1040 #undef callout_table_mask
1041 coid = CO_PLAIN_ID(co->c_xid);
1042
1043 if ((coargs->flags & COF_CHDR) && !(coargs->flags & COF_ADDR)) {
1044 /*
1045 * We need to print the headers. If walking by id, then
1046 * the list header isn't printed, so we must include
1047 * that info here.
1048 */
1049 if (!(coargs->flags & COF_VERBOSE)) {
1050 mdb_printf("%<u>%3s %-1s %-14s %</u>",
1051 "SEQ", "T", "EXP");
1052 } else if (coargs->flags & COF_BYIDH) {
1053 mdb_printf("%<u>%-14s %</u>", "EXP");
1054 }
1055 mdb_printf("%<u>%-4s %-?s %-20s%</u>",
1056 "XHAL", "XID", "FUNC(ARG)");
1057 if (coargs->flags & COF_LONGLIST) {
1058 mdb_printf("%<u> %-?s %-?s %-?s %-?s%</u>",
1059 "PREVID", "NEXTID", "PREVL", "NEXTL");
1060 mdb_printf("%<u> %-?s %-4s %-?s%</u>",
1061 "DONE", "UTOS", "THREAD");
1062 }
1063 mdb_printf("\n");
1064 coargs->flags &= ~COF_CHDR;
1065 coargs->flags |= (COF_THDR | COF_LHDR);
1066 }
1067
1068 if (!(coargs->flags & COF_ADDR)) {
1069 if (!(coargs->flags & COF_VERBOSE)) {
1070 mdb_printf("%-3d %1s %-14llx ",
1071 TABLE_TO_SEQID(tableid),
1072 co_typenames[tableid & CALLOUT_TYPE_MASK],
1073 (coargs->flags & COF_EXPREL) ?
1074 coargs->exp - coargs->now : coargs->exp);
1075 } else if (coargs->flags & COF_BYIDH) {
1076 mdb_printf("%-14x ",
1077 (coargs->flags & COF_EXPREL) ?
1078 coargs->exp - coargs->now : coargs->exp);
1079 }
1080 list_flags = coargs->list_flags;
1081 mdb_printf("%1s%1s%1s%1s %-?llx %a(%p)",
1082 (co->c_xid & CALLOUT_EXECUTING) ? "X" : " ",
1083 (list_flags & CALLOUT_LIST_FLAG_HRESTIME) ? "H" : " ",
1084 (list_flags & CALLOUT_LIST_FLAG_ABSOLUTE) ? "A" : " ",
1085 (co->c_xid & CALLOUT_LONGTERM) ? "L" : " ",
1086 (long long)coid, co->c_func, co->c_arg);
1087 if (coargs->flags & COF_LONGLIST) {
1088 mdb_printf(" %-?p %-?p %-?p %-?p",
1089 co->c_idprev, co->c_idnext, co->c_clprev,
1090 co->c_clnext);
1091 mdb_printf(" %-?p %-4d %-0?p",
1092 co->c_done, co->c_waiting, co->c_executor);
1093 }
1094 } else {
1095 /* address only */
1096 mdb_printf("%-0p", addr);
1097 }
1098 mdb_printf("\n");
1099 return (WALK_NEXT);
1100 }
1101
1102 /* this callback is for callout list handling. idhash is done by callout_t_cb */
1103 /*ARGSUSED*/
1104 static int
callout_list_cb(uintptr_t addr,const void * data,void * priv)1105 callout_list_cb(uintptr_t addr, const void *data, void *priv)
1106 {
1107 callout_data_t *coargs = (callout_data_t *)priv;
1108 callout_list_t *cl = (callout_list_t *)data;
1109 callout_t *coptr;
1110 int list_flags;
1111
1112 if ((coargs == NULL) || (cl == NULL)) {
1113 return (WALK_ERR);
1114 }
1115
1116 coargs->exp = cl->cl_expiration;
1117 coargs->list_flags = cl->cl_flags;
1118 if ((coargs->flags & COF_FREE) &&
1119 !(cl->cl_flags & CALLOUT_LIST_FLAG_FREE)) {
1120 /*
1121 * The callout list must have been reallocated. No point in
1122 * walking any more.
1123 */
1124 return (WALK_DONE);
1125 }
1126 if (!(coargs->flags & COF_FREE) &&
1127 (cl->cl_flags & CALLOUT_LIST_FLAG_FREE)) {
1128 /*
1129 * The callout list must have been freed. No point in
1130 * walking any more.
1131 */
1132 return (WALK_DONE);
1133 }
1134 if ((coargs->flags & COF_TIME) &&
1135 (cl->cl_expiration != coargs->time)) {
1136 return (WALK_NEXT);
1137 }
1138 if ((coargs->flags & COF_BEFORE) &&
1139 (cl->cl_expiration > coargs->btime)) {
1140 return (WALK_NEXT);
1141 }
1142 if ((coargs->flags & COF_AFTER) &&
1143 (cl->cl_expiration < coargs->atime)) {
1144 return (WALK_NEXT);
1145 }
1146 if (!(coargs->flags & COF_EMPTY) &&
1147 (cl->cl_callouts.ch_head == NULL)) {
1148 return (WALK_NEXT);
1149 }
1150 /* FOUR cases, each different, !A!B, !AB, A!B, AB */
1151 if ((coargs->flags & COF_HIRES) && (coargs->flags & COF_ABS)) {
1152 /* both flags are set, only skip "regular" ones */
1153 if (! (cl->cl_flags & COF_LIST_FLAGS)) {
1154 return (WALK_NEXT);
1155 }
1156 } else {
1157 if ((coargs->flags & COF_HIRES) &&
1158 !(cl->cl_flags & CALLOUT_LIST_FLAG_HRESTIME)) {
1159 return (WALK_NEXT);
1160 }
1161 if ((coargs->flags & COF_ABS) &&
1162 !(cl->cl_flags & CALLOUT_LIST_FLAG_ABSOLUTE)) {
1163 return (WALK_NEXT);
1164 }
1165 }
1166
1167 if ((coargs->flags & COF_HEAP) &&
1168 !(coargs->list_flags & CALLOUT_LIST_FLAG_HEAPED)) {
1169 return (WALK_NEXT);
1170 }
1171
1172 if ((coargs->flags & COF_QUEUE) &&
1173 !(coargs->list_flags & CALLOUT_LIST_FLAG_QUEUED)) {
1174 return (WALK_NEXT);
1175 }
1176
1177 if ((coargs->flags & COF_LHDR) && !(coargs->flags & COF_ADDR) &&
1178 (coargs->flags & (COF_LIST | COF_VERBOSE))) {
1179 if (!(coargs->flags & COF_VERBOSE)) {
1180 /* don't be redundant again */
1181 mdb_printf("%<u>SEQ T %</u>");
1182 }
1183 mdb_printf("%<u>EXP HA BUCKET "
1184 "CALLOUTS %</u>");
1185
1186 if (coargs->flags & COF_LONGLIST) {
1187 mdb_printf("%<u> %-?s %-?s%</u>",
1188 "PREV", "NEXT");
1189 }
1190 mdb_printf("\n");
1191 coargs->flags &= ~COF_LHDR;
1192 coargs->flags |= (COF_THDR | COF_CHDR);
1193 }
1194 if (coargs->flags & (COF_LIST | COF_VERBOSE)) {
1195 if (!(coargs->flags & COF_ADDR)) {
1196 if (!(coargs->flags & COF_VERBOSE)) {
1197 mdb_printf("%3d %1s ",
1198 TABLE_TO_SEQID(coargs->ndx),
1199 co_typenames[coargs->ndx &
1200 CALLOUT_TYPE_MASK]);
1201 }
1202
1203 list_flags = coargs->list_flags;
1204 mdb_printf("%-14llx %1s%1s %-6d %-0?p ",
1205 (coargs->flags & COF_EXPREL) ?
1206 coargs->exp - coargs->now : coargs->exp,
1207 (list_flags & CALLOUT_LIST_FLAG_HRESTIME) ?
1208 "H" : " ",
1209 (list_flags & CALLOUT_LIST_FLAG_ABSOLUTE) ?
1210 "A" : " ",
1211 coargs->bucket, cl->cl_callouts.ch_head);
1212
1213 if (coargs->flags & COF_LONGLIST) {
1214 mdb_printf(" %-?p %-?p",
1215 cl->cl_prev, cl->cl_next);
1216 }
1217 } else {
1218 /* address only */
1219 mdb_printf("%-0p", addr);
1220 }
1221 mdb_printf("\n");
1222 if (coargs->flags & COF_LIST) {
1223 return (WALK_NEXT);
1224 }
1225 }
1226 /* yet another layer as we walk the actual callouts via list. */
1227 if (cl->cl_callouts.ch_head == NULL) {
1228 return (WALK_NEXT);
1229 }
1230 /* free list structures do not have valid callouts off of them. */
1231 if (coargs->flags & COF_FREE) {
1232 return (WALK_NEXT);
1233 }
1234 coptr = (callout_t *)cl->cl_callouts.ch_head;
1235
1236 if (coargs->flags & COF_VERBOSE) {
1237 mdb_inc_indent(4);
1238 }
1239 /*
1240 * walk callouts using yet another callback routine.
1241 * we use callouts_bytime because id hash is handled via
1242 * the callout_t_cb callback.
1243 */
1244 if (mdb_pwalk("callouts_bytime", callouts_cb, coargs,
1245 (uintptr_t)coptr) == -1) {
1246 mdb_warn("cannot walk callouts at %p", coptr);
1247 return (WALK_ERR);
1248 }
1249 if (coargs->flags & COF_VERBOSE) {
1250 mdb_dec_indent(4);
1251 }
1252
1253 return (WALK_NEXT);
1254 }
1255
1256 /* this callback handles the details of callout table walking. */
1257 static int
callout_t_cb(uintptr_t addr,const void * data,void * priv)1258 callout_t_cb(uintptr_t addr, const void *data, void *priv)
1259 {
1260 callout_data_t *coargs = (callout_data_t *)priv;
1261 cot_data_t *cotwd = (cot_data_t *)data;
1262 callout_table_t *ct = &(cotwd->ct);
1263 int index, seqid, cotype;
1264 int i;
1265 callout_list_t *clptr;
1266 callout_t *coptr;
1267
1268 if ((coargs == NULL) || (ct == NULL) || (coargs->co_table == NULL)) {
1269 return (WALK_ERR);
1270 }
1271
1272 index = ((char *)addr - (char *)coargs->co_table) /
1273 sizeof (callout_table_t);
1274 cotype = index & CALLOUT_TYPE_MASK;
1275 seqid = TABLE_TO_SEQID(index);
1276
1277 if ((coargs->flags & COF_SEQID) && (coargs->seqid != seqid)) {
1278 return (WALK_NEXT);
1279 }
1280
1281 if (!(coargs->flags & COF_REAL) && (cotype == CALLOUT_REALTIME)) {
1282 return (WALK_NEXT);
1283 }
1284
1285 if (!(coargs->flags & COF_NORM) && (cotype == CALLOUT_NORMAL)) {
1286 return (WALK_NEXT);
1287 }
1288
1289 if (!(coargs->flags & COF_EMPTY) && (
1290 (ct->ct_heap == NULL) || (ct->ct_cyclic == 0))) {
1291 return (WALK_NEXT);
1292 }
1293
1294 if ((coargs->flags & COF_THDR) && !(coargs->flags & COF_ADDR) &&
1295 (coargs->flags & (COF_TABLE | COF_VERBOSE))) {
1296 /* print table hdr */
1297 mdb_printf("%<u>%-3s %-1s %-?s %-?s %-?s %-?s%</u>",
1298 "SEQ", "T", "FREE", "LFREE", "CYCLIC", "HEAP");
1299 coargs->flags &= ~COF_THDR;
1300 coargs->flags |= (COF_LHDR | COF_CHDR);
1301 if (coargs->flags & COF_LONGLIST) {
1302 /* more info! */
1303 mdb_printf("%<u> %-T%-7s %-7s %-?s %-?s %-?s"
1304 " %-?s %-?s %-?s%</u>",
1305 "HEAPNUM", "HEAPMAX", "TASKQ", "EXPQ", "QUE",
1306 "PEND", "FREE", "LOCK");
1307 }
1308 mdb_printf("\n");
1309 }
1310 if (coargs->flags & (COF_TABLE | COF_VERBOSE)) {
1311 if (!(coargs->flags & COF_ADDR)) {
1312 mdb_printf("%-3d %-1s %-0?p %-0?p %-0?p %-?p",
1313 seqid, co_typenames[cotype],
1314 ct->ct_free, ct->ct_lfree, ct->ct_cyclic,
1315 ct->ct_heap);
1316 if (coargs->flags & COF_LONGLIST) {
1317 /* more info! */
1318 mdb_printf(" %-7d %-7d %-?p %-?p %-?p"
1319 " %-?lld %-?lld %-?p",
1320 ct->ct_heap_num, ct->ct_heap_max,
1321 ct->ct_taskq, ct->ct_expired.ch_head,
1322 ct->ct_queue.ch_head,
1323 cotwd->ct_timeouts_pending,
1324 cotwd->ct_allocations -
1325 cotwd->ct_timeouts_pending,
1326 ct->ct_mutex);
1327 }
1328 } else {
1329 /* address only */
1330 mdb_printf("%-0?p", addr);
1331 }
1332 mdb_printf("\n");
1333 if (coargs->flags & COF_TABLE) {
1334 return (WALK_NEXT);
1335 }
1336 }
1337
1338 coargs->ndx = index;
1339 if (coargs->flags & COF_VERBOSE) {
1340 mdb_inc_indent(4);
1341 }
1342 /* keep digging. */
1343 if (!(coargs->flags & COF_BYIDH)) {
1344 /* walk the list hash table */
1345 if (coargs->flags & COF_FREE) {
1346 clptr = ct->ct_lfree;
1347 coargs->bucket = 0;
1348 if (clptr == NULL) {
1349 return (WALK_NEXT);
1350 }
1351 if (mdb_pwalk("callout_list", callout_list_cb, coargs,
1352 (uintptr_t)clptr) == -1) {
1353 mdb_warn("cannot walk callout free list at %p",
1354 clptr);
1355 return (WALK_ERR);
1356 }
1357 } else {
1358 /* first print the expired list. */
1359 clptr = (callout_list_t *)ct->ct_expired.ch_head;
1360 if (clptr != NULL) {
1361 coargs->bucket = -1;
1362 if (mdb_pwalk("callout_list", callout_list_cb,
1363 coargs, (uintptr_t)clptr) == -1) {
1364 mdb_warn("cannot walk callout_list"
1365 " at %p", clptr);
1366 return (WALK_ERR);
1367 }
1368 }
1369 /* then, print the callout queue */
1370 clptr = (callout_list_t *)ct->ct_queue.ch_head;
1371 if (clptr != NULL) {
1372 coargs->bucket = -1;
1373 if (mdb_pwalk("callout_list", callout_list_cb,
1374 coargs, (uintptr_t)clptr) == -1) {
1375 mdb_warn("cannot walk callout_list"
1376 " at %p", clptr);
1377 return (WALK_ERR);
1378 }
1379 }
1380 for (i = 0; i < CALLOUT_BUCKETS; i++) {
1381 if (ct->ct_clhash == NULL) {
1382 /* nothing to do */
1383 break;
1384 }
1385 if (cotwd->cot_clhash[i].ch_head == NULL) {
1386 continue;
1387 }
1388 clptr = (callout_list_t *)
1389 cotwd->cot_clhash[i].ch_head;
1390 coargs->bucket = i;
1391 /* walk list with callback routine. */
1392 if (mdb_pwalk("callout_list", callout_list_cb,
1393 coargs, (uintptr_t)clptr) == -1) {
1394 mdb_warn("cannot walk callout_list"
1395 " at %p", clptr);
1396 return (WALK_ERR);
1397 }
1398 }
1399 }
1400 } else {
1401 /* walk the id hash table. */
1402 if (coargs->flags & COF_FREE) {
1403 coptr = ct->ct_free;
1404 coargs->bucket = 0;
1405 if (coptr == NULL) {
1406 return (WALK_NEXT);
1407 }
1408 if (mdb_pwalk("callouts_byid", callouts_cb, coargs,
1409 (uintptr_t)coptr) == -1) {
1410 mdb_warn("cannot walk callout id free list"
1411 " at %p", coptr);
1412 return (WALK_ERR);
1413 }
1414 } else {
1415 for (i = 0; i < CALLOUT_BUCKETS; i++) {
1416 if (ct->ct_idhash == NULL) {
1417 break;
1418 }
1419 coptr = (callout_t *)
1420 cotwd->cot_idhash[i].ch_head;
1421 if (coptr == NULL) {
1422 continue;
1423 }
1424 coargs->bucket = i;
1425
1426 /*
1427 * walk callouts directly by id. For id
1428 * chain, the callout list is just a header,
1429 * so there's no need to walk it.
1430 */
1431 if (mdb_pwalk("callouts_byid", callouts_cb,
1432 coargs, (uintptr_t)coptr) == -1) {
1433 mdb_warn("cannot walk callouts at %p",
1434 coptr);
1435 return (WALK_ERR);
1436 }
1437 }
1438 }
1439 }
1440 if (coargs->flags & COF_VERBOSE) {
1441 mdb_dec_indent(4);
1442 }
1443 return (WALK_NEXT);
1444 }
1445
1446 /*
1447 * initialize some common info for both callout dcmds.
1448 */
1449 int
callout_common_init(callout_data_t * coargs)1450 callout_common_init(callout_data_t *coargs)
1451 {
1452 /* we need a couple of things */
1453 if (mdb_readvar(&(coargs->co_table), "callout_table") == -1) {
1454 mdb_warn("failed to read 'callout_table'");
1455 return (DCMD_ERR);
1456 }
1457 /* need to get now in nsecs. Approximate with hrtime vars */
1458 if (mdb_readsym(&(coargs->now), sizeof (hrtime_t), "hrtime_last") !=
1459 sizeof (hrtime_t)) {
1460 if (mdb_readsym(&(coargs->now), sizeof (hrtime_t),
1461 "hrtime_base") != sizeof (hrtime_t)) {
1462 mdb_warn("Could not determine current system time");
1463 return (DCMD_ERR);
1464 }
1465 }
1466
1467 if (mdb_readvar(&(coargs->ctbits), "callout_table_bits") == -1) {
1468 mdb_warn("failed to read 'callout_table_bits'");
1469 return (DCMD_ERR);
1470 }
1471 if (mdb_readvar(&(coargs->nsec_per_tick), "nsec_per_tick") == -1) {
1472 mdb_warn("failed to read 'nsec_per_tick'");
1473 return (DCMD_ERR);
1474 }
1475 return (DCMD_OK);
1476 }
1477
1478 /*
1479 * dcmd to print callouts. Optional addr limits to specific table.
1480 * Parses lots of options that get passed to callbacks for walkers.
1481 * Has it's own help function.
1482 */
1483 /*ARGSUSED*/
1484 int
callout(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1485 callout(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1486 {
1487 callout_data_t coargs;
1488 /* getopts doesn't help much with stuff like this */
1489 boolean_t Sflag, Cflag, tflag, aflag, bflag, dflag, kflag;
1490 char *funcname = NULL;
1491 char *paramstr = NULL;
1492 uintptr_t Stmp, Ctmp; /* for getopt. */
1493 int retval;
1494
1495 coargs.flags = COF_DEFAULT;
1496 Sflag = Cflag = tflag = bflag = aflag = dflag = kflag = FALSE;
1497 coargs.seqid = -1;
1498
1499 if (mdb_getopts(argc, argv,
1500 'r', MDB_OPT_CLRBITS, COF_NORM, &coargs.flags,
1501 'n', MDB_OPT_CLRBITS, COF_REAL, &coargs.flags,
1502 'l', MDB_OPT_CLRBITS, COF_SHORT, &coargs.flags,
1503 's', MDB_OPT_CLRBITS, COF_LONG, &coargs.flags,
1504 'x', MDB_OPT_SETBITS, COF_EXEC, &coargs.flags,
1505 'h', MDB_OPT_SETBITS, COF_HIRES, &coargs.flags,
1506 'B', MDB_OPT_SETBITS, COF_ABS, &coargs.flags,
1507 'E', MDB_OPT_SETBITS, COF_EMPTY, &coargs.flags,
1508 'd', MDB_OPT_SETBITS, 1, &dflag,
1509 'C', MDB_OPT_UINTPTR_SET, &Cflag, &Ctmp,
1510 'S', MDB_OPT_UINTPTR_SET, &Sflag, &Stmp,
1511 't', MDB_OPT_UINTPTR_SET, &tflag, (uintptr_t *)&coargs.time,
1512 'a', MDB_OPT_UINTPTR_SET, &aflag, (uintptr_t *)&coargs.atime,
1513 'b', MDB_OPT_UINTPTR_SET, &bflag, (uintptr_t *)&coargs.btime,
1514 'k', MDB_OPT_SETBITS, 1, &kflag,
1515 'f', MDB_OPT_STR, &funcname,
1516 'p', MDB_OPT_STR, ¶mstr,
1517 'T', MDB_OPT_SETBITS, COF_TABLE, &coargs.flags,
1518 'D', MDB_OPT_SETBITS, COF_EXPREL, &coargs.flags,
1519 'L', MDB_OPT_SETBITS, COF_LIST, &coargs.flags,
1520 'V', MDB_OPT_SETBITS, COF_VERBOSE, &coargs.flags,
1521 'v', MDB_OPT_SETBITS, COF_LONGLIST, &coargs.flags,
1522 'i', MDB_OPT_SETBITS, COF_BYIDH, &coargs.flags,
1523 'F', MDB_OPT_SETBITS, COF_FREE, &coargs.flags,
1524 'H', MDB_OPT_SETBITS, COF_HEAP, &coargs.flags,
1525 'Q', MDB_OPT_SETBITS, COF_QUEUE, &coargs.flags,
1526 'A', MDB_OPT_SETBITS, COF_ADDR, &coargs.flags,
1527 NULL) != argc) {
1528 return (DCMD_USAGE);
1529 }
1530
1531 /* initialize from kernel variables */
1532 if ((retval = callout_common_init(&coargs)) != DCMD_OK) {
1533 return (retval);
1534 }
1535
1536 /* do some option post-processing */
1537 if (kflag) {
1538 coargs.time *= coargs.nsec_per_tick;
1539 coargs.atime *= coargs.nsec_per_tick;
1540 coargs.btime *= coargs.nsec_per_tick;
1541 }
1542
1543 if (dflag) {
1544 coargs.time += coargs.now;
1545 coargs.atime += coargs.now;
1546 coargs.btime += coargs.now;
1547 }
1548 if (Sflag) {
1549 if (flags & DCMD_ADDRSPEC) {
1550 mdb_printf("-S option conflicts with explicit"
1551 " address\n");
1552 return (DCMD_USAGE);
1553 }
1554 coargs.flags |= COF_SEQID;
1555 coargs.seqid = (int)Stmp;
1556 }
1557 if (Cflag) {
1558 if (flags & DCMD_ADDRSPEC) {
1559 mdb_printf("-C option conflicts with explicit"
1560 " address\n");
1561 return (DCMD_USAGE);
1562 }
1563 if (coargs.flags & COF_SEQID) {
1564 mdb_printf("-C and -S are mutually exclusive\n");
1565 return (DCMD_USAGE);
1566 }
1567 coargs.cpu = (cpu_t *)Ctmp;
1568 if (mdb_vread(&coargs.seqid, sizeof (processorid_t),
1569 (uintptr_t)&(coargs.cpu->cpu_seqid)) == -1) {
1570 mdb_warn("failed to read cpu_t at %p", Ctmp);
1571 return (DCMD_ERR);
1572 }
1573 coargs.flags |= COF_SEQID;
1574 }
1575 /* avoid null outputs. */
1576 if (!(coargs.flags & (COF_REAL | COF_NORM))) {
1577 coargs.flags |= COF_REAL | COF_NORM;
1578 }
1579 if (!(coargs.flags & (COF_LONG | COF_SHORT))) {
1580 coargs.flags |= COF_LONG | COF_SHORT;
1581 }
1582 if (tflag) {
1583 if (aflag || bflag) {
1584 mdb_printf("-t and -a|b are mutually exclusive\n");
1585 return (DCMD_USAGE);
1586 }
1587 coargs.flags |= COF_TIME;
1588 }
1589 if (aflag) {
1590 coargs.flags |= COF_AFTER;
1591 }
1592 if (bflag) {
1593 coargs.flags |= COF_BEFORE;
1594 }
1595 if ((aflag && bflag) && (coargs.btime <= coargs.atime)) {
1596 mdb_printf("value for -a must be earlier than the value"
1597 " for -b.\n");
1598 return (DCMD_USAGE);
1599 }
1600
1601 if ((coargs.flags & COF_HEAP) && (coargs.flags & COF_QUEUE)) {
1602 mdb_printf("-H and -Q are mutually exclusive\n");
1603 return (DCMD_USAGE);
1604 }
1605
1606 if (funcname != NULL) {
1607 GElf_Sym sym;
1608
1609 if (mdb_lookup_by_name(funcname, &sym) != 0) {
1610 coargs.funcaddr = mdb_strtoull(funcname);
1611 } else {
1612 coargs.funcaddr = sym.st_value;
1613 }
1614 coargs.flags |= COF_FUNC;
1615 }
1616
1617 if (paramstr != NULL) {
1618 GElf_Sym sym;
1619
1620 if (mdb_lookup_by_name(paramstr, &sym) != 0) {
1621 coargs.param = mdb_strtoull(paramstr);
1622 } else {
1623 coargs.param = sym.st_value;
1624 }
1625 coargs.flags |= COF_PARAM;
1626 }
1627
1628 if (!(flags & DCMD_ADDRSPEC)) {
1629 /* don't pass "dot" if no addr. */
1630 addr = 0;
1631 }
1632 if (addr != 0) {
1633 /*
1634 * a callout table was specified. Ignore -r|n option
1635 * to avoid null output.
1636 */
1637 coargs.flags |= (COF_REAL | COF_NORM);
1638 }
1639
1640 if (DCMD_HDRSPEC(flags) || (coargs.flags & COF_VERBOSE)) {
1641 coargs.flags |= COF_THDR | COF_LHDR | COF_CHDR;
1642 }
1643 if (coargs.flags & COF_FREE) {
1644 coargs.flags |= COF_EMPTY;
1645 /* -F = free callouts, -FL = free lists */
1646 if (!(coargs.flags & COF_LIST)) {
1647 coargs.flags |= COF_BYIDH;
1648 }
1649 }
1650
1651 /* walk table, using specialized callback routine. */
1652 if (mdb_pwalk("callout_table", callout_t_cb, &coargs, addr) == -1) {
1653 mdb_warn("cannot walk callout_table");
1654 return (DCMD_ERR);
1655 }
1656 return (DCMD_OK);
1657 }
1658
1659
1660 /*
1661 * Given an extended callout id, dump its information.
1662 */
1663 /*ARGSUSED*/
1664 int
calloutid(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1665 calloutid(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1666 {
1667 callout_data_t coargs;
1668 callout_table_t *ctptr;
1669 callout_table_t ct;
1670 callout_id_t coid;
1671 callout_t *coptr;
1672 int tableid;
1673 callout_id_t xid;
1674 ulong_t idhash;
1675 int i, retval;
1676 const mdb_arg_t *arg;
1677 size_t size;
1678 callout_hash_t cot_idhash[CALLOUT_BUCKETS];
1679
1680 coargs.flags = COF_DEFAULT | COF_BYIDH;
1681 i = mdb_getopts(argc, argv,
1682 'd', MDB_OPT_SETBITS, COF_DECODE, &coargs.flags,
1683 'v', MDB_OPT_SETBITS, COF_LONGLIST, &coargs.flags,
1684 NULL);
1685 argc -= i;
1686 argv += i;
1687
1688 if (argc != 1) {
1689 return (DCMD_USAGE);
1690 }
1691 arg = &argv[0];
1692
1693 xid = (callout_id_t)mdb_argtoull(arg);
1694
1695 if (DCMD_HDRSPEC(flags)) {
1696 coargs.flags |= COF_CHDR;
1697 }
1698
1699
1700 /* initialize from kernel variables */
1701 if ((retval = callout_common_init(&coargs)) != DCMD_OK) {
1702 return (retval);
1703 }
1704
1705 /* we must massage the environment so that the macros will play nice */
1706 #define callout_table_mask ((1 << coargs.ctbits) - 1)
1707 #define callout_table_bits coargs.ctbits
1708 #define nsec_per_tick coargs.nsec_per_tick
1709 tableid = CALLOUT_ID_TO_TABLE(xid);
1710 idhash = CALLOUT_IDHASH(xid);
1711 #undef callouts_table_bits
1712 #undef callout_table_mask
1713 #undef nsec_per_tick
1714 coid = CO_PLAIN_ID(xid);
1715
1716 if (flags & DCMD_ADDRSPEC) {
1717 mdb_printf("calloutid does not accept explicit address.\n");
1718 return (DCMD_USAGE);
1719 }
1720
1721 if (coargs.flags & COF_DECODE) {
1722 if (DCMD_HDRSPEC(flags)) {
1723 mdb_printf("%<u>%3s %1s %2s %-?s %-6s %</u>\n",
1724 "SEQ", "T", "XL", "XID", "IDHASH");
1725 }
1726 mdb_printf("%-3d %1s %1s%1s %-?llx %-6d\n",
1727 TABLE_TO_SEQID(tableid),
1728 co_typenames[tableid & CALLOUT_TYPE_MASK],
1729 (xid & CALLOUT_EXECUTING) ? "X" : " ",
1730 (xid & CALLOUT_LONGTERM) ? "L" : " ",
1731 (long long)coid, idhash);
1732 return (DCMD_OK);
1733 }
1734
1735 /* get our table. Note this relies on the types being correct */
1736 ctptr = coargs.co_table + tableid;
1737 if (mdb_vread(&ct, sizeof (callout_table_t), (uintptr_t)ctptr) == -1) {
1738 mdb_warn("failed to read callout_table at %p", ctptr);
1739 return (DCMD_ERR);
1740 }
1741 size = sizeof (callout_hash_t) * CALLOUT_BUCKETS;
1742 if (ct.ct_idhash != NULL) {
1743 if (mdb_vread(&(cot_idhash), size,
1744 (uintptr_t)ct.ct_idhash) == -1) {
1745 mdb_warn("failed to read id_hash at %p",
1746 ct.ct_idhash);
1747 return (WALK_ERR);
1748 }
1749 }
1750
1751 /* callout at beginning of hash chain */
1752 if (ct.ct_idhash == NULL) {
1753 mdb_printf("id hash chain for this xid is empty\n");
1754 return (DCMD_ERR);
1755 }
1756 coptr = (callout_t *)cot_idhash[idhash].ch_head;
1757 if (coptr == NULL) {
1758 mdb_printf("id hash chain for this xid is empty\n");
1759 return (DCMD_ERR);
1760 }
1761
1762 coargs.ndx = tableid;
1763 coargs.bucket = idhash;
1764
1765 /* use the walker, luke */
1766 if (mdb_pwalk("callouts_byid", callouts_cb, &coargs,
1767 (uintptr_t)coptr) == -1) {
1768 mdb_warn("cannot walk callouts at %p", coptr);
1769 return (WALK_ERR);
1770 }
1771
1772 return (DCMD_OK);
1773 }
1774
1775 void
callout_help(void)1776 callout_help(void)
1777 {
1778 mdb_printf("callout: display callouts.\n"
1779 "Given a callout table address, display callouts from table.\n"
1780 "Without an address, display callouts from all tables.\n"
1781 "options:\n"
1782 " -r|n : limit display to (r)ealtime or (n)ormal type callouts\n"
1783 " -s|l : limit display to (s)hort-term ids or (l)ong-term ids\n"
1784 " -x : limit display to callouts which are executing\n"
1785 " -h : limit display to callouts based on hrestime\n"
1786 " -B : limit display to callouts based on absolute time\n"
1787 " -t|a|b nsec: limit display to callouts that expire a(t) time,"
1788 " (a)fter time,\n or (b)efore time. Use -a and -b together "
1789 " to specify a range.\n For \"now\", use -d[t|a|b] 0.\n"
1790 " -d : interpret time option to -t|a|b as delta from current time\n"
1791 " -k : use ticks instead of nanoseconds as arguments to"
1792 " -t|a|b. Note that\n ticks are less accurate and may not"
1793 " match other tick times (ie: lbolt).\n"
1794 " -D : display exiration time as delta from current time\n"
1795 " -S seqid : limit display to callouts for this cpu sequence id\n"
1796 " -C addr : limit display to callouts for this cpu pointer\n"
1797 " -f name|addr : limit display to callouts with this function\n"
1798 " -p name|addr : limit display to callouts functions with this"
1799 " parameter\n"
1800 " -T : display the callout table itself, instead of callouts\n"
1801 " -L : display callout lists instead of callouts\n"
1802 " -E : with -T or L, display empty data structures.\n"
1803 " -i : traverse callouts by id hash instead of list hash\n"
1804 " -F : walk free callout list (free list with -i) instead\n"
1805 " -v : display more info for each item\n"
1806 " -V : show details of each level of info as it is traversed\n"
1807 " -H : limit display to callouts in the callout heap\n"
1808 " -Q : limit display to callouts in the callout queue\n"
1809 " -A : show only addresses. Useful for pipelines.\n");
1810 }
1811
1812 void
calloutid_help(void)1813 calloutid_help(void)
1814 {
1815 mdb_printf("calloutid: display callout by id.\n"
1816 "Given an extended callout id, display the callout infomation.\n"
1817 "options:\n"
1818 " -d : do not dereference callout, just decode the id.\n"
1819 " -v : verbose display more info about the callout\n");
1820 }
1821
1822 /*ARGSUSED*/
1823 int
class(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1824 class(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1825 {
1826 long num_classes, i;
1827 sclass_t *class_tbl;
1828 GElf_Sym g_sclass;
1829 char class_name[PC_CLNMSZ];
1830 size_t tbl_size;
1831
1832 if (mdb_lookup_by_name("sclass", &g_sclass) == -1) {
1833 mdb_warn("failed to find symbol sclass\n");
1834 return (DCMD_ERR);
1835 }
1836
1837 tbl_size = (size_t)g_sclass.st_size;
1838 num_classes = tbl_size / (sizeof (sclass_t));
1839 class_tbl = mdb_alloc(tbl_size, UM_SLEEP | UM_GC);
1840
1841 if (mdb_readsym(class_tbl, tbl_size, "sclass") == -1) {
1842 mdb_warn("failed to read sclass");
1843 return (DCMD_ERR);
1844 }
1845
1846 mdb_printf("%<u>%4s %-10s %-24s %-24s%</u>\n", "SLOT", "NAME",
1847 "INIT FCN", "CLASS FCN");
1848
1849 for (i = 0; i < num_classes; i++) {
1850 if (mdb_vread(class_name, sizeof (class_name),
1851 (uintptr_t)class_tbl[i].cl_name) == -1)
1852 (void) strcpy(class_name, "???");
1853
1854 mdb_printf("%4ld %-10s %-24a %-24a\n", i, class_name,
1855 class_tbl[i].cl_init, class_tbl[i].cl_funcs);
1856 }
1857
1858 return (DCMD_OK);
1859 }
1860
1861 #define FSNAMELEN 32 /* Max len of FS name we read from vnodeops */
1862
1863 int
vnode2path(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1864 vnode2path(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1865 {
1866 uintptr_t rootdir;
1867 vnode_t vn;
1868 char buf[MAXPATHLEN];
1869
1870 uint_t opt_F = FALSE;
1871
1872 if (mdb_getopts(argc, argv,
1873 'F', MDB_OPT_SETBITS, TRUE, &opt_F, NULL) != argc)
1874 return (DCMD_USAGE);
1875
1876 if (!(flags & DCMD_ADDRSPEC)) {
1877 mdb_warn("expected explicit vnode_t address before ::\n");
1878 return (DCMD_USAGE);
1879 }
1880
1881 if (mdb_readvar(&rootdir, "rootdir") == -1) {
1882 mdb_warn("failed to read rootdir");
1883 return (DCMD_ERR);
1884 }
1885
1886 if (mdb_vnode2path(addr, buf, sizeof (buf)) == -1)
1887 return (DCMD_ERR);
1888
1889 if (*buf == '\0') {
1890 mdb_printf("??\n");
1891 return (DCMD_OK);
1892 }
1893
1894 mdb_printf("%s", buf);
1895 if (opt_F && buf[strlen(buf)-1] != '/' &&
1896 mdb_vread(&vn, sizeof (vn), addr) == sizeof (vn))
1897 mdb_printf("%c", mdb_vtype2chr(vn.v_type, 0));
1898 mdb_printf("\n");
1899
1900 return (DCMD_OK);
1901 }
1902
1903 int
ld_walk_init(mdb_walk_state_t * wsp)1904 ld_walk_init(mdb_walk_state_t *wsp)
1905 {
1906 wsp->walk_data = (void *)wsp->walk_addr;
1907 return (WALK_NEXT);
1908 }
1909
1910 int
ld_walk_step(mdb_walk_state_t * wsp)1911 ld_walk_step(mdb_walk_state_t *wsp)
1912 {
1913 int status;
1914 lock_descriptor_t ld;
1915
1916 if (mdb_vread(&ld, sizeof (lock_descriptor_t), wsp->walk_addr) == -1) {
1917 mdb_warn("couldn't read lock_descriptor_t at %p\n",
1918 wsp->walk_addr);
1919 return (WALK_ERR);
1920 }
1921
1922 status = wsp->walk_callback(wsp->walk_addr, &ld, wsp->walk_cbdata);
1923 if (status == WALK_ERR)
1924 return (WALK_ERR);
1925
1926 wsp->walk_addr = (uintptr_t)ld.l_next;
1927 if (wsp->walk_addr == (uintptr_t)wsp->walk_data)
1928 return (WALK_DONE);
1929
1930 return (status);
1931 }
1932
1933 int
lg_walk_init(mdb_walk_state_t * wsp)1934 lg_walk_init(mdb_walk_state_t *wsp)
1935 {
1936 GElf_Sym sym;
1937
1938 if (mdb_lookup_by_name("lock_graph", &sym) == -1) {
1939 mdb_warn("failed to find symbol 'lock_graph'\n");
1940 return (WALK_ERR);
1941 }
1942
1943 wsp->walk_addr = (uintptr_t)sym.st_value;
1944 wsp->walk_data = (void *)(uintptr_t)(sym.st_value + sym.st_size);
1945
1946 return (WALK_NEXT);
1947 }
1948
1949 typedef struct lg_walk_data {
1950 uintptr_t startaddr;
1951 mdb_walk_cb_t callback;
1952 void *data;
1953 } lg_walk_data_t;
1954
1955 /*
1956 * We can't use ::walk lock_descriptor directly, because the head of each graph
1957 * is really a dummy lock. Rather than trying to dynamically determine if this
1958 * is a dummy node or not, we just filter out the initial element of the
1959 * list.
1960 */
1961 static int
lg_walk_cb(uintptr_t addr,const void * data,void * priv)1962 lg_walk_cb(uintptr_t addr, const void *data, void *priv)
1963 {
1964 lg_walk_data_t *lw = priv;
1965
1966 if (addr != lw->startaddr)
1967 return (lw->callback(addr, data, lw->data));
1968
1969 return (WALK_NEXT);
1970 }
1971
1972 int
lg_walk_step(mdb_walk_state_t * wsp)1973 lg_walk_step(mdb_walk_state_t *wsp)
1974 {
1975 graph_t *graph;
1976 lg_walk_data_t lw;
1977
1978 if (wsp->walk_addr >= (uintptr_t)wsp->walk_data)
1979 return (WALK_DONE);
1980
1981 if (mdb_vread(&graph, sizeof (graph), wsp->walk_addr) == -1) {
1982 mdb_warn("failed to read graph_t at %p", wsp->walk_addr);
1983 return (WALK_ERR);
1984 }
1985
1986 wsp->walk_addr += sizeof (graph);
1987
1988 if (graph == NULL)
1989 return (WALK_NEXT);
1990
1991 lw.callback = wsp->walk_callback;
1992 lw.data = wsp->walk_cbdata;
1993
1994 lw.startaddr = (uintptr_t)&(graph->active_locks);
1995 if (mdb_pwalk("lock_descriptor", lg_walk_cb, &lw, lw.startaddr)) {
1996 mdb_warn("couldn't walk lock_descriptor at %p\n", lw.startaddr);
1997 return (WALK_ERR);
1998 }
1999
2000 lw.startaddr = (uintptr_t)&(graph->sleeping_locks);
2001 if (mdb_pwalk("lock_descriptor", lg_walk_cb, &lw, lw.startaddr)) {
2002 mdb_warn("couldn't walk lock_descriptor at %p\n", lw.startaddr);
2003 return (WALK_ERR);
2004 }
2005
2006 return (WALK_NEXT);
2007 }
2008
2009 /*
2010 * The space available for the path corresponding to the locked vnode depends
2011 * on whether we are printing 32- or 64-bit addresses.
2012 */
2013 #ifdef _LP64
2014 #define LM_VNPATHLEN 20
2015 #else
2016 #define LM_VNPATHLEN 30
2017 #endif
2018
2019 typedef struct mdb_lminfo_proc {
2020 struct {
2021 char u_comm[MAXCOMLEN + 1];
2022 } p_user;
2023 } mdb_lminfo_proc_t;
2024
2025 /*ARGSUSED*/
2026 static int
lminfo_cb(uintptr_t addr,const void * data,void * priv)2027 lminfo_cb(uintptr_t addr, const void *data, void *priv)
2028 {
2029 const lock_descriptor_t *ld = data;
2030 char buf[LM_VNPATHLEN];
2031 mdb_lminfo_proc_t p;
2032 uintptr_t paddr = 0;
2033
2034 if (ld->l_flock.l_pid != 0)
2035 paddr = mdb_pid2proc(ld->l_flock.l_pid, NULL);
2036
2037 if (paddr != 0)
2038 mdb_ctf_vread(&p, "proc_t", "mdb_lminfo_proc_t", paddr, 0);
2039
2040 mdb_printf("%-?p %2s %04x %6d %-16s %-?p ",
2041 addr, ld->l_type == F_RDLCK ? "RD" :
2042 ld->l_type == F_WRLCK ? "WR" : "??",
2043 ld->l_state, ld->l_flock.l_pid,
2044 ld->l_flock.l_pid == 0 ? "<kernel>" :
2045 paddr == 0 ? "<defunct>" : p.p_user.u_comm, ld->l_vnode);
2046
2047 mdb_vnode2path((uintptr_t)ld->l_vnode, buf,
2048 sizeof (buf));
2049 mdb_printf("%s\n", buf);
2050
2051 return (WALK_NEXT);
2052 }
2053
2054 /*ARGSUSED*/
2055 int
lminfo(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)2056 lminfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2057 {
2058 if (DCMD_HDRSPEC(flags))
2059 mdb_printf("%<u>%-?s %2s %4s %6s %-16s %-?s %s%</u>\n",
2060 "ADDR", "TP", "FLAG", "PID", "COMM", "VNODE", "PATH");
2061
2062 return (mdb_pwalk("lock_graph", lminfo_cb, NULL, 0));
2063 }
2064
2065 typedef struct mdb_whereopen {
2066 uint_t mwo_flags;
2067 uintptr_t mwo_target;
2068 boolean_t mwo_found;
2069 } mdb_whereopen_t;
2070
2071 /*ARGSUSED*/
2072 int
whereopen_fwalk(uintptr_t addr,const void * farg,void * arg)2073 whereopen_fwalk(uintptr_t addr, const void *farg, void *arg)
2074 {
2075 const struct file *f = farg;
2076 mdb_whereopen_t *mwo = arg;
2077
2078 if ((uintptr_t)f->f_vnode == mwo->mwo_target) {
2079 if ((mwo->mwo_flags & DCMD_PIPE_OUT) == 0 &&
2080 !mwo->mwo_found) {
2081 mdb_printf("file %p\n", addr);
2082 }
2083 mwo->mwo_found = B_TRUE;
2084 }
2085
2086 return (WALK_NEXT);
2087 }
2088
2089 /*ARGSUSED*/
2090 int
whereopen_pwalk(uintptr_t addr,const void * ignored,void * arg)2091 whereopen_pwalk(uintptr_t addr, const void *ignored, void *arg)
2092 {
2093 mdb_whereopen_t *mwo = arg;
2094
2095 mwo->mwo_found = B_FALSE;
2096 if (mdb_pwalk("file", whereopen_fwalk, mwo, addr) == -1) {
2097 mdb_warn("couldn't file walk proc %p", addr);
2098 return (WALK_ERR);
2099 }
2100
2101 if (mwo->mwo_found) {
2102 mdb_printf("%p\n", addr);
2103 }
2104
2105 return (WALK_NEXT);
2106 }
2107
2108 /*ARGSUSED*/
2109 int
whereopen(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)2110 whereopen(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2111 {
2112 mdb_whereopen_t mwo;
2113
2114 if (!(flags & DCMD_ADDRSPEC) || addr == 0)
2115 return (DCMD_USAGE);
2116
2117 mwo.mwo_flags = flags;
2118 mwo.mwo_target = addr;
2119 mwo.mwo_found = B_FALSE;
2120
2121 if (mdb_walk("proc", whereopen_pwalk, &mwo) == -1) {
2122 mdb_warn("can't proc walk");
2123 return (DCMD_ERR);
2124 }
2125
2126 return (DCMD_OK);
2127 }
2128
2129 typedef struct datafmt {
2130 char *hdr1;
2131 char *hdr2;
2132 char *dashes;
2133 char *fmt;
2134 } datafmt_t;
2135
2136 static datafmt_t kmemfmt[] = {
2137 { "cache ", "name ",
2138 "-------------------------", "%-25s " },
2139 { " buf", " size", "------", "%6u " },
2140 { " buf", "in use", "------", "%6u " },
2141 { " buf", " total", "------", "%6u " },
2142 { " memory", " in use", "----------", "%10lu%c " },
2143 { " alloc", " succeed", "---------", "%9u " },
2144 { "alloc", " fail", "-----", "%5u " },
2145 { NULL, NULL, NULL, NULL }
2146 };
2147
2148 static datafmt_t vmemfmt[] = {
2149 { "vmem ", "name ",
2150 "-------------------------", "%-*s " },
2151 { " memory", " in use", "----------", "%9llu%c " },
2152 { " memory", " total", "-----------", "%10llu%c " },
2153 { " memory", " import", "----------", "%9llu%c " },
2154 { " alloc", " succeed", "---------", "%9llu " },
2155 { "alloc", " fail", "-----", "%5llu " },
2156 { NULL, NULL, NULL, NULL }
2157 };
2158
2159 /*ARGSUSED*/
2160 static int
kmastat_cpu_avail(uintptr_t addr,const kmem_cpu_cache_t * ccp,int * avail)2161 kmastat_cpu_avail(uintptr_t addr, const kmem_cpu_cache_t *ccp, int *avail)
2162 {
2163 short rounds, prounds;
2164
2165 if (KMEM_DUMPCC(ccp)) {
2166 rounds = ccp->cc_dump_rounds;
2167 prounds = ccp->cc_dump_prounds;
2168 } else {
2169 rounds = ccp->cc_rounds;
2170 prounds = ccp->cc_prounds;
2171 }
2172 if (rounds > 0)
2173 *avail += rounds;
2174 if (prounds > 0)
2175 *avail += prounds;
2176
2177 return (WALK_NEXT);
2178 }
2179
2180 /*ARGSUSED*/
2181 static int
kmastat_cpu_alloc(uintptr_t addr,const kmem_cpu_cache_t * ccp,int * alloc)2182 kmastat_cpu_alloc(uintptr_t addr, const kmem_cpu_cache_t *ccp, int *alloc)
2183 {
2184 *alloc += ccp->cc_alloc;
2185
2186 return (WALK_NEXT);
2187 }
2188
2189 /*ARGSUSED*/
2190 static int
kmastat_slab_avail(uintptr_t addr,const kmem_slab_t * sp,int * avail)2191 kmastat_slab_avail(uintptr_t addr, const kmem_slab_t *sp, int *avail)
2192 {
2193 *avail += sp->slab_chunks - sp->slab_refcnt;
2194
2195 return (WALK_NEXT);
2196 }
2197
2198 typedef struct kmastat_vmem {
2199 uintptr_t kv_addr;
2200 struct kmastat_vmem *kv_next;
2201 size_t kv_meminuse;
2202 int kv_alloc;
2203 int kv_fail;
2204 } kmastat_vmem_t;
2205
2206 typedef struct kmastat_args {
2207 kmastat_vmem_t **ka_kvpp;
2208 uint_t ka_shift;
2209 } kmastat_args_t;
2210
2211 static int
kmastat_cache(uintptr_t addr,const kmem_cache_t * cp,kmastat_args_t * kap)2212 kmastat_cache(uintptr_t addr, const kmem_cache_t *cp, kmastat_args_t *kap)
2213 {
2214 kmastat_vmem_t **kvpp = kap->ka_kvpp;
2215 kmastat_vmem_t *kv;
2216 datafmt_t *dfp = kmemfmt;
2217 int magsize;
2218
2219 int avail, alloc, total;
2220 size_t meminuse = (cp->cache_slab_create - cp->cache_slab_destroy) *
2221 cp->cache_slabsize;
2222
2223 mdb_walk_cb_t cpu_avail = (mdb_walk_cb_t)kmastat_cpu_avail;
2224 mdb_walk_cb_t cpu_alloc = (mdb_walk_cb_t)kmastat_cpu_alloc;
2225 mdb_walk_cb_t slab_avail = (mdb_walk_cb_t)kmastat_slab_avail;
2226
2227 magsize = kmem_get_magsize(cp);
2228
2229 alloc = cp->cache_slab_alloc + cp->cache_full.ml_alloc;
2230 avail = cp->cache_full.ml_total * magsize;
2231 total = cp->cache_buftotal;
2232
2233 (void) mdb_pwalk("kmem_cpu_cache", cpu_alloc, &alloc, addr);
2234 (void) mdb_pwalk("kmem_cpu_cache", cpu_avail, &avail, addr);
2235 (void) mdb_pwalk("kmem_slab_partial", slab_avail, &avail, addr);
2236
2237 for (kv = *kvpp; kv != NULL; kv = kv->kv_next) {
2238 if (kv->kv_addr == (uintptr_t)cp->cache_arena)
2239 goto out;
2240 }
2241
2242 kv = mdb_zalloc(sizeof (kmastat_vmem_t), UM_SLEEP | UM_GC);
2243 kv->kv_next = *kvpp;
2244 kv->kv_addr = (uintptr_t)cp->cache_arena;
2245 *kvpp = kv;
2246 out:
2247 kv->kv_meminuse += meminuse;
2248 kv->kv_alloc += alloc;
2249 kv->kv_fail += cp->cache_alloc_fail;
2250
2251 mdb_printf((dfp++)->fmt, cp->cache_name);
2252 mdb_printf((dfp++)->fmt, cp->cache_bufsize);
2253 mdb_printf((dfp++)->fmt, total - avail);
2254 mdb_printf((dfp++)->fmt, total);
2255 mdb_printf((dfp++)->fmt, meminuse >> kap->ka_shift,
2256 kap->ka_shift == GIGS ? 'G' : kap->ka_shift == MEGS ? 'M' :
2257 kap->ka_shift == KILOS ? 'K' : 'B');
2258 mdb_printf((dfp++)->fmt, alloc);
2259 mdb_printf((dfp++)->fmt, cp->cache_alloc_fail);
2260 mdb_printf("\n");
2261
2262 return (WALK_NEXT);
2263 }
2264
2265 static int
kmastat_vmem_totals(uintptr_t addr,const vmem_t * v,kmastat_args_t * kap)2266 kmastat_vmem_totals(uintptr_t addr, const vmem_t *v, kmastat_args_t *kap)
2267 {
2268 kmastat_vmem_t *kv = *kap->ka_kvpp;
2269 size_t len;
2270
2271 while (kv != NULL && kv->kv_addr != addr)
2272 kv = kv->kv_next;
2273
2274 if (kv == NULL || kv->kv_alloc == 0)
2275 return (WALK_NEXT);
2276
2277 len = MIN(17, strlen(v->vm_name));
2278
2279 mdb_printf("Total [%s]%*s %6s %6s %6s %10lu%c %9u %5u\n", v->vm_name,
2280 17 - len, "", "", "", "",
2281 kv->kv_meminuse >> kap->ka_shift,
2282 kap->ka_shift == GIGS ? 'G' : kap->ka_shift == MEGS ? 'M' :
2283 kap->ka_shift == KILOS ? 'K' : 'B', kv->kv_alloc, kv->kv_fail);
2284
2285 return (WALK_NEXT);
2286 }
2287
2288 /*ARGSUSED*/
2289 static int
kmastat_vmem(uintptr_t addr,const vmem_t * v,const uint_t * shiftp)2290 kmastat_vmem(uintptr_t addr, const vmem_t *v, const uint_t *shiftp)
2291 {
2292 datafmt_t *dfp = vmemfmt;
2293 const vmem_kstat_t *vkp = &v->vm_kstat;
2294 uintptr_t paddr;
2295 vmem_t parent;
2296 int ident = 0;
2297
2298 for (paddr = (uintptr_t)v->vm_source; paddr != 0; ident += 4) {
2299 if (mdb_vread(&parent, sizeof (parent), paddr) == -1) {
2300 mdb_warn("couldn't trace %p's ancestry", addr);
2301 ident = 0;
2302 break;
2303 }
2304 paddr = (uintptr_t)parent.vm_source;
2305 }
2306
2307 mdb_printf("%*s", ident, "");
2308 mdb_printf((dfp++)->fmt, 25 - ident, v->vm_name);
2309 mdb_printf((dfp++)->fmt, vkp->vk_mem_inuse.value.ui64 >> *shiftp,
2310 *shiftp == GIGS ? 'G' : *shiftp == MEGS ? 'M' :
2311 *shiftp == KILOS ? 'K' : 'B');
2312 mdb_printf((dfp++)->fmt, vkp->vk_mem_total.value.ui64 >> *shiftp,
2313 *shiftp == GIGS ? 'G' : *shiftp == MEGS ? 'M' :
2314 *shiftp == KILOS ? 'K' : 'B');
2315 mdb_printf((dfp++)->fmt, vkp->vk_mem_import.value.ui64 >> *shiftp,
2316 *shiftp == GIGS ? 'G' : *shiftp == MEGS ? 'M' :
2317 *shiftp == KILOS ? 'K' : 'B');
2318 mdb_printf((dfp++)->fmt, vkp->vk_alloc.value.ui64);
2319 mdb_printf((dfp++)->fmt, vkp->vk_fail.value.ui64);
2320
2321 mdb_printf("\n");
2322
2323 return (WALK_NEXT);
2324 }
2325
2326 /*ARGSUSED*/
2327 int
kmastat(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)2328 kmastat(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2329 {
2330 kmastat_vmem_t *kv = NULL;
2331 datafmt_t *dfp;
2332 kmastat_args_t ka;
2333
2334 ka.ka_shift = 0;
2335 if (mdb_getopts(argc, argv,
2336 'k', MDB_OPT_SETBITS, KILOS, &ka.ka_shift,
2337 'm', MDB_OPT_SETBITS, MEGS, &ka.ka_shift,
2338 'g', MDB_OPT_SETBITS, GIGS, &ka.ka_shift, NULL) != argc)
2339 return (DCMD_USAGE);
2340
2341 for (dfp = kmemfmt; dfp->hdr1 != NULL; dfp++)
2342 mdb_printf("%s ", dfp->hdr1);
2343 mdb_printf("\n");
2344
2345 for (dfp = kmemfmt; dfp->hdr1 != NULL; dfp++)
2346 mdb_printf("%s ", dfp->hdr2);
2347 mdb_printf("\n");
2348
2349 for (dfp = kmemfmt; dfp->hdr1 != NULL; dfp++)
2350 mdb_printf("%s ", dfp->dashes);
2351 mdb_printf("\n");
2352
2353 ka.ka_kvpp = &kv;
2354 if (mdb_walk("kmem_cache", (mdb_walk_cb_t)kmastat_cache, &ka) == -1) {
2355 mdb_warn("can't walk 'kmem_cache'");
2356 return (DCMD_ERR);
2357 }
2358
2359 for (dfp = kmemfmt; dfp->hdr1 != NULL; dfp++)
2360 mdb_printf("%s ", dfp->dashes);
2361 mdb_printf("\n");
2362
2363 if (mdb_walk("vmem", (mdb_walk_cb_t)kmastat_vmem_totals, &ka) == -1) {
2364 mdb_warn("can't walk 'vmem'");
2365 return (DCMD_ERR);
2366 }
2367
2368 for (dfp = kmemfmt; dfp->hdr1 != NULL; dfp++)
2369 mdb_printf("%s ", dfp->dashes);
2370 mdb_printf("\n");
2371
2372 mdb_printf("\n");
2373
2374 for (dfp = vmemfmt; dfp->hdr1 != NULL; dfp++)
2375 mdb_printf("%s ", dfp->hdr1);
2376 mdb_printf("\n");
2377
2378 for (dfp = vmemfmt; dfp->hdr1 != NULL; dfp++)
2379 mdb_printf("%s ", dfp->hdr2);
2380 mdb_printf("\n");
2381
2382 for (dfp = vmemfmt; dfp->hdr1 != NULL; dfp++)
2383 mdb_printf("%s ", dfp->dashes);
2384 mdb_printf("\n");
2385
2386 if (mdb_walk("vmem", (mdb_walk_cb_t)kmastat_vmem, &ka.ka_shift) == -1) {
2387 mdb_warn("can't walk 'vmem'");
2388 return (DCMD_ERR);
2389 }
2390
2391 for (dfp = vmemfmt; dfp->hdr1 != NULL; dfp++)
2392 mdb_printf("%s ", dfp->dashes);
2393 mdb_printf("\n");
2394 return (DCMD_OK);
2395 }
2396
2397 /*
2398 * Our ::kgrep callback scans the entire kernel VA space (kas). kas is made
2399 * up of a set of 'struct seg's. We could just scan each seg en masse, but
2400 * unfortunately, a few of the segs are both large and sparse, so we could
2401 * spend quite a bit of time scanning VAs which have no backing pages.
2402 *
2403 * So for the few very sparse segs, we skip the segment itself, and scan
2404 * the allocated vmem_segs in the vmem arena which manages that part of kas.
2405 * Currently, we do this for:
2406 *
2407 * SEG VMEM ARENA
2408 * kvseg heap_arena
2409 * kvseg32 heap32_arena
2410 * kvseg_core heap_core_arena
2411 *
2412 * In addition, we skip the segkpm segment in its entirety, since it is very
2413 * sparse, and contains no new kernel data.
2414 */
2415 typedef struct kgrep_walk_data {
2416 kgrep_cb_func *kg_cb;
2417 void *kg_cbdata;
2418 uintptr_t kg_kvseg;
2419 uintptr_t kg_kvseg32;
2420 uintptr_t kg_kvseg_core;
2421 uintptr_t kg_segkpm;
2422 uintptr_t kg_heap_lp_base;
2423 uintptr_t kg_heap_lp_end;
2424 } kgrep_walk_data_t;
2425
2426 static int
kgrep_walk_seg(uintptr_t addr,const struct seg * seg,kgrep_walk_data_t * kg)2427 kgrep_walk_seg(uintptr_t addr, const struct seg *seg, kgrep_walk_data_t *kg)
2428 {
2429 uintptr_t base = (uintptr_t)seg->s_base;
2430
2431 if (addr == kg->kg_kvseg || addr == kg->kg_kvseg32 ||
2432 addr == kg->kg_kvseg_core)
2433 return (WALK_NEXT);
2434
2435 if ((uintptr_t)seg->s_ops == kg->kg_segkpm)
2436 return (WALK_NEXT);
2437
2438 return (kg->kg_cb(base, base + seg->s_size, kg->kg_cbdata));
2439 }
2440
2441 /*ARGSUSED*/
2442 static int
kgrep_walk_vseg(uintptr_t addr,const vmem_seg_t * seg,kgrep_walk_data_t * kg)2443 kgrep_walk_vseg(uintptr_t addr, const vmem_seg_t *seg, kgrep_walk_data_t *kg)
2444 {
2445 /*
2446 * skip large page heap address range - it is scanned by walking
2447 * allocated vmem_segs in the heap_lp_arena
2448 */
2449 if (seg->vs_start == kg->kg_heap_lp_base &&
2450 seg->vs_end == kg->kg_heap_lp_end)
2451 return (WALK_NEXT);
2452
2453 return (kg->kg_cb(seg->vs_start, seg->vs_end, kg->kg_cbdata));
2454 }
2455
2456 /*ARGSUSED*/
2457 static int
kgrep_xwalk_vseg(uintptr_t addr,const vmem_seg_t * seg,kgrep_walk_data_t * kg)2458 kgrep_xwalk_vseg(uintptr_t addr, const vmem_seg_t *seg, kgrep_walk_data_t *kg)
2459 {
2460 return (kg->kg_cb(seg->vs_start, seg->vs_end, kg->kg_cbdata));
2461 }
2462
2463 static int
kgrep_walk_vmem(uintptr_t addr,const vmem_t * vmem,kgrep_walk_data_t * kg)2464 kgrep_walk_vmem(uintptr_t addr, const vmem_t *vmem, kgrep_walk_data_t *kg)
2465 {
2466 mdb_walk_cb_t walk_vseg = (mdb_walk_cb_t)kgrep_walk_vseg;
2467
2468 if (strcmp(vmem->vm_name, "heap") != 0 &&
2469 strcmp(vmem->vm_name, "heap32") != 0 &&
2470 strcmp(vmem->vm_name, "heap_core") != 0 &&
2471 strcmp(vmem->vm_name, "heap_lp") != 0)
2472 return (WALK_NEXT);
2473
2474 if (strcmp(vmem->vm_name, "heap_lp") == 0)
2475 walk_vseg = (mdb_walk_cb_t)kgrep_xwalk_vseg;
2476
2477 if (mdb_pwalk("vmem_alloc", walk_vseg, kg, addr) == -1) {
2478 mdb_warn("couldn't walk vmem_alloc for vmem %p", addr);
2479 return (WALK_ERR);
2480 }
2481
2482 return (WALK_NEXT);
2483 }
2484
2485 int
kgrep_subr(kgrep_cb_func * cb,void * cbdata)2486 kgrep_subr(kgrep_cb_func *cb, void *cbdata)
2487 {
2488 GElf_Sym kas, kvseg, kvseg32, kvseg_core, segkpm;
2489 kgrep_walk_data_t kg;
2490
2491 if (mdb_get_state() == MDB_STATE_RUNNING) {
2492 mdb_warn("kgrep can only be run on a system "
2493 "dump or under kmdb; see dumpadm(8)\n");
2494 return (DCMD_ERR);
2495 }
2496
2497 if (mdb_lookup_by_name("kas", &kas) == -1) {
2498 mdb_warn("failed to locate 'kas' symbol\n");
2499 return (DCMD_ERR);
2500 }
2501
2502 if (mdb_lookup_by_name("kvseg", &kvseg) == -1) {
2503 mdb_warn("failed to locate 'kvseg' symbol\n");
2504 return (DCMD_ERR);
2505 }
2506
2507 if (mdb_lookup_by_name("kvseg32", &kvseg32) == -1) {
2508 mdb_warn("failed to locate 'kvseg32' symbol\n");
2509 return (DCMD_ERR);
2510 }
2511
2512 if (mdb_lookup_by_name("kvseg_core", &kvseg_core) == -1) {
2513 mdb_warn("failed to locate 'kvseg_core' symbol\n");
2514 return (DCMD_ERR);
2515 }
2516
2517 if (mdb_lookup_by_name("segkpm_ops", &segkpm) == -1) {
2518 mdb_warn("failed to locate 'segkpm_ops' symbol\n");
2519 return (DCMD_ERR);
2520 }
2521
2522 if (mdb_readvar(&kg.kg_heap_lp_base, "heap_lp_base") == -1) {
2523 mdb_warn("failed to read 'heap_lp_base'\n");
2524 return (DCMD_ERR);
2525 }
2526
2527 if (mdb_readvar(&kg.kg_heap_lp_end, "heap_lp_end") == -1) {
2528 mdb_warn("failed to read 'heap_lp_end'\n");
2529 return (DCMD_ERR);
2530 }
2531
2532 kg.kg_cb = cb;
2533 kg.kg_cbdata = cbdata;
2534 kg.kg_kvseg = (uintptr_t)kvseg.st_value;
2535 kg.kg_kvseg32 = (uintptr_t)kvseg32.st_value;
2536 kg.kg_kvseg_core = (uintptr_t)kvseg_core.st_value;
2537 kg.kg_segkpm = (uintptr_t)segkpm.st_value;
2538
2539 if (mdb_pwalk("seg", (mdb_walk_cb_t)kgrep_walk_seg,
2540 &kg, kas.st_value) == -1) {
2541 mdb_warn("failed to walk kas segments");
2542 return (DCMD_ERR);
2543 }
2544
2545 if (mdb_walk("vmem", (mdb_walk_cb_t)kgrep_walk_vmem, &kg) == -1) {
2546 mdb_warn("failed to walk heap/heap32 vmem arenas");
2547 return (DCMD_ERR);
2548 }
2549
2550 return (DCMD_OK);
2551 }
2552
2553 size_t
kgrep_subr_pagesize(void)2554 kgrep_subr_pagesize(void)
2555 {
2556 return (PAGESIZE);
2557 }
2558
2559 typedef struct file_walk_data {
2560 struct uf_entry *fw_flist;
2561 int fw_flistsz;
2562 int fw_ndx;
2563 int fw_nofiles;
2564 } file_walk_data_t;
2565
2566 typedef struct mdb_file_proc {
2567 struct {
2568 struct {
2569 int fi_nfiles;
2570 uf_entry_t *volatile fi_list;
2571 } u_finfo;
2572 } p_user;
2573 } mdb_file_proc_t;
2574
2575 int
file_walk_init(mdb_walk_state_t * wsp)2576 file_walk_init(mdb_walk_state_t *wsp)
2577 {
2578 file_walk_data_t *fw;
2579 mdb_file_proc_t p;
2580
2581 if (wsp->walk_addr == 0) {
2582 mdb_warn("file walk doesn't support global walks\n");
2583 return (WALK_ERR);
2584 }
2585
2586 fw = mdb_alloc(sizeof (file_walk_data_t), UM_SLEEP);
2587
2588 if (mdb_ctf_vread(&p, "proc_t", "mdb_file_proc_t",
2589 wsp->walk_addr, 0) == -1) {
2590 mdb_free(fw, sizeof (file_walk_data_t));
2591 mdb_warn("failed to read proc structure at %p", wsp->walk_addr);
2592 return (WALK_ERR);
2593 }
2594
2595 if (p.p_user.u_finfo.fi_nfiles == 0) {
2596 mdb_free(fw, sizeof (file_walk_data_t));
2597 return (WALK_DONE);
2598 }
2599
2600 fw->fw_nofiles = p.p_user.u_finfo.fi_nfiles;
2601 fw->fw_flistsz = sizeof (struct uf_entry) * fw->fw_nofiles;
2602 fw->fw_flist = mdb_alloc(fw->fw_flistsz, UM_SLEEP);
2603
2604 if (mdb_vread(fw->fw_flist, fw->fw_flistsz,
2605 (uintptr_t)p.p_user.u_finfo.fi_list) == -1) {
2606 mdb_warn("failed to read file array at %p",
2607 p.p_user.u_finfo.fi_list);
2608 mdb_free(fw->fw_flist, fw->fw_flistsz);
2609 mdb_free(fw, sizeof (file_walk_data_t));
2610 return (WALK_ERR);
2611 }
2612
2613 fw->fw_ndx = 0;
2614 wsp->walk_data = fw;
2615
2616 return (WALK_NEXT);
2617 }
2618
2619 int
file_walk_step(mdb_walk_state_t * wsp)2620 file_walk_step(mdb_walk_state_t *wsp)
2621 {
2622 file_walk_data_t *fw = (file_walk_data_t *)wsp->walk_data;
2623 struct file file;
2624 uintptr_t fp;
2625
2626 again:
2627 if (fw->fw_ndx == fw->fw_nofiles)
2628 return (WALK_DONE);
2629
2630 if ((fp = (uintptr_t)fw->fw_flist[fw->fw_ndx++].uf_file) == 0)
2631 goto again;
2632
2633 (void) mdb_vread(&file, sizeof (file), (uintptr_t)fp);
2634 return (wsp->walk_callback(fp, &file, wsp->walk_cbdata));
2635 }
2636
2637 int
allfile_walk_step(mdb_walk_state_t * wsp)2638 allfile_walk_step(mdb_walk_state_t *wsp)
2639 {
2640 file_walk_data_t *fw = (file_walk_data_t *)wsp->walk_data;
2641 struct file file;
2642 uintptr_t fp;
2643
2644 if (fw->fw_ndx == fw->fw_nofiles)
2645 return (WALK_DONE);
2646
2647 if ((fp = (uintptr_t)fw->fw_flist[fw->fw_ndx++].uf_file) != 0)
2648 (void) mdb_vread(&file, sizeof (file), (uintptr_t)fp);
2649 else
2650 bzero(&file, sizeof (file));
2651
2652 return (wsp->walk_callback(fp, &file, wsp->walk_cbdata));
2653 }
2654
2655 void
file_walk_fini(mdb_walk_state_t * wsp)2656 file_walk_fini(mdb_walk_state_t *wsp)
2657 {
2658 file_walk_data_t *fw = (file_walk_data_t *)wsp->walk_data;
2659
2660 mdb_free(fw->fw_flist, fw->fw_flistsz);
2661 mdb_free(fw, sizeof (file_walk_data_t));
2662 }
2663
2664 int
port_walk_init(mdb_walk_state_t * wsp)2665 port_walk_init(mdb_walk_state_t *wsp)
2666 {
2667 if (wsp->walk_addr == 0) {
2668 mdb_warn("port walk doesn't support global walks\n");
2669 return (WALK_ERR);
2670 }
2671
2672 if (mdb_layered_walk("file", wsp) == -1) {
2673 mdb_warn("couldn't walk 'file'");
2674 return (WALK_ERR);
2675 }
2676 return (WALK_NEXT);
2677 }
2678
2679 int
port_walk_step(mdb_walk_state_t * wsp)2680 port_walk_step(mdb_walk_state_t *wsp)
2681 {
2682 struct vnode vn;
2683 uintptr_t vp;
2684 uintptr_t pp;
2685 struct port port;
2686
2687 vp = (uintptr_t)((struct file *)wsp->walk_layer)->f_vnode;
2688 if (mdb_vread(&vn, sizeof (vn), vp) == -1) {
2689 mdb_warn("failed to read vnode_t at %p", vp);
2690 return (WALK_ERR);
2691 }
2692 if (vn.v_type != VPORT)
2693 return (WALK_NEXT);
2694
2695 pp = (uintptr_t)vn.v_data;
2696 if (mdb_vread(&port, sizeof (port), pp) == -1) {
2697 mdb_warn("failed to read port_t at %p", pp);
2698 return (WALK_ERR);
2699 }
2700 return (wsp->walk_callback(pp, &port, wsp->walk_cbdata));
2701 }
2702
2703 typedef struct portev_walk_data {
2704 list_node_t *pev_node;
2705 list_node_t *pev_last;
2706 size_t pev_offset;
2707 } portev_walk_data_t;
2708
2709 int
portev_walk_init(mdb_walk_state_t * wsp)2710 portev_walk_init(mdb_walk_state_t *wsp)
2711 {
2712 portev_walk_data_t *pevd;
2713 struct port port;
2714 struct vnode vn;
2715 struct list *list;
2716 uintptr_t vp;
2717
2718 if (wsp->walk_addr == 0) {
2719 mdb_warn("portev walk doesn't support global walks\n");
2720 return (WALK_ERR);
2721 }
2722
2723 pevd = mdb_alloc(sizeof (portev_walk_data_t), UM_SLEEP);
2724
2725 if (mdb_vread(&port, sizeof (port), wsp->walk_addr) == -1) {
2726 mdb_free(pevd, sizeof (portev_walk_data_t));
2727 mdb_warn("failed to read port structure at %p", wsp->walk_addr);
2728 return (WALK_ERR);
2729 }
2730
2731 vp = (uintptr_t)port.port_vnode;
2732 if (mdb_vread(&vn, sizeof (vn), vp) == -1) {
2733 mdb_free(pevd, sizeof (portev_walk_data_t));
2734 mdb_warn("failed to read vnode_t at %p", vp);
2735 return (WALK_ERR);
2736 }
2737
2738 if (vn.v_type != VPORT) {
2739 mdb_free(pevd, sizeof (portev_walk_data_t));
2740 mdb_warn("input address (%p) does not point to an event port",
2741 wsp->walk_addr);
2742 return (WALK_ERR);
2743 }
2744
2745 if (port.port_queue.portq_nent == 0) {
2746 mdb_free(pevd, sizeof (portev_walk_data_t));
2747 return (WALK_DONE);
2748 }
2749 list = &port.port_queue.portq_list;
2750 pevd->pev_offset = list->list_offset;
2751 pevd->pev_last = list->list_head.list_prev;
2752 pevd->pev_node = list->list_head.list_next;
2753 wsp->walk_data = pevd;
2754 return (WALK_NEXT);
2755 }
2756
2757 int
portev_walk_step(mdb_walk_state_t * wsp)2758 portev_walk_step(mdb_walk_state_t *wsp)
2759 {
2760 portev_walk_data_t *pevd;
2761 struct port_kevent ev;
2762 uintptr_t evp;
2763
2764 pevd = (portev_walk_data_t *)wsp->walk_data;
2765
2766 if (pevd->pev_last == NULL)
2767 return (WALK_DONE);
2768 if (pevd->pev_node == pevd->pev_last)
2769 pevd->pev_last = NULL; /* last round */
2770
2771 evp = ((uintptr_t)(((char *)pevd->pev_node) - pevd->pev_offset));
2772 if (mdb_vread(&ev, sizeof (ev), evp) == -1) {
2773 mdb_warn("failed to read port_kevent at %p", evp);
2774 return (WALK_DONE);
2775 }
2776 pevd->pev_node = ev.portkev_node.list_next;
2777 return (wsp->walk_callback(evp, &ev, wsp->walk_cbdata));
2778 }
2779
2780 void
portev_walk_fini(mdb_walk_state_t * wsp)2781 portev_walk_fini(mdb_walk_state_t *wsp)
2782 {
2783 portev_walk_data_t *pevd = (portev_walk_data_t *)wsp->walk_data;
2784
2785 if (pevd != NULL)
2786 mdb_free(pevd, sizeof (portev_walk_data_t));
2787 }
2788
2789 typedef struct proc_walk_data {
2790 uintptr_t *pw_stack;
2791 int pw_depth;
2792 int pw_max;
2793 } proc_walk_data_t;
2794
2795 int
proc_walk_init(mdb_walk_state_t * wsp)2796 proc_walk_init(mdb_walk_state_t *wsp)
2797 {
2798 GElf_Sym sym;
2799 proc_walk_data_t *pw;
2800
2801 if (wsp->walk_addr == 0) {
2802 if (mdb_lookup_by_name("p0", &sym) == -1) {
2803 mdb_warn("failed to read 'practive'");
2804 return (WALK_ERR);
2805 }
2806 wsp->walk_addr = (uintptr_t)sym.st_value;
2807 }
2808
2809 pw = mdb_zalloc(sizeof (proc_walk_data_t), UM_SLEEP);
2810
2811 if (mdb_readvar(&pw->pw_max, "nproc") == -1) {
2812 mdb_warn("failed to read 'nproc'");
2813 mdb_free(pw, sizeof (pw));
2814 return (WALK_ERR);
2815 }
2816
2817 pw->pw_stack = mdb_alloc(pw->pw_max * sizeof (uintptr_t), UM_SLEEP);
2818 wsp->walk_data = pw;
2819
2820 return (WALK_NEXT);
2821 }
2822
2823 typedef struct mdb_walk_proc {
2824 struct proc *p_child;
2825 struct proc *p_sibling;
2826 } mdb_walk_proc_t;
2827
2828 int
proc_walk_step(mdb_walk_state_t * wsp)2829 proc_walk_step(mdb_walk_state_t *wsp)
2830 {
2831 proc_walk_data_t *pw = wsp->walk_data;
2832 uintptr_t addr = wsp->walk_addr;
2833 uintptr_t cld, sib;
2834 int status;
2835 mdb_walk_proc_t pr;
2836
2837 if (mdb_ctf_vread(&pr, "proc_t", "mdb_walk_proc_t",
2838 addr, 0) == -1) {
2839 mdb_warn("failed to read proc at %p", addr);
2840 return (WALK_DONE);
2841 }
2842
2843 cld = (uintptr_t)pr.p_child;
2844 sib = (uintptr_t)pr.p_sibling;
2845
2846 if (pw->pw_depth > 0 && addr == pw->pw_stack[pw->pw_depth - 1]) {
2847 pw->pw_depth--;
2848 goto sib;
2849 }
2850
2851 /*
2852 * Always pass NULL as the local copy pointer. Consumers
2853 * should use mdb_ctf_vread() to read their own minimal
2854 * version of proc_t. Thus minimizing the chance of breakage
2855 * with older crash dumps.
2856 */
2857 status = wsp->walk_callback(addr, NULL, wsp->walk_cbdata);
2858
2859 if (status != WALK_NEXT)
2860 return (status);
2861
2862 if ((wsp->walk_addr = cld) != 0) {
2863 if (mdb_ctf_vread(&pr, "proc_t", "mdb_walk_proc_t",
2864 cld, 0) == -1) {
2865 mdb_warn("proc %p has invalid p_child %p; skipping\n",
2866 addr, cld);
2867 goto sib;
2868 }
2869
2870 pw->pw_stack[pw->pw_depth++] = addr;
2871
2872 if (pw->pw_depth == pw->pw_max) {
2873 mdb_warn("depth %d exceeds max depth; try again\n",
2874 pw->pw_depth);
2875 return (WALK_DONE);
2876 }
2877 return (WALK_NEXT);
2878 }
2879
2880 sib:
2881 /*
2882 * We know that p0 has no siblings, and if another starting proc
2883 * was given, we don't want to walk its siblings anyway.
2884 */
2885 if (pw->pw_depth == 0)
2886 return (WALK_DONE);
2887
2888 if (sib != 0 && mdb_ctf_vread(&pr, "proc_t", "mdb_walk_proc_t",
2889 sib, 0) == -1) {
2890 mdb_warn("proc %p has invalid p_sibling %p; skipping\n",
2891 addr, sib);
2892 sib = 0;
2893 }
2894
2895 if ((wsp->walk_addr = sib) == 0) {
2896 if (pw->pw_depth > 0) {
2897 wsp->walk_addr = pw->pw_stack[pw->pw_depth - 1];
2898 return (WALK_NEXT);
2899 }
2900 return (WALK_DONE);
2901 }
2902
2903 return (WALK_NEXT);
2904 }
2905
2906 void
proc_walk_fini(mdb_walk_state_t * wsp)2907 proc_walk_fini(mdb_walk_state_t *wsp)
2908 {
2909 proc_walk_data_t *pw = wsp->walk_data;
2910
2911 mdb_free(pw->pw_stack, pw->pw_max * sizeof (uintptr_t));
2912 mdb_free(pw, sizeof (proc_walk_data_t));
2913 }
2914
2915 int
task_walk_init(mdb_walk_state_t * wsp)2916 task_walk_init(mdb_walk_state_t *wsp)
2917 {
2918 task_t task;
2919
2920 if (mdb_vread(&task, sizeof (task_t), wsp->walk_addr) == -1) {
2921 mdb_warn("failed to read task at %p", wsp->walk_addr);
2922 return (WALK_ERR);
2923 }
2924 wsp->walk_addr = (uintptr_t)task.tk_memb_list;
2925 wsp->walk_data = task.tk_memb_list;
2926 return (WALK_NEXT);
2927 }
2928
2929 typedef struct mdb_task_proc {
2930 struct proc *p_tasknext;
2931 } mdb_task_proc_t;
2932
2933 int
task_walk_step(mdb_walk_state_t * wsp)2934 task_walk_step(mdb_walk_state_t *wsp)
2935 {
2936 mdb_task_proc_t proc;
2937 int status;
2938
2939 if (mdb_ctf_vread(&proc, "proc_t", "mdb_task_proc_t",
2940 wsp->walk_addr, 0) == -1) {
2941 mdb_warn("failed to read proc at %p", wsp->walk_addr);
2942 return (WALK_DONE);
2943 }
2944
2945 status = wsp->walk_callback(wsp->walk_addr, NULL, wsp->walk_cbdata);
2946
2947 if (proc.p_tasknext == wsp->walk_data)
2948 return (WALK_DONE);
2949
2950 wsp->walk_addr = (uintptr_t)proc.p_tasknext;
2951 return (status);
2952 }
2953
2954 int
project_walk_init(mdb_walk_state_t * wsp)2955 project_walk_init(mdb_walk_state_t *wsp)
2956 {
2957 if (wsp->walk_addr == 0) {
2958 if (mdb_readvar(&wsp->walk_addr, "proj0p") == -1) {
2959 mdb_warn("failed to read 'proj0p'");
2960 return (WALK_ERR);
2961 }
2962 }
2963 wsp->walk_data = (void *)wsp->walk_addr;
2964 return (WALK_NEXT);
2965 }
2966
2967 int
project_walk_step(mdb_walk_state_t * wsp)2968 project_walk_step(mdb_walk_state_t *wsp)
2969 {
2970 uintptr_t addr = wsp->walk_addr;
2971 kproject_t pj;
2972 int status;
2973
2974 if (mdb_vread(&pj, sizeof (kproject_t), addr) == -1) {
2975 mdb_warn("failed to read project at %p", addr);
2976 return (WALK_DONE);
2977 }
2978 status = wsp->walk_callback(addr, &pj, wsp->walk_cbdata);
2979 if (status != WALK_NEXT)
2980 return (status);
2981 wsp->walk_addr = (uintptr_t)pj.kpj_next;
2982 if ((void *)wsp->walk_addr == wsp->walk_data)
2983 return (WALK_DONE);
2984 return (WALK_NEXT);
2985 }
2986
2987 static int
generic_walk_step(mdb_walk_state_t * wsp)2988 generic_walk_step(mdb_walk_state_t *wsp)
2989 {
2990 return (wsp->walk_callback(wsp->walk_addr, wsp->walk_layer,
2991 wsp->walk_cbdata));
2992 }
2993
2994 static int
cpu_walk_cmp(const void * l,const void * r)2995 cpu_walk_cmp(const void *l, const void *r)
2996 {
2997 uintptr_t lhs = *((uintptr_t *)l);
2998 uintptr_t rhs = *((uintptr_t *)r);
2999 cpu_t lcpu, rcpu;
3000
3001 (void) mdb_vread(&lcpu, sizeof (lcpu), lhs);
3002 (void) mdb_vread(&rcpu, sizeof (rcpu), rhs);
3003
3004 if (lcpu.cpu_id < rcpu.cpu_id)
3005 return (-1);
3006
3007 if (lcpu.cpu_id > rcpu.cpu_id)
3008 return (1);
3009
3010 return (0);
3011 }
3012
3013 typedef struct cpu_walk {
3014 uintptr_t *cw_array;
3015 int cw_ndx;
3016 } cpu_walk_t;
3017
3018 int
cpu_walk_init(mdb_walk_state_t * wsp)3019 cpu_walk_init(mdb_walk_state_t *wsp)
3020 {
3021 cpu_walk_t *cw;
3022 int max_ncpus, i = 0;
3023 uintptr_t current, first;
3024 cpu_t cpu, panic_cpu;
3025 uintptr_t panicstr, addr = 0;
3026 GElf_Sym sym;
3027
3028 cw = mdb_zalloc(sizeof (cpu_walk_t), UM_SLEEP | UM_GC);
3029
3030 if (mdb_readvar(&max_ncpus, "max_ncpus") == -1) {
3031 mdb_warn("failed to read 'max_ncpus'");
3032 return (WALK_ERR);
3033 }
3034
3035 if (mdb_readvar(&panicstr, "panicstr") == -1) {
3036 mdb_warn("failed to read 'panicstr'");
3037 return (WALK_ERR);
3038 }
3039
3040 if (panicstr != 0) {
3041 if (mdb_lookup_by_name("panic_cpu", &sym) == -1) {
3042 mdb_warn("failed to find 'panic_cpu'");
3043 return (WALK_ERR);
3044 }
3045
3046 addr = (uintptr_t)sym.st_value;
3047
3048 if (mdb_vread(&panic_cpu, sizeof (cpu_t), addr) == -1) {
3049 mdb_warn("failed to read 'panic_cpu'");
3050 return (WALK_ERR);
3051 }
3052 }
3053
3054 /*
3055 * Unfortunately, there is no platform-independent way to walk
3056 * CPUs in ID order. We therefore loop through in cpu_next order,
3057 * building an array of CPU pointers which will subsequently be
3058 * sorted.
3059 */
3060 cw->cw_array =
3061 mdb_zalloc((max_ncpus + 1) * sizeof (uintptr_t), UM_SLEEP | UM_GC);
3062
3063 if (mdb_readvar(&first, "cpu_list") == -1) {
3064 mdb_warn("failed to read 'cpu_list'");
3065 return (WALK_ERR);
3066 }
3067
3068 current = first;
3069 do {
3070 if (mdb_vread(&cpu, sizeof (cpu), current) == -1) {
3071 mdb_warn("failed to read cpu at %p", current);
3072 return (WALK_ERR);
3073 }
3074
3075 if (panicstr != 0 && panic_cpu.cpu_id == cpu.cpu_id) {
3076 cw->cw_array[i++] = addr;
3077 } else {
3078 cw->cw_array[i++] = current;
3079 }
3080 } while ((current = (uintptr_t)cpu.cpu_next) != first);
3081
3082 qsort(cw->cw_array, i, sizeof (uintptr_t), cpu_walk_cmp);
3083 wsp->walk_data = cw;
3084
3085 return (WALK_NEXT);
3086 }
3087
3088 int
cpu_walk_step(mdb_walk_state_t * wsp)3089 cpu_walk_step(mdb_walk_state_t *wsp)
3090 {
3091 cpu_walk_t *cw = wsp->walk_data;
3092 cpu_t cpu;
3093 uintptr_t addr = cw->cw_array[cw->cw_ndx++];
3094
3095 if (addr == 0)
3096 return (WALK_DONE);
3097
3098 if (mdb_vread(&cpu, sizeof (cpu), addr) == -1) {
3099 mdb_warn("failed to read cpu at %p", addr);
3100 return (WALK_DONE);
3101 }
3102
3103 return (wsp->walk_callback(addr, &cpu, wsp->walk_cbdata));
3104 }
3105
3106 typedef struct cpuinfo_data {
3107 intptr_t cid_cpu;
3108 uintptr_t **cid_ithr;
3109 char cid_print_head;
3110 char cid_print_thr;
3111 char cid_print_ithr;
3112 char cid_print_flags;
3113 } cpuinfo_data_t;
3114
3115 int
cpuinfo_walk_ithread(uintptr_t addr,const kthread_t * thr,cpuinfo_data_t * cid)3116 cpuinfo_walk_ithread(uintptr_t addr, const kthread_t *thr, cpuinfo_data_t *cid)
3117 {
3118 cpu_t c;
3119 int id;
3120 uint8_t pil;
3121
3122 if (!(thr->t_flag & T_INTR_THREAD) || thr->t_state == TS_FREE)
3123 return (WALK_NEXT);
3124
3125 if (thr->t_bound_cpu == NULL) {
3126 mdb_warn("thr %p is intr thread w/out a CPU\n", addr);
3127 return (WALK_NEXT);
3128 }
3129
3130 (void) mdb_vread(&c, sizeof (c), (uintptr_t)thr->t_bound_cpu);
3131
3132 if ((id = c.cpu_id) >= NCPU) {
3133 mdb_warn("CPU %p has id (%d) greater than NCPU (%d)\n",
3134 thr->t_bound_cpu, id, NCPU);
3135 return (WALK_NEXT);
3136 }
3137
3138 if ((pil = thr->t_pil) >= NINTR) {
3139 mdb_warn("thread %p has pil (%d) greater than %d\n",
3140 addr, pil, NINTR);
3141 return (WALK_NEXT);
3142 }
3143
3144 if (cid->cid_ithr[id][pil] != 0) {
3145 mdb_warn("CPU %d has multiple threads at pil %d (at least "
3146 "%p and %p)\n", id, pil, addr, cid->cid_ithr[id][pil]);
3147 return (WALK_NEXT);
3148 }
3149
3150 cid->cid_ithr[id][pil] = addr;
3151
3152 return (WALK_NEXT);
3153 }
3154
3155 #define CPUINFO_IDWIDTH 3
3156 #define CPUINFO_FLAGWIDTH 9
3157
3158 #ifdef _LP64
3159 #if defined(__amd64)
3160 #define CPUINFO_TWIDTH 16
3161 #define CPUINFO_CPUWIDTH 16
3162 #else
3163 #define CPUINFO_CPUWIDTH 11
3164 #define CPUINFO_TWIDTH 11
3165 #endif
3166 #else
3167 #define CPUINFO_CPUWIDTH 8
3168 #define CPUINFO_TWIDTH 8
3169 #endif
3170
3171 #define CPUINFO_THRDELT (CPUINFO_IDWIDTH + CPUINFO_CPUWIDTH + 9)
3172 #define CPUINFO_FLAGDELT (CPUINFO_IDWIDTH + CPUINFO_CPUWIDTH + 4)
3173 #define CPUINFO_ITHRDELT 4
3174
3175 #define CPUINFO_INDENT mdb_printf("%*s", CPUINFO_THRDELT, \
3176 flagline < nflaglines ? flagbuf[flagline++] : "")
3177
3178 typedef struct mdb_cpuinfo_proc {
3179 struct {
3180 char u_comm[MAXCOMLEN + 1];
3181 } p_user;
3182 } mdb_cpuinfo_proc_t;
3183
3184 int
cpuinfo_walk_cpu(uintptr_t addr,const cpu_t * cpu,cpuinfo_data_t * cid)3185 cpuinfo_walk_cpu(uintptr_t addr, const cpu_t *cpu, cpuinfo_data_t *cid)
3186 {
3187 kthread_t t;
3188 disp_t disp;
3189 mdb_cpuinfo_proc_t p;
3190 uintptr_t pinned = 0;
3191 char **flagbuf;
3192 int nflaglines = 0, flagline = 0, bspl, rval = WALK_NEXT;
3193
3194 const char *flags[] = {
3195 "RUNNING", "READY", "QUIESCED", "EXISTS",
3196 "ENABLE", "OFFLINE", "POWEROFF", "FROZEN",
3197 "SPARE", "FAULTED", "DISABLED", NULL
3198 };
3199
3200 if (cid->cid_cpu != -1) {
3201 if (addr != cid->cid_cpu && cpu->cpu_id != cid->cid_cpu)
3202 return (WALK_NEXT);
3203
3204 /*
3205 * Set cid_cpu to -1 to indicate that we found a matching CPU.
3206 */
3207 cid->cid_cpu = -1;
3208 rval = WALK_DONE;
3209 }
3210
3211 if (cid->cid_print_head) {
3212 mdb_printf("%3s %-*s %3s %4s %4s %3s %4s %5s %-6s %-*s %s\n",
3213 "ID", CPUINFO_CPUWIDTH, "ADDR", "FLG", "NRUN", "BSPL",
3214 "PRI", "RNRN", "KRNRN", "SWITCH", CPUINFO_TWIDTH, "THREAD",
3215 "PROC");
3216 cid->cid_print_head = FALSE;
3217 }
3218
3219 bspl = cpu->cpu_base_spl;
3220
3221 if (mdb_vread(&disp, sizeof (disp_t), (uintptr_t)cpu->cpu_disp) == -1) {
3222 mdb_warn("failed to read disp_t at %p", cpu->cpu_disp);
3223 return (WALK_ERR);
3224 }
3225
3226 mdb_printf("%3d %0*p %3x %4d %4d ",
3227 cpu->cpu_id, CPUINFO_CPUWIDTH, addr, cpu->cpu_flags,
3228 disp.disp_nrunnable, bspl);
3229
3230 if (mdb_vread(&t, sizeof (t), (uintptr_t)cpu->cpu_thread) != -1) {
3231 mdb_printf("%3d ", t.t_pri);
3232 } else {
3233 mdb_printf("%3s ", "-");
3234 }
3235
3236 mdb_printf("%4s %5s ", cpu->cpu_runrun ? "yes" : "no",
3237 cpu->cpu_kprunrun ? "yes" : "no");
3238
3239 if (cpu->cpu_last_swtch) {
3240 mdb_printf("t-%-4d ",
3241 (clock_t)mdb_get_lbolt() - cpu->cpu_last_swtch);
3242 } else {
3243 mdb_printf("%-6s ", "-");
3244 }
3245
3246 mdb_printf("%0*p", CPUINFO_TWIDTH, cpu->cpu_thread);
3247
3248 if (cpu->cpu_thread == cpu->cpu_idle_thread)
3249 mdb_printf(" (idle)\n");
3250 else if (cpu->cpu_thread == NULL)
3251 mdb_printf(" -\n");
3252 else {
3253 if (mdb_ctf_vread(&p, "proc_t", "mdb_cpuinfo_proc_t",
3254 (uintptr_t)t.t_procp, 0) != -1) {
3255 mdb_printf(" %s\n", p.p_user.u_comm);
3256 } else {
3257 mdb_printf(" ?\n");
3258 }
3259 }
3260
3261 flagbuf = mdb_zalloc(sizeof (flags), UM_SLEEP | UM_GC);
3262
3263 if (cid->cid_print_flags) {
3264 int first = 1, i, j, k;
3265 char *s;
3266
3267 cid->cid_print_head = TRUE;
3268
3269 for (i = 1, j = 0; flags[j] != NULL; i <<= 1, j++) {
3270 if (!(cpu->cpu_flags & i))
3271 continue;
3272
3273 if (first) {
3274 s = mdb_alloc(CPUINFO_THRDELT + 1,
3275 UM_GC | UM_SLEEP);
3276
3277 (void) mdb_snprintf(s, CPUINFO_THRDELT + 1,
3278 "%*s|%*s", CPUINFO_FLAGDELT, "",
3279 CPUINFO_THRDELT - 1 - CPUINFO_FLAGDELT, "");
3280 flagbuf[nflaglines++] = s;
3281 }
3282
3283 s = mdb_alloc(CPUINFO_THRDELT + 1, UM_GC | UM_SLEEP);
3284 (void) mdb_snprintf(s, CPUINFO_THRDELT + 1, "%*s%*s %s",
3285 CPUINFO_IDWIDTH + CPUINFO_CPUWIDTH -
3286 CPUINFO_FLAGWIDTH, "", CPUINFO_FLAGWIDTH, flags[j],
3287 first ? "<--+" : "");
3288
3289 for (k = strlen(s); k < CPUINFO_THRDELT; k++)
3290 s[k] = ' ';
3291 s[k] = '\0';
3292
3293 flagbuf[nflaglines++] = s;
3294 first = 0;
3295 }
3296 }
3297
3298 if (cid->cid_print_ithr) {
3299 int i, found_one = FALSE;
3300 int print_thr = disp.disp_nrunnable && cid->cid_print_thr;
3301
3302 for (i = NINTR - 1; i >= 0; i--) {
3303 uintptr_t iaddr = cid->cid_ithr[cpu->cpu_id][i];
3304
3305 if (iaddr == 0)
3306 continue;
3307
3308 if (!found_one) {
3309 found_one = TRUE;
3310
3311 CPUINFO_INDENT;
3312 mdb_printf("%c%*s|\n", print_thr ? '|' : ' ',
3313 CPUINFO_ITHRDELT, "");
3314
3315 CPUINFO_INDENT;
3316 mdb_printf("%c%*s+--> %3s %s\n",
3317 print_thr ? '|' : ' ', CPUINFO_ITHRDELT,
3318 "", "PIL", "THREAD");
3319 }
3320
3321 if (mdb_vread(&t, sizeof (t), iaddr) == -1) {
3322 mdb_warn("failed to read kthread_t at %p",
3323 iaddr);
3324 return (WALK_ERR);
3325 }
3326
3327 CPUINFO_INDENT;
3328 mdb_printf("%c%*s %3d %0*p\n",
3329 print_thr ? '|' : ' ', CPUINFO_ITHRDELT, "",
3330 t.t_pil, CPUINFO_TWIDTH, iaddr);
3331
3332 pinned = (uintptr_t)t.t_intr;
3333 }
3334
3335 if (found_one && pinned != 0) {
3336 cid->cid_print_head = TRUE;
3337 (void) strcpy(p.p_user.u_comm, "?");
3338
3339 if (mdb_vread(&t, sizeof (t),
3340 (uintptr_t)pinned) == -1) {
3341 mdb_warn("failed to read kthread_t at %p",
3342 pinned);
3343 return (WALK_ERR);
3344 }
3345 if (mdb_ctf_vread(&p, "proc_t", "mdb_cpuinfo_proc_t",
3346 (uintptr_t)t.t_procp, 0) == -1) {
3347 mdb_warn("failed to read proc_t at %p",
3348 t.t_procp);
3349 return (WALK_ERR);
3350 }
3351
3352 CPUINFO_INDENT;
3353 mdb_printf("%c%*s %3s %0*p %s\n",
3354 print_thr ? '|' : ' ', CPUINFO_ITHRDELT, "", "-",
3355 CPUINFO_TWIDTH, pinned,
3356 pinned == (uintptr_t)cpu->cpu_idle_thread ?
3357 "(idle)" : p.p_user.u_comm);
3358 }
3359 }
3360
3361 if (disp.disp_nrunnable && cid->cid_print_thr) {
3362 dispq_t *dq;
3363
3364 int i, npri = disp.disp_npri;
3365
3366 dq = mdb_alloc(sizeof (dispq_t) * npri, UM_SLEEP | UM_GC);
3367
3368 if (mdb_vread(dq, sizeof (dispq_t) * npri,
3369 (uintptr_t)disp.disp_q) == -1) {
3370 mdb_warn("failed to read dispq_t at %p", disp.disp_q);
3371 return (WALK_ERR);
3372 }
3373
3374 CPUINFO_INDENT;
3375 mdb_printf("|\n");
3376
3377 CPUINFO_INDENT;
3378 mdb_printf("+--> %3s %-*s %s\n", "PRI",
3379 CPUINFO_TWIDTH, "THREAD", "PROC");
3380
3381 for (i = npri - 1; i >= 0; i--) {
3382 uintptr_t taddr = (uintptr_t)dq[i].dq_first;
3383
3384 while (taddr != 0) {
3385 if (mdb_vread(&t, sizeof (t), taddr) == -1) {
3386 mdb_warn("failed to read kthread_t "
3387 "at %p", taddr);
3388 return (WALK_ERR);
3389 }
3390 if (mdb_ctf_vread(&p, "proc_t",
3391 "mdb_cpuinfo_proc_t",
3392 (uintptr_t)t.t_procp, 0) == -1) {
3393 mdb_warn("failed to read proc_t at %p",
3394 t.t_procp);
3395 return (WALK_ERR);
3396 }
3397
3398 CPUINFO_INDENT;
3399 mdb_printf(" %3d %0*p %s\n", t.t_pri,
3400 CPUINFO_TWIDTH, taddr, p.p_user.u_comm);
3401
3402 taddr = (uintptr_t)t.t_link;
3403 }
3404 }
3405 cid->cid_print_head = TRUE;
3406 }
3407
3408 while (flagline < nflaglines)
3409 mdb_printf("%s\n", flagbuf[flagline++]);
3410
3411 if (cid->cid_print_head)
3412 mdb_printf("\n");
3413
3414 return (rval);
3415 }
3416
3417 int
cpuinfo(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3418 cpuinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3419 {
3420 uint_t verbose = FALSE;
3421 cpuinfo_data_t cid;
3422
3423 cid.cid_print_ithr = FALSE;
3424 cid.cid_print_thr = FALSE;
3425 cid.cid_print_flags = FALSE;
3426 cid.cid_print_head = DCMD_HDRSPEC(flags) ? TRUE : FALSE;
3427 cid.cid_cpu = -1;
3428
3429 if (flags & DCMD_ADDRSPEC)
3430 cid.cid_cpu = addr;
3431
3432 if (mdb_getopts(argc, argv,
3433 'v', MDB_OPT_SETBITS, TRUE, &verbose, NULL) != argc)
3434 return (DCMD_USAGE);
3435
3436 if (verbose) {
3437 cid.cid_print_ithr = TRUE;
3438 cid.cid_print_thr = TRUE;
3439 cid.cid_print_flags = TRUE;
3440 cid.cid_print_head = TRUE;
3441 }
3442
3443 if (cid.cid_print_ithr) {
3444 int i;
3445
3446 cid.cid_ithr = mdb_alloc(sizeof (uintptr_t **)
3447 * NCPU, UM_SLEEP | UM_GC);
3448
3449 for (i = 0; i < NCPU; i++)
3450 cid.cid_ithr[i] = mdb_zalloc(sizeof (uintptr_t *) *
3451 NINTR, UM_SLEEP | UM_GC);
3452
3453 if (mdb_walk("thread", (mdb_walk_cb_t)cpuinfo_walk_ithread,
3454 &cid) == -1) {
3455 mdb_warn("couldn't walk thread");
3456 return (DCMD_ERR);
3457 }
3458 }
3459
3460 if (mdb_walk("cpu", (mdb_walk_cb_t)cpuinfo_walk_cpu, &cid) == -1) {
3461 mdb_warn("can't walk cpus");
3462 return (DCMD_ERR);
3463 }
3464
3465 if (cid.cid_cpu != -1) {
3466 /*
3467 * We didn't find this CPU when we walked through the CPUs
3468 * (i.e. the address specified doesn't show up in the "cpu"
3469 * walk). However, the specified address may still correspond
3470 * to a valid cpu_t (for example, if the specified address is
3471 * the actual panicking cpu_t and not the cached panic_cpu).
3472 * Point is: even if we didn't find it, we still want to try
3473 * to print the specified address as a cpu_t.
3474 */
3475 cpu_t cpu;
3476
3477 if (mdb_vread(&cpu, sizeof (cpu), cid.cid_cpu) == -1) {
3478 mdb_warn("%p is neither a valid CPU ID nor a "
3479 "valid cpu_t address\n", cid.cid_cpu);
3480 return (DCMD_ERR);
3481 }
3482
3483 (void) cpuinfo_walk_cpu(cid.cid_cpu, &cpu, &cid);
3484 }
3485
3486 return (DCMD_OK);
3487 }
3488
3489 /*ARGSUSED*/
3490 int
flipone(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3491 flipone(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3492 {
3493 int i;
3494
3495 if (!(flags & DCMD_ADDRSPEC))
3496 return (DCMD_USAGE);
3497
3498 for (i = 0; i < sizeof (addr) * NBBY; i++)
3499 mdb_printf("%p\n", addr ^ (1UL << i));
3500
3501 return (DCMD_OK);
3502 }
3503
3504 typedef struct mdb_as2proc_proc {
3505 struct as *p_as;
3506 } mdb_as2proc_proc_t;
3507
3508 /*ARGSUSED*/
3509 int
as2proc_walk(uintptr_t addr,const void * ignored,struct as ** asp)3510 as2proc_walk(uintptr_t addr, const void *ignored, struct as **asp)
3511 {
3512 mdb_as2proc_proc_t p;
3513
3514 mdb_ctf_vread(&p, "proc_t", "mdb_as2proc_proc_t", addr, 0);
3515
3516 if (p.p_as == *asp)
3517 mdb_printf("%p\n", addr);
3518 return (WALK_NEXT);
3519 }
3520
3521 /*ARGSUSED*/
3522 int
as2proc(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3523 as2proc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3524 {
3525 if (!(flags & DCMD_ADDRSPEC) || argc != 0)
3526 return (DCMD_USAGE);
3527
3528 if (mdb_walk("proc", (mdb_walk_cb_t)as2proc_walk, &addr) == -1) {
3529 mdb_warn("failed to walk proc");
3530 return (DCMD_ERR);
3531 }
3532
3533 return (DCMD_OK);
3534 }
3535
3536 typedef struct mdb_ptree_proc {
3537 struct proc *p_parent;
3538 struct {
3539 char u_comm[MAXCOMLEN + 1];
3540 } p_user;
3541 } mdb_ptree_proc_t;
3542
3543 /*ARGSUSED*/
3544 int
ptree_walk(uintptr_t addr,const void * ignored,void * data)3545 ptree_walk(uintptr_t addr, const void *ignored, void *data)
3546 {
3547 mdb_ptree_proc_t proc;
3548 mdb_ptree_proc_t parent;
3549 int ident = 0;
3550 uintptr_t paddr;
3551
3552 mdb_ctf_vread(&proc, "proc_t", "mdb_ptree_proc_t", addr, 0);
3553
3554 for (paddr = (uintptr_t)proc.p_parent; paddr != 0; ident += 5) {
3555 mdb_ctf_vread(&parent, "proc_t", "mdb_ptree_proc_t", paddr, 0);
3556 paddr = (uintptr_t)parent.p_parent;
3557 }
3558
3559 mdb_inc_indent(ident);
3560 mdb_printf("%0?p %s\n", addr, proc.p_user.u_comm);
3561 mdb_dec_indent(ident);
3562
3563 return (WALK_NEXT);
3564 }
3565
3566 void
ptree_ancestors(uintptr_t addr,uintptr_t start)3567 ptree_ancestors(uintptr_t addr, uintptr_t start)
3568 {
3569 mdb_ptree_proc_t p;
3570
3571 if (mdb_ctf_vread(&p, "proc_t", "mdb_ptree_proc_t", addr, 0) == -1) {
3572 mdb_warn("couldn't read ancestor at %p", addr);
3573 return;
3574 }
3575
3576 if (p.p_parent != NULL)
3577 ptree_ancestors((uintptr_t)p.p_parent, start);
3578
3579 if (addr != start)
3580 (void) ptree_walk(addr, &p, NULL);
3581 }
3582
3583 /*ARGSUSED*/
3584 int
ptree(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3585 ptree(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3586 {
3587 if (!(flags & DCMD_ADDRSPEC))
3588 addr = 0;
3589 else
3590 ptree_ancestors(addr, addr);
3591
3592 if (mdb_pwalk("proc", (mdb_walk_cb_t)ptree_walk, NULL, addr) == -1) {
3593 mdb_warn("couldn't walk 'proc'");
3594 return (DCMD_ERR);
3595 }
3596
3597 return (DCMD_OK);
3598 }
3599
3600 typedef struct mdb_fd_proc {
3601 struct {
3602 struct {
3603 int fi_nfiles;
3604 uf_entry_t *volatile fi_list;
3605 } u_finfo;
3606 } p_user;
3607 } mdb_fd_proc_t;
3608
3609 /*ARGSUSED*/
3610 static int
fd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3611 fd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3612 {
3613 int fdnum;
3614 const mdb_arg_t *argp = &argv[0];
3615 mdb_fd_proc_t p;
3616 uf_entry_t uf;
3617
3618 if ((flags & DCMD_ADDRSPEC) == 0) {
3619 mdb_warn("fd doesn't give global information\n");
3620 return (DCMD_ERR);
3621 }
3622 if (argc != 1)
3623 return (DCMD_USAGE);
3624
3625 fdnum = (int)mdb_argtoull(argp);
3626
3627 if (mdb_ctf_vread(&p, "proc_t", "mdb_fd_proc_t", addr, 0) == -1) {
3628 mdb_warn("couldn't read proc_t at %p", addr);
3629 return (DCMD_ERR);
3630 }
3631 if (fdnum > p.p_user.u_finfo.fi_nfiles) {
3632 mdb_warn("process %p only has %d files open.\n",
3633 addr, p.p_user.u_finfo.fi_nfiles);
3634 return (DCMD_ERR);
3635 }
3636 if (mdb_vread(&uf, sizeof (uf_entry_t),
3637 (uintptr_t)&p.p_user.u_finfo.fi_list[fdnum]) == -1) {
3638 mdb_warn("couldn't read uf_entry_t at %p",
3639 &p.p_user.u_finfo.fi_list[fdnum]);
3640 return (DCMD_ERR);
3641 }
3642
3643 mdb_printf("%p\n", uf.uf_file);
3644 return (DCMD_OK);
3645 }
3646
3647 /*ARGSUSED*/
3648 static int
pid2proc(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3649 pid2proc(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3650 {
3651 pid_t pid = (pid_t)addr;
3652
3653 if (argc != 0)
3654 return (DCMD_USAGE);
3655
3656 if ((addr = mdb_pid2proc(pid, NULL)) == 0) {
3657 mdb_warn("PID 0t%d not found\n", pid);
3658 return (DCMD_ERR);
3659 }
3660
3661 mdb_printf("%p\n", addr);
3662 return (DCMD_OK);
3663 }
3664
3665 static char *sysfile_cmd[] = {
3666 "exclude:",
3667 "include:",
3668 "forceload:",
3669 "rootdev:",
3670 "rootfs:",
3671 "swapdev:",
3672 "swapfs:",
3673 "moddir:",
3674 "set",
3675 "unknown",
3676 };
3677
3678 static char *sysfile_ops[] = { "", "=", "&", "|" };
3679
3680 /*ARGSUSED*/
3681 static int
sysfile_vmem_seg(uintptr_t addr,const vmem_seg_t * vsp,void ** target)3682 sysfile_vmem_seg(uintptr_t addr, const vmem_seg_t *vsp, void **target)
3683 {
3684 if (vsp->vs_type == VMEM_ALLOC && (void *)vsp->vs_start == *target) {
3685 *target = NULL;
3686 return (WALK_DONE);
3687 }
3688 return (WALK_NEXT);
3689 }
3690
3691 /*ARGSUSED*/
3692 static int
sysfile(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3693 sysfile(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3694 {
3695 struct sysparam *sysp, sys;
3696 char var[256];
3697 char modname[256];
3698 char val[256];
3699 char strval[256];
3700 vmem_t *mod_sysfile_arena;
3701 void *straddr;
3702
3703 if (mdb_readvar(&sysp, "sysparam_hd") == -1) {
3704 mdb_warn("failed to read sysparam_hd");
3705 return (DCMD_ERR);
3706 }
3707
3708 if (mdb_readvar(&mod_sysfile_arena, "mod_sysfile_arena") == -1) {
3709 mdb_warn("failed to read mod_sysfile_arena");
3710 return (DCMD_ERR);
3711 }
3712
3713 while (sysp != NULL) {
3714 var[0] = '\0';
3715 val[0] = '\0';
3716 modname[0] = '\0';
3717 if (mdb_vread(&sys, sizeof (sys), (uintptr_t)sysp) == -1) {
3718 mdb_warn("couldn't read sysparam %p", sysp);
3719 return (DCMD_ERR);
3720 }
3721 if (sys.sys_modnam != NULL &&
3722 mdb_readstr(modname, 256,
3723 (uintptr_t)sys.sys_modnam) == -1) {
3724 mdb_warn("couldn't read modname in %p", sysp);
3725 return (DCMD_ERR);
3726 }
3727 if (sys.sys_ptr != NULL &&
3728 mdb_readstr(var, 256, (uintptr_t)sys.sys_ptr) == -1) {
3729 mdb_warn("couldn't read ptr in %p", sysp);
3730 return (DCMD_ERR);
3731 }
3732 if (sys.sys_op != SETOP_NONE) {
3733 /*
3734 * Is this an int or a string? We determine this
3735 * by checking whether straddr is contained in
3736 * mod_sysfile_arena. If so, the walker will set
3737 * straddr to NULL.
3738 */
3739 straddr = (void *)(uintptr_t)sys.sys_info;
3740 if (sys.sys_op == SETOP_ASSIGN &&
3741 sys.sys_info != 0 &&
3742 mdb_pwalk("vmem_seg",
3743 (mdb_walk_cb_t)sysfile_vmem_seg, &straddr,
3744 (uintptr_t)mod_sysfile_arena) == 0 &&
3745 straddr == NULL &&
3746 mdb_readstr(strval, 256,
3747 (uintptr_t)sys.sys_info) != -1) {
3748 (void) mdb_snprintf(val, sizeof (val), "\"%s\"",
3749 strval);
3750 } else {
3751 (void) mdb_snprintf(val, sizeof (val),
3752 "0x%llx [0t%llu]", sys.sys_info,
3753 sys.sys_info);
3754 }
3755 }
3756 mdb_printf("%s %s%s%s%s%s\n", sysfile_cmd[sys.sys_type],
3757 modname, modname[0] == '\0' ? "" : ":",
3758 var, sysfile_ops[sys.sys_op], val);
3759
3760 sysp = sys.sys_next;
3761 }
3762
3763 return (DCMD_OK);
3764 }
3765
3766 int
didmatch(uintptr_t addr,const kthread_t * thr,kt_did_t * didp)3767 didmatch(uintptr_t addr, const kthread_t *thr, kt_did_t *didp)
3768 {
3769
3770 if (*didp == thr->t_did) {
3771 mdb_printf("%p\n", addr);
3772 return (WALK_DONE);
3773 } else
3774 return (WALK_NEXT);
3775 }
3776
3777 /*ARGSUSED*/
3778 int
did2thread(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3779 did2thread(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3780 {
3781 const mdb_arg_t *argp = &argv[0];
3782 kt_did_t did;
3783
3784 if (argc != 1)
3785 return (DCMD_USAGE);
3786
3787 did = (kt_did_t)mdb_argtoull(argp);
3788
3789 if (mdb_walk("thread", (mdb_walk_cb_t)didmatch, (void *)&did) == -1) {
3790 mdb_warn("failed to walk thread");
3791 return (DCMD_ERR);
3792
3793 }
3794 return (DCMD_OK);
3795
3796 }
3797
3798 static int
errorq_walk_init(mdb_walk_state_t * wsp)3799 errorq_walk_init(mdb_walk_state_t *wsp)
3800 {
3801 if (wsp->walk_addr == 0 &&
3802 mdb_readvar(&wsp->walk_addr, "errorq_list") == -1) {
3803 mdb_warn("failed to read errorq_list");
3804 return (WALK_ERR);
3805 }
3806
3807 return (WALK_NEXT);
3808 }
3809
3810 static int
errorq_walk_step(mdb_walk_state_t * wsp)3811 errorq_walk_step(mdb_walk_state_t *wsp)
3812 {
3813 uintptr_t addr = wsp->walk_addr;
3814 errorq_t eq;
3815
3816 if (addr == 0)
3817 return (WALK_DONE);
3818
3819 if (mdb_vread(&eq, sizeof (eq), addr) == -1) {
3820 mdb_warn("failed to read errorq at %p", addr);
3821 return (WALK_ERR);
3822 }
3823
3824 wsp->walk_addr = (uintptr_t)eq.eq_next;
3825 return (wsp->walk_callback(addr, &eq, wsp->walk_cbdata));
3826 }
3827
3828 typedef struct eqd_walk_data {
3829 uintptr_t *eqd_stack;
3830 void *eqd_buf;
3831 ulong_t eqd_qpos;
3832 ulong_t eqd_qlen;
3833 size_t eqd_size;
3834 } eqd_walk_data_t;
3835
3836 /*
3837 * In order to walk the list of pending error queue elements, we push the
3838 * addresses of the corresponding data buffers in to the eqd_stack array.
3839 * The error lists are in reverse chronological order when iterating using
3840 * eqe_prev, so we then pop things off the top in eqd_walk_step so that the
3841 * walker client gets addresses in order from oldest error to newest error.
3842 */
3843 static void
eqd_push_list(eqd_walk_data_t * eqdp,uintptr_t addr)3844 eqd_push_list(eqd_walk_data_t *eqdp, uintptr_t addr)
3845 {
3846 errorq_elem_t eqe;
3847
3848 while (addr != 0) {
3849 if (mdb_vread(&eqe, sizeof (eqe), addr) != sizeof (eqe)) {
3850 mdb_warn("failed to read errorq element at %p", addr);
3851 break;
3852 }
3853
3854 if (eqdp->eqd_qpos == eqdp->eqd_qlen) {
3855 mdb_warn("errorq is overfull -- more than %lu "
3856 "elems found\n", eqdp->eqd_qlen);
3857 break;
3858 }
3859
3860 eqdp->eqd_stack[eqdp->eqd_qpos++] = (uintptr_t)eqe.eqe_data;
3861 addr = (uintptr_t)eqe.eqe_prev;
3862 }
3863 }
3864
3865 static int
eqd_walk_init(mdb_walk_state_t * wsp)3866 eqd_walk_init(mdb_walk_state_t *wsp)
3867 {
3868 eqd_walk_data_t *eqdp;
3869 errorq_elem_t eqe, *addr;
3870 errorq_t eq;
3871 ulong_t i;
3872
3873 if (mdb_vread(&eq, sizeof (eq), wsp->walk_addr) == -1) {
3874 mdb_warn("failed to read errorq at %p", wsp->walk_addr);
3875 return (WALK_ERR);
3876 }
3877
3878 if (eq.eq_ptail != NULL &&
3879 mdb_vread(&eqe, sizeof (eqe), (uintptr_t)eq.eq_ptail) == -1) {
3880 mdb_warn("failed to read errorq element at %p", eq.eq_ptail);
3881 return (WALK_ERR);
3882 }
3883
3884 eqdp = mdb_alloc(sizeof (eqd_walk_data_t), UM_SLEEP);
3885 wsp->walk_data = eqdp;
3886
3887 eqdp->eqd_stack = mdb_zalloc(sizeof (uintptr_t) * eq.eq_qlen, UM_SLEEP);
3888 eqdp->eqd_buf = mdb_alloc(eq.eq_size, UM_SLEEP);
3889 eqdp->eqd_qlen = eq.eq_qlen;
3890 eqdp->eqd_qpos = 0;
3891 eqdp->eqd_size = eq.eq_size;
3892
3893 /*
3894 * The newest elements in the queue are on the pending list, so we
3895 * push those on to our stack first.
3896 */
3897 eqd_push_list(eqdp, (uintptr_t)eq.eq_pend);
3898
3899 /*
3900 * If eq_ptail is set, it may point to a subset of the errors on the
3901 * pending list in the event a atomic_cas_ptr() failed; if ptail's
3902 * data is already in our stack, NULL out eq_ptail and ignore it.
3903 */
3904 if (eq.eq_ptail != NULL) {
3905 for (i = 0; i < eqdp->eqd_qpos; i++) {
3906 if (eqdp->eqd_stack[i] == (uintptr_t)eqe.eqe_data) {
3907 eq.eq_ptail = NULL;
3908 break;
3909 }
3910 }
3911 }
3912
3913 /*
3914 * If eq_phead is set, it has the processing list in order from oldest
3915 * to newest. Use this to recompute eq_ptail as best we can and then
3916 * we nicely fall into eqd_push_list() of eq_ptail below.
3917 */
3918 for (addr = eq.eq_phead; addr != NULL && mdb_vread(&eqe, sizeof (eqe),
3919 (uintptr_t)addr) == sizeof (eqe); addr = eqe.eqe_next)
3920 eq.eq_ptail = addr;
3921
3922 /*
3923 * The oldest elements in the queue are on the processing list, subject
3924 * to machinations in the if-clauses above. Push any such elements.
3925 */
3926 eqd_push_list(eqdp, (uintptr_t)eq.eq_ptail);
3927 return (WALK_NEXT);
3928 }
3929
3930 static int
eqd_walk_step(mdb_walk_state_t * wsp)3931 eqd_walk_step(mdb_walk_state_t *wsp)
3932 {
3933 eqd_walk_data_t *eqdp = wsp->walk_data;
3934 uintptr_t addr;
3935
3936 if (eqdp->eqd_qpos == 0)
3937 return (WALK_DONE);
3938
3939 addr = eqdp->eqd_stack[--eqdp->eqd_qpos];
3940
3941 if (mdb_vread(eqdp->eqd_buf, eqdp->eqd_size, addr) != eqdp->eqd_size) {
3942 mdb_warn("failed to read errorq data at %p", addr);
3943 return (WALK_ERR);
3944 }
3945
3946 return (wsp->walk_callback(addr, eqdp->eqd_buf, wsp->walk_cbdata));
3947 }
3948
3949 static void
eqd_walk_fini(mdb_walk_state_t * wsp)3950 eqd_walk_fini(mdb_walk_state_t *wsp)
3951 {
3952 eqd_walk_data_t *eqdp = wsp->walk_data;
3953
3954 mdb_free(eqdp->eqd_stack, sizeof (uintptr_t) * eqdp->eqd_qlen);
3955 mdb_free(eqdp->eqd_buf, eqdp->eqd_size);
3956 mdb_free(eqdp, sizeof (eqd_walk_data_t));
3957 }
3958
3959 #define EQKSVAL(eqv, what) (eqv.eq_kstat.what.value.ui64)
3960
3961 static int
errorq(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)3962 errorq(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
3963 {
3964 int i;
3965 errorq_t eq;
3966 uint_t opt_v = FALSE;
3967
3968 if (!(flags & DCMD_ADDRSPEC)) {
3969 if (mdb_walk_dcmd("errorq", "errorq", argc, argv) == -1) {
3970 mdb_warn("can't walk 'errorq'");
3971 return (DCMD_ERR);
3972 }
3973 return (DCMD_OK);
3974 }
3975
3976 i = mdb_getopts(argc, argv, 'v', MDB_OPT_SETBITS, TRUE, &opt_v, NULL);
3977 argc -= i;
3978 argv += i;
3979
3980 if (argc != 0)
3981 return (DCMD_USAGE);
3982
3983 if (opt_v || DCMD_HDRSPEC(flags)) {
3984 mdb_printf("%<u>%-11s %-16s %1s %1s %1s ",
3985 "ADDR", "NAME", "S", "V", "N");
3986 if (!opt_v) {
3987 mdb_printf("%7s %7s %7s%</u>\n",
3988 "ACCEPT", "DROP", "LOG");
3989 } else {
3990 mdb_printf("%5s %6s %6s %3s %16s%</u>\n",
3991 "KSTAT", "QLEN", "SIZE", "IPL", "FUNC");
3992 }
3993 }
3994
3995 if (mdb_vread(&eq, sizeof (eq), addr) != sizeof (eq)) {
3996 mdb_warn("failed to read errorq at %p", addr);
3997 return (DCMD_ERR);
3998 }
3999
4000 mdb_printf("%-11p %-16s %c %c %c ", addr, eq.eq_name,
4001 (eq.eq_flags & ERRORQ_ACTIVE) ? '+' : '-',
4002 (eq.eq_flags & ERRORQ_VITAL) ? '!' : ' ',
4003 (eq.eq_flags & ERRORQ_NVLIST) ? '*' : ' ');
4004
4005 if (!opt_v) {
4006 mdb_printf("%7llu %7llu %7llu\n",
4007 EQKSVAL(eq, eqk_dispatched) + EQKSVAL(eq, eqk_committed),
4008 EQKSVAL(eq, eqk_dropped) + EQKSVAL(eq, eqk_reserve_fail) +
4009 EQKSVAL(eq, eqk_commit_fail), EQKSVAL(eq, eqk_logged));
4010 } else {
4011 mdb_printf("%5s %6lu %6lu %3u %a\n",
4012 " | ", eq.eq_qlen, eq.eq_size, eq.eq_ipl, eq.eq_func);
4013 mdb_printf("%38s\n%41s"
4014 "%12s %llu\n"
4015 "%53s %llu\n"
4016 "%53s %llu\n"
4017 "%53s %llu\n"
4018 "%53s %llu\n"
4019 "%53s %llu\n"
4020 "%53s %llu\n"
4021 "%53s %llu\n\n",
4022 "|", "+-> ",
4023 "DISPATCHED", EQKSVAL(eq, eqk_dispatched),
4024 "DROPPED", EQKSVAL(eq, eqk_dropped),
4025 "LOGGED", EQKSVAL(eq, eqk_logged),
4026 "RESERVED", EQKSVAL(eq, eqk_reserved),
4027 "RESERVE FAIL", EQKSVAL(eq, eqk_reserve_fail),
4028 "COMMITTED", EQKSVAL(eq, eqk_committed),
4029 "COMMIT FAIL", EQKSVAL(eq, eqk_commit_fail),
4030 "CANCELLED", EQKSVAL(eq, eqk_cancelled));
4031 }
4032
4033 return (DCMD_OK);
4034 }
4035
4036 /*ARGSUSED*/
4037 static int
panicinfo(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)4038 panicinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
4039 {
4040 cpu_t panic_cpu;
4041 kthread_t *panic_thread;
4042 void *buf;
4043 panic_data_t *pd;
4044 int i, n;
4045
4046 if (!mdb_prop_postmortem) {
4047 mdb_warn("panicinfo can only be run on a system "
4048 "dump; see dumpadm(8)\n");
4049 return (DCMD_ERR);
4050 }
4051
4052 if (flags & DCMD_ADDRSPEC || argc != 0)
4053 return (DCMD_USAGE);
4054
4055 if (mdb_readsym(&panic_cpu, sizeof (cpu_t), "panic_cpu") == -1)
4056 mdb_warn("failed to read 'panic_cpu'");
4057 else
4058 mdb_printf("%16s %?d\n", "cpu", panic_cpu.cpu_id);
4059
4060 if (mdb_readvar(&panic_thread, "panic_thread") == -1)
4061 mdb_warn("failed to read 'panic_thread'");
4062 else
4063 mdb_printf("%16s %?p\n", "thread", panic_thread);
4064
4065 buf = mdb_alloc(PANICBUFSIZE, UM_SLEEP);
4066 pd = (panic_data_t *)buf;
4067
4068 if (mdb_readsym(buf, PANICBUFSIZE, "panicbuf") == -1 ||
4069 pd->pd_version != PANICBUFVERS) {
4070 mdb_warn("failed to read 'panicbuf'");
4071 mdb_free(buf, PANICBUFSIZE);
4072 return (DCMD_ERR);
4073 }
4074
4075 mdb_printf("%16s %s\n", "message", (char *)buf + pd->pd_msgoff);
4076
4077 n = (pd->pd_msgoff - (sizeof (panic_data_t) -
4078 sizeof (panic_nv_t))) / sizeof (panic_nv_t);
4079
4080 for (i = 0; i < n; i++)
4081 mdb_printf("%16s %?llx\n",
4082 pd->pd_nvdata[i].pnv_name, pd->pd_nvdata[i].pnv_value);
4083
4084 mdb_free(buf, PANICBUFSIZE);
4085 return (DCMD_OK);
4086 }
4087
4088 /*
4089 * ::time dcmd, which will print a hires timestamp of when we entered the
4090 * debugger, or the lbolt value if used with the -l option.
4091 *
4092 */
4093 /*ARGSUSED*/
4094 static int
time(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)4095 time(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
4096 {
4097 uint_t opt_dec = FALSE;
4098 uint_t opt_lbolt = FALSE;
4099 uint_t opt_hex = FALSE;
4100 const char *fmt;
4101 hrtime_t result;
4102
4103 if (mdb_getopts(argc, argv,
4104 'd', MDB_OPT_SETBITS, TRUE, &opt_dec,
4105 'l', MDB_OPT_SETBITS, TRUE, &opt_lbolt,
4106 'x', MDB_OPT_SETBITS, TRUE, &opt_hex,
4107 NULL) != argc)
4108 return (DCMD_USAGE);
4109
4110 if (opt_dec && opt_hex)
4111 return (DCMD_USAGE);
4112
4113 result = opt_lbolt ? mdb_get_lbolt() : mdb_gethrtime();
4114 fmt =
4115 opt_hex ? "0x%llx\n" :
4116 opt_dec ? "0t%lld\n" : "%#llr\n";
4117
4118 mdb_printf(fmt, result);
4119 return (DCMD_OK);
4120 }
4121
4122 void
time_help(void)4123 time_help(void)
4124 {
4125 mdb_printf("Prints the system time in nanoseconds.\n\n"
4126 "::time will return the timestamp at which we dropped into, \n"
4127 "if called from, kmdb(1); the core dump's high resolution \n"
4128 "time if inspecting one; or the running hires time if we're \n"
4129 "looking at a live system.\n\n"
4130 "Switches:\n"
4131 " -d report times in decimal\n"
4132 " -l prints the number of clock ticks since system boot\n"
4133 " -x report times in hexadecimal\n");
4134 }
4135
4136 extern int cmd_refstr(uintptr_t, uint_t, int, const mdb_arg_t *);
4137
4138 static const mdb_dcmd_t dcmds[] = {
4139
4140 /* from genunix.c */
4141 { "as2proc", ":", "convert as to proc_t address", as2proc },
4142 { "binding_hash_entry", ":", "print driver names hash table entry",
4143 binding_hash_entry },
4144 { "callout", "?[-r|n] [-s|l] [-xhB] [-t | -ab nsec [-dkD]]"
4145 " [-C addr | -S seqid] [-f name|addr] [-p name| addr] [-T|L [-E]]"
4146 " [-FivVA]",
4147 "display callouts", callout, callout_help },
4148 { "calloutid", "[-d|v] xid", "print callout by extended id",
4149 calloutid, calloutid_help },
4150 { "class", NULL, "print process scheduler classes", class },
4151 { "cpuinfo", "?[-v]", "print CPUs and runnable threads", cpuinfo },
4152 { "did2thread", "? kt_did", "find kernel thread for this id",
4153 did2thread },
4154 { "errorq", "?[-v]", "display kernel error queues", errorq },
4155 { "fd", ":[fd num]", "get a file pointer from an fd", fd },
4156 { "flipone", ":", "the vik_rev_level 2 special", flipone },
4157 { "lminfo", NULL, "print lock manager information", lminfo },
4158 { "ndi_event_hdl", "?", "print ndi_event_hdl", ndi_event_hdl },
4159 { "panicinfo", NULL, "print panic information", panicinfo },
4160 { "pid2proc", "?", "convert PID to proc_t address", pid2proc },
4161 { "project", NULL, "display kernel project(s)", project },
4162 { "ps", "[-fltzTP]", "list processes (and associated thr,lwp)", ps,
4163 ps_help },
4164 { "pflags", NULL, "display various proc_t flags", pflags },
4165 { "pgrep", "[-x] [-n | -o] pattern",
4166 "pattern match against all processes", pgrep },
4167 { "ptree", NULL, "print process tree", ptree },
4168 { "refstr", NULL, "print string from a refstr_t", cmd_refstr, NULL },
4169 { "sysevent", "?[-sv]", "print sysevent pending or sent queue",
4170 sysevent},
4171 { "sysevent_channel", "?", "print sysevent channel database",
4172 sysevent_channel},
4173 { "sysevent_class_list", ":", "print sysevent class list",
4174 sysevent_class_list},
4175 { "sysevent_subclass_list", ":",
4176 "print sysevent subclass list", sysevent_subclass_list},
4177 { "system", NULL, "print contents of /etc/system file", sysfile },
4178 { "task", NULL, "display kernel task(s)", task },
4179 { "time", "[-dlx]", "display system time", time, time_help },
4180 { "vnode2path", ":[-F]", "vnode address to pathname", vnode2path },
4181 { "whereopen", ":", "given a vnode, dumps procs which have it open",
4182 whereopen },
4183
4184 /* from bio.c */
4185 { "bufpagefind", ":addr", "find page_t on buf_t list", bufpagefind },
4186
4187 /* from bitset.c */
4188 { "bitset", ":", "display a bitset", bitset, bitset_help },
4189
4190 /* from contract.c */
4191 { "contract", "?", "display a contract", cmd_contract },
4192 { "ctevent", ":", "display a contract event", cmd_ctevent },
4193 { "ctid", ":", "convert id to a contract pointer", cmd_ctid },
4194
4195 /* from cpupart.c */
4196 { "cpupart", "?[-v]", "print cpu partition info", cpupart },
4197
4198 /* from cred.c */
4199 { "cred", ":[-v]", "display a credential", cmd_cred },
4200 { "credgrp", ":[-v]", "display cred_t groups", cmd_credgrp },
4201 { "credsid", ":[-v]", "display a credsid_t", cmd_credsid },
4202 { "ksidlist", ":[-v]", "display a ksidlist_t", cmd_ksidlist },
4203
4204 /* from cyclic.c */
4205 { "cyccover", NULL, "dump cyclic coverage information", cyccover },
4206 { "cycid", "?", "dump a cyclic id", cycid },
4207 { "cycinfo", "?", "dump cyc_cpu info", cycinfo },
4208 { "cyclic", ":", "developer information", cyclic },
4209 { "cyctrace", "?", "dump cyclic trace buffer", cyctrace },
4210
4211 /* from damap.c */
4212 { "damap", ":", "display a damap_t", damap, damap_help },
4213
4214 /* from ddi_periodic.c */
4215 { "ddi_periodic", "?[-v]", "dump ddi_periodic_impl_t info", dprinfo },
4216
4217 /* from devinfo.c */
4218 { "devbindings", "?[-qs] [device-name | major-num]",
4219 "print devinfo nodes bound to device-name or major-num",
4220 devbindings, devinfo_help },
4221 { "devinfo", ":[-qsd] [-b bus]", "detailed devinfo of one node",
4222 devinfo, devinfo_help },
4223 { "devinfo_audit", ":[-v]", "devinfo configuration audit record",
4224 devinfo_audit },
4225 { "devinfo_audit_log", "?[-v]", "system wide devinfo configuration log",
4226 devinfo_audit_log },
4227 { "devinfo_audit_node", ":[-v]", "devinfo node configuration history",
4228 devinfo_audit_node },
4229 { "devinfo2driver", ":", "find driver name for this devinfo node",
4230 devinfo2driver },
4231 { "devnames", "?[-vm] [num]", "print devnames array", devnames },
4232 { "dev2major", "?<dev_t>", "convert dev_t to a major number",
4233 dev2major },
4234 { "dev2minor", "?<dev_t>", "convert dev_t to a minor number",
4235 dev2minor },
4236 { "devt", "?<dev_t>", "display a dev_t's major and minor numbers",
4237 devt },
4238 { "major2name", "?<major-num>", "convert major number to dev name",
4239 major2name },
4240 { "minornodes", ":", "given a devinfo node, print its minor nodes",
4241 minornodes },
4242 { "modctl2devinfo", ":", "given a modctl, list its devinfos",
4243 modctl2devinfo },
4244 { "name2major", "<dev-name>", "convert dev name to major number",
4245 name2major },
4246 { "prtconf", "?[-vpc] [-d driver] [-i inst]", "print devinfo tree",
4247 prtconf, prtconf_help },
4248 { "softstate", ":<instance>", "retrieve soft-state pointer",
4249 softstate },
4250 { "devinfo_fm", ":", "devinfo fault managment configuration",
4251 devinfo_fm },
4252 { "devinfo_fmce", ":", "devinfo fault managment cache entry",
4253 devinfo_fmce},
4254
4255 /* from findstack.c */
4256 { "findstack", ":[-v]", "find kernel thread stack", findstack },
4257 { "findstack_debug", NULL, "toggle findstack debugging",
4258 findstack_debug },
4259 { "stacks", "?[-afiv] [-c func] [-C func] [-m module] [-M module] "
4260 "[-s sobj | -S sobj] [-t tstate | -T tstate]",
4261 "print unique kernel thread stacks",
4262 stacks, stacks_help },
4263
4264 /* from fm.c */
4265 { "ereport", "[-v]", "print ereports logged in dump",
4266 ereport },
4267
4268 /* from group.c */
4269 { "group", "?[-q]", "display a group", group},
4270
4271 /* from hotplug.c */
4272 { "hotplug", "?[-p]", "display a registered hotplug attachment",
4273 hotplug, hotplug_help },
4274
4275 /* from irm.c */
4276 { "irmpools", NULL, "display interrupt pools", irmpools_dcmd },
4277 { "irmreqs", NULL, "display interrupt requests in an interrupt pool",
4278 irmreqs_dcmd },
4279 { "irmreq", NULL, "display an interrupt request", irmreq_dcmd },
4280
4281 /* from kgrep.c + genunix.c */
4282 { "kgrep", KGREP_USAGE, "search kernel as for a pointer", kgrep,
4283 kgrep_help },
4284
4285 /* from kmem.c */
4286 { "allocdby", ":", "given a thread, print its allocated buffers",
4287 allocdby },
4288 { "bufctl", ":[-vh] [-a addr] [-c caller] [-e earliest] [-l latest] "
4289 "[-t thd]", "print or filter a bufctl", bufctl, bufctl_help },
4290 { "freedby", ":", "given a thread, print its freed buffers", freedby },
4291 { "kmalog", "?[ fail | slab | zerosized ]",
4292 "display kmem transaction log and stack traces for specified type",
4293 kmalog },
4294 { "kmastat", "[-kmg]", "kernel memory allocator stats",
4295 kmastat },
4296 { "kmausers", "?[-ef] [cache ...]", "current medium and large users "
4297 "of the kmem allocator", kmausers, kmausers_help },
4298 { "kmem_cache", "?[-n name]",
4299 "print kernel memory caches", kmem_cache, kmem_cache_help},
4300 { "kmem_slabs", "?[-v] [-n cache] [-N cache] [-b maxbins] "
4301 "[-B minbinsize]", "display slab usage per kmem cache",
4302 kmem_slabs, kmem_slabs_help },
4303 { "kmem_debug", NULL, "toggle kmem dcmd/walk debugging", kmem_debug },
4304 { "kmem_log", "?[-b]", "dump kmem transaction log", kmem_log },
4305 { "kmem_verify", "?", "check integrity of kmem-managed memory",
4306 kmem_verify },
4307 { "vmem", "?", "print a vmem_t", vmem },
4308 { "vmem_seg", ":[-sv] [-c caller] [-e earliest] [-l latest] "
4309 "[-m minsize] [-M maxsize] [-t thread] [-T type]",
4310 "print or filter a vmem_seg", vmem_seg, vmem_seg_help },
4311 { "whatthread", ":[-v]", "print threads whose stack contains the "
4312 "given address", whatthread },
4313
4314 /* from ldi.c */
4315 { "ldi_handle", "?[-i]", "display a layered driver handle",
4316 ldi_handle, ldi_handle_help },
4317 { "ldi_ident", NULL, "display a layered driver identifier",
4318 ldi_ident, ldi_ident_help },
4319
4320 /* from leaky.c + leaky_subr.c */
4321 { "findleaks", FINDLEAKS_USAGE,
4322 "search for potential kernel memory leaks", findleaks,
4323 findleaks_help },
4324
4325 /* from lgrp.c */
4326 { "lgrp", "?[-q] [-p | -Pih]", "display an lgrp", lgrp},
4327 { "lgrp_set", "", "display bitmask of lgroups as a list", lgrp_set},
4328
4329 /* from log.c */
4330 { "msgbuf", "?[-tTv]", "print most recent console messages", msgbuf,
4331 msgbuf_help },
4332
4333 /* from mdi.c */
4334 { "mdipi", NULL, "given a path, dump mdi_pathinfo "
4335 "and detailed pi_prop list", mdipi },
4336 { "mdiprops", NULL, "given a pi_prop, dump the pi_prop list",
4337 mdiprops },
4338 { "mdiphci", NULL, "given a phci, dump mdi_phci and "
4339 "list all paths", mdiphci },
4340 { "mdivhci", NULL, "given a vhci, dump mdi_vhci and list "
4341 "all phcis", mdivhci },
4342 { "mdiclient_paths", NULL, "given a path, walk mdi_pathinfo "
4343 "client links", mdiclient_paths },
4344 { "mdiphci_paths", NULL, "given a path, walk through mdi_pathinfo "
4345 "phci links", mdiphci_paths },
4346 { "mdiphcis", NULL, "given a phci, walk through mdi_phci ph_next links",
4347 mdiphcis },
4348
4349 /* from memory.c */
4350 { "addr2smap", ":[offset]", "translate address to smap", addr2smap },
4351 { "memlist", "?[-iav]", "display a struct memlist", memlist },
4352 { "memstat", NULL, "display memory usage summary", memstat },
4353 { "page", "?", "display a summarized page_t", page },
4354 { "pagelookup", "?[-v vp] [-o offset]",
4355 "find the page_t with the name {vp, offset}",
4356 pagelookup, pagelookup_help },
4357 { "page_num2pp", ":", "find the page_t for a given page frame number",
4358 page_num2pp },
4359 { "pmap", ":[-q]", "print process memory map", pmap },
4360 { "seg", ":", "print address space segment", seg },
4361 { "swapinfo", "?", "display a struct swapinfo", swapinfof },
4362 { "vnode2smap", ":[offset]", "translate vnode to smap", vnode2smap },
4363
4364 /* from modhash.c */
4365 { "modhash", "?[-ceht] [-k key] [-v val] [-i index]",
4366 "display information about one or all mod_hash structures",
4367 modhash, modhash_help },
4368 { "modent", ":[-k | -v | -t type]",
4369 "display information about a mod_hash_entry", modent,
4370 modent_help },
4371
4372 /* from net.c */
4373 { "dladm", "?<sub-command> [flags]", "show data link information",
4374 dladm, dladm_help },
4375 { "mi", ":[-p] [-d | -m]", "filter and display MI object or payload",
4376 mi },
4377 { "netstat", "[-arv] [-f inet | inet6 | unix] [-P tcp | udp | icmp]",
4378 "show network statistics", netstat },
4379 { "sonode", "?[-f inet | inet6 | unix | #] "
4380 "[-t stream | dgram | raw | #] [-p #]",
4381 "filter and display sonode", sonode },
4382
4383 /* from netstack.c */
4384 { "netstack", "", "show stack instances", netstack },
4385 { "netstackid2netstack", ":",
4386 "translate a netstack id to its netstack_t",
4387 netstackid2netstack },
4388
4389 /* from nvpair.c */
4390 { NVPAIR_DCMD_NAME, NVPAIR_DCMD_USAGE, NVPAIR_DCMD_DESCR,
4391 nvpair_print },
4392 { NVLIST_DCMD_NAME, NVLIST_DCMD_USAGE, NVLIST_DCMD_DESCR,
4393 print_nvlist },
4394
4395 /* from pg.c */
4396 { "pg", "?[-q]", "display a pg", pg},
4397
4398 /* from rctl.c */
4399 { "rctl_dict", "?", "print systemwide default rctl definitions",
4400 rctl_dict },
4401 { "rctl_list", ":[handle]", "print rctls for the given proc",
4402 rctl_list },
4403 { "rctl", ":[handle]", "print a rctl_t, only if it matches the handle",
4404 rctl },
4405 { "rctl_validate", ":[-v] [-n #]", "test resource control value "
4406 "sequence", rctl_validate },
4407
4408 /* from sobj.c */
4409 { "rwlock", ":", "dump out a readers/writer lock", rwlock },
4410 { "mutex", ":[-f]", "dump out an adaptive or spin mutex", mutex,
4411 mutex_help },
4412 { "sobj2ts", ":", "perform turnstile lookup on synch object", sobj2ts },
4413 { "wchaninfo", "?[-v]", "dump condition variable", wchaninfo },
4414 { "turnstile", "?", "display a turnstile", turnstile },
4415
4416 /* from stream.c */
4417 { "mblk", ":[-q|v] [-f|F flag] [-t|T type] [-l|L|B len] [-d dbaddr]",
4418 "print an mblk", mblk_prt, mblk_help },
4419 { "mblk_verify", "?", "verify integrity of an mblk", mblk_verify },
4420 { "mblk2dblk", ":", "convert mblk_t address to dblk_t address",
4421 mblk2dblk },
4422 { "q2otherq", ":", "print peer queue for a given queue", q2otherq },
4423 { "q2rdq", ":", "print read queue for a given queue", q2rdq },
4424 { "q2syncq", ":", "print syncq for a given queue", q2syncq },
4425 { "q2stream", ":", "print stream pointer for a given queue", q2stream },
4426 { "q2wrq", ":", "print write queue for a given queue", q2wrq },
4427 { "queue", ":[-q|v] [-m mod] [-f flag] [-F flag] [-s syncq_addr]",
4428 "filter and display STREAM queue", queue, queue_help },
4429 { "stdata", ":[-q|v] [-f flag] [-F flag]",
4430 "filter and display STREAM head", stdata, stdata_help },
4431 { "str2mate", ":", "print mate of this stream", str2mate },
4432 { "str2wrq", ":", "print write queue of this stream", str2wrq },
4433 { "stream", ":", "display STREAM", stream },
4434 { "strftevent", ":", "print STREAMS flow trace event", strftevent },
4435 { "syncq", ":[-q|v] [-f flag] [-F flag] [-t type] [-T type]",
4436 "filter and display STREAM sync queue", syncq, syncq_help },
4437 { "syncq2q", ":", "print queue for a given syncq", syncq2q },
4438
4439 /* from taskq.c */
4440 { "taskq", ":[-atT] [-m min_maxq] [-n name]",
4441 "display a taskq", taskq, taskq_help },
4442 { "taskq_entry", ":", "display a taskq_ent_t", taskq_ent },
4443
4444 /* from thread.c */
4445 { "thread", "?[-bdfimps]", "display a summarized kthread_t", thread,
4446 thread_help },
4447 { "threadlist", "?[-t] [-v [count]]",
4448 "display threads and associated C stack traces", threadlist,
4449 threadlist_help },
4450 { "stackinfo", "?[-h|-a]", "display kthread_t stack usage", stackinfo,
4451 stackinfo_help },
4452
4453 /* from tsd.c */
4454 { "tsd", ":-k key", "print tsd[key-1] for this thread", ttotsd },
4455 { "tsdtot", ":", "find thread with this tsd", tsdtot },
4456
4457 /*
4458 * typegraph does not work under kmdb, as it requires too much memory
4459 * for its internal data structures.
4460 */
4461 #ifndef _KMDB
4462 /* from typegraph.c */
4463 { "findlocks", ":", "find locks held by specified thread", findlocks },
4464 { "findfalse", "?[-v]", "find potentially falsely shared structures",
4465 findfalse },
4466 { "typegraph", NULL, "build type graph", typegraph },
4467 { "istype", ":type", "manually set object type", istype },
4468 { "notype", ":", "manually clear object type", notype },
4469 { "whattype", ":", "determine object type", whattype },
4470 #endif
4471
4472 /* from vfs.c */
4473 { "fsinfo", "?[-v]", "print mounted filesystems", fsinfo },
4474 { "pfiles", ":[-fp]", "print process file information", pfiles,
4475 pfiles_help },
4476
4477 /* from zone.c */
4478 { "zid2zone", ":", "find the zone_t with the given zone id",
4479 zid2zone },
4480 { "zone", "?[-r [-v]]", "display kernel zone(s)", zoneprt },
4481 { "zsd", ":[-v] [zsd_key]", "display zone-specific-data entries for "
4482 "selected zones", zsd },
4483
4484 #ifndef _KMDB
4485 { "gcore", NULL, "generate a user core for the given process",
4486 gcore_dcmd },
4487 #endif
4488
4489 { NULL }
4490 };
4491
4492 static const mdb_walker_t walkers[] = {
4493
4494 /* from genunix.c */
4495 { "callouts_bytime", "walk callouts by list chain (expiration time)",
4496 callout_walk_init, callout_walk_step, callout_walk_fini,
4497 (void *)CALLOUT_WALK_BYLIST },
4498 { "callouts_byid", "walk callouts by id hash chain",
4499 callout_walk_init, callout_walk_step, callout_walk_fini,
4500 (void *)CALLOUT_WALK_BYID },
4501 { "callout_list", "walk a callout list", callout_list_walk_init,
4502 callout_list_walk_step, callout_list_walk_fini },
4503 { "callout_table", "walk callout table array", callout_table_walk_init,
4504 callout_table_walk_step, callout_table_walk_fini },
4505 { "cpu", "walk cpu structures", cpu_walk_init, cpu_walk_step },
4506 { "dnlc", "walk dnlc entries",
4507 dnlc_walk_init, dnlc_walk_step, dnlc_walk_fini },
4508 { "ereportq_dump", "walk list of ereports in dump error queue",
4509 ereportq_dump_walk_init, ereportq_dump_walk_step, NULL },
4510 { "ereportq_pend", "walk list of ereports in pending error queue",
4511 ereportq_pend_walk_init, ereportq_pend_walk_step, NULL },
4512 { "errorq", "walk list of system error queues",
4513 errorq_walk_init, errorq_walk_step, NULL },
4514 { "errorq_data", "walk pending error queue data buffers",
4515 eqd_walk_init, eqd_walk_step, eqd_walk_fini },
4516 { "allfile", "given a proc pointer, list all file pointers",
4517 file_walk_init, allfile_walk_step, file_walk_fini },
4518 { "file", "given a proc pointer, list of open file pointers",
4519 file_walk_init, file_walk_step, file_walk_fini },
4520 { "lock_descriptor", "walk lock_descriptor_t structures",
4521 ld_walk_init, ld_walk_step, NULL },
4522 { "lock_graph", "walk lock graph",
4523 lg_walk_init, lg_walk_step, NULL },
4524 { "port", "given a proc pointer, list of created event ports",
4525 port_walk_init, port_walk_step, NULL },
4526 { "portev", "given a port pointer, list of events in the queue",
4527 portev_walk_init, portev_walk_step, portev_walk_fini },
4528 { "proc", "list of active proc_t structures",
4529 proc_walk_init, proc_walk_step, proc_walk_fini },
4530 { "projects", "walk a list of kernel projects",
4531 project_walk_init, project_walk_step, NULL },
4532 { "sysevent_pend", "walk sysevent pending queue",
4533 sysevent_pend_walk_init, sysevent_walk_step,
4534 sysevent_walk_fini},
4535 { "sysevent_sent", "walk sysevent sent queue", sysevent_sent_walk_init,
4536 sysevent_walk_step, sysevent_walk_fini},
4537 { "sysevent_channel", "walk sysevent channel subscriptions",
4538 sysevent_channel_walk_init, sysevent_channel_walk_step,
4539 sysevent_channel_walk_fini},
4540 { "sysevent_class_list", "walk sysevent subscription's class list",
4541 sysevent_class_list_walk_init, sysevent_class_list_walk_step,
4542 sysevent_class_list_walk_fini},
4543 { "sysevent_subclass_list",
4544 "walk sysevent subscription's subclass list",
4545 sysevent_subclass_list_walk_init,
4546 sysevent_subclass_list_walk_step,
4547 sysevent_subclass_list_walk_fini},
4548 { "task", "given a task pointer, walk its processes",
4549 task_walk_init, task_walk_step, NULL },
4550
4551 /* from avl.c */
4552 { AVL_WALK_NAME, AVL_WALK_DESC,
4553 avl_walk_init, avl_walk_step, avl_walk_fini },
4554
4555 /* from bio.c */
4556 { "buf", "walk the bio buf hash",
4557 buf_walk_init, buf_walk_step, buf_walk_fini },
4558
4559 /* from contract.c */
4560 { "contract", "walk all contracts, or those of the specified type",
4561 ct_walk_init, generic_walk_step, NULL },
4562 { "ct_event", "walk events on a contract event queue",
4563 ct_event_walk_init, generic_walk_step, NULL },
4564 { "ct_listener", "walk contract event queue listeners",
4565 ct_listener_walk_init, generic_walk_step, NULL },
4566
4567 /* from cpupart.c */
4568 { "cpupart_cpulist", "given an cpupart_t, walk cpus in partition",
4569 cpupart_cpulist_walk_init, cpupart_cpulist_walk_step,
4570 NULL },
4571 { "cpupart_walk", "walk the set of cpu partitions",
4572 cpupart_walk_init, cpupart_walk_step, NULL },
4573
4574 /* from ctxop.c */
4575 { "ctxop", "walk list of context ops on a thread",
4576 ctxop_walk_init, ctxop_walk_step, ctxop_walk_fini },
4577
4578 /* from cyclic.c */
4579 { "cyccpu", "walk per-CPU cyc_cpu structures",
4580 cyccpu_walk_init, cyccpu_walk_step, NULL },
4581 { "cycomni", "for an omnipresent cyclic, walk cyc_omni_cpu list",
4582 cycomni_walk_init, cycomni_walk_step, NULL },
4583 { "cyctrace", "walk cyclic trace buffer",
4584 cyctrace_walk_init, cyctrace_walk_step, cyctrace_walk_fini },
4585
4586 /* from devinfo.c */
4587 { "binding_hash", "walk all entries in binding hash table",
4588 binding_hash_walk_init, binding_hash_walk_step, NULL },
4589 { "devinfo", "walk devinfo tree or subtree",
4590 devinfo_walk_init, devinfo_walk_step, devinfo_walk_fini },
4591 { "devinfo_audit_log", "walk devinfo audit system-wide log",
4592 devinfo_audit_log_walk_init, devinfo_audit_log_walk_step,
4593 devinfo_audit_log_walk_fini},
4594 { "devinfo_audit_node", "walk per-devinfo audit history",
4595 devinfo_audit_node_walk_init, devinfo_audit_node_walk_step,
4596 devinfo_audit_node_walk_fini},
4597 { "devinfo_children", "walk children of devinfo node",
4598 devinfo_children_walk_init, devinfo_children_walk_step,
4599 devinfo_children_walk_fini },
4600 { "devinfo_parents", "walk ancestors of devinfo node",
4601 devinfo_parents_walk_init, devinfo_parents_walk_step,
4602 devinfo_parents_walk_fini },
4603 { "devinfo_siblings", "walk siblings of devinfo node",
4604 devinfo_siblings_walk_init, devinfo_siblings_walk_step, NULL },
4605 { "devi_next", "walk devinfo list",
4606 NULL, devi_next_walk_step, NULL },
4607 { "devnames", "walk devnames array",
4608 devnames_walk_init, devnames_walk_step, devnames_walk_fini },
4609 { "minornode", "given a devinfo node, walk minor nodes",
4610 minornode_walk_init, minornode_walk_step, NULL },
4611 { "softstate",
4612 "given an i_ddi_soft_state*, list all in-use driver stateps",
4613 soft_state_walk_init, soft_state_walk_step,
4614 NULL, NULL },
4615 { "softstate_all",
4616 "given an i_ddi_soft_state*, list all driver stateps",
4617 soft_state_walk_init, soft_state_all_walk_step,
4618 NULL, NULL },
4619 { "devinfo_fmc",
4620 "walk a fault management handle cache active list",
4621 devinfo_fmc_walk_init, devinfo_fmc_walk_step, NULL },
4622
4623 /* from group.c */
4624 { "group", "walk all elements of a group",
4625 group_walk_init, group_walk_step, NULL },
4626
4627 /* from irm.c */
4628 { "irmpools", "walk global list of interrupt pools",
4629 irmpools_walk_init, list_walk_step, list_walk_fini },
4630 { "irmreqs", "walk list of interrupt requests in an interrupt pool",
4631 irmreqs_walk_init, list_walk_step, list_walk_fini },
4632
4633 /* from kmem.c */
4634 { "allocdby", "given a thread, walk its allocated bufctls",
4635 allocdby_walk_init, allocdby_walk_step, allocdby_walk_fini },
4636 { "bufctl", "walk a kmem cache's bufctls",
4637 bufctl_walk_init, kmem_walk_step, kmem_walk_fini },
4638 { "bufctl_history", "walk the available history of a bufctl",
4639 bufctl_history_walk_init, bufctl_history_walk_step,
4640 bufctl_history_walk_fini },
4641 { "freedby", "given a thread, walk its freed bufctls",
4642 freedby_walk_init, allocdby_walk_step, allocdby_walk_fini },
4643 { "freectl", "walk a kmem cache's free bufctls",
4644 freectl_walk_init, kmem_walk_step, kmem_walk_fini },
4645 { "freectl_constructed", "walk a kmem cache's constructed free bufctls",
4646 freectl_constructed_walk_init, kmem_walk_step, kmem_walk_fini },
4647 { "freemem", "walk a kmem cache's free memory",
4648 freemem_walk_init, kmem_walk_step, kmem_walk_fini },
4649 { "freemem_constructed", "walk a kmem cache's constructed free memory",
4650 freemem_constructed_walk_init, kmem_walk_step, kmem_walk_fini },
4651 { "kmem", "walk a kmem cache",
4652 kmem_walk_init, kmem_walk_step, kmem_walk_fini },
4653 { "kmem_cpu_cache", "given a kmem cache, walk its per-CPU caches",
4654 kmem_cpu_cache_walk_init, kmem_cpu_cache_walk_step, NULL },
4655 { "kmem_hash", "given a kmem cache, walk its allocated hash table",
4656 kmem_hash_walk_init, kmem_hash_walk_step, kmem_hash_walk_fini },
4657 { "kmem_log", "walk the kmem transaction log",
4658 kmem_log_walk_init, kmem_log_walk_step, kmem_log_walk_fini },
4659 { "kmem_slab", "given a kmem cache, walk its slabs",
4660 kmem_slab_walk_init, combined_walk_step, combined_walk_fini },
4661 { "kmem_slab_partial",
4662 "given a kmem cache, walk its partially allocated slabs (min 1)",
4663 kmem_slab_walk_partial_init, combined_walk_step,
4664 combined_walk_fini },
4665 { "vmem", "walk vmem structures in pre-fix, depth-first order",
4666 vmem_walk_init, vmem_walk_step, vmem_walk_fini },
4667 { "vmem_alloc", "given a vmem_t, walk its allocated vmem_segs",
4668 vmem_alloc_walk_init, vmem_seg_walk_step, vmem_seg_walk_fini },
4669 { "vmem_free", "given a vmem_t, walk its free vmem_segs",
4670 vmem_free_walk_init, vmem_seg_walk_step, vmem_seg_walk_fini },
4671 { "vmem_postfix", "walk vmem structures in post-fix, depth-first order",
4672 vmem_walk_init, vmem_postfix_walk_step, vmem_walk_fini },
4673 { "vmem_seg", "given a vmem_t, walk all of its vmem_segs",
4674 vmem_seg_walk_init, vmem_seg_walk_step, vmem_seg_walk_fini },
4675 { "vmem_span", "given a vmem_t, walk its spanning vmem_segs",
4676 vmem_span_walk_init, vmem_seg_walk_step, vmem_seg_walk_fini },
4677
4678 /* from ldi.c */
4679 { "ldi_handle", "walk the layered driver handle hash",
4680 ldi_handle_walk_init, ldi_handle_walk_step, NULL },
4681 { "ldi_ident", "walk the layered driver identifier hash",
4682 ldi_ident_walk_init, ldi_ident_walk_step, NULL },
4683
4684 /* from leaky.c + leaky_subr.c */
4685 { "leak", "given a leaked bufctl or vmem_seg, find leaks w/ same "
4686 "stack trace",
4687 leaky_walk_init, leaky_walk_step, leaky_walk_fini },
4688 { "leakbuf", "given a leaked bufctl or vmem_seg, walk buffers for "
4689 "leaks w/ same stack trace",
4690 leaky_walk_init, leaky_buf_walk_step, leaky_walk_fini },
4691
4692 /* from lgrp.c */
4693 { "lgrp_cpulist", "walk CPUs in a given lgroup",
4694 lgrp_cpulist_walk_init, lgrp_cpulist_walk_step, NULL },
4695 { "lgrptbl", "walk lgroup table",
4696 lgrp_walk_init, lgrp_walk_step, NULL },
4697 { "lgrp_parents", "walk up lgroup lineage from given lgroup",
4698 lgrp_parents_walk_init, lgrp_parents_walk_step, NULL },
4699 { "lgrp_rsrc_mem", "walk lgroup memory resources of given lgroup",
4700 lgrp_rsrc_mem_walk_init, lgrp_set_walk_step, NULL },
4701 { "lgrp_rsrc_cpu", "walk lgroup CPU resources of given lgroup",
4702 lgrp_rsrc_cpu_walk_init, lgrp_set_walk_step, NULL },
4703
4704 /* from list.c */
4705 { LIST_WALK_NAME, LIST_WALK_DESC,
4706 list_walk_init, list_walk_step, list_walk_fini },
4707
4708 /* from mdi.c */
4709 { "mdipi_client_list", "Walker for mdi_pathinfo pi_client_link",
4710 mdi_pi_client_link_walk_init,
4711 mdi_pi_client_link_walk_step,
4712 mdi_pi_client_link_walk_fini },
4713 { "mdipi_phci_list", "Walker for mdi_pathinfo pi_phci_link",
4714 mdi_pi_phci_link_walk_init,
4715 mdi_pi_phci_link_walk_step,
4716 mdi_pi_phci_link_walk_fini },
4717 { "mdiphci_list", "Walker for mdi_phci ph_next link",
4718 mdi_phci_ph_next_walk_init,
4719 mdi_phci_ph_next_walk_step,
4720 mdi_phci_ph_next_walk_fini },
4721
4722 /* from memory.c */
4723 { "allpages", "walk all pages, including free pages",
4724 allpages_walk_init, allpages_walk_step, allpages_walk_fini },
4725 { "anon", "given an amp, list allocated anon structures",
4726 anon_walk_init, anon_walk_step, anon_walk_fini,
4727 ANON_WALK_ALLOC },
4728 { "anon_all", "given an amp, list contents of all anon slots",
4729 anon_walk_init, anon_walk_step, anon_walk_fini,
4730 ANON_WALK_ALL },
4731 { "memlist", "walk specified memlist",
4732 NULL, memlist_walk_step, NULL },
4733 { "page", "walk all pages, or those from the specified vnode",
4734 page_walk_init, page_walk_step, page_walk_fini },
4735 { "seg", "given an as, list of segments",
4736 seg_walk_init, avl_walk_step, avl_walk_fini },
4737 { "segvn_anon",
4738 "given a struct segvn_data, list allocated anon structures",
4739 segvn_anon_walk_init, anon_walk_step, anon_walk_fini,
4740 ANON_WALK_ALLOC },
4741 { "segvn_anon_all",
4742 "given a struct segvn_data, list contents of all anon slots",
4743 segvn_anon_walk_init, anon_walk_step, anon_walk_fini,
4744 ANON_WALK_ALL },
4745 { "segvn_pages",
4746 "given a struct segvn_data, list resident pages in "
4747 "offset order",
4748 segvn_pages_walk_init, segvn_pages_walk_step,
4749 segvn_pages_walk_fini, SEGVN_PAGES_RESIDENT },
4750 { "segvn_pages_all",
4751 "for each offset in a struct segvn_data, give page_t pointer "
4752 "(if resident), or NULL.",
4753 segvn_pages_walk_init, segvn_pages_walk_step,
4754 segvn_pages_walk_fini, SEGVN_PAGES_ALL },
4755 { "swapinfo", "walk swapinfo structures",
4756 swap_walk_init, swap_walk_step, NULL },
4757
4758 /* from modhash.c */
4759 { "modhash", "walk list of mod_hash structures", modhash_walk_init,
4760 modhash_walk_step, NULL },
4761 { "modent", "walk list of entries in a given mod_hash",
4762 modent_walk_init, modent_walk_step, modent_walk_fini },
4763 { "modchain", "walk list of entries in a given mod_hash_entry",
4764 NULL, modchain_walk_step, NULL },
4765
4766 /* from net.c */
4767 { "icmp", "walk ICMP control structures using MI for all stacks",
4768 mi_payload_walk_init, mi_payload_walk_step, NULL,
4769 &mi_icmp_arg },
4770 { "mi", "given a MI_O, walk the MI",
4771 mi_walk_init, mi_walk_step, mi_walk_fini, NULL },
4772 { "sonode", "given a sonode, walk its children",
4773 sonode_walk_init, sonode_walk_step, sonode_walk_fini, NULL },
4774 { "icmp_stacks", "walk all the icmp_stack_t",
4775 icmp_stacks_walk_init, icmp_stacks_walk_step, NULL },
4776 { "tcp_stacks", "walk all the tcp_stack_t",
4777 tcp_stacks_walk_init, tcp_stacks_walk_step, NULL },
4778 { "udp_stacks", "walk all the udp_stack_t",
4779 udp_stacks_walk_init, udp_stacks_walk_step, NULL },
4780
4781 /* from netstack.c */
4782 { "netstack", "walk a list of kernel netstacks",
4783 netstack_walk_init, netstack_walk_step, NULL },
4784
4785 /* from nvpair.c */
4786 { NVPAIR_WALKER_NAME, NVPAIR_WALKER_DESCR,
4787 nvpair_walk_init, nvpair_walk_step, NULL },
4788
4789 /* from pci.c */
4790 { "pcie_bus", "walk all pcie_bus_t's", pcie_bus_walk_init,
4791 pcie_bus_walk_step, NULL },
4792
4793 /* from rctl.c */
4794 { "rctl_dict_list", "walk all rctl_dict_entry_t's from rctl_lists",
4795 rctl_dict_walk_init, rctl_dict_walk_step, NULL },
4796 { "rctl_set", "given a rctl_set, walk all rctls", rctl_set_walk_init,
4797 rctl_set_walk_step, NULL },
4798 { "rctl_val", "given a rctl_t, walk all rctl_val entries associated",
4799 rctl_val_walk_init, rctl_val_walk_step },
4800
4801 /* from sobj.c */
4802 { "blocked", "walk threads blocked on a given sobj",
4803 blocked_walk_init, blocked_walk_step, NULL },
4804 { "wchan", "given a wchan, list of blocked threads",
4805 wchan_walk_init, wchan_walk_step, wchan_walk_fini },
4806
4807 /* from stream.c */
4808 { "b_cont", "walk mblk_t list using b_cont",
4809 mblk_walk_init, b_cont_step, mblk_walk_fini },
4810 { "b_next", "walk mblk_t list using b_next",
4811 mblk_walk_init, b_next_step, mblk_walk_fini },
4812 { "qlink", "walk queue_t list using q_link",
4813 queue_walk_init, queue_link_step, queue_walk_fini },
4814 { "qnext", "walk queue_t list using q_next",
4815 queue_walk_init, queue_next_step, queue_walk_fini },
4816 { "strftblk", "given a dblk_t, walk STREAMS flow trace event list",
4817 strftblk_walk_init, strftblk_step, strftblk_walk_fini },
4818 { "readq", "walk read queue side of stdata",
4819 str_walk_init, strr_walk_step, str_walk_fini },
4820 { "writeq", "walk write queue side of stdata",
4821 str_walk_init, strw_walk_step, str_walk_fini },
4822
4823 /* from taskq.c */
4824 { "taskq_thread", "given a taskq_t, list all of its threads",
4825 taskq_thread_walk_init,
4826 taskq_thread_walk_step,
4827 taskq_thread_walk_fini },
4828 { "taskq_entry", "given a taskq_t*, list all taskq_ent_t in the list",
4829 taskq_ent_walk_init, taskq_ent_walk_step, NULL },
4830
4831 /* from thread.c */
4832 { "deathrow", "walk threads on both lwp_ and thread_deathrow",
4833 deathrow_walk_init, deathrow_walk_step, NULL },
4834 { "cpu_dispq", "given a cpu_t, walk threads in dispatcher queues",
4835 cpu_dispq_walk_init, dispq_walk_step, dispq_walk_fini },
4836 { "cpupart_dispq",
4837 "given a cpupart_t, walk threads in dispatcher queues",
4838 cpupart_dispq_walk_init, dispq_walk_step, dispq_walk_fini },
4839 { "lwp_deathrow", "walk lwp_deathrow",
4840 lwp_deathrow_walk_init, deathrow_walk_step, NULL },
4841 { "thread", "global or per-process kthread_t structures",
4842 thread_walk_init, thread_walk_step, thread_walk_fini },
4843 { "thread_deathrow", "walk threads on thread_deathrow",
4844 thread_deathrow_walk_init, deathrow_walk_step, NULL },
4845
4846 /* from tsd.c */
4847 { "tsd", "walk list of thread-specific data",
4848 tsd_walk_init, tsd_walk_step, tsd_walk_fini },
4849
4850 /* from tsol.c */
4851 { "tnrh", "walk remote host cache structures",
4852 tnrh_walk_init, tnrh_walk_step, tnrh_walk_fini },
4853 { "tnrhtp", "walk remote host template structures",
4854 tnrhtp_walk_init, tnrhtp_walk_step, tnrhtp_walk_fini },
4855
4856 /*
4857 * typegraph does not work under kmdb, as it requires too much memory
4858 * for its internal data structures.
4859 */
4860 #ifndef _KMDB
4861 /* from typegraph.c */
4862 { "typeconflict", "walk buffers with conflicting type inferences",
4863 typegraph_walk_init, typeconflict_walk_step },
4864 { "typeunknown", "walk buffers with unknown types",
4865 typegraph_walk_init, typeunknown_walk_step },
4866 #endif
4867
4868 /* from vfs.c */
4869 { "vfs", "walk file system list",
4870 vfs_walk_init, vfs_walk_step },
4871
4872 /* from zone.c */
4873 { "zone", "walk a list of kernel zones",
4874 zone_walk_init, zone_walk_step, NULL },
4875 { "zsd", "walk list of zsd entries for a zone",
4876 zsd_walk_init, zsd_walk_step, NULL },
4877
4878 { NULL }
4879 };
4880
4881 static const mdb_modinfo_t modinfo = { MDB_API_VERSION, dcmds, walkers };
4882
4883 /*ARGSUSED*/
4884 static void
genunix_statechange_cb(void * ignored)4885 genunix_statechange_cb(void *ignored)
4886 {
4887 /*
4888 * Force ::findleaks and ::stacks to let go any cached state.
4889 */
4890 leaky_cleanup(1);
4891 stacks_cleanup(1);
4892
4893 kmem_statechange(); /* notify kmem */
4894 }
4895
4896 const mdb_modinfo_t *
_mdb_init(void)4897 _mdb_init(void)
4898 {
4899 kmem_init();
4900
4901 (void) mdb_callback_add(MDB_CALLBACK_STCHG,
4902 genunix_statechange_cb, NULL);
4903
4904 #ifndef _KMDB
4905 gcore_init();
4906 #endif
4907
4908 return (&modinfo);
4909 }
4910
4911 void
_mdb_fini(void)4912 _mdb_fini(void)
4913 {
4914 leaky_cleanup(1);
4915 stacks_cleanup(1);
4916 }
4917