libc.c revision 3cd8a1a62a3a0a1219f9dd12e5700e1dff5ca79f
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/*
23 * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26#include <sys/mdb_modapi.h>
27#include <mdb/mdb_whatis.h>
28#include <procfs.h>
29#include <ucontext.h>
30#include <siginfo.h>
31#include <signal.h>
32#include <setjmp.h>
33#include <string.h>
34#include <thr_uberdata.h>
35
36static const char *
37stack_flags(const stack_t *sp)
38{
39	static char buf[32];
40
41	if (sp->ss_flags == 0)
42		(void) strcpy(buf, " 0");
43	else if (sp->ss_flags & ~(SS_ONSTACK | SS_DISABLE))
44		(void) mdb_snprintf(buf, sizeof (buf), " 0x%x", sp->ss_flags);
45	else {
46		buf[0] = '\0';
47		if (sp->ss_flags & SS_ONSTACK)
48			(void) strcat(buf, "|ONSTACK");
49		if (sp->ss_flags & SS_DISABLE)
50			(void) strcat(buf, "|DISABLE");
51	}
52
53	return (buf + 1);
54}
55
56/*ARGSUSED*/
57static int
58d_jmp_buf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
59{
60	jmp_buf jb;
61	const ulong_t *b = (const ulong_t *)jb;
62
63	if (argc != 0)
64		return (DCMD_USAGE);
65
66	if (mdb_vread(&jb, sizeof (jb), addr) != sizeof (jb)) {
67		mdb_warn("failed to read jmp_buf at %p", addr);
68		return (DCMD_ERR);
69	}
70
71#if defined(__sparc)
72	mdb_printf("  %%sp = 0x%lx\n", b[1]);
73	mdb_printf("  %%pc = 0x%lx %lA\n", b[2], b[2]);
74	mdb_printf("  %%fp = 0x%lx\n", b[3]);
75	mdb_printf("  %%i7 = 0x%lx %lA\n", b[4], b[4]);
76#elif defined(__amd64)
77	mdb_printf("  %%rbx = 0x%lx\n", b[0]);
78	mdb_printf("  %%r12 = 0x%lx\n", b[1]);
79	mdb_printf("  %%r13 = 0x%lx\n", b[2]);
80	mdb_printf("  %%r14 = 0x%lx\n", b[3]);
81	mdb_printf("  %%r15 = 0x%lx\n", b[4]);
82	mdb_printf("  %%rbp = 0x%lx\n", b[5]);
83	mdb_printf("  %%rsp = 0x%lx\n", b[6]);
84	mdb_printf("  %%rip = 0x%lx %lA\n", b[7], b[7]);
85#elif defined(__i386)
86	mdb_printf("  %%ebx = 0x%lx\n", b[0]);
87	mdb_printf("  %%esi = 0x%lx\n", b[1]);
88	mdb_printf("  %%edi = 0x%lx\n", b[2]);
89	mdb_printf("  %%ebp = 0x%lx\n", b[3]);
90	mdb_printf("  %%esp = 0x%lx\n", b[4]);
91	mdb_printf("  %%eip = 0x%lx %lA\n", b[5], b[5]);
92#endif
93	return (DCMD_OK);
94}
95
96/*ARGSUSED*/
97static int
98d_ucontext(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
99{
100	ucontext_t uc;
101
102	if (argc != 0)
103		return (DCMD_USAGE);
104
105	if (mdb_vread(&uc, sizeof (uc), addr) != sizeof (uc)) {
106		mdb_warn("failed to read ucontext at %p", addr);
107		return (DCMD_ERR);
108	}
109
110	mdb_printf("  flags    = 0x%lx\n", uc.uc_flags);
111	mdb_printf("  link     = 0x%p\n", uc.uc_link);
112	mdb_printf("  sigmask  = 0x%08x 0x%08x 0x%08x 0x%08x\n",
113	    uc.uc_sigmask.__sigbits[0], uc.uc_sigmask.__sigbits[1],
114	    uc.uc_sigmask.__sigbits[2], uc.uc_sigmask.__sigbits[3]);
115	mdb_printf("  stack    = sp 0x%p size 0x%lx flags %s\n",
116	    uc.uc_stack.ss_sp, uc.uc_stack.ss_size, stack_flags(&uc.uc_stack));
117	mdb_printf("  mcontext = 0x%p\n",
118	    addr + OFFSETOF(ucontext_t, uc_mcontext));
119
120	return (DCMD_OK);
121}
122
123/*ARGSUSED*/
124static int
125d_sigjmp_buf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
126{
127#if defined(__sparc)
128	struct {
129		int sjs_flags;
130		greg_t sjs_sp;
131		greg_t sjs_pc;
132		greg_t sjs_fp;
133		greg_t sjs_i7;
134		ucontext_t *sjs_uclink;
135		ulong_t sjs_pad[_JBLEN - 6];
136		sigset_t sjs_sigmask;
137#if defined(_LP64)
138		greg_t sjs_asi;
139		greg_t sjs_fprs;
140#endif
141		stack_t sjs_stack;
142	} s;
143
144	if (argc != 0)
145		return (DCMD_USAGE);
146
147	if (mdb_vread(&s, sizeof (s), addr) != sizeof (s)) {
148		mdb_warn("failed to read sigjmp_buf at %p", addr);
149		return (DCMD_ERR);
150	}
151
152	mdb_printf("  flags  = 0x%x\n", s.sjs_flags);
153	mdb_printf("  %%sp    = 0x%lx %lA\n", s.sjs_sp, s.sjs_sp);
154	mdb_printf("  %%pc    = 0x%lx %lA\n", s.sjs_pc, s.sjs_pc);
155	mdb_printf("  %%fp    = 0x%lx %lA\n", s.sjs_fp, s.sjs_fp);
156	mdb_printf("  %%i7    = 0x%lx %lA\n", s.sjs_i7, s.sjs_i7);
157	mdb_printf("  uclink = %p\n", s.sjs_uclink);
158	mdb_printf("  sigset = 0x%08x 0x%08x 0x%08x 0x%08x\n",
159	    s.sjs_sigmask.__sigbits[0], s.sjs_sigmask.__sigbits[1],
160	    s.sjs_sigmask.__sigbits[2], s.sjs_sigmask.__sigbits[3]);
161#if defined(_LP64)
162	mdb_printf("  %%asi   = 0x%lx\n", s.sjs_asi);
163	mdb_printf("  %%fprs  = 0x%lx\n", s.sjs_fprs);
164#endif
165	mdb_printf("  stack  = sp 0x%p size 0x%lx flags %s\n",
166	    s.sjs_stack.ss_sp, s.sjs_stack.ss_size, stack_flags(&s.sjs_stack));
167
168	return (DCMD_OK);
169
170#elif defined(__i386) || defined(__amd64)
171	return (d_ucontext(addr, flags, argc, argv));
172#endif
173}
174
175/*ARGSUSED*/
176static int
177d_siginfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
178{
179	static const char *const msname[] = {
180		"USER", "SYSTEM", "TRAP", "TFAULT", "DFAULT", "KFAULT",
181		"USER_LOCK", "SLEEP", "WAIT_CPU", "STOPPED"
182	};
183
184	char signame[SIG2STR_MAX];
185	siginfo_t si;
186	int i;
187
188	if (argc != 0)
189		return (DCMD_USAGE);
190
191	if (mdb_vread(&si, sizeof (si), addr) != sizeof (si)) {
192		mdb_warn("failed to read siginfo at %p", addr);
193		return (DCMD_ERR);
194	}
195
196	if (sig2str(si.si_signo, signame) == -1)
197		(void) strcpy(signame, "unknown");
198
199	mdb_printf("  signal %5d (%s)\n", si.si_signo, signame);
200	mdb_printf("  code   %5d (", si.si_code);
201
202	switch (si.si_code) {
203	case SI_NOINFO:
204		mdb_printf("no info");
205		break;
206	case SI_DTRACE:
207		mdb_printf("from DTrace raise() action");
208		break;
209	case SI_RCTL:
210		mdb_printf("from rctl action");
211		break;
212	case SI_USER:
213		mdb_printf("user generated via kill");
214		break;
215	case SI_LWP:
216		mdb_printf("user generated via lwp_kill");
217		break;
218	case SI_QUEUE:
219		mdb_printf("user generated via sigqueue");
220		break;
221	case SI_TIMER:
222		mdb_printf("from timer expiration");
223		break;
224	case SI_ASYNCIO:
225		mdb_printf("from async i/o completion");
226		break;
227	case SI_MESGQ:
228		mdb_printf("from message arrival");
229		break;
230	default:
231		if (SI_FROMUSER(&si))
232			mdb_printf("from user process");
233		else
234			mdb_printf("from kernel");
235	}
236
237	mdb_printf(")\n  errno  %5d (%s)\n",
238	    si.si_errno, strerror(si.si_errno));
239
240	if (si.si_code == SI_USER || si.si_code == SI_QUEUE) {
241		mdb_printf("  signal sent from PID %d (uid %d)\n",
242		    si.si_pid, si.si_uid);
243	}
244
245	if (si.si_code == SI_QUEUE) {
246		mdb_printf("  signal value = 0t%d / %p\n",
247		    si.si_value.sival_int, si.si_value.sival_ptr);
248	}
249
250	switch (si.si_signo) {
251	case SIGCLD:
252		mdb_printf("  signal sent from child PID %d (uid %d)\n",
253		    si.si_pid, si.si_uid);
254		mdb_printf("  usr time = 0t%ld ticks, sys time = 0t%ld ticks\n",
255		    si.si_utime, si.si_stime);
256		mdb_printf("  wait status = 0x%x\n", si.si_status);
257		break;
258
259	case SIGSEGV:
260	case SIGBUS:
261	case SIGILL:
262	case SIGTRAP:
263	case SIGFPE:
264		mdb_printf("  fault address = 0x%p\n  trapno = %d\n",
265		    si.si_addr, si.si_trapno);
266		mdb_printf("  instruction address = 0x%p %lA\n",
267		    si.si_pc, si.si_pc);
268		break;
269
270	case SIGPOLL:
271	case SIGXFSZ:
272		mdb_printf("  fd = %d  band = 0x%lx\n",
273		    si.si_fd, si.si_band);
274		break;
275
276	case SIGPROF:
277		mdb_printf("  last fault address = 0x%p fault type = %d\n",
278		    si.si_faddr, si.si_fault);
279		mdb_printf("  timestamp = 0t%ld sec 0t%ld nsec\n",
280		    si.si_tstamp.tv_sec, si.si_tstamp.tv_nsec);
281
282		if (si.__data.__prof.__syscall != 0) {
283			mdb_printf("  system call %d (", si.si_syscall);
284			if (si.si_nsysarg > 0) {
285				mdb_printf("%lx", si.si_sysarg[0]);
286				for (i = 1; i < si.si_nsysarg; i++)
287					mdb_printf(", %lx", si.si_sysarg[i]);
288			}
289			mdb_printf("  )\n");
290		}
291
292		for (i = 0; i < sizeof (msname) / sizeof (msname[0]); i++) {
293			mdb_printf("  mstate[\"%s\"] = %d\n",
294			    msname[i], si.si_mstate[i]);
295		}
296		break;
297	}
298
299	return (DCMD_OK);
300}
301
302static int
303uc_walk_step(mdb_walk_state_t *wsp)
304{
305	uintptr_t addr = wsp->walk_addr;
306	ucontext_t uc;
307
308	if (addr == NULL)
309		return (WALK_DONE);
310
311	if (mdb_vread(&uc, sizeof (uc), addr) != sizeof (uc)) {
312		mdb_warn("failed to read ucontext at %p", addr);
313		return (WALK_ERR);
314	}
315
316	wsp->walk_addr = (uintptr_t)uc.uc_link;
317	return (wsp->walk_callback(addr, &uc, wsp->walk_cbdata));
318}
319
320static int
321oldc_walk_init(mdb_walk_state_t *wsp)
322{
323	ssize_t nbytes = mdb_get_xdata("lwpstatus", NULL, 0);
324
325	if (nbytes <= 0) {
326		mdb_warn("lwpstatus information not available");
327		return (WALK_ERR);
328	}
329
330	if (wsp->walk_addr != NULL) {
331		mdb_warn("walker only supports global walk\n");
332		return (WALK_ERR);
333	}
334
335	wsp->walk_addr = nbytes; /* Use walk_addr to track size */
336	wsp->walk_data = mdb_alloc(nbytes, UM_SLEEP);
337
338	if (mdb_get_xdata("lwpstatus", wsp->walk_data, nbytes) != nbytes) {
339		mdb_warn("failed to read lwpstatus information");
340		mdb_free(wsp->walk_data, nbytes);
341		return (WALK_ERR);
342	}
343
344	wsp->walk_arg = wsp->walk_data; /* Use walk_arg to track pointer */
345	return (WALK_NEXT);
346}
347
348static int
349oldc_walk_step(mdb_walk_state_t *wsp)
350{
351	const lwpstatus_t *lsp, *end;
352
353	end = (const lwpstatus_t *)((uintptr_t)wsp->walk_data + wsp->walk_addr);
354	lsp = wsp->walk_arg;
355
356	wsp->walk_arg = (void *)(lsp + 1);
357
358	if (lsp < end) {
359		uintptr_t addr = lsp->pr_oldcontext;
360		ucontext_t uc;
361
362		if (addr == NULL)
363			return (WALK_NEXT);
364
365		if (mdb_vread(&uc, sizeof (uc), addr) != sizeof (uc)) {
366			mdb_warn("failed to read ucontext at %p", addr);
367			return (WALK_NEXT);
368		}
369
370		return (wsp->walk_callback(addr, &uc, wsp->walk_cbdata));
371	}
372
373	return (WALK_DONE);
374}
375
376static void
377oldc_walk_fini(mdb_walk_state_t *wsp)
378{
379	mdb_free(wsp->walk_data, wsp->walk_addr); /* walk_addr has size */
380}
381
382/*
383 * ==================== threads ==========================
384 * These are the interfaces that used to require libthread.
385 * Now, libthread has been folded into libc.
386 * =======================================================
387 */
388
389/*
390 * prt_addr() is called up to three times to generate arguments for
391 * one call to mdb_printf().  We must return at least three different
392 * pointers to static storage for consecutive calls to prt_addr().
393 */
394static const char *
395prt_addr(void *addr, int pad)
396{
397	static char buffer[4][24];
398	static int ix = 0;
399	char *buf;
400
401	if (ix == 4)	/* use buffers in sequence: 0, 1, 2, 3 */
402		ix = 0;
403	buf = buffer[ix++];
404	if (addr == NULL)
405		return (pad? "<NULL>               " : "<NULL>");
406	else {
407#ifdef _LP64
408		(void) mdb_snprintf(buf, sizeof (buffer[0]), "0x%016lx", addr);
409		if (pad)
410			(void) strcpy(buf + 18, "   ");
411#else
412		(void) mdb_snprintf(buf, sizeof (buffer[0]), "0x%08lx", addr);
413		if (pad)
414			(void) strcpy(buf + 10, "           ");
415#endif	/* _LP64 */
416		return (buf);
417	}
418}
419
420#define	HD(str)		mdb_printf("           " str "\n")
421#define	OFFSTR		"+0x%-7lx "
422#define	OFFSET(member)	((size_t)OFFSETOF(ulwp_t, member))
423
424/*ARGSUSED*/
425static int
426d_ulwp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
427{
428	ulwp_t ulwp;
429
430	if (argc != 0 || !(flags & DCMD_ADDRSPEC))
431		return (DCMD_USAGE);
432
433	if (mdb_vread(&ulwp, sizeof (ulwp), addr) != sizeof (ulwp) &&
434	    (bzero(&ulwp, sizeof (ulwp)),
435	    mdb_vread(&ulwp, REPLACEMENT_SIZE, addr)) != REPLACEMENT_SIZE) {
436		mdb_warn("failed to read ulwp at 0x%p", addr);
437		return (DCMD_ERR);
438	}
439
440	mdb_printf("%#a\n", addr);
441
442	HD("self                  uberdata");
443	mdb_printf(OFFSTR "%s %s\n",
444	    OFFSET(ul_self),
445	    prt_addr(ulwp.ul_self, 1),
446	    prt_addr(ulwp.ul_uberdata, 0));
447
448	HD("tlsent                ntlsent");
449	mdb_printf(OFFSTR "%s %ld\n",
450	    OFFSET(ul_tlsent),
451	    prt_addr(ulwp.ul_tlsent, 1),
452	    ulwp.ul_ntlsent);
453
454	HD("forw                  back                  next");
455	mdb_printf(OFFSTR "%s %s %s\n",
456	    OFFSET(ul_forw),
457	    prt_addr(ulwp.ul_forw, 1),
458	    prt_addr(ulwp.ul_back, 1),
459	    prt_addr(ulwp.ul_next, 0));
460
461	HD("hash                  rval                  stk");
462	mdb_printf(OFFSTR "%s %s %s\n",
463	    OFFSET(ul_hash),
464	    prt_addr(ulwp.ul_hash, 1),
465	    prt_addr(ulwp.ul_rval, 1),
466	    prt_addr(ulwp.ul_stk, 0));
467
468	HD("mapsiz     guardsize  stktop                stksiz");
469	mdb_printf(OFFSTR "%-10ld %-10ld %s %ld\n",
470	    OFFSET(ul_mapsiz),
471	    ulwp.ul_mapsiz,
472	    ulwp.ul_guardsize,
473	    prt_addr((void *)ulwp.ul_stktop, 1),
474	    ulwp.ul_stksiz);
475
476	HD("ustack.ss_sp          ustack.ss_size        ustack.ss_flags");
477	mdb_printf(OFFSTR "%s %-21ld %s\n",
478	    OFFSET(ul_ustack.ss_sp),
479	    prt_addr(ulwp.ul_ustack.ss_sp, 1),
480	    ulwp.ul_ustack.ss_size,
481	    stack_flags(&ulwp.ul_ustack));
482
483	HD("ix         lwpid      pri        epri       policy     cid");
484	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
485	    OFFSET(ul_ix),
486	    ulwp.ul_ix,
487	    ulwp.ul_lwpid,
488	    ulwp.ul_pri,
489	    ulwp.ul_epri,
490	    ulwp.ul_policy,
491	    ulwp.ul_cid);
492
493	HD("cursig     pleasestop stop       signalled  dead       unwind");
494	mdb_printf(OFFSTR "%-10d ",
495	    OFFSET(ul_cursig),
496	    ulwp.ul_cursig);
497	mdb_printf(ulwp.ul_pleasestop? "0x%-8x " : "%-10d ",
498	    ulwp.ul_pleasestop);
499	mdb_printf(ulwp.ul_stop? "0x%-8x " : "%-10d ",
500	    ulwp.ul_stop);
501	mdb_printf("%-10d %-10d %d\n",
502	    ulwp.ul_signalled,
503	    ulwp.ul_dead,
504	    ulwp.ul_unwind);
505
506	HD("detached   writer     stopping   can'prolog preempt    savpreempt");
507	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
508	    OFFSET(ul_detached),
509	    ulwp.ul_detached,
510	    ulwp.ul_writer,
511	    ulwp.ul_stopping,
512	    ulwp.ul_cancel_prologue,
513	    ulwp.ul_preempt,
514	    ulwp.ul_savpreempt);
515
516	HD("sigsuspend main       fork       primarymap m'spinners d'noreserv");
517	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
518	    OFFSET(ul_sigsuspend),
519	    ulwp.ul_sigsuspend,
520	    ulwp.ul_main,
521	    ulwp.ul_fork,
522	    ulwp.ul_primarymap,
523	    ulwp.ul_max_spinners,
524	    ulwp.ul_door_noreserve);
525
526	HD("queue_fifo c'w'defer  e'detect'  async_safe rt         rtqueued");
527	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
528	    OFFSET(ul_queue_fifo),
529	    ulwp.ul_queue_fifo,
530	    ulwp.ul_cond_wait_defer,
531	    ulwp.ul_error_detection,
532	    ulwp.ul_async_safe,
533	    ulwp.ul_rt,
534	    ulwp.ul_rtqueued);
535
536	HD("misaligned adapt'spin queue_spin critical   sigdefer   vfork");
537	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
538	    OFFSET(ul_misaligned),
539	    ulwp.ul_misaligned,
540	    ulwp.ul_adaptive_spin,
541	    ulwp.ul_queue_spin,
542	    ulwp.ul_critical,
543	    ulwp.ul_sigdefer,
544	    ulwp.ul_vfork);
545
546	HD("cancelable c'pending  c'disabled c'async    save_async mutator");
547	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
548	    OFFSET(ul_cancelable),
549	    ulwp.ul_cancelable,
550	    ulwp.ul_cancel_pending,
551	    ulwp.ul_cancel_disabled,
552	    ulwp.ul_cancel_async,
553	    ulwp.ul_save_async,
554	    ulwp.ul_mutator);
555
556	HD("created    replace    nocancel   errno      errnop");
557	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %s\n",
558	    OFFSET(ul_created),
559	    ulwp.ul_created,
560	    ulwp.ul_replace,
561	    ulwp.ul_nocancel,
562	    ulwp.ul_errno,
563	    prt_addr(ulwp.ul_errnop, 0));
564
565	HD("clnup_hdr             schedctl_called       schedctl");
566	mdb_printf(OFFSTR "%s %s %s\n",
567	    OFFSET(ul_clnup_hdr),
568	    prt_addr(ulwp.ul_clnup_hdr, 1),
569	    prt_addr(ulwp.ul_schedctl_called, 1),
570	    prt_addr((void *)ulwp.ul_schedctl, 0));
571
572	HD("bindflags  libc_locks stsd                  &ftsd");
573	mdb_printf(OFFSTR,
574	    OFFSET(ul_bindflags));
575	mdb_printf(ulwp.ul_bindflags? "0x%-8x " : "%-10d ",
576	    ulwp.ul_bindflags);
577	mdb_printf("%-10d ", ulwp.ul_libc_locks);
578	mdb_printf("%s %s\n",
579	    prt_addr(ulwp.ul_stsd, 1),
580	    prt_addr((void *)(addr + OFFSET(ul_ftsd[0])), 0));
581
582	HD("eventmask[0..1]       eventnum              eventdata");
583	mdb_printf(OFFSTR "0x%08x 0x%08x %-21d %s\n",
584	    OFFSET(ul_td_evbuf.eventmask.event_bits[0]),
585	    ulwp.ul_td_evbuf.eventmask.event_bits[0],
586	    ulwp.ul_td_evbuf.eventmask.event_bits[1],
587	    ulwp.ul_td_evbuf.eventnum,
588	    prt_addr(ulwp.ul_td_evbuf.eventdata, 0));
589
590	HD("td'enable  sync'reg   qtype      cv_wake    rtld       usropts");
591	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d ",
592	    OFFSET(ul_td_events_enable),
593	    ulwp.ul_td_events_enable,
594	    ulwp.ul_sync_obj_reg,
595	    ulwp.ul_qtype,
596	    ulwp.ul_cv_wake,
597	    ulwp.ul_rtld);
598	mdb_printf(ulwp.ul_usropts? "0x%x\n" : "%d\n",
599	    ulwp.ul_usropts);
600
601	HD("startpc               startarg              wchan");
602	mdb_printf(OFFSTR "%s %s %s\n",
603	    OFFSET(ul_startpc),
604	    prt_addr((void *)ulwp.ul_startpc, 1),
605	    prt_addr(ulwp.ul_startarg, 1),
606	    prt_addr(ulwp.ul_wchan, 0));
607
608	HD("link                  sleepq                cvmutex");
609	mdb_printf(OFFSTR "%s %s %s\n",
610	    OFFSET(ul_link),
611	    prt_addr(ulwp.ul_link, 1),
612	    prt_addr(ulwp.ul_sleepq, 1),
613	    prt_addr(ulwp.ul_cvmutex, 0));
614
615	HD("mxchain               save_state");
616	mdb_printf(OFFSTR "%s %d\n",
617	    OFFSET(ul_mxchain),
618	    prt_addr(ulwp.ul_mxchain, 1),
619	    ulwp.ul_save_state);
620
621	HD("rdlockcnt             rd_rwlock             rd_count");
622	mdb_printf(OFFSTR "%-21d %s %d\n",
623	    OFFSET(ul_rdlockcnt),
624	    ulwp.ul_rdlockcnt,
625	    prt_addr(ulwp.ul_readlock.single.rd_rwlock, 1),
626	    ulwp.ul_readlock.single.rd_count);
627
628	HD("heldlockcnt           heldlocks             tpdp");
629	mdb_printf(OFFSTR "%-21d %s %s\n",
630	    OFFSET(ul_heldlockcnt),
631	    ulwp.ul_heldlockcnt,
632	    prt_addr(ulwp.ul_heldlocks.single, 1),
633	    prt_addr(ulwp.ul_tpdp, 0));
634
635	HD("siglink               s'l'spin   s'l'spin2  s'l'sleep  s'l'wakeup");
636	mdb_printf(OFFSTR "%s %-10d %-10d %-10d %d\n",
637	    OFFSET(ul_siglink),
638	    prt_addr(ulwp.ul_siglink, 1),
639	    ulwp.ul_spin_lock_spin,
640	    ulwp.ul_spin_lock_spin2,
641	    ulwp.ul_spin_lock_sleep,
642	    ulwp.ul_spin_lock_wakeup);
643
644	HD("&queue_root           rtclassid  pilocks");
645	mdb_printf(OFFSTR "%s %-10d %d\n",
646	    OFFSET(ul_queue_root),
647	    prt_addr((void *)(addr + OFFSET(ul_queue_root)), 1),
648	    ulwp.ul_rtclassid,
649	    ulwp.ul_pilocks);
650
651	/*
652	 * The remainder of the ulwp_t structure
653	 * is invalid if this is a replacement.
654	 */
655	if (ulwp.ul_replace)
656		return (DCMD_OK);
657
658	HD("sigmask[0..3]");
659	mdb_printf(OFFSTR "0x%08x 0x%08x 0x%08x 0x%08x\n",
660	    OFFSET(ul_sigmask.__sigbits[0]),
661	    ulwp.ul_sigmask.__sigbits[0],
662	    ulwp.ul_sigmask.__sigbits[1],
663	    ulwp.ul_sigmask.__sigbits[2],
664	    ulwp.ul_sigmask.__sigbits[3]);
665
666	HD("tmpmask[0..3]");
667	mdb_printf(OFFSTR "0x%08x 0x%08x 0x%08x 0x%08x\n",
668	    OFFSET(ul_tmpmask.__sigbits[0]),
669	    ulwp.ul_tmpmask.__sigbits[0],
670	    ulwp.ul_tmpmask.__sigbits[1],
671	    ulwp.ul_tmpmask.__sigbits[2],
672	    ulwp.ul_tmpmask.__sigbits[3]);
673
674	HD("&siginfo              &spinlock             &fpuenv");
675	mdb_printf(OFFSTR "%s %s %s\n",
676	    OFFSET(ul_siginfo),
677	    prt_addr((void *)(addr + OFFSET(ul_siginfo)), 1),
678	    prt_addr((void *)(addr + OFFSET(ul_spinlock)), 1),
679	    prt_addr((void *)(addr + OFFSET(ul_fpuenv)), 0));
680
681	return (DCMD_OK);
682}
683
684/*
685 * Get the address of the unique uberdata_t structure.
686 */
687static uintptr_t
688uberdata_addr(void)
689{
690	uintptr_t uaddr;
691	uintptr_t addr;
692	GElf_Sym sym;
693
694	if (mdb_lookup_by_obj("libc.so.1", "_tdb_bootstrap", &sym) != 0) {
695		mdb_warn("cannot find libc.so.1`_tdb_bootstrap");
696		return (NULL);
697	}
698	if (mdb_vread(&addr, sizeof (addr), sym.st_value) == sizeof (addr) &&
699	    addr != NULL &&
700	    mdb_vread(&uaddr, sizeof (uaddr), addr) == sizeof (uaddr) &&
701	    uaddr != NULL) {
702		return (uaddr);
703	}
704	if (mdb_lookup_by_obj("libc.so.1", "_uberdata", &sym) != 0) {
705		mdb_warn("cannot find libc.so.1`_uberdata");
706		return (NULL);
707	}
708	return ((uintptr_t)sym.st_value);
709}
710
711#undef OFFSET
712#define	OFFSET(member)	((size_t)OFFSETOF(uberdata_t, member))
713
714/*ARGSUSED*/
715static int
716d_uberdata(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
717{
718	uberdata_t uberdata;
719	int i;
720
721	if (argc != 0)
722		return (DCMD_USAGE);
723	if (!(flags & DCMD_ADDRSPEC) && (addr = uberdata_addr()) == NULL)
724		return (DCMD_ERR);
725
726	if (mdb_vread(&uberdata, sizeof (uberdata), addr) !=
727	    sizeof (uberdata)) {
728		mdb_warn("failed to read uberdata at 0x%p", addr);
729		return (DCMD_ERR);
730	}
731
732	mdb_printf("%#a\n", addr);
733
734	HD("&link_lock            &ld_lock              &fork_lock");
735	mdb_printf(OFFSTR "%s %s %s\n",
736	    OFFSET(link_lock),
737	    prt_addr((void *)(addr + OFFSET(link_lock)), 1),
738	    prt_addr((void *)(addr + OFFSET(ld_lock)), 1),
739	    prt_addr((void *)(addr + OFFSET(fork_lock)), 0));
740
741	HD("&atfork_lock          &callout_lock         &tdb_hash_lock");
742	mdb_printf(OFFSTR "%s %s %s\n",
743	    OFFSET(atfork_lock),
744	    prt_addr((void *)(addr + OFFSET(atfork_lock)), 1),
745	    prt_addr((void *)(addr + OFFSET(callout_lock)), 1),
746	    prt_addr((void *)(addr + OFFSET(tdb_hash_lock)), 0));
747
748	HD("&tdb_hash_lock_stats  &siguaction[0]");
749	mdb_printf(OFFSTR "%s %s\n",
750	    OFFSET(tdb_hash_lock_stats),
751	    prt_addr((void *)(addr + OFFSET(tdb_hash_lock_stats)), 1),
752	    prt_addr((void *)(addr + OFFSET(siguaction)), 0));
753
754	HD("&bucket               free_list             chunks");
755	for (i = 0; i < NBUCKETS; i++) {
756		mdb_printf(OFFSTR "%s %s %ld\n",
757		    OFFSET(bucket[i]),
758		    prt_addr((void *)(addr + OFFSET(bucket[i])), 1),
759		    prt_addr(uberdata.bucket[i].free_list, 1),
760		    uberdata.bucket[i].chunks);
761	}
762
763	HD("&atexit_root          head                  exit_frame_monitor");
764	mdb_printf(OFFSTR "%s %s %s\n",
765	    OFFSET(atexit_root),
766	    prt_addr((void *)(addr + OFFSET(atexit_root.exitfns_lock)), 1),
767	    prt_addr(uberdata.atexit_root.head, 1),
768	    prt_addr(uberdata.atexit_root.exit_frame_monitor, 0));
769
770	HD("&tsd_metadata         tsdm_nkeys tsdm_nused tsdm_destro");
771	mdb_printf(OFFSTR "%s %-10d %-10d %s\n",
772	    OFFSET(tsd_metadata),
773	    prt_addr((void *)(addr + OFFSET(tsd_metadata.tsdm_lock)), 1),
774	    uberdata.tsd_metadata.tsdm_nkeys,
775	    uberdata.tsd_metadata.tsdm_nused,
776	    prt_addr((void *)uberdata.tsd_metadata.tsdm_destro, 0));
777
778	HD("&tls_metadata         tls_modinfo.data      tls_modinfo.size");
779	mdb_printf(OFFSTR "%s %s %ld\n",
780	    OFFSET(tls_metadata),
781	    prt_addr((void *)(addr + OFFSET(tls_metadata.tls_lock)), 1),
782	    prt_addr(uberdata.tls_metadata.tls_modinfo.tls_data, 1),
783	    uberdata.tls_metadata.tls_modinfo.tls_size);
784
785	HD("                      static_tls.data       static_tls.size");
786	mdb_printf(OFFSTR "%s %s %ld\n",
787	    OFFSET(tls_metadata.static_tls),
788	    "                     ",
789	    prt_addr(uberdata.tls_metadata.static_tls.tls_data, 1),
790	    uberdata.tls_metadata.static_tls.tls_size);
791
792	HD("primary_ma bucket_ini uflags.mt  uflags.pad uflags.trs uflags.ted");
793	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
794	    OFFSET(primary_map),
795	    uberdata.primary_map,
796	    uberdata.bucket_init,
797	    uberdata.uberflags.uf_x.x_mt,
798	    uberdata.uberflags.uf_x.x_pad,
799	    uberdata.uberflags.uf_x.x_tdb_register_sync,
800	    uberdata.uberflags.uf_x.x_thread_error_detection);
801
802	HD("queue_head            thr_hash_table        hash_size  hash_mask");
803	mdb_printf(OFFSTR "%s %s %-10d 0x%x\n",
804	    OFFSET(queue_head),
805	    prt_addr(uberdata.queue_head, 1),
806	    prt_addr(uberdata.thr_hash_table, 1),
807	    uberdata.hash_size,
808	    uberdata.hash_mask);
809
810	HD("ulwp_one              all_lwps              all_zombies");
811	mdb_printf(OFFSTR "%s %s %s\n",
812	    OFFSET(ulwp_one),
813	    prt_addr(uberdata.ulwp_one, 1),
814	    prt_addr(uberdata.all_lwps, 1),
815	    prt_addr(uberdata.all_zombies, 0));
816
817	HD("nthreads   nzombies   ndaemons   pid        sigacthandler");
818	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %s\n",
819	    OFFSET(nthreads),
820	    uberdata.nthreads,
821	    uberdata.nzombies,
822	    uberdata.ndaemons,
823	    (int)uberdata.pid,
824	    prt_addr((void *)uberdata.sigacthandler, 0));
825
826	HD("lwp_stacks            lwp_laststack         nfreestack stk_cache");
827	mdb_printf(OFFSTR "%s %s %-10d %d\n",
828	    OFFSET(lwp_stacks),
829	    prt_addr(uberdata.lwp_stacks, 1),
830	    prt_addr(uberdata.lwp_laststack, 1),
831	    uberdata.nfreestack,
832	    uberdata.thread_stack_cache);
833
834	HD("ulwp_freelist         ulwp_lastfree         ulwp_replace_free");
835	mdb_printf(OFFSTR "%s %s %s\n",
836	    OFFSET(ulwp_freelist),
837	    prt_addr(uberdata.ulwp_freelist, 1),
838	    prt_addr(uberdata.ulwp_lastfree, 1),
839	    prt_addr(uberdata.ulwp_replace_free, 0));
840
841	HD("ulwp_replace_last     atforklist");
842	mdb_printf(OFFSTR "%s %s\n",
843	    OFFSET(ulwp_replace_last),
844	    prt_addr(uberdata.ulwp_replace_last, 1),
845	    prt_addr(uberdata.atforklist, 0));
846
847	HD("robustlocks           robustlist");
848	mdb_printf(OFFSTR "%s %s\n",
849	    OFFSET(robustlocks),
850	    prt_addr(uberdata.robustlocks, 1),
851	    prt_addr(uberdata.robustlist, 0));
852
853	HD("tdb_bootstrap         tdb_sync_addr_hash    tdb_'count tdb_'fail");
854	mdb_printf(OFFSTR "%s %s %-10d %d\n",
855	    OFFSET(tdb_bootstrap),
856	    prt_addr(uberdata.tdb_bootstrap, 1),
857	    prt_addr(uberdata.tdb.tdb_sync_addr_hash, 1),
858	    uberdata.tdb.tdb_register_count,
859	    uberdata.tdb.tdb_hash_alloc_failed);
860
861	HD("tdb_sync_addr_free    tdb_sync_addr_last    tdb_sync_alloc");
862	mdb_printf(OFFSTR "%s %s %ld\n",
863	    OFFSET(tdb.tdb_sync_addr_free),
864	    prt_addr(uberdata.tdb.tdb_sync_addr_free, 1),
865	    prt_addr(uberdata.tdb.tdb_sync_addr_last, 1),
866	    uberdata.tdb.tdb_sync_alloc);
867
868	HD("tdb_ev_global_mask    tdb_events");
869	mdb_printf(OFFSTR "0x%08x 0x%08x %s\n",
870	    OFFSET(tdb.tdb_ev_global_mask),
871	    uberdata.tdb.tdb_ev_global_mask.event_bits[0],
872	    uberdata.tdb.tdb_ev_global_mask.event_bits[1],
873	    prt_addr((void *)uberdata.tdb.tdb_events, 0));
874
875	return (DCMD_OK);
876}
877
878static int
879ulwp_walk_init(mdb_walk_state_t *wsp)
880{
881	uintptr_t addr = wsp->walk_addr;
882	uintptr_t uber_addr;
883
884	if (addr == NULL &&
885	    ((uber_addr = uberdata_addr()) == NULL ||
886	    mdb_vread(&addr, sizeof (addr),
887	    uber_addr + OFFSETOF(uberdata_t, all_lwps))
888	    != sizeof (addr))) {
889		mdb_warn("cannot find 'uberdata.all_lwps'");
890		return (WALK_ERR);
891	}
892	if (addr == NULL)
893		return (WALK_DONE);
894	wsp->walk_addr = addr;
895	wsp->walk_data = (void *)addr;
896	return (WALK_NEXT);
897}
898
899static int
900ulwp_walk_step(mdb_walk_state_t *wsp)
901{
902	uintptr_t addr = wsp->walk_addr;
903	ulwp_t ulwp;
904
905	if (addr == NULL)
906		return (WALK_DONE);
907	if (mdb_vread(&ulwp, sizeof (ulwp), addr) != sizeof (ulwp) &&
908	    (bzero(&ulwp, sizeof (ulwp)),
909	    mdb_vread(&ulwp, REPLACEMENT_SIZE, addr)) != REPLACEMENT_SIZE) {
910		mdb_warn("failed to read ulwp at 0x%p", addr);
911		return (WALK_ERR);
912	}
913	/*
914	 * If we have looped around to the beginning
915	 * of the circular linked list, we are done.
916	 */
917	if ((wsp->walk_addr = (uintptr_t)ulwp.ul_forw)
918	    == (uintptr_t)wsp->walk_data)
919		wsp->walk_addr = NULL;
920	return (wsp->walk_callback(addr, &ulwp, wsp->walk_cbdata));
921}
922
923/* Avoid classifying NULL pointers as part of the main stack on x86 */
924#define	MIN_STACK_ADDR		(0x10000ul)
925
926static int
927whatis_walk_ulwp(uintptr_t addr, const ulwp_t *ulwp, mdb_whatis_t *w)
928{
929	uintptr_t cur;
930	lwpid_t id = ulwp->ul_lwpid;
931	uintptr_t top, base, size;
932
933	while (mdb_whatis_match(w, addr, sizeof (ulwp_t), &cur))
934		mdb_whatis_report_object(w, cur, addr,
935		    "allocated as thread %#r's ulwp_t\n", id);
936
937	top = (uintptr_t)ulwp->ul_stktop;
938	size = ulwp->ul_stksiz;
939
940	/*
941	 * The main stack ends up being a little weird, especially if
942	 * the stack ulimit is unlimited.  This tries to take that into
943	 * account.
944	 */
945	if (size > top)
946		size = top;
947	if (top > MIN_STACK_ADDR && top - size < MIN_STACK_ADDR)
948		size = top - MIN_STACK_ADDR;
949
950	base = top - size;
951
952	while (mdb_whatis_match(w, base, size, &cur))
953		mdb_whatis_report_address(w, cur, "in [ stack tid=%#r ]\n", id);
954
955	if (ulwp->ul_ustack.ss_flags & SS_ONSTACK) {
956		base = (uintptr_t)ulwp->ul_ustack.ss_sp;
957		size = ulwp->ul_ustack.ss_size;
958
959		while (mdb_whatis_match(w, base, size, &cur))
960			mdb_whatis_report_address(w, cur,
961			    "in [ altstack tid=%#r ]\n", id);
962	}
963
964	return (WHATIS_WALKRET(w));
965}
966
967/*ARGSUSED*/
968static int
969whatis_run_ulwps(mdb_whatis_t *w, void *arg)
970{
971	if (mdb_walk("ulwps", (mdb_walk_cb_t)whatis_walk_ulwp, w) == -1) {
972		mdb_warn("couldn't find ulwps walker");
973		return (1);
974	}
975	return (0);
976}
977
978/*
979 * =======================================================
980 * End of thread (previously libthread) interfaces.
981 * ==================== threads ==========================
982 */
983
984static const mdb_dcmd_t dcmds[] = {
985	{ "jmp_buf", ":", "print jmp_buf contents", d_jmp_buf, NULL },
986	{ "sigjmp_buf", ":", "print sigjmp_buf contents", d_sigjmp_buf, NULL },
987	{ "siginfo", ":", "print siginfo_t structure", d_siginfo, NULL },
988	{ "ucontext", ":", "print ucontext_t structure", d_ucontext, NULL },
989	{ "ulwp", ":", "print ulwp_t structure", d_ulwp, NULL },
990	{ "uberdata", ":", "print uberdata_t structure", d_uberdata, NULL },
991	{ NULL }
992};
993
994static const mdb_walker_t walkers[] = {
995	{ "ucontext", "walk ucontext_t uc_link list",
996		NULL, uc_walk_step, NULL, NULL },
997	{ "oldcontext", "walk per-lwp oldcontext pointers",
998		oldc_walk_init, oldc_walk_step, oldc_walk_fini, NULL },
999	{ "ulwps", "walk list of ulwp_t pointers",
1000		ulwp_walk_init, ulwp_walk_step, NULL, NULL },
1001	{ NULL }
1002};
1003
1004static const mdb_modinfo_t modinfo = { MDB_API_VERSION, dcmds, walkers };
1005
1006const mdb_modinfo_t *
1007_mdb_init(void)
1008{
1009	mdb_whatis_register("threads", whatis_run_ulwps, NULL,
1010	    WHATIS_PRIO_EARLY, WHATIS_REG_NO_ID);
1011
1012	return (&modinfo);
1013}
1014