1c9a6ea2eSBryan Cantrill /*
2c9a6ea2eSBryan Cantrill * CDDL HEADER START
3c9a6ea2eSBryan Cantrill *
4c9a6ea2eSBryan Cantrill * The contents of this file are subject to the terms of the
5c9a6ea2eSBryan Cantrill * Common Development and Distribution License (the "License").
6c9a6ea2eSBryan Cantrill * You may not use this file except in compliance with the License.
7c9a6ea2eSBryan Cantrill *
8c9a6ea2eSBryan Cantrill * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9c9a6ea2eSBryan Cantrill * or http://www.opensolaris.org/os/licensing.
10c9a6ea2eSBryan Cantrill * See the License for the specific language governing permissions
11c9a6ea2eSBryan Cantrill * and limitations under the License.
12c9a6ea2eSBryan Cantrill *
13c9a6ea2eSBryan Cantrill * When distributing Covered Code, include this CDDL HEADER in each
14c9a6ea2eSBryan Cantrill * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15c9a6ea2eSBryan Cantrill * If applicable, add the following below this CDDL HEADER, with the
16c9a6ea2eSBryan Cantrill * fields enclosed by brackets "[]" replaced with your own identifying
17c9a6ea2eSBryan Cantrill * information: Portions Copyright [yyyy] [name of copyright owner]
18c9a6ea2eSBryan Cantrill *
19c9a6ea2eSBryan Cantrill * CDDL HEADER END
20c9a6ea2eSBryan Cantrill */
21c9a6ea2eSBryan Cantrill
22c9a6ea2eSBryan Cantrill /*
23c9a6ea2eSBryan Cantrill * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
2428e4da25SMatthew Ahrens * Copyright (c) 2012 by Delphix. All rights reserved.
25*2fc9ab6eSJerry Jelinek * Copyright 2020 Joyent, Inc.
26c9a6ea2eSBryan Cantrill */
27c9a6ea2eSBryan Cantrill
28c9a6ea2eSBryan Cantrill #include <mdb/mdb_modapi.h>
29c9a6ea2eSBryan Cantrill #include <mdb/mdb_ctf.h>
30c9a6ea2eSBryan Cantrill
31c9a6ea2eSBryan Cantrill #include <sys/types.h>
32c9a6ea2eSBryan Cantrill #include <sys/regset.h>
33c9a6ea2eSBryan Cantrill #include <sys/stack.h>
34c9a6ea2eSBryan Cantrill #include <sys/thread.h>
35c9a6ea2eSBryan Cantrill #include <sys/modctl.h>
36c9a6ea2eSBryan Cantrill
37c9a6ea2eSBryan Cantrill #include "findstack.h"
38c9a6ea2eSBryan Cantrill #include "thread.h"
39c9a6ea2eSBryan Cantrill #include "sobj.h"
40c9a6ea2eSBryan Cantrill
41c9a6ea2eSBryan Cantrill #define TOO_BIG_FOR_A_STACK (1024 * 1024)
42c9a6ea2eSBryan Cantrill
43c9a6ea2eSBryan Cantrill #define KTOU(p) ((p) - kbase + ubase)
44c9a6ea2eSBryan Cantrill #define UTOK(p) ((p) - ubase + kbase)
45c9a6ea2eSBryan Cantrill
46c9a6ea2eSBryan Cantrill #define CRAWL_FOUNDALL (-1)
47c9a6ea2eSBryan Cantrill
48c9a6ea2eSBryan Cantrill #if defined(__i386) || defined(__amd64)
49c9a6ea2eSBryan Cantrill struct rwindow {
50c9a6ea2eSBryan Cantrill uintptr_t rw_fp;
51c9a6ea2eSBryan Cantrill uintptr_t rw_rtn;
52c9a6ea2eSBryan Cantrill };
53c9a6ea2eSBryan Cantrill #endif
54c9a6ea2eSBryan Cantrill
55c9a6ea2eSBryan Cantrill #ifndef STACK_BIAS
56c9a6ea2eSBryan Cantrill #define STACK_BIAS 0
57c9a6ea2eSBryan Cantrill #endif
58c9a6ea2eSBryan Cantrill
59c9a6ea2eSBryan Cantrill /*
60c9a6ea2eSBryan Cantrill * Given a stack pointer, try to crawl down it to the bottom.
61c9a6ea2eSBryan Cantrill * "frame" is a VA in MDB's address space.
62c9a6ea2eSBryan Cantrill *
63c9a6ea2eSBryan Cantrill * Returns the number of frames successfully crawled down, or
64c9a6ea2eSBryan Cantrill * CRAWL_FOUNDALL if it got to the bottom of the stack.
65c9a6ea2eSBryan Cantrill */
66c9a6ea2eSBryan Cantrill static int
crawl(uintptr_t frame,uintptr_t kbase,uintptr_t ktop,uintptr_t ubase,int kill_fp,findstack_info_t * fsip)67c9a6ea2eSBryan Cantrill crawl(uintptr_t frame, uintptr_t kbase, uintptr_t ktop, uintptr_t ubase,
68c9a6ea2eSBryan Cantrill int kill_fp, findstack_info_t *fsip)
69c9a6ea2eSBryan Cantrill {
70c9a6ea2eSBryan Cantrill int levels = 0;
71c9a6ea2eSBryan Cantrill
72c9a6ea2eSBryan Cantrill fsip->fsi_depth = 0;
73c9a6ea2eSBryan Cantrill fsip->fsi_overflow = 0;
74c9a6ea2eSBryan Cantrill
75c9a6ea2eSBryan Cantrill fs_dprintf(("<0> frame = %p, kbase = %p, ktop = %p, ubase = %p\n",
76c9a6ea2eSBryan Cantrill frame, kbase, ktop, ubase));
77c9a6ea2eSBryan Cantrill for (;;) {
78c9a6ea2eSBryan Cantrill uintptr_t fp;
79c9a6ea2eSBryan Cantrill long *fpp = (long *)&((struct rwindow *)frame)->rw_fp;
80c9a6ea2eSBryan Cantrill
81c9a6ea2eSBryan Cantrill fs_dprintf(("<1> fpp = %p, frame = %p\n", fpp, frame));
82c9a6ea2eSBryan Cantrill
83c9a6ea2eSBryan Cantrill if ((frame & (STACK_ALIGN - 1)) != 0)
84c9a6ea2eSBryan Cantrill break;
85c9a6ea2eSBryan Cantrill
86c9a6ea2eSBryan Cantrill fp = ((struct rwindow *)frame)->rw_fp + STACK_BIAS;
87c9a6ea2eSBryan Cantrill if (fsip->fsi_depth < fsip->fsi_max_depth)
88c9a6ea2eSBryan Cantrill fsip->fsi_stack[fsip->fsi_depth++] =
89c9a6ea2eSBryan Cantrill ((struct rwindow *)frame)->rw_rtn;
90c9a6ea2eSBryan Cantrill else
91c9a6ea2eSBryan Cantrill fsip->fsi_overflow = 1;
92c9a6ea2eSBryan Cantrill
93c9a6ea2eSBryan Cantrill fs_dprintf(("<2> fp = %p\n", fp));
94c9a6ea2eSBryan Cantrill
95c9a6ea2eSBryan Cantrill if (fp == ktop)
96c9a6ea2eSBryan Cantrill return (CRAWL_FOUNDALL);
97c9a6ea2eSBryan Cantrill fs_dprintf(("<3> not at base\n"));
98c9a6ea2eSBryan Cantrill
99c9a6ea2eSBryan Cantrill #if defined(__i386) || defined(__amd64)
100c9a6ea2eSBryan Cantrill if (ktop - fp == sizeof (struct rwindow)) {
101c9a6ea2eSBryan Cantrill fs_dprintf(("<4> found base\n"));
102c9a6ea2eSBryan Cantrill return (CRAWL_FOUNDALL);
103c9a6ea2eSBryan Cantrill }
104c9a6ea2eSBryan Cantrill #endif
105c9a6ea2eSBryan Cantrill
106c9a6ea2eSBryan Cantrill fs_dprintf(("<5> fp = %p, kbase = %p, ktop - size = %p\n",
107c9a6ea2eSBryan Cantrill fp, kbase, ktop - sizeof (struct rwindow)));
108c9a6ea2eSBryan Cantrill
109c9a6ea2eSBryan Cantrill if (fp < kbase || fp >= (ktop - sizeof (struct rwindow)))
110c9a6ea2eSBryan Cantrill break;
111c9a6ea2eSBryan Cantrill
112c9a6ea2eSBryan Cantrill frame = KTOU(fp);
113c9a6ea2eSBryan Cantrill fs_dprintf(("<6> frame = %p\n", frame));
114c9a6ea2eSBryan Cantrill
115c9a6ea2eSBryan Cantrill /*
116c9a6ea2eSBryan Cantrill * NULL out the old %fp so we don't go down this stack
117c9a6ea2eSBryan Cantrill * more than once.
118c9a6ea2eSBryan Cantrill */
119c9a6ea2eSBryan Cantrill if (kill_fp) {
120c9a6ea2eSBryan Cantrill fs_dprintf(("<7> fpp = %p\n", fpp));
121892ad162SToomas Soome *fpp = 0;
122c9a6ea2eSBryan Cantrill }
123c9a6ea2eSBryan Cantrill
124c9a6ea2eSBryan Cantrill fs_dprintf(("<8> levels = %d\n", levels));
125c9a6ea2eSBryan Cantrill levels++;
126c9a6ea2eSBryan Cantrill }
127c9a6ea2eSBryan Cantrill
128c9a6ea2eSBryan Cantrill return (levels);
129c9a6ea2eSBryan Cantrill }
130c9a6ea2eSBryan Cantrill
13128e4da25SMatthew Ahrens typedef struct mdb_findstack_kthread {
13228e4da25SMatthew Ahrens struct _sobj_ops *t_sobj_ops;
13328e4da25SMatthew Ahrens uint_t t_state;
134*2fc9ab6eSJerry Jelinek uint_t t_flag;
13528e4da25SMatthew Ahrens ushort_t t_schedflag;
13628e4da25SMatthew Ahrens caddr_t t_stk;
13728e4da25SMatthew Ahrens caddr_t t_stkbase;
13828e4da25SMatthew Ahrens label_t t_pcb;
13928e4da25SMatthew Ahrens } mdb_findstack_kthread_t;
14028e4da25SMatthew Ahrens
141c9a6ea2eSBryan Cantrill /*ARGSUSED*/
142c9a6ea2eSBryan Cantrill int
stacks_findstack(uintptr_t addr,findstack_info_t * fsip,uint_t print_warnings)143c9a6ea2eSBryan Cantrill stacks_findstack(uintptr_t addr, findstack_info_t *fsip, uint_t print_warnings)
144c9a6ea2eSBryan Cantrill {
14528e4da25SMatthew Ahrens mdb_findstack_kthread_t thr;
146c9a6ea2eSBryan Cantrill size_t stksz;
147c9a6ea2eSBryan Cantrill uintptr_t ubase, utop;
148c9a6ea2eSBryan Cantrill uintptr_t kbase, ktop;
149c9a6ea2eSBryan Cantrill uintptr_t win, sp;
150c9a6ea2eSBryan Cantrill
151c9a6ea2eSBryan Cantrill fsip->fsi_failed = 0;
152c9a6ea2eSBryan Cantrill fsip->fsi_pc = 0;
153c9a6ea2eSBryan Cantrill fsip->fsi_sp = 0;
154c9a6ea2eSBryan Cantrill fsip->fsi_depth = 0;
155c9a6ea2eSBryan Cantrill fsip->fsi_overflow = 0;
156c9a6ea2eSBryan Cantrill
15728e4da25SMatthew Ahrens if (mdb_ctf_vread(&thr, "kthread_t", "mdb_findstack_kthread_t",
15828e4da25SMatthew Ahrens addr, print_warnings ? 0 : MDB_CTF_VREAD_QUIET) == -1) {
159c9a6ea2eSBryan Cantrill fsip->fsi_failed = FSI_FAIL_BADTHREAD;
160c9a6ea2eSBryan Cantrill return (DCMD_ERR);
161c9a6ea2eSBryan Cantrill }
162c9a6ea2eSBryan Cantrill
163c9a6ea2eSBryan Cantrill fsip->fsi_sobj_ops = (uintptr_t)thr.t_sobj_ops;
164c9a6ea2eSBryan Cantrill fsip->fsi_tstate = thr.t_state;
165c9a6ea2eSBryan Cantrill fsip->fsi_panic = !!(thr.t_flag & T_PANIC);
166c9a6ea2eSBryan Cantrill
167c9a6ea2eSBryan Cantrill if ((thr.t_schedflag & TS_LOAD) == 0) {
168c9a6ea2eSBryan Cantrill if (print_warnings)
169c9a6ea2eSBryan Cantrill mdb_warn("thread %p isn't in memory\n", addr);
170c9a6ea2eSBryan Cantrill fsip->fsi_failed = FSI_FAIL_NOTINMEMORY;
171c9a6ea2eSBryan Cantrill return (DCMD_ERR);
172c9a6ea2eSBryan Cantrill }
173c9a6ea2eSBryan Cantrill
174c9a6ea2eSBryan Cantrill if (thr.t_stk < thr.t_stkbase) {
175c9a6ea2eSBryan Cantrill if (print_warnings)
176c9a6ea2eSBryan Cantrill mdb_warn(
177c9a6ea2eSBryan Cantrill "stack base or stack top corrupt for thread %p\n",
178c9a6ea2eSBryan Cantrill addr);
179c9a6ea2eSBryan Cantrill fsip->fsi_failed = FSI_FAIL_THREADCORRUPT;
180c9a6ea2eSBryan Cantrill return (DCMD_ERR);
181c9a6ea2eSBryan Cantrill }
182c9a6ea2eSBryan Cantrill
183c9a6ea2eSBryan Cantrill kbase = (uintptr_t)thr.t_stkbase;
184c9a6ea2eSBryan Cantrill ktop = (uintptr_t)thr.t_stk;
185c9a6ea2eSBryan Cantrill stksz = ktop - kbase;
186c9a6ea2eSBryan Cantrill
187c9a6ea2eSBryan Cantrill #ifdef __amd64
188c9a6ea2eSBryan Cantrill /*
189c9a6ea2eSBryan Cantrill * The stack on amd64 is intentionally misaligned, so ignore the top
190c9a6ea2eSBryan Cantrill * half-frame. See thread_stk_init(). When handling traps, the frame
191c9a6ea2eSBryan Cantrill * is automatically aligned by the hardware, so we only alter ktop if
192c9a6ea2eSBryan Cantrill * needed.
193c9a6ea2eSBryan Cantrill */
194c9a6ea2eSBryan Cantrill if ((ktop & (STACK_ALIGN - 1)) != 0)
195c9a6ea2eSBryan Cantrill ktop -= STACK_ENTRY_ALIGN;
196c9a6ea2eSBryan Cantrill #endif
197c9a6ea2eSBryan Cantrill
198c9a6ea2eSBryan Cantrill /*
199c9a6ea2eSBryan Cantrill * If the stack size is larger than a meg, assume that it's bogus.
200c9a6ea2eSBryan Cantrill */
201c9a6ea2eSBryan Cantrill if (stksz > TOO_BIG_FOR_A_STACK) {
202c9a6ea2eSBryan Cantrill if (print_warnings)
203c9a6ea2eSBryan Cantrill mdb_warn("stack size for thread %p is too big to be "
204c9a6ea2eSBryan Cantrill "reasonable\n", addr);
205c9a6ea2eSBryan Cantrill fsip->fsi_failed = FSI_FAIL_THREADCORRUPT;
206c9a6ea2eSBryan Cantrill return (DCMD_ERR);
207c9a6ea2eSBryan Cantrill }
208c9a6ea2eSBryan Cantrill
209c9a6ea2eSBryan Cantrill /*
210c9a6ea2eSBryan Cantrill * This could be (and was) a UM_GC allocation. Unfortunately,
211c9a6ea2eSBryan Cantrill * stksz tends to be very large. As currently implemented, dcmds
212c9a6ea2eSBryan Cantrill * invoked as part of pipelines don't have their UM_GC-allocated
213c9a6ea2eSBryan Cantrill * memory freed until the pipeline completes. With stksz in the
214c9a6ea2eSBryan Cantrill * neighborhood of 20k, the popular ::walk thread |::findstack
215c9a6ea2eSBryan Cantrill * pipeline can easily run memory-constrained debuggers (kmdb) out
216c9a6ea2eSBryan Cantrill * of memory. This can be changed back to a gc-able allocation when
217c9a6ea2eSBryan Cantrill * the debugger is changed to free UM_GC memory more promptly.
218c9a6ea2eSBryan Cantrill */
219c9a6ea2eSBryan Cantrill ubase = (uintptr_t)mdb_alloc(stksz, UM_SLEEP);
220c9a6ea2eSBryan Cantrill utop = ubase + stksz;
221c9a6ea2eSBryan Cantrill if (mdb_vread((caddr_t)ubase, stksz, kbase) != stksz) {
222c9a6ea2eSBryan Cantrill mdb_free((void *)ubase, stksz);
223c9a6ea2eSBryan Cantrill if (print_warnings)
224c9a6ea2eSBryan Cantrill mdb_warn("couldn't read entire stack for thread %p\n",
225c9a6ea2eSBryan Cantrill addr);
226c9a6ea2eSBryan Cantrill fsip->fsi_failed = FSI_FAIL_THREADCORRUPT;
227c9a6ea2eSBryan Cantrill return (DCMD_ERR);
228c9a6ea2eSBryan Cantrill }
229c9a6ea2eSBryan Cantrill
230c9a6ea2eSBryan Cantrill /*
231c9a6ea2eSBryan Cantrill * Try the saved %sp first, if it looks reasonable.
232c9a6ea2eSBryan Cantrill */
233c9a6ea2eSBryan Cantrill sp = KTOU((uintptr_t)thr.t_sp + STACK_BIAS);
234c9a6ea2eSBryan Cantrill if (sp >= ubase && sp <= utop) {
235c9a6ea2eSBryan Cantrill if (crawl(sp, kbase, ktop, ubase, 0, fsip) == CRAWL_FOUNDALL) {
236c9a6ea2eSBryan Cantrill fsip->fsi_sp = (uintptr_t)thr.t_sp;
237c9a6ea2eSBryan Cantrill #if !defined(__i386)
238c9a6ea2eSBryan Cantrill fsip->fsi_pc = (uintptr_t)thr.t_pc;
239c9a6ea2eSBryan Cantrill #endif
240c9a6ea2eSBryan Cantrill goto found;
241c9a6ea2eSBryan Cantrill }
242c9a6ea2eSBryan Cantrill }
243c9a6ea2eSBryan Cantrill
244c9a6ea2eSBryan Cantrill /*
245c9a6ea2eSBryan Cantrill * Now walk through the whole stack, starting at the base,
246c9a6ea2eSBryan Cantrill * trying every possible "window".
247c9a6ea2eSBryan Cantrill */
248c9a6ea2eSBryan Cantrill for (win = ubase;
249c9a6ea2eSBryan Cantrill win + sizeof (struct rwindow) <= utop;
250c9a6ea2eSBryan Cantrill win += sizeof (struct rwindow *)) {
251c9a6ea2eSBryan Cantrill if (crawl(win, kbase, ktop, ubase, 1, fsip) == CRAWL_FOUNDALL) {
252c9a6ea2eSBryan Cantrill fsip->fsi_sp = UTOK(win) - STACK_BIAS;
253c9a6ea2eSBryan Cantrill goto found;
254c9a6ea2eSBryan Cantrill }
255c9a6ea2eSBryan Cantrill }
256c9a6ea2eSBryan Cantrill
257c9a6ea2eSBryan Cantrill /*
258c9a6ea2eSBryan Cantrill * We didn't conclusively find the stack. So we'll take another lap,
259c9a6ea2eSBryan Cantrill * and print out anything that looks possible.
260c9a6ea2eSBryan Cantrill */
261c9a6ea2eSBryan Cantrill if (print_warnings)
262c9a6ea2eSBryan Cantrill mdb_printf("Possible stack pointers for thread %p:\n", addr);
263c9a6ea2eSBryan Cantrill (void) mdb_vread((caddr_t)ubase, stksz, kbase);
264c9a6ea2eSBryan Cantrill
265c9a6ea2eSBryan Cantrill for (win = ubase;
266c9a6ea2eSBryan Cantrill win + sizeof (struct rwindow) <= utop;
267c9a6ea2eSBryan Cantrill win += sizeof (struct rwindow *)) {
268c9a6ea2eSBryan Cantrill uintptr_t fp = ((struct rwindow *)win)->rw_fp;
269c9a6ea2eSBryan Cantrill int levels;
270c9a6ea2eSBryan Cantrill
271c9a6ea2eSBryan Cantrill if ((levels = crawl(win, kbase, ktop, ubase, 1, fsip)) > 1) {
272c9a6ea2eSBryan Cantrill if (print_warnings)
273c9a6ea2eSBryan Cantrill mdb_printf(" %p (%d)\n", fp, levels);
274c9a6ea2eSBryan Cantrill } else if (levels == CRAWL_FOUNDALL) {
275c9a6ea2eSBryan Cantrill /*
276c9a6ea2eSBryan Cantrill * If this is a live system, the stack could change
277c9a6ea2eSBryan Cantrill * between the two mdb_vread(ubase, utop, kbase)'s,
278c9a6ea2eSBryan Cantrill * and we could have a fully valid stack here.
279c9a6ea2eSBryan Cantrill */
280c9a6ea2eSBryan Cantrill fsip->fsi_sp = UTOK(win) - STACK_BIAS;
281c9a6ea2eSBryan Cantrill goto found;
282c9a6ea2eSBryan Cantrill }
283c9a6ea2eSBryan Cantrill }
284c9a6ea2eSBryan Cantrill
285c9a6ea2eSBryan Cantrill fsip->fsi_depth = 0;
286c9a6ea2eSBryan Cantrill fsip->fsi_overflow = 0;
287c9a6ea2eSBryan Cantrill fsip->fsi_failed = FSI_FAIL_STACKNOTFOUND;
288c9a6ea2eSBryan Cantrill
289c9a6ea2eSBryan Cantrill mdb_free((void *)ubase, stksz);
290c9a6ea2eSBryan Cantrill return (DCMD_ERR);
291c9a6ea2eSBryan Cantrill found:
292c9a6ea2eSBryan Cantrill mdb_free((void *)ubase, stksz);
293c9a6ea2eSBryan Cantrill return (DCMD_OK);
294c9a6ea2eSBryan Cantrill }
295c9a6ea2eSBryan Cantrill
296c9a6ea2eSBryan Cantrill void
stacks_findstack_cleanup()297c9a6ea2eSBryan Cantrill stacks_findstack_cleanup()
298c9a6ea2eSBryan Cantrill {}
299c9a6ea2eSBryan Cantrill
300c9a6ea2eSBryan Cantrill /*ARGSUSED*/
301c9a6ea2eSBryan Cantrill int
stacks_module_cb(uintptr_t addr,const modctl_t * mp,stacks_module_t * smp)302c9a6ea2eSBryan Cantrill stacks_module_cb(uintptr_t addr, const modctl_t *mp, stacks_module_t *smp)
303c9a6ea2eSBryan Cantrill {
304c9a6ea2eSBryan Cantrill char mod_modname[MODMAXNAMELEN + 1];
305c9a6ea2eSBryan Cantrill
306c9a6ea2eSBryan Cantrill if (!mp->mod_modname)
307c9a6ea2eSBryan Cantrill return (WALK_NEXT);
308c9a6ea2eSBryan Cantrill
309c9a6ea2eSBryan Cantrill if (mdb_readstr(mod_modname, sizeof (mod_modname),
310c9a6ea2eSBryan Cantrill (uintptr_t)mp->mod_modname) == -1) {
311c9a6ea2eSBryan Cantrill mdb_warn("failed to read mod_modname in \"modctl\" walk");
312c9a6ea2eSBryan Cantrill return (WALK_ERR);
313c9a6ea2eSBryan Cantrill }
314c9a6ea2eSBryan Cantrill
315c9a6ea2eSBryan Cantrill if (strcmp(smp->sm_name, mod_modname))
316c9a6ea2eSBryan Cantrill return (WALK_NEXT);
317c9a6ea2eSBryan Cantrill
318c9a6ea2eSBryan Cantrill smp->sm_text = (uintptr_t)mp->mod_text;
319c9a6ea2eSBryan Cantrill smp->sm_size = mp->mod_text_size;
320c9a6ea2eSBryan Cantrill
321c9a6ea2eSBryan Cantrill return (WALK_DONE);
322c9a6ea2eSBryan Cantrill }
323c9a6ea2eSBryan Cantrill
324c9a6ea2eSBryan Cantrill int
stacks_module(stacks_module_t * smp)325c9a6ea2eSBryan Cantrill stacks_module(stacks_module_t *smp)
326c9a6ea2eSBryan Cantrill {
327c9a6ea2eSBryan Cantrill if (mdb_walk("modctl", (mdb_walk_cb_t)stacks_module_cb, smp) != 0) {
328c9a6ea2eSBryan Cantrill mdb_warn("cannot walk \"modctl\"");
329c9a6ea2eSBryan Cantrill return (-1);
330c9a6ea2eSBryan Cantrill }
331c9a6ea2eSBryan Cantrill
332c9a6ea2eSBryan Cantrill return (0);
333c9a6ea2eSBryan Cantrill }
334c9a6ea2eSBryan Cantrill
335c9a6ea2eSBryan Cantrill /*ARGSUSED*/
336c9a6ea2eSBryan Cantrill static void
print_sobj_help(int type,const char * name,const char * ops_name,void * ign)337c9a6ea2eSBryan Cantrill print_sobj_help(int type, const char *name, const char *ops_name, void *ign)
338c9a6ea2eSBryan Cantrill {
339c9a6ea2eSBryan Cantrill mdb_printf(" %s", name);
340c9a6ea2eSBryan Cantrill }
341c9a6ea2eSBryan Cantrill
342c9a6ea2eSBryan Cantrill /*ARGSUSED*/
343c9a6ea2eSBryan Cantrill static void
print_tstate_help(uint_t state,const char * name,void * ignored)344c9a6ea2eSBryan Cantrill print_tstate_help(uint_t state, const char *name, void *ignored)
345c9a6ea2eSBryan Cantrill {
346c9a6ea2eSBryan Cantrill mdb_printf(" %s", name);
347c9a6ea2eSBryan Cantrill }
348c9a6ea2eSBryan Cantrill
349c9a6ea2eSBryan Cantrill void
stacks_help(void)350c9a6ea2eSBryan Cantrill stacks_help(void)
351c9a6ea2eSBryan Cantrill {
352c9a6ea2eSBryan Cantrill mdb_printf(
353c9a6ea2eSBryan Cantrill "::stacks processes all of the thread stacks on the system, grouping\n"
354c9a6ea2eSBryan Cantrill "together threads which have the same:\n"
355c9a6ea2eSBryan Cantrill "\n"
356c9a6ea2eSBryan Cantrill " * Thread state,\n"
357c9a6ea2eSBryan Cantrill " * Sync object type, and\n"
358c9a6ea2eSBryan Cantrill " * PCs in their stack trace.\n"
359c9a6ea2eSBryan Cantrill "\n"
360c9a6ea2eSBryan Cantrill "The default output (no address or options) is just a dump of the thread\n"
361c9a6ea2eSBryan Cantrill "groups in the system. For a view of active threads, use \"::stacks -i\",\n"
362c9a6ea2eSBryan Cantrill "which filters out FREE threads (interrupt threads which are currently\n"
363c9a6ea2eSBryan Cantrill "inactive) and threads sleeping on a CV. (Note that those threads may still\n"
364c9a6ea2eSBryan Cantrill "be noteworthy; this is just for a first glance.) More general filtering\n"
365c9a6ea2eSBryan Cantrill "options are described below, in the \"FILTERS\" section.\n"
366c9a6ea2eSBryan Cantrill "\n"
367c9a6ea2eSBryan Cantrill "::stacks can be used in a pipeline. The input to ::stacks is one or more\n"
368c9a6ea2eSBryan Cantrill "thread pointers. For example, to get a summary of threads in a process,\n"
369c9a6ea2eSBryan Cantrill "you can do:\n"
370c9a6ea2eSBryan Cantrill "\n"
371c9a6ea2eSBryan Cantrill " %<b>procp%</b>::walk thread | ::stacks\n"
372c9a6ea2eSBryan Cantrill "\n"
373c9a6ea2eSBryan Cantrill "When output into a pipe, ::stacks prints all of the threads input,\n"
374c9a6ea2eSBryan Cantrill "filtered by the given filtering options. This means that multiple\n"
375c9a6ea2eSBryan Cantrill "::stacks invocations can be piped together to achieve more complicated\n"
376c9a6ea2eSBryan Cantrill "filters. For example, to get threads which have both 'fop_read' and\n"
377c9a6ea2eSBryan Cantrill "'cv_wait_sig_swap' in their stack trace, you could do:\n"
378c9a6ea2eSBryan Cantrill "\n"
379c9a6ea2eSBryan Cantrill " ::stacks -c fop_read | ::stacks -c cv_wait_sig_swap_core\n"
380c9a6ea2eSBryan Cantrill "\n"
381c9a6ea2eSBryan Cantrill "To get the full list of threads in each group, use the '-a' flag:\n"
382c9a6ea2eSBryan Cantrill "\n"
383c9a6ea2eSBryan Cantrill " ::stacks -a\n"
384c9a6ea2eSBryan Cantrill "\n");
385c9a6ea2eSBryan Cantrill mdb_dec_indent(2);
386c9a6ea2eSBryan Cantrill mdb_printf("%<b>OPTIONS%</b>\n");
387c9a6ea2eSBryan Cantrill mdb_inc_indent(2);
388c9a6ea2eSBryan Cantrill mdb_printf("%s",
389c9a6ea2eSBryan Cantrill " -a Print all of the grouped threads, instead of just a count.\n"
390c9a6ea2eSBryan Cantrill " -f Force a re-run of the thread stack gathering.\n"
391c9a6ea2eSBryan Cantrill " -v Be verbose about thread stack gathering.\n"
392c9a6ea2eSBryan Cantrill "\n");
393c9a6ea2eSBryan Cantrill mdb_dec_indent(2);
394c9a6ea2eSBryan Cantrill mdb_printf("%<b>FILTERS%</b>\n");
395c9a6ea2eSBryan Cantrill mdb_inc_indent(2);
396c9a6ea2eSBryan Cantrill mdb_printf("%s",
397c9a6ea2eSBryan Cantrill " -i Show active threads; equivalent to '-S CV -T FREE'.\n"
398c9a6ea2eSBryan Cantrill " -c func[+offset]\n"
399c9a6ea2eSBryan Cantrill " Only print threads whose stacks contain func/func+offset.\n"
400c9a6ea2eSBryan Cantrill " -C func[+offset]\n"
401c9a6ea2eSBryan Cantrill " Only print threads whose stacks do not contain func/func+offset.\n"
402c9a6ea2eSBryan Cantrill " -m module\n"
403c9a6ea2eSBryan Cantrill " Only print threads whose stacks contain functions from module.\n"
404c9a6ea2eSBryan Cantrill " -M module\n"
405c9a6ea2eSBryan Cantrill " Only print threads whose stacks do not contain functions from\n"
406c9a6ea2eSBryan Cantrill " module.\n"
407c9a6ea2eSBryan Cantrill " -s {type | ALL}\n"
408c9a6ea2eSBryan Cantrill " Only print threads which are on a 'type' synchronization object\n"
409c9a6ea2eSBryan Cantrill " (SOBJ).\n"
410c9a6ea2eSBryan Cantrill " -S {type | ALL}\n"
411c9a6ea2eSBryan Cantrill " Only print threads which are not on a 'type' SOBJ.\n"
412c9a6ea2eSBryan Cantrill " -t tstate\n"
413c9a6ea2eSBryan Cantrill " Only print threads which are in thread state 'tstate'.\n"
414c9a6ea2eSBryan Cantrill " -T tstate\n"
415c9a6ea2eSBryan Cantrill " Only print threads which are not in thread state 'tstate'.\n"
416c9a6ea2eSBryan Cantrill "\n");
417c9a6ea2eSBryan Cantrill mdb_printf(" SOBJ types:");
418c9a6ea2eSBryan Cantrill sobj_type_walk(print_sobj_help, NULL);
419c9a6ea2eSBryan Cantrill mdb_printf("\n");
420c9a6ea2eSBryan Cantrill mdb_printf("Thread states:");
421c9a6ea2eSBryan Cantrill thread_walk_states(print_tstate_help, NULL);
422c9a6ea2eSBryan Cantrill mdb_printf(" panic\n");
423c9a6ea2eSBryan Cantrill }
424