xref: /illumos-gate/usr/src/cmd/mdb/common/modules/libc/libc.c (revision 542a7b7f5ccc44e3c95d6dce4ec0566f60bd9ff4)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
534709573Sraf  * Common Development and Distribution License (the "License").
634709573Sraf  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
2134709573Sraf 
227c478bd9Sstevel@tonic-gate /*
233cd8a1a6SRoger A. Faulkner  * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
2428e4da25SMatthew Ahrens  * Copyright (c) 2012 by Delphix. All rights reserved.
25e0ee3cedSJason King  * Copyright 2017, Joyent, Inc.
26*542a7b7fSCarlos Neira  * Copyright (c) 2019 Carlos Neira <cneirabustos@gmail.com>
27*542a7b7fSCarlos Neira  * Copyright 2019 OmniOS Community Edition (OmniOSce) Association.
284f364e7cSRobert Mustacchi  */
297c478bd9Sstevel@tonic-gate 
307c478bd9Sstevel@tonic-gate #include <sys/mdb_modapi.h>
314a1c2431SJonathan Adams #include <mdb/mdb_whatis.h>
3228e4da25SMatthew Ahrens #include <mdb/mdb_ctf.h>
337c478bd9Sstevel@tonic-gate #include <procfs.h>
347c478bd9Sstevel@tonic-gate #include <ucontext.h>
357c478bd9Sstevel@tonic-gate #include <siginfo.h>
367c478bd9Sstevel@tonic-gate #include <signal.h>
377c478bd9Sstevel@tonic-gate #include <setjmp.h>
387c478bd9Sstevel@tonic-gate #include <string.h>
397c478bd9Sstevel@tonic-gate #include <thr_uberdata.h>
40c9a6ea2eSBryan Cantrill #include "findstack.h"
41*542a7b7fSCarlos Neira #include <libproc.h>
427c478bd9Sstevel@tonic-gate 
437c478bd9Sstevel@tonic-gate static const char *
447c478bd9Sstevel@tonic-gate stack_flags(const stack_t *sp)
457c478bd9Sstevel@tonic-gate {
467c478bd9Sstevel@tonic-gate 	static char buf[32];
477c478bd9Sstevel@tonic-gate 
487c478bd9Sstevel@tonic-gate 	if (sp->ss_flags == 0)
497c478bd9Sstevel@tonic-gate 		(void) strcpy(buf, " 0");
507c478bd9Sstevel@tonic-gate 	else if (sp->ss_flags & ~(SS_ONSTACK | SS_DISABLE))
517c478bd9Sstevel@tonic-gate 		(void) mdb_snprintf(buf, sizeof (buf), " 0x%x", sp->ss_flags);
527c478bd9Sstevel@tonic-gate 	else {
537c478bd9Sstevel@tonic-gate 		buf[0] = '\0';
547c478bd9Sstevel@tonic-gate 		if (sp->ss_flags & SS_ONSTACK)
557c478bd9Sstevel@tonic-gate 			(void) strcat(buf, "|ONSTACK");
567c478bd9Sstevel@tonic-gate 		if (sp->ss_flags & SS_DISABLE)
577c478bd9Sstevel@tonic-gate 			(void) strcat(buf, "|DISABLE");
587c478bd9Sstevel@tonic-gate 	}
597c478bd9Sstevel@tonic-gate 
607c478bd9Sstevel@tonic-gate 	return (buf + 1);
617c478bd9Sstevel@tonic-gate }
627c478bd9Sstevel@tonic-gate 
637c478bd9Sstevel@tonic-gate /*ARGSUSED*/
647c478bd9Sstevel@tonic-gate static int
657c478bd9Sstevel@tonic-gate d_jmp_buf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
667c478bd9Sstevel@tonic-gate {
677c478bd9Sstevel@tonic-gate 	jmp_buf jb;
687c478bd9Sstevel@tonic-gate 	const ulong_t *b = (const ulong_t *)jb;
697c478bd9Sstevel@tonic-gate 
707c478bd9Sstevel@tonic-gate 	if (argc != 0)
717c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
727c478bd9Sstevel@tonic-gate 
737c478bd9Sstevel@tonic-gate 	if (mdb_vread(&jb, sizeof (jb), addr) != sizeof (jb)) {
747c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read jmp_buf at %p", addr);
757c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
767c478bd9Sstevel@tonic-gate 	}
777c478bd9Sstevel@tonic-gate 
787c478bd9Sstevel@tonic-gate #if defined(__sparc)
797c478bd9Sstevel@tonic-gate 	mdb_printf("  %%sp = 0x%lx\n", b[1]);
807c478bd9Sstevel@tonic-gate 	mdb_printf("  %%pc = 0x%lx %lA\n", b[2], b[2]);
817c478bd9Sstevel@tonic-gate 	mdb_printf("  %%fp = 0x%lx\n", b[3]);
827c478bd9Sstevel@tonic-gate 	mdb_printf("  %%i7 = 0x%lx %lA\n", b[4], b[4]);
837c478bd9Sstevel@tonic-gate #elif defined(__amd64)
847c478bd9Sstevel@tonic-gate 	mdb_printf("  %%rbx = 0x%lx\n", b[0]);
857c478bd9Sstevel@tonic-gate 	mdb_printf("  %%r12 = 0x%lx\n", b[1]);
867c478bd9Sstevel@tonic-gate 	mdb_printf("  %%r13 = 0x%lx\n", b[2]);
877c478bd9Sstevel@tonic-gate 	mdb_printf("  %%r14 = 0x%lx\n", b[3]);
887c478bd9Sstevel@tonic-gate 	mdb_printf("  %%r15 = 0x%lx\n", b[4]);
897c478bd9Sstevel@tonic-gate 	mdb_printf("  %%rbp = 0x%lx\n", b[5]);
907c478bd9Sstevel@tonic-gate 	mdb_printf("  %%rsp = 0x%lx\n", b[6]);
917c478bd9Sstevel@tonic-gate 	mdb_printf("  %%rip = 0x%lx %lA\n", b[7], b[7]);
927c478bd9Sstevel@tonic-gate #elif defined(__i386)
937c478bd9Sstevel@tonic-gate 	mdb_printf("  %%ebx = 0x%lx\n", b[0]);
947c478bd9Sstevel@tonic-gate 	mdb_printf("  %%esi = 0x%lx\n", b[1]);
957c478bd9Sstevel@tonic-gate 	mdb_printf("  %%edi = 0x%lx\n", b[2]);
967c478bd9Sstevel@tonic-gate 	mdb_printf("  %%ebp = 0x%lx\n", b[3]);
977c478bd9Sstevel@tonic-gate 	mdb_printf("  %%esp = 0x%lx\n", b[4]);
987c478bd9Sstevel@tonic-gate 	mdb_printf("  %%eip = 0x%lx %lA\n", b[5], b[5]);
997c478bd9Sstevel@tonic-gate #endif
1007c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
1017c478bd9Sstevel@tonic-gate }
1027c478bd9Sstevel@tonic-gate 
1038f88a51fSJoshua M. Clulow const mdb_bitmask_t uc_flags_bits[] = {
1048f88a51fSJoshua M. Clulow 	{ "UC_SIGMASK", UC_SIGMASK, UC_SIGMASK },
1058f88a51fSJoshua M. Clulow 	{ "UC_STACK", UC_STACK, UC_STACK },
1068f88a51fSJoshua M. Clulow 	{ "UC_CPU", UC_CPU, UC_CPU },
1078f88a51fSJoshua M. Clulow 	{ "UC_FPU", UC_FPU, UC_FPU },
1088f88a51fSJoshua M. Clulow #if defined(UC_INTR)
1098f88a51fSJoshua M. Clulow 	{ "UC_INTR", UC_INTR, UC_INTR },
1108f88a51fSJoshua M. Clulow #endif
1118f88a51fSJoshua M. Clulow #if defined(UC_ASR)
1128f88a51fSJoshua M. Clulow 	{ "UC_ASR", UC_ASR, UC_ASR },
1138f88a51fSJoshua M. Clulow #endif
1148f88a51fSJoshua M. Clulow 	{ NULL, 0, 0 }
1158f88a51fSJoshua M. Clulow };
1168f88a51fSJoshua M. Clulow 
1177c478bd9Sstevel@tonic-gate /*ARGSUSED*/
1187c478bd9Sstevel@tonic-gate static int
1197c478bd9Sstevel@tonic-gate d_ucontext(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1207c478bd9Sstevel@tonic-gate {
1217c478bd9Sstevel@tonic-gate 	ucontext_t uc;
1227c478bd9Sstevel@tonic-gate 
1237c478bd9Sstevel@tonic-gate 	if (argc != 0)
1247c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
1257c478bd9Sstevel@tonic-gate 
1267c478bd9Sstevel@tonic-gate 	if (mdb_vread(&uc, sizeof (uc), addr) != sizeof (uc)) {
1277c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read ucontext at %p", addr);
1287c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
1297c478bd9Sstevel@tonic-gate 	}
1307c478bd9Sstevel@tonic-gate 
1318f88a51fSJoshua M. Clulow 	mdb_printf("  flags    = 0x%lx <%b>\n", uc.uc_flags,
1328f88a51fSJoshua M. Clulow 	    (uint_t)uc.uc_flags, uc_flags_bits);
1337c478bd9Sstevel@tonic-gate 	mdb_printf("  link     = 0x%p\n", uc.uc_link);
1347c478bd9Sstevel@tonic-gate 	mdb_printf("  sigmask  = 0x%08x 0x%08x 0x%08x 0x%08x\n",
1357c478bd9Sstevel@tonic-gate 	    uc.uc_sigmask.__sigbits[0], uc.uc_sigmask.__sigbits[1],
1367c478bd9Sstevel@tonic-gate 	    uc.uc_sigmask.__sigbits[2], uc.uc_sigmask.__sigbits[3]);
1377c478bd9Sstevel@tonic-gate 	mdb_printf("  stack    = sp 0x%p size 0x%lx flags %s\n",
1387c478bd9Sstevel@tonic-gate 	    uc.uc_stack.ss_sp, uc.uc_stack.ss_size, stack_flags(&uc.uc_stack));
1397c478bd9Sstevel@tonic-gate 	mdb_printf("  mcontext = 0x%p\n",
1407c478bd9Sstevel@tonic-gate 	    addr + OFFSETOF(ucontext_t, uc_mcontext));
1417c478bd9Sstevel@tonic-gate 
1427c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
1437c478bd9Sstevel@tonic-gate }
1447c478bd9Sstevel@tonic-gate 
1457c478bd9Sstevel@tonic-gate /*ARGSUSED*/
1467c478bd9Sstevel@tonic-gate static int
1477c478bd9Sstevel@tonic-gate d_sigjmp_buf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1487c478bd9Sstevel@tonic-gate {
1497c478bd9Sstevel@tonic-gate #if defined(__sparc)
1507c478bd9Sstevel@tonic-gate 	struct {
1517c478bd9Sstevel@tonic-gate 		int sjs_flags;
1527c478bd9Sstevel@tonic-gate 		greg_t sjs_sp;
1537c478bd9Sstevel@tonic-gate 		greg_t sjs_pc;
1547c478bd9Sstevel@tonic-gate 		greg_t sjs_fp;
1557c478bd9Sstevel@tonic-gate 		greg_t sjs_i7;
1567c478bd9Sstevel@tonic-gate 		ucontext_t *sjs_uclink;
1577c478bd9Sstevel@tonic-gate 		ulong_t sjs_pad[_JBLEN - 6];
1587c478bd9Sstevel@tonic-gate 		sigset_t sjs_sigmask;
1597c478bd9Sstevel@tonic-gate #if defined(_LP64)
1603cd8a1a6SRoger A. Faulkner 		greg_t sjs_asi;
1613cd8a1a6SRoger A. Faulkner 		greg_t sjs_fprs;
1627c478bd9Sstevel@tonic-gate #endif
1637c478bd9Sstevel@tonic-gate 		stack_t sjs_stack;
1647c478bd9Sstevel@tonic-gate 	} s;
1657c478bd9Sstevel@tonic-gate 
1667c478bd9Sstevel@tonic-gate 	if (argc != 0)
1677c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
1687c478bd9Sstevel@tonic-gate 
1697c478bd9Sstevel@tonic-gate 	if (mdb_vread(&s, sizeof (s), addr) != sizeof (s)) {
1707c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read sigjmp_buf at %p", addr);
1717c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
1727c478bd9Sstevel@tonic-gate 	}
1737c478bd9Sstevel@tonic-gate 
1747c478bd9Sstevel@tonic-gate 	mdb_printf("  flags  = 0x%x\n", s.sjs_flags);
1757c478bd9Sstevel@tonic-gate 	mdb_printf("  %%sp    = 0x%lx %lA\n", s.sjs_sp, s.sjs_sp);
1767c478bd9Sstevel@tonic-gate 	mdb_printf("  %%pc    = 0x%lx %lA\n", s.sjs_pc, s.sjs_pc);
1777c478bd9Sstevel@tonic-gate 	mdb_printf("  %%fp    = 0x%lx %lA\n", s.sjs_fp, s.sjs_fp);
1787c478bd9Sstevel@tonic-gate 	mdb_printf("  %%i7    = 0x%lx %lA\n", s.sjs_i7, s.sjs_i7);
1797c478bd9Sstevel@tonic-gate 	mdb_printf("  uclink = %p\n", s.sjs_uclink);
1807c478bd9Sstevel@tonic-gate 	mdb_printf("  sigset = 0x%08x 0x%08x 0x%08x 0x%08x\n",
1817c478bd9Sstevel@tonic-gate 	    s.sjs_sigmask.__sigbits[0], s.sjs_sigmask.__sigbits[1],
1827c478bd9Sstevel@tonic-gate 	    s.sjs_sigmask.__sigbits[2], s.sjs_sigmask.__sigbits[3]);
1833cd8a1a6SRoger A. Faulkner #if defined(_LP64)
1843cd8a1a6SRoger A. Faulkner 	mdb_printf("  %%asi   = 0x%lx\n", s.sjs_asi);
1853cd8a1a6SRoger A. Faulkner 	mdb_printf("  %%fprs  = 0x%lx\n", s.sjs_fprs);
1863cd8a1a6SRoger A. Faulkner #endif
1877c478bd9Sstevel@tonic-gate 	mdb_printf("  stack  = sp 0x%p size 0x%lx flags %s\n",
1887c478bd9Sstevel@tonic-gate 	    s.sjs_stack.ss_sp, s.sjs_stack.ss_size, stack_flags(&s.sjs_stack));
1897c478bd9Sstevel@tonic-gate 
1907c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
1917c478bd9Sstevel@tonic-gate 
1927c478bd9Sstevel@tonic-gate #elif defined(__i386) || defined(__amd64)
1937c478bd9Sstevel@tonic-gate 	return (d_ucontext(addr, flags, argc, argv));
1947c478bd9Sstevel@tonic-gate #endif
1957c478bd9Sstevel@tonic-gate }
1967c478bd9Sstevel@tonic-gate 
1977c478bd9Sstevel@tonic-gate /*ARGSUSED*/
1987c478bd9Sstevel@tonic-gate static int
1997c478bd9Sstevel@tonic-gate d_siginfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2007c478bd9Sstevel@tonic-gate {
2017c478bd9Sstevel@tonic-gate 	static const char *const msname[] = {
2027c478bd9Sstevel@tonic-gate 		"USER", "SYSTEM", "TRAP", "TFAULT", "DFAULT", "KFAULT",
2037c478bd9Sstevel@tonic-gate 		"USER_LOCK", "SLEEP", "WAIT_CPU", "STOPPED"
2047c478bd9Sstevel@tonic-gate 	};
2057c478bd9Sstevel@tonic-gate 
2067c478bd9Sstevel@tonic-gate 	char signame[SIG2STR_MAX];
2077c478bd9Sstevel@tonic-gate 	siginfo_t si;
2087c478bd9Sstevel@tonic-gate 	int i;
2097c478bd9Sstevel@tonic-gate 
2107c478bd9Sstevel@tonic-gate 	if (argc != 0)
2117c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
2127c478bd9Sstevel@tonic-gate 
2137c478bd9Sstevel@tonic-gate 	if (mdb_vread(&si, sizeof (si), addr) != sizeof (si)) {
2147c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read siginfo at %p", addr);
2157c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
2167c478bd9Sstevel@tonic-gate 	}
2177c478bd9Sstevel@tonic-gate 
2187c478bd9Sstevel@tonic-gate 	if (sig2str(si.si_signo, signame) == -1)
2197c478bd9Sstevel@tonic-gate 		(void) strcpy(signame, "unknown");
2207c478bd9Sstevel@tonic-gate 
2217c478bd9Sstevel@tonic-gate 	mdb_printf("  signal %5d (%s)\n", si.si_signo, signame);
2227c478bd9Sstevel@tonic-gate 	mdb_printf("  code   %5d (", si.si_code);
2237c478bd9Sstevel@tonic-gate 
2247c478bd9Sstevel@tonic-gate 	switch (si.si_code) {
2257c478bd9Sstevel@tonic-gate 	case SI_NOINFO:
2267c478bd9Sstevel@tonic-gate 		mdb_printf("no info");
2277c478bd9Sstevel@tonic-gate 		break;
2287c478bd9Sstevel@tonic-gate 	case SI_DTRACE:
2297c478bd9Sstevel@tonic-gate 		mdb_printf("from DTrace raise() action");
2307c478bd9Sstevel@tonic-gate 		break;
2317c478bd9Sstevel@tonic-gate 	case SI_RCTL:
2327c478bd9Sstevel@tonic-gate 		mdb_printf("from rctl action");
2337c478bd9Sstevel@tonic-gate 		break;
2347c478bd9Sstevel@tonic-gate 	case SI_USER:
2357c478bd9Sstevel@tonic-gate 		mdb_printf("user generated via kill");
2367c478bd9Sstevel@tonic-gate 		break;
2377c478bd9Sstevel@tonic-gate 	case SI_LWP:
2387c478bd9Sstevel@tonic-gate 		mdb_printf("user generated via lwp_kill");
2397c478bd9Sstevel@tonic-gate 		break;
2407c478bd9Sstevel@tonic-gate 	case SI_QUEUE:
2417c478bd9Sstevel@tonic-gate 		mdb_printf("user generated via sigqueue");
2427c478bd9Sstevel@tonic-gate 		break;
2437c478bd9Sstevel@tonic-gate 	case SI_TIMER:
2447c478bd9Sstevel@tonic-gate 		mdb_printf("from timer expiration");
2457c478bd9Sstevel@tonic-gate 		break;
2467c478bd9Sstevel@tonic-gate 	case SI_ASYNCIO:
2477c478bd9Sstevel@tonic-gate 		mdb_printf("from async i/o completion");
2487c478bd9Sstevel@tonic-gate 		break;
2497c478bd9Sstevel@tonic-gate 	case SI_MESGQ:
2507c478bd9Sstevel@tonic-gate 		mdb_printf("from message arrival");
2517c478bd9Sstevel@tonic-gate 		break;
2527c478bd9Sstevel@tonic-gate 	default:
2537c478bd9Sstevel@tonic-gate 		if (SI_FROMUSER(&si))
2547c478bd9Sstevel@tonic-gate 			mdb_printf("from user process");
2557c478bd9Sstevel@tonic-gate 		else
2567c478bd9Sstevel@tonic-gate 			mdb_printf("from kernel");
2577c478bd9Sstevel@tonic-gate 	}
2587c478bd9Sstevel@tonic-gate 
2597c478bd9Sstevel@tonic-gate 	mdb_printf(")\n  errno  %5d (%s)\n",
2607c478bd9Sstevel@tonic-gate 	    si.si_errno, strerror(si.si_errno));
2617c478bd9Sstevel@tonic-gate 
2627c478bd9Sstevel@tonic-gate 	if (si.si_code == SI_USER || si.si_code == SI_QUEUE) {
2637c478bd9Sstevel@tonic-gate 		mdb_printf("  signal sent from PID %d (uid %d)\n",
2647c478bd9Sstevel@tonic-gate 		    si.si_pid, si.si_uid);
2657c478bd9Sstevel@tonic-gate 	}
2667c478bd9Sstevel@tonic-gate 
2677c478bd9Sstevel@tonic-gate 	if (si.si_code == SI_QUEUE) {
2687c478bd9Sstevel@tonic-gate 		mdb_printf("  signal value = 0t%d / %p\n",
2697c478bd9Sstevel@tonic-gate 		    si.si_value.sival_int, si.si_value.sival_ptr);
2707c478bd9Sstevel@tonic-gate 	}
2717c478bd9Sstevel@tonic-gate 
2727c478bd9Sstevel@tonic-gate 	switch (si.si_signo) {
2737c478bd9Sstevel@tonic-gate 	case SIGCLD:
2747c478bd9Sstevel@tonic-gate 		mdb_printf("  signal sent from child PID %d (uid %d)\n",
2757c478bd9Sstevel@tonic-gate 		    si.si_pid, si.si_uid);
2767c478bd9Sstevel@tonic-gate 		mdb_printf("  usr time = 0t%ld ticks, sys time = 0t%ld ticks\n",
2777c478bd9Sstevel@tonic-gate 		    si.si_utime, si.si_stime);
2787c478bd9Sstevel@tonic-gate 		mdb_printf("  wait status = 0x%x\n", si.si_status);
2797c478bd9Sstevel@tonic-gate 		break;
2807c478bd9Sstevel@tonic-gate 
2817c478bd9Sstevel@tonic-gate 	case SIGSEGV:
2827c478bd9Sstevel@tonic-gate 	case SIGBUS:
2837c478bd9Sstevel@tonic-gate 	case SIGILL:
2847c478bd9Sstevel@tonic-gate 	case SIGTRAP:
2857c478bd9Sstevel@tonic-gate 	case SIGFPE:
2867c478bd9Sstevel@tonic-gate 		mdb_printf("  fault address = 0x%p\n  trapno = %d\n",
2877c478bd9Sstevel@tonic-gate 		    si.si_addr, si.si_trapno);
2887c478bd9Sstevel@tonic-gate 		mdb_printf("  instruction address = 0x%p %lA\n",
2897c478bd9Sstevel@tonic-gate 		    si.si_pc, si.si_pc);
2907c478bd9Sstevel@tonic-gate 		break;
2917c478bd9Sstevel@tonic-gate 
2927c478bd9Sstevel@tonic-gate 	case SIGPOLL:
2937c478bd9Sstevel@tonic-gate 	case SIGXFSZ:
2947c478bd9Sstevel@tonic-gate 		mdb_printf("  fd = %d  band = 0x%lx\n",
2957c478bd9Sstevel@tonic-gate 		    si.si_fd, si.si_band);
2967c478bd9Sstevel@tonic-gate 		break;
2977c478bd9Sstevel@tonic-gate 
2987c478bd9Sstevel@tonic-gate 	case SIGPROF:
2997c478bd9Sstevel@tonic-gate 		mdb_printf("  last fault address = 0x%p fault type = %d\n",
3007c478bd9Sstevel@tonic-gate 		    si.si_faddr, si.si_fault);
3017c478bd9Sstevel@tonic-gate 		mdb_printf("  timestamp = 0t%ld sec 0t%ld nsec\n",
3027c478bd9Sstevel@tonic-gate 		    si.si_tstamp.tv_sec, si.si_tstamp.tv_nsec);
3037c478bd9Sstevel@tonic-gate 
3047c478bd9Sstevel@tonic-gate 		if (si.__data.__prof.__syscall != 0) {
3057c478bd9Sstevel@tonic-gate 			mdb_printf("  system call %d (", si.si_syscall);
3067c478bd9Sstevel@tonic-gate 			if (si.si_nsysarg > 0) {
3077c478bd9Sstevel@tonic-gate 				mdb_printf("%lx", si.si_sysarg[0]);
3087c478bd9Sstevel@tonic-gate 				for (i = 1; i < si.si_nsysarg; i++)
3097c478bd9Sstevel@tonic-gate 					mdb_printf(", %lx", si.si_sysarg[i]);
3107c478bd9Sstevel@tonic-gate 			}
3117c478bd9Sstevel@tonic-gate 			mdb_printf("  )\n");
3127c478bd9Sstevel@tonic-gate 		}
3137c478bd9Sstevel@tonic-gate 
3147c478bd9Sstevel@tonic-gate 		for (i = 0; i < sizeof (msname) / sizeof (msname[0]); i++) {
3157c478bd9Sstevel@tonic-gate 			mdb_printf("  mstate[\"%s\"] = %d\n",
3167c478bd9Sstevel@tonic-gate 			    msname[i], si.si_mstate[i]);
3177c478bd9Sstevel@tonic-gate 		}
3187c478bd9Sstevel@tonic-gate 		break;
3197c478bd9Sstevel@tonic-gate 	}
3207c478bd9Sstevel@tonic-gate 
3217c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
3227c478bd9Sstevel@tonic-gate }
3237c478bd9Sstevel@tonic-gate 
3247c478bd9Sstevel@tonic-gate static int
3257c478bd9Sstevel@tonic-gate uc_walk_step(mdb_walk_state_t *wsp)
3267c478bd9Sstevel@tonic-gate {
3277c478bd9Sstevel@tonic-gate 	uintptr_t addr = wsp->walk_addr;
3287c478bd9Sstevel@tonic-gate 	ucontext_t uc;
3297c478bd9Sstevel@tonic-gate 
330892ad162SToomas Soome 	if (addr == 0)
3317c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
3327c478bd9Sstevel@tonic-gate 
3337c478bd9Sstevel@tonic-gate 	if (mdb_vread(&uc, sizeof (uc), addr) != sizeof (uc)) {
3347c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read ucontext at %p", addr);
3357c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
3367c478bd9Sstevel@tonic-gate 	}
3377c478bd9Sstevel@tonic-gate 
3387c478bd9Sstevel@tonic-gate 	wsp->walk_addr = (uintptr_t)uc.uc_link;
3397c478bd9Sstevel@tonic-gate 	return (wsp->walk_callback(addr, &uc, wsp->walk_cbdata));
3407c478bd9Sstevel@tonic-gate }
3417c478bd9Sstevel@tonic-gate 
3427c478bd9Sstevel@tonic-gate static int
3437c478bd9Sstevel@tonic-gate oldc_walk_init(mdb_walk_state_t *wsp)
3447c478bd9Sstevel@tonic-gate {
3457c478bd9Sstevel@tonic-gate 	ssize_t nbytes = mdb_get_xdata("lwpstatus", NULL, 0);
3467c478bd9Sstevel@tonic-gate 
3477c478bd9Sstevel@tonic-gate 	if (nbytes <= 0) {
3487c478bd9Sstevel@tonic-gate 		mdb_warn("lwpstatus information not available");
3497c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
3507c478bd9Sstevel@tonic-gate 	}
3517c478bd9Sstevel@tonic-gate 
352892ad162SToomas Soome 	if (wsp->walk_addr != 0) {
3537c478bd9Sstevel@tonic-gate 		mdb_warn("walker only supports global walk\n");
3547c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
3557c478bd9Sstevel@tonic-gate 	}
3567c478bd9Sstevel@tonic-gate 
3577c478bd9Sstevel@tonic-gate 	wsp->walk_addr = nbytes; /* Use walk_addr to track size */
3587c478bd9Sstevel@tonic-gate 	wsp->walk_data = mdb_alloc(nbytes, UM_SLEEP);
3597c478bd9Sstevel@tonic-gate 
3607c478bd9Sstevel@tonic-gate 	if (mdb_get_xdata("lwpstatus", wsp->walk_data, nbytes) != nbytes) {
3617c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read lwpstatus information");
3627c478bd9Sstevel@tonic-gate 		mdb_free(wsp->walk_data, nbytes);
3637c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
3647c478bd9Sstevel@tonic-gate 	}
3657c478bd9Sstevel@tonic-gate 
3667c478bd9Sstevel@tonic-gate 	wsp->walk_arg = wsp->walk_data; /* Use walk_arg to track pointer */
3677c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
3687c478bd9Sstevel@tonic-gate }
3697c478bd9Sstevel@tonic-gate 
3707c478bd9Sstevel@tonic-gate static int
3717c478bd9Sstevel@tonic-gate oldc_walk_step(mdb_walk_state_t *wsp)
3727c478bd9Sstevel@tonic-gate {
3737c478bd9Sstevel@tonic-gate 	const lwpstatus_t *lsp, *end;
3747c478bd9Sstevel@tonic-gate 
3757c478bd9Sstevel@tonic-gate 	end = (const lwpstatus_t *)((uintptr_t)wsp->walk_data + wsp->walk_addr);
3767c478bd9Sstevel@tonic-gate 	lsp = wsp->walk_arg;
3777c478bd9Sstevel@tonic-gate 
3787c478bd9Sstevel@tonic-gate 	wsp->walk_arg = (void *)(lsp + 1);
3797c478bd9Sstevel@tonic-gate 
3807c478bd9Sstevel@tonic-gate 	if (lsp < end) {
3817c478bd9Sstevel@tonic-gate 		uintptr_t addr = lsp->pr_oldcontext;
3827c478bd9Sstevel@tonic-gate 		ucontext_t uc;
3837c478bd9Sstevel@tonic-gate 
384892ad162SToomas Soome 		if (addr == 0)
3857c478bd9Sstevel@tonic-gate 			return (WALK_NEXT);
3867c478bd9Sstevel@tonic-gate 
3877c478bd9Sstevel@tonic-gate 		if (mdb_vread(&uc, sizeof (uc), addr) != sizeof (uc)) {
3887c478bd9Sstevel@tonic-gate 			mdb_warn("failed to read ucontext at %p", addr);
3897c478bd9Sstevel@tonic-gate 			return (WALK_NEXT);
3907c478bd9Sstevel@tonic-gate 		}
3917c478bd9Sstevel@tonic-gate 
3927c478bd9Sstevel@tonic-gate 		return (wsp->walk_callback(addr, &uc, wsp->walk_cbdata));
3937c478bd9Sstevel@tonic-gate 	}
3947c478bd9Sstevel@tonic-gate 
3957c478bd9Sstevel@tonic-gate 	return (WALK_DONE);
3967c478bd9Sstevel@tonic-gate }
3977c478bd9Sstevel@tonic-gate 
3987c478bd9Sstevel@tonic-gate static void
3997c478bd9Sstevel@tonic-gate oldc_walk_fini(mdb_walk_state_t *wsp)
4007c478bd9Sstevel@tonic-gate {
4017c478bd9Sstevel@tonic-gate 	mdb_free(wsp->walk_data, wsp->walk_addr); /* walk_addr has size */
4027c478bd9Sstevel@tonic-gate }
4037c478bd9Sstevel@tonic-gate 
4047c478bd9Sstevel@tonic-gate /*
4057c478bd9Sstevel@tonic-gate  * ==================== threads ==========================
4067c478bd9Sstevel@tonic-gate  * These are the interfaces that used to require libthread.
4077c478bd9Sstevel@tonic-gate  * Now, libthread has been folded into libc.
4087c478bd9Sstevel@tonic-gate  * =======================================================
4097c478bd9Sstevel@tonic-gate  */
4107c478bd9Sstevel@tonic-gate 
4117c478bd9Sstevel@tonic-gate /*
4127c478bd9Sstevel@tonic-gate  * prt_addr() is called up to three times to generate arguments for
4137c478bd9Sstevel@tonic-gate  * one call to mdb_printf().  We must return at least three different
4147c478bd9Sstevel@tonic-gate  * pointers to static storage for consecutive calls to prt_addr().
4157c478bd9Sstevel@tonic-gate  */
4167c478bd9Sstevel@tonic-gate static const char *
4177c478bd9Sstevel@tonic-gate prt_addr(void *addr, int pad)
4187c478bd9Sstevel@tonic-gate {
4197c478bd9Sstevel@tonic-gate 	static char buffer[4][24];
4207c478bd9Sstevel@tonic-gate 	static int ix = 0;
4217c478bd9Sstevel@tonic-gate 	char *buf;
4227c478bd9Sstevel@tonic-gate 
4237c478bd9Sstevel@tonic-gate 	if (ix == 4)	/* use buffers in sequence: 0, 1, 2, 3 */
4247c478bd9Sstevel@tonic-gate 		ix = 0;
4257c478bd9Sstevel@tonic-gate 	buf = buffer[ix++];
4267c478bd9Sstevel@tonic-gate 	if (addr == NULL)
4277c478bd9Sstevel@tonic-gate 		return (pad? "<NULL>               " : "<NULL>");
4287c478bd9Sstevel@tonic-gate 	else {
4297c478bd9Sstevel@tonic-gate #ifdef _LP64
4307c478bd9Sstevel@tonic-gate 		(void) mdb_snprintf(buf, sizeof (buffer[0]), "0x%016lx", addr);
4317c478bd9Sstevel@tonic-gate 		if (pad)
4327c478bd9Sstevel@tonic-gate 			(void) strcpy(buf + 18, "   ");
4337c478bd9Sstevel@tonic-gate #else
4347c478bd9Sstevel@tonic-gate 		(void) mdb_snprintf(buf, sizeof (buffer[0]), "0x%08lx", addr);
4357c478bd9Sstevel@tonic-gate 		if (pad)
4367c478bd9Sstevel@tonic-gate 			(void) strcpy(buf + 10, "           ");
4377c478bd9Sstevel@tonic-gate #endif	/* _LP64 */
4387c478bd9Sstevel@tonic-gate 		return (buf);
4397c478bd9Sstevel@tonic-gate 	}
4407c478bd9Sstevel@tonic-gate }
4417c478bd9Sstevel@tonic-gate 
4427c478bd9Sstevel@tonic-gate #define	HD(str)		mdb_printf("           " str "\n")
4437c478bd9Sstevel@tonic-gate #define	OFFSTR		"+0x%-7lx "
4447c478bd9Sstevel@tonic-gate #define	OFFSET(member)	((size_t)OFFSETOF(ulwp_t, member))
4457c478bd9Sstevel@tonic-gate 
4467c478bd9Sstevel@tonic-gate /*ARGSUSED*/
4477c478bd9Sstevel@tonic-gate static int
4487c478bd9Sstevel@tonic-gate d_ulwp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
4497c478bd9Sstevel@tonic-gate {
4507c478bd9Sstevel@tonic-gate 	ulwp_t ulwp;
4517c478bd9Sstevel@tonic-gate 
4527c478bd9Sstevel@tonic-gate 	if (argc != 0 || !(flags & DCMD_ADDRSPEC))
4537c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
4547c478bd9Sstevel@tonic-gate 
4557c478bd9Sstevel@tonic-gate 	if (mdb_vread(&ulwp, sizeof (ulwp), addr) != sizeof (ulwp) &&
4567c478bd9Sstevel@tonic-gate 	    (bzero(&ulwp, sizeof (ulwp)),
4577c478bd9Sstevel@tonic-gate 	    mdb_vread(&ulwp, REPLACEMENT_SIZE, addr)) != REPLACEMENT_SIZE) {
4587c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read ulwp at 0x%p", addr);
4597c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
4607c478bd9Sstevel@tonic-gate 	}
4617c478bd9Sstevel@tonic-gate 
4627c478bd9Sstevel@tonic-gate 	mdb_printf("%#a\n", addr);
4637c478bd9Sstevel@tonic-gate 
4647c478bd9Sstevel@tonic-gate 	HD("self                  uberdata");
4657c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %s\n",
4668cd45542Sraf 	    OFFSET(ul_self),
4678cd45542Sraf 	    prt_addr(ulwp.ul_self, 1),
4688cd45542Sraf 	    prt_addr(ulwp.ul_uberdata, 0));
4697c478bd9Sstevel@tonic-gate 
4707c478bd9Sstevel@tonic-gate 	HD("tlsent                ntlsent");
4717c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %ld\n",
4728cd45542Sraf 	    OFFSET(ul_tlsent),
4738cd45542Sraf 	    prt_addr(ulwp.ul_tlsent, 1),
4748cd45542Sraf 	    ulwp.ul_ntlsent);
4757c478bd9Sstevel@tonic-gate 
4767c478bd9Sstevel@tonic-gate 	HD("forw                  back                  next");
4777c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %s %s\n",
4788cd45542Sraf 	    OFFSET(ul_forw),
4798cd45542Sraf 	    prt_addr(ulwp.ul_forw, 1),
4808cd45542Sraf 	    prt_addr(ulwp.ul_back, 1),
4818cd45542Sraf 	    prt_addr(ulwp.ul_next, 0));
4827c478bd9Sstevel@tonic-gate 
4837c478bd9Sstevel@tonic-gate 	HD("hash                  rval                  stk");
4847c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %s %s\n",
4858cd45542Sraf 	    OFFSET(ul_hash),
4868cd45542Sraf 	    prt_addr(ulwp.ul_hash, 1),
4878cd45542Sraf 	    prt_addr(ulwp.ul_rval, 1),
4888cd45542Sraf 	    prt_addr(ulwp.ul_stk, 0));
4897c478bd9Sstevel@tonic-gate 
4907c478bd9Sstevel@tonic-gate 	HD("mapsiz     guardsize  stktop                stksiz");
4917c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%-10ld %-10ld %s %ld\n",
4928cd45542Sraf 	    OFFSET(ul_mapsiz),
4938cd45542Sraf 	    ulwp.ul_mapsiz,
4948cd45542Sraf 	    ulwp.ul_guardsize,
4958cd45542Sraf 	    prt_addr((void *)ulwp.ul_stktop, 1),
4968cd45542Sraf 	    ulwp.ul_stksiz);
4977c478bd9Sstevel@tonic-gate 
4987c478bd9Sstevel@tonic-gate 	HD("ustack.ss_sp          ustack.ss_size        ustack.ss_flags");
4997c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %-21ld %s\n",
5008cd45542Sraf 	    OFFSET(ul_ustack.ss_sp),
5018cd45542Sraf 	    prt_addr(ulwp.ul_ustack.ss_sp, 1),
5028cd45542Sraf 	    ulwp.ul_ustack.ss_size,
5038cd45542Sraf 	    stack_flags(&ulwp.ul_ustack));
5047c478bd9Sstevel@tonic-gate 
505d4204c85Sraf 	HD("ix         lwpid      pri        epri       policy     cid");
5067c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
5078cd45542Sraf 	    OFFSET(ul_ix),
5088cd45542Sraf 	    ulwp.ul_ix,
5098cd45542Sraf 	    ulwp.ul_lwpid,
5108cd45542Sraf 	    ulwp.ul_pri,
5118cd45542Sraf 	    ulwp.ul_epri,
5128cd45542Sraf 	    ulwp.ul_policy,
5138cd45542Sraf 	    ulwp.ul_cid);
5147c478bd9Sstevel@tonic-gate 
5157c478bd9Sstevel@tonic-gate 	HD("cursig     pleasestop stop       signalled  dead       unwind");
5167c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%-10d ",
5178cd45542Sraf 	    OFFSET(ul_cursig),
5188cd45542Sraf 	    ulwp.ul_cursig);
5197c478bd9Sstevel@tonic-gate 	mdb_printf(ulwp.ul_pleasestop? "0x%-8x " : "%-10d ",
5208cd45542Sraf 	    ulwp.ul_pleasestop);
5217c478bd9Sstevel@tonic-gate 	mdb_printf(ulwp.ul_stop? "0x%-8x " : "%-10d ",
5228cd45542Sraf 	    ulwp.ul_stop);
5237c478bd9Sstevel@tonic-gate 	mdb_printf("%-10d %-10d %d\n",
5248cd45542Sraf 	    ulwp.ul_signalled,
5258cd45542Sraf 	    ulwp.ul_dead,
5268cd45542Sraf 	    ulwp.ul_unwind);
5277c478bd9Sstevel@tonic-gate 
52834709573Sraf 	HD("detached   writer     stopping   can'prolog preempt    savpreempt");
5297c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
5308cd45542Sraf 	    OFFSET(ul_detached),
5318cd45542Sraf 	    ulwp.ul_detached,
5328cd45542Sraf 	    ulwp.ul_writer,
5338cd45542Sraf 	    ulwp.ul_stopping,
5348cd45542Sraf 	    ulwp.ul_cancel_prologue,
5358cd45542Sraf 	    ulwp.ul_preempt,
5368cd45542Sraf 	    ulwp.ul_savpreempt);
5377c478bd9Sstevel@tonic-gate 
5387c478bd9Sstevel@tonic-gate 	HD("sigsuspend main       fork       primarymap m'spinners d'noreserv");
5397c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
5408cd45542Sraf 	    OFFSET(ul_sigsuspend),
5418cd45542Sraf 	    ulwp.ul_sigsuspend,
5428cd45542Sraf 	    ulwp.ul_main,
5438cd45542Sraf 	    ulwp.ul_fork,
5448cd45542Sraf 	    ulwp.ul_primarymap,
5458cd45542Sraf 	    ulwp.ul_max_spinners,
5468cd45542Sraf 	    ulwp.ul_door_noreserve);
5477c478bd9Sstevel@tonic-gate 
548d4204c85Sraf 	HD("queue_fifo c'w'defer  e'detect'  async_safe rt         rtqueued");
5497c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
5508cd45542Sraf 	    OFFSET(ul_queue_fifo),
5518cd45542Sraf 	    ulwp.ul_queue_fifo,
5528cd45542Sraf 	    ulwp.ul_cond_wait_defer,
5538cd45542Sraf 	    ulwp.ul_error_detection,
5548cd45542Sraf 	    ulwp.ul_async_safe,
5558cd45542Sraf 	    ulwp.ul_rt,
5568cd45542Sraf 	    ulwp.ul_rtqueued);
5577c478bd9Sstevel@tonic-gate 
5587c5714f6Sraf 	HD("misaligned adapt'spin queue_spin critical   sigdefer   vfork");
5597c5714f6Sraf 	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
5607c5714f6Sraf 	    OFFSET(ul_misaligned),
5617c5714f6Sraf 	    ulwp.ul_misaligned,
5628cd45542Sraf 	    ulwp.ul_adaptive_spin,
5638cd45542Sraf 	    ulwp.ul_queue_spin,
5648cd45542Sraf 	    ulwp.ul_critical,
5658cd45542Sraf 	    ulwp.ul_sigdefer,
5668cd45542Sraf 	    ulwp.ul_vfork);
5677c478bd9Sstevel@tonic-gate 
5687c478bd9Sstevel@tonic-gate 	HD("cancelable c'pending  c'disabled c'async    save_async mutator");
5697c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
5708cd45542Sraf 	    OFFSET(ul_cancelable),
5718cd45542Sraf 	    ulwp.ul_cancelable,
5728cd45542Sraf 	    ulwp.ul_cancel_pending,
5738cd45542Sraf 	    ulwp.ul_cancel_disabled,
5748cd45542Sraf 	    ulwp.ul_cancel_async,
5758cd45542Sraf 	    ulwp.ul_save_async,
5768cd45542Sraf 	    ulwp.ul_mutator);
5777c478bd9Sstevel@tonic-gate 
5787c478bd9Sstevel@tonic-gate 	HD("created    replace    nocancel   errno      errnop");
5797c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %s\n",
5808cd45542Sraf 	    OFFSET(ul_created),
5818cd45542Sraf 	    ulwp.ul_created,
5828cd45542Sraf 	    ulwp.ul_replace,
5838cd45542Sraf 	    ulwp.ul_nocancel,
5848cd45542Sraf 	    ulwp.ul_errno,
5858cd45542Sraf 	    prt_addr(ulwp.ul_errnop, 0));
5867c478bd9Sstevel@tonic-gate 
5877c478bd9Sstevel@tonic-gate 	HD("clnup_hdr             schedctl_called       schedctl");
5887c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %s %s\n",
5898cd45542Sraf 	    OFFSET(ul_clnup_hdr),
5908cd45542Sraf 	    prt_addr(ulwp.ul_clnup_hdr, 1),
5918cd45542Sraf 	    prt_addr(ulwp.ul_schedctl_called, 1),
5928cd45542Sraf 	    prt_addr((void *)ulwp.ul_schedctl, 0));
5937c478bd9Sstevel@tonic-gate 
594a574db85Sraf 	HD("bindflags  libc_locks stsd                  &ftsd");
5957c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR,
5968cd45542Sraf 	    OFFSET(ul_bindflags));
5977c478bd9Sstevel@tonic-gate 	mdb_printf(ulwp.ul_bindflags? "0x%-8x " : "%-10d ",
5988cd45542Sraf 	    ulwp.ul_bindflags);
599a574db85Sraf 	mdb_printf("%-10d ", ulwp.ul_libc_locks);
6007c478bd9Sstevel@tonic-gate 	mdb_printf("%s %s\n",
6018cd45542Sraf 	    prt_addr(ulwp.ul_stsd, 1),
6028cd45542Sraf 	    prt_addr((void *)(addr + OFFSET(ul_ftsd[0])), 0));
6037c478bd9Sstevel@tonic-gate 
6047c478bd9Sstevel@tonic-gate 	HD("eventmask[0..1]       eventnum              eventdata");
6057c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "0x%08x 0x%08x %-21d %s\n",
6068cd45542Sraf 	    OFFSET(ul_td_evbuf.eventmask.event_bits[0]),
6078cd45542Sraf 	    ulwp.ul_td_evbuf.eventmask.event_bits[0],
6088cd45542Sraf 	    ulwp.ul_td_evbuf.eventmask.event_bits[1],
6098cd45542Sraf 	    ulwp.ul_td_evbuf.eventnum,
6108cd45542Sraf 	    prt_addr(ulwp.ul_td_evbuf.eventdata, 0));
6117c478bd9Sstevel@tonic-gate 
612e54ab87fSRoger A. Faulkner 	HD("td'enable  sync'reg   qtype      cv_wake    rtld       usropts");
613e54ab87fSRoger A. Faulkner 	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d ",
6148cd45542Sraf 	    OFFSET(ul_td_events_enable),
6158cd45542Sraf 	    ulwp.ul_td_events_enable,
6168cd45542Sraf 	    ulwp.ul_sync_obj_reg,
6178cd45542Sraf 	    ulwp.ul_qtype,
618e54ab87fSRoger A. Faulkner 	    ulwp.ul_cv_wake,
619e54ab87fSRoger A. Faulkner 	    ulwp.ul_rtld);
6207c478bd9Sstevel@tonic-gate 	mdb_printf(ulwp.ul_usropts? "0x%x\n" : "%d\n",
6218cd45542Sraf 	    ulwp.ul_usropts);
6227c478bd9Sstevel@tonic-gate 
6237c478bd9Sstevel@tonic-gate 	HD("startpc               startarg              wchan");
6247c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %s %s\n",
6258cd45542Sraf 	    OFFSET(ul_startpc),
6268cd45542Sraf 	    prt_addr((void *)ulwp.ul_startpc, 1),
6278cd45542Sraf 	    prt_addr(ulwp.ul_startarg, 1),
6288cd45542Sraf 	    prt_addr(ulwp.ul_wchan, 0));
6297c478bd9Sstevel@tonic-gate 
6307c478bd9Sstevel@tonic-gate 	HD("link                  sleepq                cvmutex");
6317c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %s %s\n",
6328cd45542Sraf 	    OFFSET(ul_link),
6338cd45542Sraf 	    prt_addr(ulwp.ul_link, 1),
6348cd45542Sraf 	    prt_addr(ulwp.ul_sleepq, 1),
6358cd45542Sraf 	    prt_addr(ulwp.ul_cvmutex, 0));
6367c478bd9Sstevel@tonic-gate 
637d4204c85Sraf 	HD("mxchain               save_state");
638d4204c85Sraf 	mdb_printf(OFFSTR "%s %d\n",
6398cd45542Sraf 	    OFFSET(ul_mxchain),
6408cd45542Sraf 	    prt_addr(ulwp.ul_mxchain, 1),
6418cd45542Sraf 	    ulwp.ul_save_state);
6427c478bd9Sstevel@tonic-gate 
643883492d5Sraf 	HD("rdlockcnt             rd_rwlock             rd_count");
644883492d5Sraf 	mdb_printf(OFFSTR "%-21d %s %d\n",
6458cd45542Sraf 	    OFFSET(ul_rdlockcnt),
6468cd45542Sraf 	    ulwp.ul_rdlockcnt,
6478cd45542Sraf 	    prt_addr(ulwp.ul_readlock.single.rd_rwlock, 1),
6488cd45542Sraf 	    ulwp.ul_readlock.single.rd_count);
649883492d5Sraf 
650883492d5Sraf 	HD("heldlockcnt           heldlocks             tpdp");
651883492d5Sraf 	mdb_printf(OFFSTR "%-21d %s %s\n",
6528cd45542Sraf 	    OFFSET(ul_heldlockcnt),
6538cd45542Sraf 	    ulwp.ul_heldlockcnt,
6548cd45542Sraf 	    prt_addr(ulwp.ul_heldlocks.single, 1),
6558cd45542Sraf 	    prt_addr(ulwp.ul_tpdp, 0));
6567c478bd9Sstevel@tonic-gate 
6577c478bd9Sstevel@tonic-gate 	HD("siglink               s'l'spin   s'l'spin2  s'l'sleep  s'l'wakeup");
658d4204c85Sraf 	mdb_printf(OFFSTR "%s %-10d %-10d %-10d %d\n",
6598cd45542Sraf 	    OFFSET(ul_siglink),
6608cd45542Sraf 	    prt_addr(ulwp.ul_siglink, 1),
6618cd45542Sraf 	    ulwp.ul_spin_lock_spin,
6628cd45542Sraf 	    ulwp.ul_spin_lock_spin2,
6638cd45542Sraf 	    ulwp.ul_spin_lock_sleep,
6648cd45542Sraf 	    ulwp.ul_spin_lock_wakeup);
6657c478bd9Sstevel@tonic-gate 
666d4204c85Sraf 	HD("&queue_root           rtclassid  pilocks");
667d4204c85Sraf 	mdb_printf(OFFSTR "%s %-10d %d\n",
6688cd45542Sraf 	    OFFSET(ul_queue_root),
6698cd45542Sraf 	    prt_addr((void *)(addr + OFFSET(ul_queue_root)), 1),
6708cd45542Sraf 	    ulwp.ul_rtclassid,
6718cd45542Sraf 	    ulwp.ul_pilocks);
672d4204c85Sraf 
6737c478bd9Sstevel@tonic-gate 	/*
6747c478bd9Sstevel@tonic-gate 	 * The remainder of the ulwp_t structure
6757c478bd9Sstevel@tonic-gate 	 * is invalid if this is a replacement.
6767c478bd9Sstevel@tonic-gate 	 */
6777c478bd9Sstevel@tonic-gate 	if (ulwp.ul_replace)
6787c478bd9Sstevel@tonic-gate 		return (DCMD_OK);
6797c478bd9Sstevel@tonic-gate 
6807c478bd9Sstevel@tonic-gate 	HD("sigmask[0..3]");
6817c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "0x%08x 0x%08x 0x%08x 0x%08x\n",
6828cd45542Sraf 	    OFFSET(ul_sigmask.__sigbits[0]),
6838cd45542Sraf 	    ulwp.ul_sigmask.__sigbits[0],
6848cd45542Sraf 	    ulwp.ul_sigmask.__sigbits[1],
6858cd45542Sraf 	    ulwp.ul_sigmask.__sigbits[2],
6868cd45542Sraf 	    ulwp.ul_sigmask.__sigbits[3]);
6877c478bd9Sstevel@tonic-gate 
6887c478bd9Sstevel@tonic-gate 	HD("tmpmask[0..3]");
6897c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "0x%08x 0x%08x 0x%08x 0x%08x\n",
6908cd45542Sraf 	    OFFSET(ul_tmpmask.__sigbits[0]),
6918cd45542Sraf 	    ulwp.ul_tmpmask.__sigbits[0],
6928cd45542Sraf 	    ulwp.ul_tmpmask.__sigbits[1],
6938cd45542Sraf 	    ulwp.ul_tmpmask.__sigbits[2],
6948cd45542Sraf 	    ulwp.ul_tmpmask.__sigbits[3]);
6957c478bd9Sstevel@tonic-gate 
6967c478bd9Sstevel@tonic-gate 	HD("&siginfo              &spinlock             &fpuenv");
6977c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %s %s\n",
6988cd45542Sraf 	    OFFSET(ul_siginfo),
6998cd45542Sraf 	    prt_addr((void *)(addr + OFFSET(ul_siginfo)), 1),
7008cd45542Sraf 	    prt_addr((void *)(addr + OFFSET(ul_spinlock)), 1),
7018cd45542Sraf 	    prt_addr((void *)(addr + OFFSET(ul_fpuenv)), 0));
7027c478bd9Sstevel@tonic-gate 
7034f364e7cSRobert Mustacchi 	HD("tmem.size             &tmem.roots");
7044f364e7cSRobert Mustacchi 	mdb_printf(OFFSTR "%-21H %s\n",
7054f364e7cSRobert Mustacchi 	    OFFSET(ul_tmem),
7064f364e7cSRobert Mustacchi 	    ulwp.ul_tmem.tm_size,
7074f364e7cSRobert Mustacchi 	    prt_addr((void *)(addr + OFFSET(ul_tmem) + sizeof (size_t)), 0));
7084f364e7cSRobert Mustacchi 
7097c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
7107c478bd9Sstevel@tonic-gate }
7117c478bd9Sstevel@tonic-gate 
7127c478bd9Sstevel@tonic-gate /*
7137c478bd9Sstevel@tonic-gate  * Get the address of the unique uberdata_t structure.
7147c478bd9Sstevel@tonic-gate  */
7157c478bd9Sstevel@tonic-gate static uintptr_t
7167c478bd9Sstevel@tonic-gate uberdata_addr(void)
7177c478bd9Sstevel@tonic-gate {
7187c478bd9Sstevel@tonic-gate 	uintptr_t uaddr;
7197c478bd9Sstevel@tonic-gate 	uintptr_t addr;
7207c478bd9Sstevel@tonic-gate 	GElf_Sym sym;
7217c478bd9Sstevel@tonic-gate 
7227c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_obj("libc.so.1", "_tdb_bootstrap", &sym) != 0) {
7237c478bd9Sstevel@tonic-gate 		mdb_warn("cannot find libc.so.1`_tdb_bootstrap");
724892ad162SToomas Soome 		return (0);
7257c478bd9Sstevel@tonic-gate 	}
7267c478bd9Sstevel@tonic-gate 	if (mdb_vread(&addr, sizeof (addr), sym.st_value) == sizeof (addr) &&
727892ad162SToomas Soome 	    addr != 0 &&
7287c478bd9Sstevel@tonic-gate 	    mdb_vread(&uaddr, sizeof (uaddr), addr) == sizeof (uaddr) &&
729892ad162SToomas Soome 	    uaddr != 0) {
7307c478bd9Sstevel@tonic-gate 		return (uaddr);
7317c478bd9Sstevel@tonic-gate 	}
7327c478bd9Sstevel@tonic-gate 	if (mdb_lookup_by_obj("libc.so.1", "_uberdata", &sym) != 0) {
7337c478bd9Sstevel@tonic-gate 		mdb_warn("cannot find libc.so.1`_uberdata");
734892ad162SToomas Soome 		return (0);
7357c478bd9Sstevel@tonic-gate 	}
7367c478bd9Sstevel@tonic-gate 	return ((uintptr_t)sym.st_value);
7377c478bd9Sstevel@tonic-gate }
7387c478bd9Sstevel@tonic-gate 
7397c478bd9Sstevel@tonic-gate #undef OFFSET
7407c478bd9Sstevel@tonic-gate #define	OFFSET(member)	((size_t)OFFSETOF(uberdata_t, member))
7417c478bd9Sstevel@tonic-gate 
7427c478bd9Sstevel@tonic-gate /*ARGSUSED*/
7437c478bd9Sstevel@tonic-gate static int
7447c478bd9Sstevel@tonic-gate d_uberdata(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
7457c478bd9Sstevel@tonic-gate {
7467c478bd9Sstevel@tonic-gate 	uberdata_t uberdata;
7477c478bd9Sstevel@tonic-gate 	int i;
7487c478bd9Sstevel@tonic-gate 
7497c478bd9Sstevel@tonic-gate 	if (argc != 0)
7507c478bd9Sstevel@tonic-gate 		return (DCMD_USAGE);
751892ad162SToomas Soome 	if (!(flags & DCMD_ADDRSPEC) && (addr = uberdata_addr()) == 0)
7527c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
7537c478bd9Sstevel@tonic-gate 
7547c478bd9Sstevel@tonic-gate 	if (mdb_vread(&uberdata, sizeof (uberdata), addr) !=
7557c478bd9Sstevel@tonic-gate 	    sizeof (uberdata)) {
7567c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read uberdata at 0x%p", addr);
7577c478bd9Sstevel@tonic-gate 		return (DCMD_ERR);
7587c478bd9Sstevel@tonic-gate 	}
7597c478bd9Sstevel@tonic-gate 
7607c478bd9Sstevel@tonic-gate 	mdb_printf("%#a\n", addr);
7617c478bd9Sstevel@tonic-gate 
7628cd45542Sraf 	HD("&link_lock            &ld_lock              &fork_lock");
7637c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %s %s\n",
7648cd45542Sraf 	    OFFSET(link_lock),
7658cd45542Sraf 	    prt_addr((void *)(addr + OFFSET(link_lock)), 1),
7668cd45542Sraf 	    prt_addr((void *)(addr + OFFSET(ld_lock)), 1),
7678cd45542Sraf 	    prt_addr((void *)(addr + OFFSET(fork_lock)), 0));
7687c478bd9Sstevel@tonic-gate 
7698cd45542Sraf 	HD("&atfork_lock          &callout_lock         &tdb_hash_lock");
7707c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %s %s\n",
7718cd45542Sraf 	    OFFSET(atfork_lock),
7728cd45542Sraf 	    prt_addr((void *)(addr + OFFSET(atfork_lock)), 1),
7738cd45542Sraf 	    prt_addr((void *)(addr + OFFSET(callout_lock)), 1),
7748cd45542Sraf 	    prt_addr((void *)(addr + OFFSET(tdb_hash_lock)), 0));
7758cd45542Sraf 
7768cd45542Sraf 	HD("&tdb_hash_lock_stats  &siguaction[0]");
7778cd45542Sraf 	mdb_printf(OFFSTR "%s %s\n",
7788cd45542Sraf 	    OFFSET(tdb_hash_lock_stats),
7798cd45542Sraf 	    prt_addr((void *)(addr + OFFSET(tdb_hash_lock_stats)), 1),
7808cd45542Sraf 	    prt_addr((void *)(addr + OFFSET(siguaction)), 0));
7817c478bd9Sstevel@tonic-gate 
7827c478bd9Sstevel@tonic-gate 	HD("&bucket               free_list             chunks");
7837c478bd9Sstevel@tonic-gate 	for (i = 0; i < NBUCKETS; i++) {
7847c478bd9Sstevel@tonic-gate 		mdb_printf(OFFSTR "%s %s %ld\n",
7858cd45542Sraf 		    OFFSET(bucket[i]),
7868cd45542Sraf 		    prt_addr((void *)(addr + OFFSET(bucket[i])), 1),
7878cd45542Sraf 		    prt_addr(uberdata.bucket[i].free_list, 1),
7888cd45542Sraf 		    uberdata.bucket[i].chunks);
7897c478bd9Sstevel@tonic-gate 	}
7907c478bd9Sstevel@tonic-gate 
7917c478bd9Sstevel@tonic-gate 	HD("&atexit_root          head                  exit_frame_monitor");
7927c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %s %s\n",
7938cd45542Sraf 	    OFFSET(atexit_root),
7948cd45542Sraf 	    prt_addr((void *)(addr + OFFSET(atexit_root.exitfns_lock)), 1),
7958cd45542Sraf 	    prt_addr(uberdata.atexit_root.head, 1),
7968cd45542Sraf 	    prt_addr(uberdata.atexit_root.exit_frame_monitor, 0));
7977c478bd9Sstevel@tonic-gate 
798fc2512cfSRobert Mustacchi 	HD("&quickexit_root       head");
799fc2512cfSRobert Mustacchi 	mdb_printf(OFFSTR "%s %s\n",
800fc2512cfSRobert Mustacchi 	    OFFSET(quickexit_root),
801fc2512cfSRobert Mustacchi 	    prt_addr((void *)(addr + OFFSET(quickexit_root.exitfns_lock)), 1),
802fc2512cfSRobert Mustacchi 	    prt_addr(uberdata.quickexit_root.head, 0));
803fc2512cfSRobert Mustacchi 
804fc2512cfSRobert Mustacchi 
8057c478bd9Sstevel@tonic-gate 	HD("&tsd_metadata         tsdm_nkeys tsdm_nused tsdm_destro");
8067c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %-10d %-10d %s\n",
8078cd45542Sraf 	    OFFSET(tsd_metadata),
8088cd45542Sraf 	    prt_addr((void *)(addr + OFFSET(tsd_metadata.tsdm_lock)), 1),
8098cd45542Sraf 	    uberdata.tsd_metadata.tsdm_nkeys,
8108cd45542Sraf 	    uberdata.tsd_metadata.tsdm_nused,
8118cd45542Sraf 	    prt_addr((void *)uberdata.tsd_metadata.tsdm_destro, 0));
8127c478bd9Sstevel@tonic-gate 
8137c478bd9Sstevel@tonic-gate 	HD("&tls_metadata         tls_modinfo.data      tls_modinfo.size");
8147c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %s %ld\n",
8158cd45542Sraf 	    OFFSET(tls_metadata),
8168cd45542Sraf 	    prt_addr((void *)(addr + OFFSET(tls_metadata.tls_lock)), 1),
8178cd45542Sraf 	    prt_addr(uberdata.tls_metadata.tls_modinfo.tls_data, 1),
8188cd45542Sraf 	    uberdata.tls_metadata.tls_modinfo.tls_size);
8197c478bd9Sstevel@tonic-gate 
8207c478bd9Sstevel@tonic-gate 	HD("                      static_tls.data       static_tls.size");
8217c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %s %ld\n",
8228cd45542Sraf 	    OFFSET(tls_metadata.static_tls),
8238cd45542Sraf 	    "                     ",
8248cd45542Sraf 	    prt_addr(uberdata.tls_metadata.static_tls.tls_data, 1),
8258cd45542Sraf 	    uberdata.tls_metadata.static_tls.tls_size);
8267c478bd9Sstevel@tonic-gate 
8277c478bd9Sstevel@tonic-gate 	HD("primary_ma bucket_ini uflags.mt  uflags.pad uflags.trs uflags.ted");
8287c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
8298cd45542Sraf 	    OFFSET(primary_map),
8308cd45542Sraf 	    uberdata.primary_map,
8318cd45542Sraf 	    uberdata.bucket_init,
8328cd45542Sraf 	    uberdata.uberflags.uf_x.x_mt,
8338cd45542Sraf 	    uberdata.uberflags.uf_x.x_pad,
8348cd45542Sraf 	    uberdata.uberflags.uf_x.x_tdb_register_sync,
8358cd45542Sraf 	    uberdata.uberflags.uf_x.x_thread_error_detection);
8367c478bd9Sstevel@tonic-gate 
8377c478bd9Sstevel@tonic-gate 	HD("queue_head            thr_hash_table        hash_size  hash_mask");
8387c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %s %-10d 0x%x\n",
8398cd45542Sraf 	    OFFSET(queue_head),
8408cd45542Sraf 	    prt_addr(uberdata.queue_head, 1),
8418cd45542Sraf 	    prt_addr(uberdata.thr_hash_table, 1),
8428cd45542Sraf 	    uberdata.hash_size,
8438cd45542Sraf 	    uberdata.hash_mask);
8447c478bd9Sstevel@tonic-gate 
8457c478bd9Sstevel@tonic-gate 	HD("ulwp_one              all_lwps              all_zombies");
8467c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %s %s\n",
8478cd45542Sraf 	    OFFSET(ulwp_one),
8488cd45542Sraf 	    prt_addr(uberdata.ulwp_one, 1),
8498cd45542Sraf 	    prt_addr(uberdata.all_lwps, 1),
8508cd45542Sraf 	    prt_addr(uberdata.all_zombies, 0));
8517c478bd9Sstevel@tonic-gate 
8527c478bd9Sstevel@tonic-gate 	HD("nthreads   nzombies   ndaemons   pid        sigacthandler");
8537c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %s\n",
8548cd45542Sraf 	    OFFSET(nthreads),
8558cd45542Sraf 	    uberdata.nthreads,
8568cd45542Sraf 	    uberdata.nzombies,
8578cd45542Sraf 	    uberdata.ndaemons,
8588cd45542Sraf 	    (int)uberdata.pid,
8598cd45542Sraf 	    prt_addr((void *)uberdata.sigacthandler, 0));
8607c478bd9Sstevel@tonic-gate 
8617c478bd9Sstevel@tonic-gate 	HD("lwp_stacks            lwp_laststack         nfreestack stk_cache");
8627c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %s %-10d %d\n",
8638cd45542Sraf 	    OFFSET(lwp_stacks),
8648cd45542Sraf 	    prt_addr(uberdata.lwp_stacks, 1),
8658cd45542Sraf 	    prt_addr(uberdata.lwp_laststack, 1),
8668cd45542Sraf 	    uberdata.nfreestack,
8678cd45542Sraf 	    uberdata.thread_stack_cache);
8687c478bd9Sstevel@tonic-gate 
8698cd45542Sraf 	HD("ulwp_freelist         ulwp_lastfree         ulwp_replace_free");
8708cd45542Sraf 	mdb_printf(OFFSTR "%s %s %s\n",
8718cd45542Sraf 	    OFFSET(ulwp_freelist),
8728cd45542Sraf 	    prt_addr(uberdata.ulwp_freelist, 1),
8738cd45542Sraf 	    prt_addr(uberdata.ulwp_lastfree, 1),
8748cd45542Sraf 	    prt_addr(uberdata.ulwp_replace_free, 0));
875883492d5Sraf 
87609ce0d4aSRoger A. Faulkner 	HD("ulwp_replace_last     atforklist");
87709ce0d4aSRoger A. Faulkner 	mdb_printf(OFFSTR "%s %s\n",
8788cd45542Sraf 	    OFFSET(ulwp_replace_last),
8798cd45542Sraf 	    prt_addr(uberdata.ulwp_replace_last, 1),
88009ce0d4aSRoger A. Faulkner 	    prt_addr(uberdata.atforklist, 0));
88109ce0d4aSRoger A. Faulkner 
88223a1cceaSRoger A. Faulkner 	HD("robustlocks           robustlist            progname");
88323a1cceaSRoger A. Faulkner 	mdb_printf(OFFSTR "%s %s %s\n",
88409ce0d4aSRoger A. Faulkner 	    OFFSET(robustlocks),
88509ce0d4aSRoger A. Faulkner 	    prt_addr(uberdata.robustlocks, 1),
88623a1cceaSRoger A. Faulkner 	    prt_addr(uberdata.robustlist, 1),
88723a1cceaSRoger A. Faulkner 	    prt_addr(uberdata.progname, 0));
8887c478bd9Sstevel@tonic-gate 
8897c478bd9Sstevel@tonic-gate 	HD("tdb_bootstrap         tdb_sync_addr_hash    tdb_'count tdb_'fail");
8907c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %s %-10d %d\n",
8918cd45542Sraf 	    OFFSET(tdb_bootstrap),
8928cd45542Sraf 	    prt_addr(uberdata.tdb_bootstrap, 1),
8938cd45542Sraf 	    prt_addr(uberdata.tdb.tdb_sync_addr_hash, 1),
8948cd45542Sraf 	    uberdata.tdb.tdb_register_count,
8958cd45542Sraf 	    uberdata.tdb.tdb_hash_alloc_failed);
8967c478bd9Sstevel@tonic-gate 
8977c478bd9Sstevel@tonic-gate 	HD("tdb_sync_addr_free    tdb_sync_addr_last    tdb_sync_alloc");
8987c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "%s %s %ld\n",
8998cd45542Sraf 	    OFFSET(tdb.tdb_sync_addr_free),
9008cd45542Sraf 	    prt_addr(uberdata.tdb.tdb_sync_addr_free, 1),
9018cd45542Sraf 	    prt_addr(uberdata.tdb.tdb_sync_addr_last, 1),
9028cd45542Sraf 	    uberdata.tdb.tdb_sync_alloc);
9037c478bd9Sstevel@tonic-gate 
9047c478bd9Sstevel@tonic-gate 	HD("tdb_ev_global_mask    tdb_events");
9057c478bd9Sstevel@tonic-gate 	mdb_printf(OFFSTR "0x%08x 0x%08x %s\n",
9068cd45542Sraf 	    OFFSET(tdb.tdb_ev_global_mask),
9078cd45542Sraf 	    uberdata.tdb.tdb_ev_global_mask.event_bits[0],
9088cd45542Sraf 	    uberdata.tdb.tdb_ev_global_mask.event_bits[1],
9098cd45542Sraf 	    prt_addr((void *)uberdata.tdb.tdb_events, 0));
9107c478bd9Sstevel@tonic-gate 
9117c478bd9Sstevel@tonic-gate 	return (DCMD_OK);
9127c478bd9Sstevel@tonic-gate }
9137c478bd9Sstevel@tonic-gate 
9147c478bd9Sstevel@tonic-gate static int
9157c478bd9Sstevel@tonic-gate ulwp_walk_init(mdb_walk_state_t *wsp)
9167c478bd9Sstevel@tonic-gate {
9177c478bd9Sstevel@tonic-gate 	uintptr_t addr = wsp->walk_addr;
9187c478bd9Sstevel@tonic-gate 	uintptr_t uber_addr;
919e0ee3cedSJason King 	int offset;
920e0ee3cedSJason King 
921e0ee3cedSJason King 	offset = mdb_ctf_offsetof_by_name("uberdata_t", "all_lwps");
922e0ee3cedSJason King 	if (offset == -1) {
923e0ee3cedSJason King 		offset = OFFSETOF(uberdata_t, all_lwps);
924e0ee3cedSJason King 		mdb_warn("CTF data is missing for uberdata_t; using current "
925e0ee3cedSJason King 		    "platform's offset for uberdata.all_lwps");
926e0ee3cedSJason King 	}
9277c478bd9Sstevel@tonic-gate 
928892ad162SToomas Soome 	if (addr == 0 &&
929892ad162SToomas Soome 	    ((uber_addr = uberdata_addr()) == 0 ||
930e0ee3cedSJason King 	    mdb_vread(&addr, sizeof (addr), uber_addr + offset)
9317c478bd9Sstevel@tonic-gate 	    != sizeof (addr))) {
9327c478bd9Sstevel@tonic-gate 		mdb_warn("cannot find 'uberdata.all_lwps'");
9337c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
9347c478bd9Sstevel@tonic-gate 	}
935892ad162SToomas Soome 	if (addr == 0)
9367c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
9377c478bd9Sstevel@tonic-gate 	wsp->walk_addr = addr;
9387c478bd9Sstevel@tonic-gate 	wsp->walk_data = (void *)addr;
9397c478bd9Sstevel@tonic-gate 	return (WALK_NEXT);
9407c478bd9Sstevel@tonic-gate }
9417c478bd9Sstevel@tonic-gate 
9427c478bd9Sstevel@tonic-gate static int
9437c478bd9Sstevel@tonic-gate ulwp_walk_step(mdb_walk_state_t *wsp)
9447c478bd9Sstevel@tonic-gate {
9457c478bd9Sstevel@tonic-gate 	uintptr_t addr = wsp->walk_addr;
9467c478bd9Sstevel@tonic-gate 	ulwp_t ulwp;
9477c478bd9Sstevel@tonic-gate 
948892ad162SToomas Soome 	if (addr == 0)
9497c478bd9Sstevel@tonic-gate 		return (WALK_DONE);
9507c478bd9Sstevel@tonic-gate 	if (mdb_vread(&ulwp, sizeof (ulwp), addr) != sizeof (ulwp) &&
9517c478bd9Sstevel@tonic-gate 	    (bzero(&ulwp, sizeof (ulwp)),
9527c478bd9Sstevel@tonic-gate 	    mdb_vread(&ulwp, REPLACEMENT_SIZE, addr)) != REPLACEMENT_SIZE) {
9537c478bd9Sstevel@tonic-gate 		mdb_warn("failed to read ulwp at 0x%p", addr);
9547c478bd9Sstevel@tonic-gate 		return (WALK_ERR);
9557c478bd9Sstevel@tonic-gate 	}
9567c478bd9Sstevel@tonic-gate 	/*
9577c478bd9Sstevel@tonic-gate 	 * If we have looped around to the beginning
9587c478bd9Sstevel@tonic-gate 	 * of the circular linked list, we are done.
9597c478bd9Sstevel@tonic-gate 	 */
9607c478bd9Sstevel@tonic-gate 	if ((wsp->walk_addr = (uintptr_t)ulwp.ul_forw)
9617c478bd9Sstevel@tonic-gate 	    == (uintptr_t)wsp->walk_data)
962892ad162SToomas Soome 		wsp->walk_addr = 0;
9637c478bd9Sstevel@tonic-gate 	return (wsp->walk_callback(addr, &ulwp, wsp->walk_cbdata));
9647c478bd9Sstevel@tonic-gate }
9657c478bd9Sstevel@tonic-gate 
9664a1c2431SJonathan Adams /* Avoid classifying NULL pointers as part of the main stack on x86 */
9674a1c2431SJonathan Adams #define	MIN_STACK_ADDR		(0x10000ul)
9684a1c2431SJonathan Adams 
9694a1c2431SJonathan Adams static int
9704a1c2431SJonathan Adams whatis_walk_ulwp(uintptr_t addr, const ulwp_t *ulwp, mdb_whatis_t *w)
9714a1c2431SJonathan Adams {
9724a1c2431SJonathan Adams 	uintptr_t cur;
9734a1c2431SJonathan Adams 	lwpid_t id = ulwp->ul_lwpid;
9744a1c2431SJonathan Adams 	uintptr_t top, base, size;
9754a1c2431SJonathan Adams 
9764a1c2431SJonathan Adams 	while (mdb_whatis_match(w, addr, sizeof (ulwp_t), &cur))
9774a1c2431SJonathan Adams 		mdb_whatis_report_object(w, cur, addr,
9784a1c2431SJonathan Adams 		    "allocated as thread %#r's ulwp_t\n", id);
9794a1c2431SJonathan Adams 
9804a1c2431SJonathan Adams 	top = (uintptr_t)ulwp->ul_stktop;
9814a1c2431SJonathan Adams 	size = ulwp->ul_stksiz;
9824a1c2431SJonathan Adams 
9834a1c2431SJonathan Adams 	/*
9844a1c2431SJonathan Adams 	 * The main stack ends up being a little weird, especially if
9854a1c2431SJonathan Adams 	 * the stack ulimit is unlimited.  This tries to take that into
9864a1c2431SJonathan Adams 	 * account.
9874a1c2431SJonathan Adams 	 */
9884a1c2431SJonathan Adams 	if (size > top)
9894a1c2431SJonathan Adams 		size = top;
9904a1c2431SJonathan Adams 	if (top > MIN_STACK_ADDR && top - size < MIN_STACK_ADDR)
9914a1c2431SJonathan Adams 		size = top - MIN_STACK_ADDR;
9924a1c2431SJonathan Adams 
9934a1c2431SJonathan Adams 	base = top - size;
9944a1c2431SJonathan Adams 
9954a1c2431SJonathan Adams 	while (mdb_whatis_match(w, base, size, &cur))
9964a1c2431SJonathan Adams 		mdb_whatis_report_address(w, cur, "in [ stack tid=%#r ]\n", id);
9974a1c2431SJonathan Adams 
9984a1c2431SJonathan Adams 	if (ulwp->ul_ustack.ss_flags & SS_ONSTACK) {
9994a1c2431SJonathan Adams 		base = (uintptr_t)ulwp->ul_ustack.ss_sp;
10004a1c2431SJonathan Adams 		size = ulwp->ul_ustack.ss_size;
10014a1c2431SJonathan Adams 
10024a1c2431SJonathan Adams 		while (mdb_whatis_match(w, base, size, &cur))
10034a1c2431SJonathan Adams 			mdb_whatis_report_address(w, cur,
10044a1c2431SJonathan Adams 			    "in [ altstack tid=%#r ]\n", id);
10054a1c2431SJonathan Adams 	}
10064a1c2431SJonathan Adams 
10074a1c2431SJonathan Adams 	return (WHATIS_WALKRET(w));
10084a1c2431SJonathan Adams }
10094a1c2431SJonathan Adams 
10104a1c2431SJonathan Adams /*ARGSUSED*/
10114a1c2431SJonathan Adams static int
10124a1c2431SJonathan Adams whatis_run_ulwps(mdb_whatis_t *w, void *arg)
10134a1c2431SJonathan Adams {
10144a1c2431SJonathan Adams 	if (mdb_walk("ulwps", (mdb_walk_cb_t)whatis_walk_ulwp, w) == -1) {
10154a1c2431SJonathan Adams 		mdb_warn("couldn't find ulwps walker");
10164a1c2431SJonathan Adams 		return (1);
10174a1c2431SJonathan Adams 	}
10184a1c2431SJonathan Adams 	return (0);
10194a1c2431SJonathan Adams }
10204a1c2431SJonathan Adams 
10217c478bd9Sstevel@tonic-gate /*
10227c478bd9Sstevel@tonic-gate  * =======================================================
10237c478bd9Sstevel@tonic-gate  * End of thread (previously libthread) interfaces.
10247c478bd9Sstevel@tonic-gate  * ==================== threads ==========================
10257c478bd9Sstevel@tonic-gate  */
10267c478bd9Sstevel@tonic-gate 
1027c9a6ea2eSBryan Cantrill int
1028c9a6ea2eSBryan Cantrill stacks_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1029c9a6ea2eSBryan Cantrill {
1030c9a6ea2eSBryan Cantrill 	int rval = stacks(addr, flags, argc, argv);
1031c9a6ea2eSBryan Cantrill 
1032c9a6ea2eSBryan Cantrill 	/*
1033c9a6ea2eSBryan Cantrill 	 * For the user-level variant of ::stacks, we don't bother caching
1034c9a6ea2eSBryan Cantrill 	 * state, as even a very large program is unlikely to compare to the
1035c9a6ea2eSBryan Cantrill 	 * kernel in terms of number of threads.  (And if you find yourself
1036c9a6ea2eSBryan Cantrill 	 * here in anger, frustrated about how long ::stacks is running on
1037c9a6ea2eSBryan Cantrill 	 * your galactically complicated zillion-thread program, hopefully
1038c9a6ea2eSBryan Cantrill 	 * you will find some solace in the irony.  Okay, probably not...)
1039c9a6ea2eSBryan Cantrill 	 */
1040c9a6ea2eSBryan Cantrill 	stacks_cleanup(B_TRUE);
1041c9a6ea2eSBryan Cantrill 	return (rval);
1042c9a6ea2eSBryan Cantrill }
1043c9a6ea2eSBryan Cantrill 
1044c9a6ea2eSBryan Cantrill typedef struct tid2ulwp_walk {
1045c9a6ea2eSBryan Cantrill 	lwpid_t t2u_tid;
1046c9a6ea2eSBryan Cantrill 	uintptr_t t2u_lwp;
1047c9a6ea2eSBryan Cantrill 	boolean_t t2u_found;
1048c9a6ea2eSBryan Cantrill } tid2ulwp_walk_t;
1049c9a6ea2eSBryan Cantrill 
1050c9a6ea2eSBryan Cantrill /*ARGSUSED*/
1051c9a6ea2eSBryan Cantrill static int
1052c9a6ea2eSBryan Cantrill tid2ulwp_walk(uintptr_t addr, ulwp_t *ulwp, tid2ulwp_walk_t *t2u)
1053c9a6ea2eSBryan Cantrill {
1054c9a6ea2eSBryan Cantrill 	if (ulwp->ul_lwpid == t2u->t2u_tid) {
1055c9a6ea2eSBryan Cantrill 		t2u->t2u_lwp = addr;
1056c9a6ea2eSBryan Cantrill 		t2u->t2u_found = B_TRUE;
1057c9a6ea2eSBryan Cantrill 		return (WALK_DONE);
1058c9a6ea2eSBryan Cantrill 	}
1059c9a6ea2eSBryan Cantrill 
1060c9a6ea2eSBryan Cantrill 	return (WALK_NEXT);
1061c9a6ea2eSBryan Cantrill }
1062c9a6ea2eSBryan Cantrill 
1063c9a6ea2eSBryan Cantrill static int
106428e4da25SMatthew Ahrens tid2ulwp_impl(uintptr_t tid_addr, uintptr_t *ulwp_addrp)
1065c9a6ea2eSBryan Cantrill {
1066c9a6ea2eSBryan Cantrill 	tid2ulwp_walk_t t2u;
1067c9a6ea2eSBryan Cantrill 
1068c9a6ea2eSBryan Cantrill 	bzero(&t2u, sizeof (t2u));
106928e4da25SMatthew Ahrens 	t2u.t2u_tid = (lwpid_t)tid_addr;
1070c9a6ea2eSBryan Cantrill 
1071c9a6ea2eSBryan Cantrill 	if (mdb_walk("ulwp", (mdb_walk_cb_t)tid2ulwp_walk, &t2u) != 0) {
1072c9a6ea2eSBryan Cantrill 		mdb_warn("can't walk 'ulwp'");
1073c9a6ea2eSBryan Cantrill 		return (DCMD_ERR);
1074c9a6ea2eSBryan Cantrill 	}
1075c9a6ea2eSBryan Cantrill 
1076c9a6ea2eSBryan Cantrill 	if (!t2u.t2u_found) {
1077c9a6ea2eSBryan Cantrill 		mdb_warn("thread ID %d not found", t2u.t2u_tid);
1078c9a6ea2eSBryan Cantrill 		return (DCMD_ERR);
1079c9a6ea2eSBryan Cantrill 	}
108028e4da25SMatthew Ahrens 	*ulwp_addrp = t2u.t2u_lwp;
108128e4da25SMatthew Ahrens 	return (DCMD_OK);
108228e4da25SMatthew Ahrens }
1083c9a6ea2eSBryan Cantrill 
108428e4da25SMatthew Ahrens /*ARGSUSED*/
108528e4da25SMatthew Ahrens static int
108628e4da25SMatthew Ahrens tid2ulwp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
108728e4da25SMatthew Ahrens {
108828e4da25SMatthew Ahrens 	uintptr_t ulwp_addr;
108928e4da25SMatthew Ahrens 	int error;
109028e4da25SMatthew Ahrens 
109128e4da25SMatthew Ahrens 	if (argc != 0)
109228e4da25SMatthew Ahrens 		return (DCMD_USAGE);
109328e4da25SMatthew Ahrens 
109428e4da25SMatthew Ahrens 	error = tid2ulwp_impl(addr, &ulwp_addr);
109528e4da25SMatthew Ahrens 	if (error == DCMD_OK)
109628e4da25SMatthew Ahrens 		mdb_printf("%p\n", ulwp_addr);
109728e4da25SMatthew Ahrens 	return (error);
109828e4da25SMatthew Ahrens }
109928e4da25SMatthew Ahrens 
110028e4da25SMatthew Ahrens typedef struct mdb_libc_ulwp {
110128e4da25SMatthew Ahrens 	void *ul_ftsd[TSD_NFAST];
110228e4da25SMatthew Ahrens 	tsd_t *ul_stsd;
110328e4da25SMatthew Ahrens } mdb_libc_ulwp_t;
110428e4da25SMatthew Ahrens 
110528e4da25SMatthew Ahrens /*
110628e4da25SMatthew Ahrens  * Map from thread pointer to tsd for given key
110728e4da25SMatthew Ahrens  */
110828e4da25SMatthew Ahrens static int
110928e4da25SMatthew Ahrens d_tsd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
111028e4da25SMatthew Ahrens {
111128e4da25SMatthew Ahrens 	mdb_libc_ulwp_t u;
111228e4da25SMatthew Ahrens 	uintptr_t ulwp_addr;
1113892ad162SToomas Soome 	uintptr_t key = 0;
111428e4da25SMatthew Ahrens 	void *element = NULL;
111528e4da25SMatthew Ahrens 
111628e4da25SMatthew Ahrens 	if (mdb_getopts(argc, argv, 'k', MDB_OPT_UINTPTR, &key, NULL) != argc)
111728e4da25SMatthew Ahrens 		return (DCMD_USAGE);
111828e4da25SMatthew Ahrens 
1119892ad162SToomas Soome 	if (!(flags & DCMD_ADDRSPEC) || key == 0)
112028e4da25SMatthew Ahrens 		return (DCMD_USAGE);
112128e4da25SMatthew Ahrens 
112228e4da25SMatthew Ahrens 	if (tid2ulwp_impl(addr, &ulwp_addr) != DCMD_OK)
112328e4da25SMatthew Ahrens 		return (DCMD_ERR);
112428e4da25SMatthew Ahrens 
112528e4da25SMatthew Ahrens 	if (mdb_ctf_vread(&u, "ulwp_t", "mdb_libc_ulwp_t", ulwp_addr, 0) == -1)
112628e4da25SMatthew Ahrens 		return (DCMD_ERR);
112728e4da25SMatthew Ahrens 
112828e4da25SMatthew Ahrens 	if (key < TSD_NFAST) {
112928e4da25SMatthew Ahrens 		element = u.ul_ftsd[key];
113028e4da25SMatthew Ahrens 	} else if (u.ul_stsd != NULL) {
113128e4da25SMatthew Ahrens 		uint_t nalloc;
113228e4da25SMatthew Ahrens 		/* tsd_t is a union, so we can't use ctf_vread() on it. */
113328e4da25SMatthew Ahrens 		if (mdb_vread(&nalloc, sizeof (nalloc),
113428e4da25SMatthew Ahrens 		    (uintptr_t)&u.ul_stsd->tsd_nalloc) == -1) {
113528e4da25SMatthew Ahrens 			mdb_warn("failed to read tsd_t at %p", u.ul_stsd);
113628e4da25SMatthew Ahrens 			return (DCMD_ERR);
113728e4da25SMatthew Ahrens 		}
113828e4da25SMatthew Ahrens 		if (key < nalloc) {
113928e4da25SMatthew Ahrens 			if (mdb_vread(&element, sizeof (element),
114028e4da25SMatthew Ahrens 			    (uintptr_t)&u.ul_stsd->tsd_data[key]) == -1) {
114128e4da25SMatthew Ahrens 				mdb_warn("failed to read tsd_t at %p",
114228e4da25SMatthew Ahrens 				    u.ul_stsd);
114328e4da25SMatthew Ahrens 				return (DCMD_ERR);
114428e4da25SMatthew Ahrens 			}
114528e4da25SMatthew Ahrens 		}
114628e4da25SMatthew Ahrens 	}
114728e4da25SMatthew Ahrens 
114828e4da25SMatthew Ahrens 	if (element == NULL && (flags & DCMD_PIPE))
114928e4da25SMatthew Ahrens 		return (DCMD_OK);
1150c9a6ea2eSBryan Cantrill 
115128e4da25SMatthew Ahrens 	mdb_printf("%p\n", element);
1152c9a6ea2eSBryan Cantrill 	return (DCMD_OK);
1153c9a6ea2eSBryan Cantrill }
1154c9a6ea2eSBryan Cantrill 
1155*542a7b7fSCarlos Neira /*
1156*542a7b7fSCarlos Neira  * Print percent from 16-bit binary fraction [0 .. 1]
1157*542a7b7fSCarlos Neira  * Round up .01 to .1 to indicate some small percentage (the 0x7000 below).
1158*542a7b7fSCarlos Neira  *
1159*542a7b7fSCarlos Neira  * Note: This routine was copied from elfdump/common/corenote.c	and modified.
1160*542a7b7fSCarlos Neira  *
1161*542a7b7fSCarlos Neira  */
1162*542a7b7fSCarlos Neira static uint_t
1163*542a7b7fSCarlos Neira pct_value(ushort_t pct)
1164*542a7b7fSCarlos Neira {
1165*542a7b7fSCarlos Neira 	uint_t value = pct;
1166*542a7b7fSCarlos Neira 
1167*542a7b7fSCarlos Neira 	value = ((value * 1000) + 0x7000) >> 15;	/* [0 .. 1000] */
1168*542a7b7fSCarlos Neira 	if (value >= 1000)
1169*542a7b7fSCarlos Neira 		value = 999;
1170*542a7b7fSCarlos Neira 
1171*542a7b7fSCarlos Neira 	return (value);
1172*542a7b7fSCarlos Neira }
1173*542a7b7fSCarlos Neira 
1174*542a7b7fSCarlos Neira static void
1175*542a7b7fSCarlos Neira psinfo_raw(psinfo_t psinfo)
1176*542a7b7fSCarlos Neira {
1177*542a7b7fSCarlos Neira 	const int minspaces = 2;
1178*542a7b7fSCarlos Neira 	const int spbcols = 20;
1179*542a7b7fSCarlos Neira 	char sysname[SYS2STR_MAX];
1180*542a7b7fSCarlos Neira 	uint_t cpu, mem;
1181*542a7b7fSCarlos Neira 	char buff[32];
1182*542a7b7fSCarlos Neira 	int bufflen;
1183*542a7b7fSCarlos Neira 
1184*542a7b7fSCarlos Neira 	mdb_printf("[ NT_PRPSINFO ]\n");
1185*542a7b7fSCarlos Neira 
1186*542a7b7fSCarlos Neira 	mdb_printf("\tpr_state:   %d\t\t\tpr_sname:   %c\n",
1187*542a7b7fSCarlos Neira 	    psinfo.pr_lwp.pr_state, psinfo.pr_lwp.pr_sname);
1188*542a7b7fSCarlos Neira 
1189*542a7b7fSCarlos Neira 	mdb_printf("\tpr_zomb:    %d\t\t\tpr_nice:    %d\n",
1190*542a7b7fSCarlos Neira 	    psinfo.pr_nzomb, psinfo.pr_lwp.pr_nice);
1191*542a7b7fSCarlos Neira 
1192*542a7b7fSCarlos Neira 	mdb_printf("\tpr_uid:     %u\t\t\tpr_gid:     %u\n",
1193*542a7b7fSCarlos Neira 	    psinfo.pr_uid, psinfo.pr_gid);
1194*542a7b7fSCarlos Neira 
1195*542a7b7fSCarlos Neira 	mdb_snprintf(buff, sizeof (buff),
1196*542a7b7fSCarlos Neira 	    "%d", psinfo.pr_pid);
1197*542a7b7fSCarlos Neira 
1198*542a7b7fSCarlos Neira 	bufflen = strlen(buff);
1199*542a7b7fSCarlos Neira 	mdb_printf("\tpr_pid:     %s%*spr_ppid:    %d\n",
1200*542a7b7fSCarlos Neira 	    buff, strlen(buff) > spbcols ? minspaces : (spbcols - bufflen), " ",
1201*542a7b7fSCarlos Neira 	    psinfo.pr_ppid);
1202*542a7b7fSCarlos Neira 
1203*542a7b7fSCarlos Neira 	mdb_printf("\tpr_pgid:    %u\t\t\tpr_sid:     %d\n",
1204*542a7b7fSCarlos Neira 	    psinfo.pr_gid, psinfo.pr_sid);
1205*542a7b7fSCarlos Neira 
1206*542a7b7fSCarlos Neira 	mdb_snprintf(buff, sizeof (buff),
1207*542a7b7fSCarlos Neira 	    "0x%lx", (ulong_t)psinfo.pr_addr);
1208*542a7b7fSCarlos Neira 
1209*542a7b7fSCarlos Neira 	bufflen = strlen(buff);
1210*542a7b7fSCarlos Neira 
1211*542a7b7fSCarlos Neira 	mdb_printf("\tpr_addr:    %s%*spr_size:    %#x\n",
1212*542a7b7fSCarlos Neira 	    buff, strlen(buff) > spbcols ? minspaces : (spbcols - bufflen), " ",
1213*542a7b7fSCarlos Neira 	    (ulong_t)psinfo.pr_size);
1214*542a7b7fSCarlos Neira 
1215*542a7b7fSCarlos Neira 	mdb_printf("\tpr_rssize:  %#lx\t\tpr_wchan:   %#lx\n",
1216*542a7b7fSCarlos Neira 	    (ulong_t)psinfo.pr_rssize, (ulong_t)psinfo.pr_lwp.pr_wchan);
1217*542a7b7fSCarlos Neira 
1218*542a7b7fSCarlos Neira 	mdb_printf("\tpr_start:\n\t    tv_sec: %ld\t\ttv_nsec:    %ld\n",
1219*542a7b7fSCarlos Neira 	    psinfo.pr_start.tv_sec, psinfo.pr_start.tv_nsec);
1220*542a7b7fSCarlos Neira 
1221*542a7b7fSCarlos Neira 	mdb_printf("\tpr_time:\n\t    tv_sec: %ld\t\t\ttv_nsec:    %ld\n",
1222*542a7b7fSCarlos Neira 	    psinfo.pr_time.tv_sec, psinfo.pr_time.tv_nsec);
1223*542a7b7fSCarlos Neira 
1224*542a7b7fSCarlos Neira 	mdb_printf("\tpr_pri:     %d\t\t\tpr_oldpri:  %d\n",
1225*542a7b7fSCarlos Neira 	    psinfo.pr_lwp.pr_pri, psinfo.pr_lwp.pr_oldpri);
1226*542a7b7fSCarlos Neira 
1227*542a7b7fSCarlos Neira 	mdb_printf("\tpr_cpu:     %d\n", psinfo.pr_lwp.pr_cpu);
1228*542a7b7fSCarlos Neira 
1229*542a7b7fSCarlos Neira 	mdb_printf("\tpr_clname:  %s\n", psinfo.pr_lwp.pr_clname);
1230*542a7b7fSCarlos Neira 
1231*542a7b7fSCarlos Neira 	mdb_printf("\tpr_fname:   %s\n", psinfo.pr_fname);
1232*542a7b7fSCarlos Neira 
1233*542a7b7fSCarlos Neira 	mdb_printf("\tpr_psargs:  %s\n", psinfo.pr_psargs);
1234*542a7b7fSCarlos Neira 
1235*542a7b7fSCarlos Neira 
1236*542a7b7fSCarlos Neira 	mdb_printf("\tpr_syscall: [ %s ]\n",
1237*542a7b7fSCarlos Neira 	    proc_sysname(psinfo.pr_lwp.pr_syscall, sysname,
1238*542a7b7fSCarlos Neira 	    sizeof (sysname)));
1239*542a7b7fSCarlos Neira 
1240*542a7b7fSCarlos Neira 	mdb_printf("\tpr_ctime:\n\t    tv_sec: %ld\t\t\ttv_nsec:    %ld\n",
1241*542a7b7fSCarlos Neira 	    psinfo.pr_ctime.tv_sec, psinfo.pr_ctime.tv_nsec);
1242*542a7b7fSCarlos Neira 
1243*542a7b7fSCarlos Neira 	mdb_printf("\tpr_argc:    %d\t\t\tpr_argv:    0x%lx\n",
1244*542a7b7fSCarlos Neira 	    psinfo.pr_argc, (ulong_t)psinfo.pr_argv);
1245*542a7b7fSCarlos Neira 
1246*542a7b7fSCarlos Neira 	mdb_snprintf(buff, sizeof (buff), "0x%lx", (ulong_t)psinfo.pr_envp);
1247*542a7b7fSCarlos Neira 
1248*542a7b7fSCarlos Neira 	bufflen = strlen(buff);
1249*542a7b7fSCarlos Neira 
1250*542a7b7fSCarlos Neira 	mdb_printf("\tpr_envp:    %s%*spr_wstat:   %d\n",
1251*542a7b7fSCarlos Neira 	    buff, strlen(buff) > spbcols ? minspaces : (spbcols - bufflen), " ",
1252*542a7b7fSCarlos Neira 	    psinfo.pr_wstat);
1253*542a7b7fSCarlos Neira 
1254*542a7b7fSCarlos Neira 	cpu = pct_value(psinfo.pr_pctcpu);
1255*542a7b7fSCarlos Neira 	mem = pct_value(psinfo.pr_pctmem);
1256*542a7b7fSCarlos Neira 
1257*542a7b7fSCarlos Neira 	mdb_printf("\tpr_pctcpu:  %u.%u%%\t\tpr_pctmem:  %u.%u%%\n",
1258*542a7b7fSCarlos Neira 	    cpu / 10, cpu % 10, mem / 10, mem % 10);
1259*542a7b7fSCarlos Neira 
1260*542a7b7fSCarlos Neira 	mdb_printf("\tpr_euid:    %u\t\t\tpr_egid:    %u\n",
1261*542a7b7fSCarlos Neira 	    psinfo.pr_euid, psinfo.pr_egid);
1262*542a7b7fSCarlos Neira 
1263*542a7b7fSCarlos Neira 	mdb_printf("\tpr_dmodel:  [%s]\n",
1264*542a7b7fSCarlos Neira 	    proc_dmodelname(psinfo.pr_dmodel, buff, sizeof (buff)));
1265*542a7b7fSCarlos Neira }
1266*542a7b7fSCarlos Neira 
1267*542a7b7fSCarlos Neira static void
1268*542a7b7fSCarlos Neira psinfo_sum(psinfo_t psinfo)
1269*542a7b7fSCarlos Neira {
1270*542a7b7fSCarlos Neira 	const int minspaces = 2;
1271*542a7b7fSCarlos Neira 	const int spbcols = 23;
1272*542a7b7fSCarlos Neira 	char buff[64];
1273*542a7b7fSCarlos Neira 	int bufflen;
1274*542a7b7fSCarlos Neira 	int ms;
1275*542a7b7fSCarlos Neira 
1276*542a7b7fSCarlos Neira 	mdb_printf("PID:    %6d  (process id)\t\t"
1277*542a7b7fSCarlos Neira 	    "UID:     %4u  (real user id)\n",
1278*542a7b7fSCarlos Neira 	    psinfo.pr_pid, psinfo.pr_uid);
1279*542a7b7fSCarlos Neira 
1280*542a7b7fSCarlos Neira 	mdb_printf("PPID:   %6d  (parent process id)\tEUID:    %4d"
1281*542a7b7fSCarlos Neira 	    "  (effective user id)\n", psinfo.pr_ppid, psinfo.pr_euid);
1282*542a7b7fSCarlos Neira 
1283*542a7b7fSCarlos Neira 	mdb_printf("PGID:   %6d  (process group id)\tGID:     %4u"
1284*542a7b7fSCarlos Neira 	    "  (real group id)\n", psinfo.pr_pgid, psinfo.pr_gid);
1285*542a7b7fSCarlos Neira 
1286*542a7b7fSCarlos Neira 	mdb_printf("SID:    %6d  (session id)\t\tEGID:    %4u"
1287*542a7b7fSCarlos Neira 	    "  (effective group id)\n",
1288*542a7b7fSCarlos Neira 	    psinfo.pr_sid, psinfo.pr_egid);
1289*542a7b7fSCarlos Neira 
1290*542a7b7fSCarlos Neira 	mdb_printf("ZONEID: %6d\t\t\t\tCONTRACT:%4d\n",
1291*542a7b7fSCarlos Neira 	    psinfo.pr_zoneid, psinfo.pr_contract);
1292*542a7b7fSCarlos Neira 
1293*542a7b7fSCarlos Neira 	mdb_printf("PROJECT:%6d \t\t\t\tTASK:    %4d\n\n",
1294*542a7b7fSCarlos Neira 	    psinfo.pr_projid, psinfo.pr_taskid);
1295*542a7b7fSCarlos Neira 
1296*542a7b7fSCarlos Neira 	mdb_printf("START: %Y   (wall timestamp when the process started)\n",
1297*542a7b7fSCarlos Neira 	    psinfo.pr_start);
1298*542a7b7fSCarlos Neira 
1299*542a7b7fSCarlos Neira 	ms = NSEC2MSEC(psinfo.pr_time.tv_nsec);
1300*542a7b7fSCarlos Neira 
1301*542a7b7fSCarlos Neira 	mdb_snprintf(buff, sizeof (buff), "%ld.%d seconds",
1302*542a7b7fSCarlos Neira 	    psinfo.pr_time.tv_sec, ms);
1303*542a7b7fSCarlos Neira 
1304*542a7b7fSCarlos Neira 	bufflen = strlen(buff);
1305*542a7b7fSCarlos Neira 
1306*542a7b7fSCarlos Neira 	mdb_printf("TIME:  %s%*s"
1307*542a7b7fSCarlos Neira 	    "(CPU time used by this process)\n",
1308*542a7b7fSCarlos Neira 	    buff, bufflen > spbcols ? minspaces : (spbcols - bufflen), " ");
1309*542a7b7fSCarlos Neira 
1310*542a7b7fSCarlos Neira 	ms = NSEC2MSEC(psinfo.pr_ctime.tv_nsec);
1311*542a7b7fSCarlos Neira 
1312*542a7b7fSCarlos Neira 	mdb_snprintf(buff, sizeof (buff), "%ld.%d seconds",
1313*542a7b7fSCarlos Neira 	    psinfo.pr_ctime.tv_sec, ms);
1314*542a7b7fSCarlos Neira 
1315*542a7b7fSCarlos Neira 	mdb_printf("CTIME: %s%*s"
1316*542a7b7fSCarlos Neira 	    "(CPU time used by child processes)\n",
1317*542a7b7fSCarlos Neira 	    buff, bufflen > spbcols ? minspaces : (spbcols - bufflen), " ");
1318*542a7b7fSCarlos Neira 
1319*542a7b7fSCarlos Neira 	mdb_snprintf(buff, sizeof (buff), "%s", psinfo.pr_fname);
1320*542a7b7fSCarlos Neira 	bufflen = strlen(buff);
1321*542a7b7fSCarlos Neira 
1322*542a7b7fSCarlos Neira 	mdb_printf("FNAME: %s%*s(name of the program executed)\n",
1323*542a7b7fSCarlos Neira 	    buff, bufflen > spbcols ? minspaces : (spbcols - bufflen), " ");
1324*542a7b7fSCarlos Neira 
1325*542a7b7fSCarlos Neira 	mdb_printf("PSARGS: \"%s\"\n", psinfo.pr_psargs);
1326*542a7b7fSCarlos Neira }
1327*542a7b7fSCarlos Neira 
1328*542a7b7fSCarlos Neira void
1329*542a7b7fSCarlos Neira d_psinfo_dcmd_help(void)
1330*542a7b7fSCarlos Neira {
1331*542a7b7fSCarlos Neira 	mdb_printf(
1332*542a7b7fSCarlos Neira 	    "Prints relevant fields from psinfo_t data and\n"
1333*542a7b7fSCarlos Neira 	    "most fields from NT_PRPSINFO note section\n\n"
1334*542a7b7fSCarlos Neira 	    "Usage:  ::psinfo [-v]\n"
1335*542a7b7fSCarlos Neira 	    "Options:\n"
1336*542a7b7fSCarlos Neira 	    "   -v   verbose output\n");
1337*542a7b7fSCarlos Neira }
1338*542a7b7fSCarlos Neira 
1339*542a7b7fSCarlos Neira static int
1340*542a7b7fSCarlos Neira d_psinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1341*542a7b7fSCarlos Neira {
1342*542a7b7fSCarlos Neira 	psinfo_t psinfo;
1343*542a7b7fSCarlos Neira 	uint_t opt_v = FALSE;
1344*542a7b7fSCarlos Neira 	ssize_t nbytes;
1345*542a7b7fSCarlos Neira 
1346*542a7b7fSCarlos Neira 	if (mdb_getopts(argc, argv, 'v',
1347*542a7b7fSCarlos Neira 	    MDB_OPT_SETBITS, TRUE, &opt_v, NULL) != argc)
1348*542a7b7fSCarlos Neira 		return (DCMD_USAGE);
1349*542a7b7fSCarlos Neira 
1350*542a7b7fSCarlos Neira 	nbytes = mdb_get_xdata("psinfo", NULL, 0);
1351*542a7b7fSCarlos Neira 
1352*542a7b7fSCarlos Neira 	if (nbytes <= 0) {
1353*542a7b7fSCarlos Neira 		mdb_warn("information not available for analysis");
1354*542a7b7fSCarlos Neira 		return (DCMD_ERR);
1355*542a7b7fSCarlos Neira 	}
1356*542a7b7fSCarlos Neira 
1357*542a7b7fSCarlos Neira 	if (mdb_get_xdata("psinfo", &psinfo, nbytes) != nbytes) {
1358*542a7b7fSCarlos Neira 		mdb_warn("failed to read psinfo information");
1359*542a7b7fSCarlos Neira 		return (DCMD_ERR);
1360*542a7b7fSCarlos Neira 	}
1361*542a7b7fSCarlos Neira 
1362*542a7b7fSCarlos Neira 	if (opt_v) {
1363*542a7b7fSCarlos Neira 		psinfo_raw(psinfo);
1364*542a7b7fSCarlos Neira 	} else {
1365*542a7b7fSCarlos Neira 		psinfo_sum(psinfo);
1366*542a7b7fSCarlos Neira 	}
1367*542a7b7fSCarlos Neira 
1368*542a7b7fSCarlos Neira 	return (DCMD_OK);
1369*542a7b7fSCarlos Neira }
1370*542a7b7fSCarlos Neira 
13717c478bd9Sstevel@tonic-gate static const mdb_dcmd_t dcmds[] = {
13727c478bd9Sstevel@tonic-gate 	{ "jmp_buf", ":", "print jmp_buf contents", d_jmp_buf, NULL },
13737c478bd9Sstevel@tonic-gate 	{ "sigjmp_buf", ":", "print sigjmp_buf contents", d_sigjmp_buf, NULL },
13747c478bd9Sstevel@tonic-gate 	{ "siginfo", ":", "print siginfo_t structure", d_siginfo, NULL },
1375c9a6ea2eSBryan Cantrill 	{ "stacks", "?[-afiv] [-c func] [-C func] [-m module] [-M module] ",
1376c9a6ea2eSBryan Cantrill 		"print unique thread stacks", stacks_dcmd, stacks_help },
1377c9a6ea2eSBryan Cantrill 	{ "tid2ulwp", "?", "convert TID to ulwp_t address", tid2ulwp },
13787c478bd9Sstevel@tonic-gate 	{ "ucontext", ":", "print ucontext_t structure", d_ucontext, NULL },
13797c478bd9Sstevel@tonic-gate 	{ "ulwp", ":", "print ulwp_t structure", d_ulwp, NULL },
13807c478bd9Sstevel@tonic-gate 	{ "uberdata", ":", "print uberdata_t structure", d_uberdata, NULL },
138128e4da25SMatthew Ahrens 	{ "tsd", ":-k key", "print tsd for this thread", d_tsd, NULL },
1382*542a7b7fSCarlos Neira 	{ "psinfo", "[-v]", "prints relevant psinfo_t data", d_psinfo,
1383*542a7b7fSCarlos Neira 	    d_psinfo_dcmd_help },
13847c478bd9Sstevel@tonic-gate 	{ NULL }
13857c478bd9Sstevel@tonic-gate };
13867c478bd9Sstevel@tonic-gate 
13877c478bd9Sstevel@tonic-gate static const mdb_walker_t walkers[] = {
13887c478bd9Sstevel@tonic-gate 	{ "ucontext", "walk ucontext_t uc_link list",
13897c478bd9Sstevel@tonic-gate 		NULL, uc_walk_step, NULL, NULL },
13907c478bd9Sstevel@tonic-gate 	{ "oldcontext", "walk per-lwp oldcontext pointers",
13917c478bd9Sstevel@tonic-gate 		oldc_walk_init, oldc_walk_step, oldc_walk_fini, NULL },
13927c478bd9Sstevel@tonic-gate 	{ "ulwps", "walk list of ulwp_t pointers",
13937c478bd9Sstevel@tonic-gate 		ulwp_walk_init, ulwp_walk_step, NULL, NULL },
1394c9a6ea2eSBryan Cantrill 	{ "ulwp", "walk list of ulwp_t pointers",
1395c9a6ea2eSBryan Cantrill 		ulwp_walk_init, ulwp_walk_step, NULL, NULL },
13967c478bd9Sstevel@tonic-gate 	{ NULL }
13977c478bd9Sstevel@tonic-gate };
13987c478bd9Sstevel@tonic-gate 
13997c478bd9Sstevel@tonic-gate static const mdb_modinfo_t modinfo = { MDB_API_VERSION, dcmds, walkers };
14007c478bd9Sstevel@tonic-gate 
14017c478bd9Sstevel@tonic-gate const mdb_modinfo_t *
14027c478bd9Sstevel@tonic-gate _mdb_init(void)
14037c478bd9Sstevel@tonic-gate {
14044a1c2431SJonathan Adams 	mdb_whatis_register("threads", whatis_run_ulwps, NULL,
14054a1c2431SJonathan Adams 	    WHATIS_PRIO_EARLY, WHATIS_REG_NO_ID);
14064a1c2431SJonathan Adams 
14077c478bd9Sstevel@tonic-gate 	return (&modinfo);
14087c478bd9Sstevel@tonic-gate }
1409