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.
25542a7b7fSCarlos Neira * Copyright (c) 2019 Carlos Neira <cneirabustos@gmail.com>
26542a7b7fSCarlos Neira * Copyright 2019 OmniOS Community Edition (OmniOSce) Association.
2707188943SJason King * Copyright 2019 Joyent, Inc.
28a48fdbefSBryan Cantrill * Copyright 2024 Oxide Computer Company
294f364e7cSRobert Mustacchi */
307c478bd9Sstevel@tonic-gate
317c478bd9Sstevel@tonic-gate #include <sys/mdb_modapi.h>
324a1c2431SJonathan Adams #include <mdb/mdb_whatis.h>
3328e4da25SMatthew Ahrens #include <mdb/mdb_ctf.h>
347c478bd9Sstevel@tonic-gate #include <procfs.h>
357c478bd9Sstevel@tonic-gate #include <ucontext.h>
367c478bd9Sstevel@tonic-gate #include <siginfo.h>
377c478bd9Sstevel@tonic-gate #include <signal.h>
387c478bd9Sstevel@tonic-gate #include <setjmp.h>
397c478bd9Sstevel@tonic-gate #include <string.h>
407c478bd9Sstevel@tonic-gate #include <thr_uberdata.h>
41c9a6ea2eSBryan Cantrill #include "findstack.h"
42542a7b7fSCarlos Neira #include <libproc.h>
437c478bd9Sstevel@tonic-gate
447c478bd9Sstevel@tonic-gate static const char *
stack_flags(const stack_t * sp)457c478bd9Sstevel@tonic-gate stack_flags(const stack_t *sp)
467c478bd9Sstevel@tonic-gate {
477c478bd9Sstevel@tonic-gate static char buf[32];
487c478bd9Sstevel@tonic-gate
497c478bd9Sstevel@tonic-gate if (sp->ss_flags == 0)
507c478bd9Sstevel@tonic-gate (void) strcpy(buf, " 0");
517c478bd9Sstevel@tonic-gate else if (sp->ss_flags & ~(SS_ONSTACK | SS_DISABLE))
527c478bd9Sstevel@tonic-gate (void) mdb_snprintf(buf, sizeof (buf), " 0x%x", sp->ss_flags);
537c478bd9Sstevel@tonic-gate else {
547c478bd9Sstevel@tonic-gate buf[0] = '\0';
557c478bd9Sstevel@tonic-gate if (sp->ss_flags & SS_ONSTACK)
567c478bd9Sstevel@tonic-gate (void) strcat(buf, "|ONSTACK");
577c478bd9Sstevel@tonic-gate if (sp->ss_flags & SS_DISABLE)
587c478bd9Sstevel@tonic-gate (void) strcat(buf, "|DISABLE");
597c478bd9Sstevel@tonic-gate }
607c478bd9Sstevel@tonic-gate
617c478bd9Sstevel@tonic-gate return (buf + 1);
627c478bd9Sstevel@tonic-gate }
637c478bd9Sstevel@tonic-gate
647c478bd9Sstevel@tonic-gate /*ARGSUSED*/
657c478bd9Sstevel@tonic-gate static int
d_jmp_buf(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)667c478bd9Sstevel@tonic-gate d_jmp_buf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
677c478bd9Sstevel@tonic-gate {
687c478bd9Sstevel@tonic-gate jmp_buf jb;
697c478bd9Sstevel@tonic-gate const ulong_t *b = (const ulong_t *)jb;
707c478bd9Sstevel@tonic-gate
717c478bd9Sstevel@tonic-gate if (argc != 0)
727c478bd9Sstevel@tonic-gate return (DCMD_USAGE);
737c478bd9Sstevel@tonic-gate
747c478bd9Sstevel@tonic-gate if (mdb_vread(&jb, sizeof (jb), addr) != sizeof (jb)) {
757c478bd9Sstevel@tonic-gate mdb_warn("failed to read jmp_buf at %p", addr);
767c478bd9Sstevel@tonic-gate return (DCMD_ERR);
777c478bd9Sstevel@tonic-gate }
787c478bd9Sstevel@tonic-gate
797c478bd9Sstevel@tonic-gate #if defined(__sparc)
807c478bd9Sstevel@tonic-gate mdb_printf(" %%sp = 0x%lx\n", b[1]);
817c478bd9Sstevel@tonic-gate mdb_printf(" %%pc = 0x%lx %lA\n", b[2], b[2]);
827c478bd9Sstevel@tonic-gate mdb_printf(" %%fp = 0x%lx\n", b[3]);
837c478bd9Sstevel@tonic-gate mdb_printf(" %%i7 = 0x%lx %lA\n", b[4], b[4]);
847c478bd9Sstevel@tonic-gate #elif defined(__amd64)
857c478bd9Sstevel@tonic-gate mdb_printf(" %%rbx = 0x%lx\n", b[0]);
867c478bd9Sstevel@tonic-gate mdb_printf(" %%r12 = 0x%lx\n", b[1]);
877c478bd9Sstevel@tonic-gate mdb_printf(" %%r13 = 0x%lx\n", b[2]);
887c478bd9Sstevel@tonic-gate mdb_printf(" %%r14 = 0x%lx\n", b[3]);
897c478bd9Sstevel@tonic-gate mdb_printf(" %%r15 = 0x%lx\n", b[4]);
907c478bd9Sstevel@tonic-gate mdb_printf(" %%rbp = 0x%lx\n", b[5]);
917c478bd9Sstevel@tonic-gate mdb_printf(" %%rsp = 0x%lx\n", b[6]);
927c478bd9Sstevel@tonic-gate mdb_printf(" %%rip = 0x%lx %lA\n", b[7], b[7]);
937c478bd9Sstevel@tonic-gate #elif defined(__i386)
947c478bd9Sstevel@tonic-gate mdb_printf(" %%ebx = 0x%lx\n", b[0]);
957c478bd9Sstevel@tonic-gate mdb_printf(" %%esi = 0x%lx\n", b[1]);
967c478bd9Sstevel@tonic-gate mdb_printf(" %%edi = 0x%lx\n", b[2]);
977c478bd9Sstevel@tonic-gate mdb_printf(" %%ebp = 0x%lx\n", b[3]);
987c478bd9Sstevel@tonic-gate mdb_printf(" %%esp = 0x%lx\n", b[4]);
997c478bd9Sstevel@tonic-gate mdb_printf(" %%eip = 0x%lx %lA\n", b[5], b[5]);
1007c478bd9Sstevel@tonic-gate #endif
1017c478bd9Sstevel@tonic-gate return (DCMD_OK);
1027c478bd9Sstevel@tonic-gate }
1037c478bd9Sstevel@tonic-gate
1048f88a51fSJoshua M. Clulow const mdb_bitmask_t uc_flags_bits[] = {
1058f88a51fSJoshua M. Clulow { "UC_SIGMASK", UC_SIGMASK, UC_SIGMASK },
1068f88a51fSJoshua M. Clulow { "UC_STACK", UC_STACK, UC_STACK },
1078f88a51fSJoshua M. Clulow { "UC_CPU", UC_CPU, UC_CPU },
1088f88a51fSJoshua M. Clulow { "UC_FPU", UC_FPU, UC_FPU },
1098f88a51fSJoshua M. Clulow #if defined(UC_INTR)
1108f88a51fSJoshua M. Clulow { "UC_INTR", UC_INTR, UC_INTR },
1118f88a51fSJoshua M. Clulow #endif
1128f88a51fSJoshua M. Clulow #if defined(UC_ASR)
1138f88a51fSJoshua M. Clulow { "UC_ASR", UC_ASR, UC_ASR },
1148f88a51fSJoshua M. Clulow #endif
1158f88a51fSJoshua M. Clulow { NULL, 0, 0 }
1168f88a51fSJoshua M. Clulow };
1178f88a51fSJoshua M. Clulow
1187c478bd9Sstevel@tonic-gate /*ARGSUSED*/
1197c478bd9Sstevel@tonic-gate static int
d_ucontext(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1207c478bd9Sstevel@tonic-gate d_ucontext(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1217c478bd9Sstevel@tonic-gate {
1227c478bd9Sstevel@tonic-gate ucontext_t uc;
1237c478bd9Sstevel@tonic-gate
1247c478bd9Sstevel@tonic-gate if (argc != 0)
1257c478bd9Sstevel@tonic-gate return (DCMD_USAGE);
1267c478bd9Sstevel@tonic-gate
1277c478bd9Sstevel@tonic-gate if (mdb_vread(&uc, sizeof (uc), addr) != sizeof (uc)) {
1287c478bd9Sstevel@tonic-gate mdb_warn("failed to read ucontext at %p", addr);
1297c478bd9Sstevel@tonic-gate return (DCMD_ERR);
1307c478bd9Sstevel@tonic-gate }
1317c478bd9Sstevel@tonic-gate
1328f88a51fSJoshua M. Clulow mdb_printf(" flags = 0x%lx <%b>\n", uc.uc_flags,
1338f88a51fSJoshua M. Clulow (uint_t)uc.uc_flags, uc_flags_bits);
1347c478bd9Sstevel@tonic-gate mdb_printf(" link = 0x%p\n", uc.uc_link);
1357c478bd9Sstevel@tonic-gate mdb_printf(" sigmask = 0x%08x 0x%08x 0x%08x 0x%08x\n",
1367c478bd9Sstevel@tonic-gate uc.uc_sigmask.__sigbits[0], uc.uc_sigmask.__sigbits[1],
1377c478bd9Sstevel@tonic-gate uc.uc_sigmask.__sigbits[2], uc.uc_sigmask.__sigbits[3]);
1387c478bd9Sstevel@tonic-gate mdb_printf(" stack = sp 0x%p size 0x%lx flags %s\n",
1397c478bd9Sstevel@tonic-gate uc.uc_stack.ss_sp, uc.uc_stack.ss_size, stack_flags(&uc.uc_stack));
1407c478bd9Sstevel@tonic-gate mdb_printf(" mcontext = 0x%p\n",
1417c478bd9Sstevel@tonic-gate addr + OFFSETOF(ucontext_t, uc_mcontext));
1427c478bd9Sstevel@tonic-gate
1437c478bd9Sstevel@tonic-gate return (DCMD_OK);
1447c478bd9Sstevel@tonic-gate }
1457c478bd9Sstevel@tonic-gate
1467c478bd9Sstevel@tonic-gate /*ARGSUSED*/
1477c478bd9Sstevel@tonic-gate static int
d_sigjmp_buf(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1487c478bd9Sstevel@tonic-gate d_sigjmp_buf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1497c478bd9Sstevel@tonic-gate {
1507c478bd9Sstevel@tonic-gate #if defined(__sparc)
1517c478bd9Sstevel@tonic-gate struct {
1527c478bd9Sstevel@tonic-gate int sjs_flags;
1537c478bd9Sstevel@tonic-gate greg_t sjs_sp;
1547c478bd9Sstevel@tonic-gate greg_t sjs_pc;
1557c478bd9Sstevel@tonic-gate greg_t sjs_fp;
1567c478bd9Sstevel@tonic-gate greg_t sjs_i7;
1577c478bd9Sstevel@tonic-gate ucontext_t *sjs_uclink;
1587c478bd9Sstevel@tonic-gate ulong_t sjs_pad[_JBLEN - 6];
1597c478bd9Sstevel@tonic-gate sigset_t sjs_sigmask;
1607c478bd9Sstevel@tonic-gate #if defined(_LP64)
1613cd8a1a6SRoger A. Faulkner greg_t sjs_asi;
1623cd8a1a6SRoger A. Faulkner greg_t sjs_fprs;
1637c478bd9Sstevel@tonic-gate #endif
1647c478bd9Sstevel@tonic-gate stack_t sjs_stack;
1657c478bd9Sstevel@tonic-gate } s;
1667c478bd9Sstevel@tonic-gate
1677c478bd9Sstevel@tonic-gate if (argc != 0)
1687c478bd9Sstevel@tonic-gate return (DCMD_USAGE);
1697c478bd9Sstevel@tonic-gate
1707c478bd9Sstevel@tonic-gate if (mdb_vread(&s, sizeof (s), addr) != sizeof (s)) {
1717c478bd9Sstevel@tonic-gate mdb_warn("failed to read sigjmp_buf at %p", addr);
1727c478bd9Sstevel@tonic-gate return (DCMD_ERR);
1737c478bd9Sstevel@tonic-gate }
1747c478bd9Sstevel@tonic-gate
1757c478bd9Sstevel@tonic-gate mdb_printf(" flags = 0x%x\n", s.sjs_flags);
1767c478bd9Sstevel@tonic-gate mdb_printf(" %%sp = 0x%lx %lA\n", s.sjs_sp, s.sjs_sp);
1777c478bd9Sstevel@tonic-gate mdb_printf(" %%pc = 0x%lx %lA\n", s.sjs_pc, s.sjs_pc);
1787c478bd9Sstevel@tonic-gate mdb_printf(" %%fp = 0x%lx %lA\n", s.sjs_fp, s.sjs_fp);
1797c478bd9Sstevel@tonic-gate mdb_printf(" %%i7 = 0x%lx %lA\n", s.sjs_i7, s.sjs_i7);
1807c478bd9Sstevel@tonic-gate mdb_printf(" uclink = %p\n", s.sjs_uclink);
1817c478bd9Sstevel@tonic-gate mdb_printf(" sigset = 0x%08x 0x%08x 0x%08x 0x%08x\n",
1827c478bd9Sstevel@tonic-gate s.sjs_sigmask.__sigbits[0], s.sjs_sigmask.__sigbits[1],
1837c478bd9Sstevel@tonic-gate s.sjs_sigmask.__sigbits[2], s.sjs_sigmask.__sigbits[3]);
1843cd8a1a6SRoger A. Faulkner #if defined(_LP64)
1853cd8a1a6SRoger A. Faulkner mdb_printf(" %%asi = 0x%lx\n", s.sjs_asi);
1863cd8a1a6SRoger A. Faulkner mdb_printf(" %%fprs = 0x%lx\n", s.sjs_fprs);
1873cd8a1a6SRoger A. Faulkner #endif
1887c478bd9Sstevel@tonic-gate mdb_printf(" stack = sp 0x%p size 0x%lx flags %s\n",
1897c478bd9Sstevel@tonic-gate s.sjs_stack.ss_sp, s.sjs_stack.ss_size, stack_flags(&s.sjs_stack));
1907c478bd9Sstevel@tonic-gate
1917c478bd9Sstevel@tonic-gate return (DCMD_OK);
1927c478bd9Sstevel@tonic-gate
1937c478bd9Sstevel@tonic-gate #elif defined(__i386) || defined(__amd64)
1947c478bd9Sstevel@tonic-gate return (d_ucontext(addr, flags, argc, argv));
1957c478bd9Sstevel@tonic-gate #endif
1967c478bd9Sstevel@tonic-gate }
1977c478bd9Sstevel@tonic-gate
1987c478bd9Sstevel@tonic-gate /*ARGSUSED*/
1997c478bd9Sstevel@tonic-gate static int
d_siginfo(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)2007c478bd9Sstevel@tonic-gate d_siginfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
2017c478bd9Sstevel@tonic-gate {
2027c478bd9Sstevel@tonic-gate static const char *const msname[] = {
2037c478bd9Sstevel@tonic-gate "USER", "SYSTEM", "TRAP", "TFAULT", "DFAULT", "KFAULT",
2047c478bd9Sstevel@tonic-gate "USER_LOCK", "SLEEP", "WAIT_CPU", "STOPPED"
2057c478bd9Sstevel@tonic-gate };
2067c478bd9Sstevel@tonic-gate
2077c478bd9Sstevel@tonic-gate char signame[SIG2STR_MAX];
2087c478bd9Sstevel@tonic-gate siginfo_t si;
2097c478bd9Sstevel@tonic-gate int i;
2107c478bd9Sstevel@tonic-gate
2117c478bd9Sstevel@tonic-gate if (argc != 0)
2127c478bd9Sstevel@tonic-gate return (DCMD_USAGE);
2137c478bd9Sstevel@tonic-gate
2147c478bd9Sstevel@tonic-gate if (mdb_vread(&si, sizeof (si), addr) != sizeof (si)) {
2157c478bd9Sstevel@tonic-gate mdb_warn("failed to read siginfo at %p", addr);
2167c478bd9Sstevel@tonic-gate return (DCMD_ERR);
2177c478bd9Sstevel@tonic-gate }
2187c478bd9Sstevel@tonic-gate
2197c478bd9Sstevel@tonic-gate if (sig2str(si.si_signo, signame) == -1)
2207c478bd9Sstevel@tonic-gate (void) strcpy(signame, "unknown");
2217c478bd9Sstevel@tonic-gate
2227c478bd9Sstevel@tonic-gate mdb_printf(" signal %5d (%s)\n", si.si_signo, signame);
2237c478bd9Sstevel@tonic-gate mdb_printf(" code %5d (", si.si_code);
2247c478bd9Sstevel@tonic-gate
2257c478bd9Sstevel@tonic-gate switch (si.si_code) {
2267c478bd9Sstevel@tonic-gate case SI_NOINFO:
2277c478bd9Sstevel@tonic-gate mdb_printf("no info");
2287c478bd9Sstevel@tonic-gate break;
2297c478bd9Sstevel@tonic-gate case SI_DTRACE:
2307c478bd9Sstevel@tonic-gate mdb_printf("from DTrace raise() action");
2317c478bd9Sstevel@tonic-gate break;
2327c478bd9Sstevel@tonic-gate case SI_RCTL:
2337c478bd9Sstevel@tonic-gate mdb_printf("from rctl action");
2347c478bd9Sstevel@tonic-gate break;
2357c478bd9Sstevel@tonic-gate case SI_USER:
2367c478bd9Sstevel@tonic-gate mdb_printf("user generated via kill");
2377c478bd9Sstevel@tonic-gate break;
2387c478bd9Sstevel@tonic-gate case SI_LWP:
2397c478bd9Sstevel@tonic-gate mdb_printf("user generated via lwp_kill");
2407c478bd9Sstevel@tonic-gate break;
2417c478bd9Sstevel@tonic-gate case SI_QUEUE:
2427c478bd9Sstevel@tonic-gate mdb_printf("user generated via sigqueue");
2437c478bd9Sstevel@tonic-gate break;
2447c478bd9Sstevel@tonic-gate case SI_TIMER:
2457c478bd9Sstevel@tonic-gate mdb_printf("from timer expiration");
2467c478bd9Sstevel@tonic-gate break;
2477c478bd9Sstevel@tonic-gate case SI_ASYNCIO:
2487c478bd9Sstevel@tonic-gate mdb_printf("from async i/o completion");
2497c478bd9Sstevel@tonic-gate break;
2507c478bd9Sstevel@tonic-gate case SI_MESGQ:
2517c478bd9Sstevel@tonic-gate mdb_printf("from message arrival");
2527c478bd9Sstevel@tonic-gate break;
2537c478bd9Sstevel@tonic-gate default:
2547c478bd9Sstevel@tonic-gate if (SI_FROMUSER(&si))
2557c478bd9Sstevel@tonic-gate mdb_printf("from user process");
2567c478bd9Sstevel@tonic-gate else
2577c478bd9Sstevel@tonic-gate mdb_printf("from kernel");
2587c478bd9Sstevel@tonic-gate }
2597c478bd9Sstevel@tonic-gate
2607c478bd9Sstevel@tonic-gate mdb_printf(")\n errno %5d (%s)\n",
2617c478bd9Sstevel@tonic-gate si.si_errno, strerror(si.si_errno));
2627c478bd9Sstevel@tonic-gate
2637c478bd9Sstevel@tonic-gate if (si.si_code == SI_USER || si.si_code == SI_QUEUE) {
2647c478bd9Sstevel@tonic-gate mdb_printf(" signal sent from PID %d (uid %d)\n",
2657c478bd9Sstevel@tonic-gate si.si_pid, si.si_uid);
2667c478bd9Sstevel@tonic-gate }
2677c478bd9Sstevel@tonic-gate
2687c478bd9Sstevel@tonic-gate if (si.si_code == SI_QUEUE) {
2697c478bd9Sstevel@tonic-gate mdb_printf(" signal value = 0t%d / %p\n",
2707c478bd9Sstevel@tonic-gate si.si_value.sival_int, si.si_value.sival_ptr);
2717c478bd9Sstevel@tonic-gate }
2727c478bd9Sstevel@tonic-gate
2737c478bd9Sstevel@tonic-gate switch (si.si_signo) {
2747c478bd9Sstevel@tonic-gate case SIGCLD:
2757c478bd9Sstevel@tonic-gate mdb_printf(" signal sent from child PID %d (uid %d)\n",
2767c478bd9Sstevel@tonic-gate si.si_pid, si.si_uid);
2777c478bd9Sstevel@tonic-gate mdb_printf(" usr time = 0t%ld ticks, sys time = 0t%ld ticks\n",
2787c478bd9Sstevel@tonic-gate si.si_utime, si.si_stime);
2797c478bd9Sstevel@tonic-gate mdb_printf(" wait status = 0x%x\n", si.si_status);
2807c478bd9Sstevel@tonic-gate break;
2817c478bd9Sstevel@tonic-gate
2827c478bd9Sstevel@tonic-gate case SIGSEGV:
2837c478bd9Sstevel@tonic-gate case SIGBUS:
2847c478bd9Sstevel@tonic-gate case SIGILL:
2857c478bd9Sstevel@tonic-gate case SIGTRAP:
2867c478bd9Sstevel@tonic-gate case SIGFPE:
2877c478bd9Sstevel@tonic-gate mdb_printf(" fault address = 0x%p\n trapno = %d\n",
2887c478bd9Sstevel@tonic-gate si.si_addr, si.si_trapno);
2897c478bd9Sstevel@tonic-gate mdb_printf(" instruction address = 0x%p %lA\n",
2907c478bd9Sstevel@tonic-gate si.si_pc, si.si_pc);
2917c478bd9Sstevel@tonic-gate break;
2927c478bd9Sstevel@tonic-gate
2937c478bd9Sstevel@tonic-gate case SIGPOLL:
2947c478bd9Sstevel@tonic-gate case SIGXFSZ:
2957c478bd9Sstevel@tonic-gate mdb_printf(" fd = %d band = 0x%lx\n",
2967c478bd9Sstevel@tonic-gate si.si_fd, si.si_band);
2977c478bd9Sstevel@tonic-gate break;
2987c478bd9Sstevel@tonic-gate
2997c478bd9Sstevel@tonic-gate case SIGPROF:
3007c478bd9Sstevel@tonic-gate mdb_printf(" last fault address = 0x%p fault type = %d\n",
3017c478bd9Sstevel@tonic-gate si.si_faddr, si.si_fault);
3027c478bd9Sstevel@tonic-gate mdb_printf(" timestamp = 0t%ld sec 0t%ld nsec\n",
3037c478bd9Sstevel@tonic-gate si.si_tstamp.tv_sec, si.si_tstamp.tv_nsec);
3047c478bd9Sstevel@tonic-gate
3057c478bd9Sstevel@tonic-gate if (si.__data.__prof.__syscall != 0) {
3067c478bd9Sstevel@tonic-gate mdb_printf(" system call %d (", si.si_syscall);
3077c478bd9Sstevel@tonic-gate if (si.si_nsysarg > 0) {
3087c478bd9Sstevel@tonic-gate mdb_printf("%lx", si.si_sysarg[0]);
3097c478bd9Sstevel@tonic-gate for (i = 1; i < si.si_nsysarg; i++)
3107c478bd9Sstevel@tonic-gate mdb_printf(", %lx", si.si_sysarg[i]);
3117c478bd9Sstevel@tonic-gate }
3127c478bd9Sstevel@tonic-gate mdb_printf(" )\n");
3137c478bd9Sstevel@tonic-gate }
3147c478bd9Sstevel@tonic-gate
3157c478bd9Sstevel@tonic-gate for (i = 0; i < sizeof (msname) / sizeof (msname[0]); i++) {
3167c478bd9Sstevel@tonic-gate mdb_printf(" mstate[\"%s\"] = %d\n",
3177c478bd9Sstevel@tonic-gate msname[i], si.si_mstate[i]);
3187c478bd9Sstevel@tonic-gate }
3197c478bd9Sstevel@tonic-gate break;
3207c478bd9Sstevel@tonic-gate }
3217c478bd9Sstevel@tonic-gate
3227c478bd9Sstevel@tonic-gate return (DCMD_OK);
3237c478bd9Sstevel@tonic-gate }
3247c478bd9Sstevel@tonic-gate
3257c478bd9Sstevel@tonic-gate static int
uc_walk_step(mdb_walk_state_t * wsp)3267c478bd9Sstevel@tonic-gate uc_walk_step(mdb_walk_state_t *wsp)
3277c478bd9Sstevel@tonic-gate {
3287c478bd9Sstevel@tonic-gate uintptr_t addr = wsp->walk_addr;
3297c478bd9Sstevel@tonic-gate ucontext_t uc;
3307c478bd9Sstevel@tonic-gate
331892ad162SToomas Soome if (addr == 0)
3327c478bd9Sstevel@tonic-gate return (WALK_DONE);
3337c478bd9Sstevel@tonic-gate
3347c478bd9Sstevel@tonic-gate if (mdb_vread(&uc, sizeof (uc), addr) != sizeof (uc)) {
3357c478bd9Sstevel@tonic-gate mdb_warn("failed to read ucontext at %p", addr);
3367c478bd9Sstevel@tonic-gate return (WALK_ERR);
3377c478bd9Sstevel@tonic-gate }
3387c478bd9Sstevel@tonic-gate
3397c478bd9Sstevel@tonic-gate wsp->walk_addr = (uintptr_t)uc.uc_link;
3407c478bd9Sstevel@tonic-gate return (wsp->walk_callback(addr, &uc, wsp->walk_cbdata));
3417c478bd9Sstevel@tonic-gate }
3427c478bd9Sstevel@tonic-gate
3437c478bd9Sstevel@tonic-gate static int
oldc_walk_init(mdb_walk_state_t * wsp)3447c478bd9Sstevel@tonic-gate oldc_walk_init(mdb_walk_state_t *wsp)
3457c478bd9Sstevel@tonic-gate {
3467c478bd9Sstevel@tonic-gate ssize_t nbytes = mdb_get_xdata("lwpstatus", NULL, 0);
3477c478bd9Sstevel@tonic-gate
3487c478bd9Sstevel@tonic-gate if (nbytes <= 0) {
3497c478bd9Sstevel@tonic-gate mdb_warn("lwpstatus information not available");
3507c478bd9Sstevel@tonic-gate return (WALK_ERR);
3517c478bd9Sstevel@tonic-gate }
3527c478bd9Sstevel@tonic-gate
353892ad162SToomas Soome if (wsp->walk_addr != 0) {
3547c478bd9Sstevel@tonic-gate mdb_warn("walker only supports global walk\n");
3557c478bd9Sstevel@tonic-gate return (WALK_ERR);
3567c478bd9Sstevel@tonic-gate }
3577c478bd9Sstevel@tonic-gate
3587c478bd9Sstevel@tonic-gate wsp->walk_addr = nbytes; /* Use walk_addr to track size */
3597c478bd9Sstevel@tonic-gate wsp->walk_data = mdb_alloc(nbytes, UM_SLEEP);
3607c478bd9Sstevel@tonic-gate
3617c478bd9Sstevel@tonic-gate if (mdb_get_xdata("lwpstatus", wsp->walk_data, nbytes) != nbytes) {
3627c478bd9Sstevel@tonic-gate mdb_warn("failed to read lwpstatus information");
3637c478bd9Sstevel@tonic-gate mdb_free(wsp->walk_data, nbytes);
3647c478bd9Sstevel@tonic-gate return (WALK_ERR);
3657c478bd9Sstevel@tonic-gate }
3667c478bd9Sstevel@tonic-gate
3677c478bd9Sstevel@tonic-gate wsp->walk_arg = wsp->walk_data; /* Use walk_arg to track pointer */
3687c478bd9Sstevel@tonic-gate return (WALK_NEXT);
3697c478bd9Sstevel@tonic-gate }
3707c478bd9Sstevel@tonic-gate
3717c478bd9Sstevel@tonic-gate static int
oldc_walk_step(mdb_walk_state_t * wsp)3727c478bd9Sstevel@tonic-gate oldc_walk_step(mdb_walk_state_t *wsp)
3737c478bd9Sstevel@tonic-gate {
3747c478bd9Sstevel@tonic-gate const lwpstatus_t *lsp, *end;
3757c478bd9Sstevel@tonic-gate
3767c478bd9Sstevel@tonic-gate end = (const lwpstatus_t *)((uintptr_t)wsp->walk_data + wsp->walk_addr);
3777c478bd9Sstevel@tonic-gate lsp = wsp->walk_arg;
3787c478bd9Sstevel@tonic-gate
3797c478bd9Sstevel@tonic-gate wsp->walk_arg = (void *)(lsp + 1);
3807c478bd9Sstevel@tonic-gate
3817c478bd9Sstevel@tonic-gate if (lsp < end) {
3827c478bd9Sstevel@tonic-gate uintptr_t addr = lsp->pr_oldcontext;
3837c478bd9Sstevel@tonic-gate ucontext_t uc;
3847c478bd9Sstevel@tonic-gate
385892ad162SToomas Soome if (addr == 0)
3867c478bd9Sstevel@tonic-gate return (WALK_NEXT);
3877c478bd9Sstevel@tonic-gate
3887c478bd9Sstevel@tonic-gate if (mdb_vread(&uc, sizeof (uc), addr) != sizeof (uc)) {
3897c478bd9Sstevel@tonic-gate mdb_warn("failed to read ucontext at %p", addr);
3907c478bd9Sstevel@tonic-gate return (WALK_NEXT);
3917c478bd9Sstevel@tonic-gate }
3927c478bd9Sstevel@tonic-gate
3937c478bd9Sstevel@tonic-gate return (wsp->walk_callback(addr, &uc, wsp->walk_cbdata));
3947c478bd9Sstevel@tonic-gate }
3957c478bd9Sstevel@tonic-gate
3967c478bd9Sstevel@tonic-gate return (WALK_DONE);
3977c478bd9Sstevel@tonic-gate }
3987c478bd9Sstevel@tonic-gate
3997c478bd9Sstevel@tonic-gate static void
oldc_walk_fini(mdb_walk_state_t * wsp)4007c478bd9Sstevel@tonic-gate oldc_walk_fini(mdb_walk_state_t *wsp)
4017c478bd9Sstevel@tonic-gate {
4027c478bd9Sstevel@tonic-gate mdb_free(wsp->walk_data, wsp->walk_addr); /* walk_addr has size */
4037c478bd9Sstevel@tonic-gate }
4047c478bd9Sstevel@tonic-gate
4057c478bd9Sstevel@tonic-gate /*
4067c478bd9Sstevel@tonic-gate * ==================== threads ==========================
4077c478bd9Sstevel@tonic-gate * These are the interfaces that used to require libthread.
4087c478bd9Sstevel@tonic-gate * Now, libthread has been folded into libc.
4097c478bd9Sstevel@tonic-gate * =======================================================
4107c478bd9Sstevel@tonic-gate */
4117c478bd9Sstevel@tonic-gate
4127c478bd9Sstevel@tonic-gate /*
4137c478bd9Sstevel@tonic-gate * prt_addr() is called up to three times to generate arguments for
4147c478bd9Sstevel@tonic-gate * one call to mdb_printf(). We must return at least three different
4157c478bd9Sstevel@tonic-gate * pointers to static storage for consecutive calls to prt_addr().
4167c478bd9Sstevel@tonic-gate */
4177c478bd9Sstevel@tonic-gate static const char *
prt_addr(void * addr,int pad)4187c478bd9Sstevel@tonic-gate prt_addr(void *addr, int pad)
4197c478bd9Sstevel@tonic-gate {
4207c478bd9Sstevel@tonic-gate static char buffer[4][24];
4217c478bd9Sstevel@tonic-gate static int ix = 0;
4227c478bd9Sstevel@tonic-gate char *buf;
4237c478bd9Sstevel@tonic-gate
4247c478bd9Sstevel@tonic-gate if (ix == 4) /* use buffers in sequence: 0, 1, 2, 3 */
4257c478bd9Sstevel@tonic-gate ix = 0;
4267c478bd9Sstevel@tonic-gate buf = buffer[ix++];
4277c478bd9Sstevel@tonic-gate if (addr == NULL)
4287c478bd9Sstevel@tonic-gate return (pad? "<NULL> " : "<NULL>");
4297c478bd9Sstevel@tonic-gate else {
4307c478bd9Sstevel@tonic-gate #ifdef _LP64
4317c478bd9Sstevel@tonic-gate (void) mdb_snprintf(buf, sizeof (buffer[0]), "0x%016lx", addr);
4327c478bd9Sstevel@tonic-gate if (pad)
4337c478bd9Sstevel@tonic-gate (void) strcpy(buf + 18, " ");
4347c478bd9Sstevel@tonic-gate #else
4357c478bd9Sstevel@tonic-gate (void) mdb_snprintf(buf, sizeof (buffer[0]), "0x%08lx", addr);
4367c478bd9Sstevel@tonic-gate if (pad)
4377c478bd9Sstevel@tonic-gate (void) strcpy(buf + 10, " ");
4387c478bd9Sstevel@tonic-gate #endif /* _LP64 */
4397c478bd9Sstevel@tonic-gate return (buf);
4407c478bd9Sstevel@tonic-gate }
4417c478bd9Sstevel@tonic-gate }
4427c478bd9Sstevel@tonic-gate
4437c478bd9Sstevel@tonic-gate #define HD(str) mdb_printf(" " str "\n")
4447c478bd9Sstevel@tonic-gate #define OFFSTR "+0x%-7lx "
4457c478bd9Sstevel@tonic-gate #define OFFSET(member) ((size_t)OFFSETOF(ulwp_t, member))
4467c478bd9Sstevel@tonic-gate
4477c478bd9Sstevel@tonic-gate /*ARGSUSED*/
4487c478bd9Sstevel@tonic-gate static int
d_ulwp(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)4497c478bd9Sstevel@tonic-gate d_ulwp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
4507c478bd9Sstevel@tonic-gate {
4517c478bd9Sstevel@tonic-gate ulwp_t ulwp;
4527c478bd9Sstevel@tonic-gate
4537c478bd9Sstevel@tonic-gate if (argc != 0 || !(flags & DCMD_ADDRSPEC))
4547c478bd9Sstevel@tonic-gate return (DCMD_USAGE);
4557c478bd9Sstevel@tonic-gate
4567c478bd9Sstevel@tonic-gate if (mdb_vread(&ulwp, sizeof (ulwp), addr) != sizeof (ulwp) &&
4577c478bd9Sstevel@tonic-gate (bzero(&ulwp, sizeof (ulwp)),
4587c478bd9Sstevel@tonic-gate mdb_vread(&ulwp, REPLACEMENT_SIZE, addr)) != REPLACEMENT_SIZE) {
4597c478bd9Sstevel@tonic-gate mdb_warn("failed to read ulwp at 0x%p", addr);
4607c478bd9Sstevel@tonic-gate return (DCMD_ERR);
4617c478bd9Sstevel@tonic-gate }
4627c478bd9Sstevel@tonic-gate
4637c478bd9Sstevel@tonic-gate mdb_printf("%#a\n", addr);
4647c478bd9Sstevel@tonic-gate
4657c478bd9Sstevel@tonic-gate HD("self uberdata");
4667c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s\n",
4678cd45542Sraf OFFSET(ul_self),
4688cd45542Sraf prt_addr(ulwp.ul_self, 1),
4698cd45542Sraf prt_addr(ulwp.ul_uberdata, 0));
4707c478bd9Sstevel@tonic-gate
4717c478bd9Sstevel@tonic-gate HD("tlsent ntlsent");
4727c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %ld\n",
4738cd45542Sraf OFFSET(ul_tlsent),
4748cd45542Sraf prt_addr(ulwp.ul_tlsent, 1),
4758cd45542Sraf ulwp.ul_ntlsent);
4767c478bd9Sstevel@tonic-gate
4777c478bd9Sstevel@tonic-gate HD("forw back next");
4787c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n",
4798cd45542Sraf OFFSET(ul_forw),
4808cd45542Sraf prt_addr(ulwp.ul_forw, 1),
4818cd45542Sraf prt_addr(ulwp.ul_back, 1),
4828cd45542Sraf prt_addr(ulwp.ul_next, 0));
4837c478bd9Sstevel@tonic-gate
4847c478bd9Sstevel@tonic-gate HD("hash rval stk");
4857c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n",
4868cd45542Sraf OFFSET(ul_hash),
4878cd45542Sraf prt_addr(ulwp.ul_hash, 1),
4888cd45542Sraf prt_addr(ulwp.ul_rval, 1),
4898cd45542Sraf prt_addr(ulwp.ul_stk, 0));
4907c478bd9Sstevel@tonic-gate
4917c478bd9Sstevel@tonic-gate HD("mapsiz guardsize stktop stksiz");
4927c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10ld %-10ld %s %ld\n",
4938cd45542Sraf OFFSET(ul_mapsiz),
4948cd45542Sraf ulwp.ul_mapsiz,
4958cd45542Sraf ulwp.ul_guardsize,
4968cd45542Sraf prt_addr((void *)ulwp.ul_stktop, 1),
4978cd45542Sraf ulwp.ul_stksiz);
4987c478bd9Sstevel@tonic-gate
4997c478bd9Sstevel@tonic-gate HD("ustack.ss_sp ustack.ss_size ustack.ss_flags");
5007c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %-21ld %s\n",
5018cd45542Sraf OFFSET(ul_ustack.ss_sp),
5028cd45542Sraf prt_addr(ulwp.ul_ustack.ss_sp, 1),
5038cd45542Sraf ulwp.ul_ustack.ss_size,
5048cd45542Sraf stack_flags(&ulwp.ul_ustack));
5057c478bd9Sstevel@tonic-gate
506d4204c85Sraf HD("ix lwpid pri epri policy cid");
5077c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
5088cd45542Sraf OFFSET(ul_ix),
5098cd45542Sraf ulwp.ul_ix,
5108cd45542Sraf ulwp.ul_lwpid,
5118cd45542Sraf ulwp.ul_pri,
5128cd45542Sraf ulwp.ul_epri,
5138cd45542Sraf ulwp.ul_policy,
5148cd45542Sraf ulwp.ul_cid);
5157c478bd9Sstevel@tonic-gate
5167c478bd9Sstevel@tonic-gate HD("cursig pleasestop stop signalled dead unwind");
5177c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10d ",
5188cd45542Sraf OFFSET(ul_cursig),
5198cd45542Sraf ulwp.ul_cursig);
5207c478bd9Sstevel@tonic-gate mdb_printf(ulwp.ul_pleasestop? "0x%-8x " : "%-10d ",
5218cd45542Sraf ulwp.ul_pleasestop);
5227c478bd9Sstevel@tonic-gate mdb_printf(ulwp.ul_stop? "0x%-8x " : "%-10d ",
5238cd45542Sraf ulwp.ul_stop);
5247c478bd9Sstevel@tonic-gate mdb_printf("%-10d %-10d %d\n",
5258cd45542Sraf ulwp.ul_signalled,
5268cd45542Sraf ulwp.ul_dead,
5278cd45542Sraf ulwp.ul_unwind);
5287c478bd9Sstevel@tonic-gate
52934709573Sraf HD("detached writer stopping can'prolog preempt savpreempt");
5307c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
5318cd45542Sraf OFFSET(ul_detached),
5328cd45542Sraf ulwp.ul_detached,
5338cd45542Sraf ulwp.ul_writer,
5348cd45542Sraf ulwp.ul_stopping,
5358cd45542Sraf ulwp.ul_cancel_prologue,
5368cd45542Sraf ulwp.ul_preempt,
5378cd45542Sraf ulwp.ul_savpreempt);
5387c478bd9Sstevel@tonic-gate
5397c478bd9Sstevel@tonic-gate HD("sigsuspend main fork primarymap m'spinners d'noreserv");
5407c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
5418cd45542Sraf OFFSET(ul_sigsuspend),
5428cd45542Sraf ulwp.ul_sigsuspend,
5438cd45542Sraf ulwp.ul_main,
5448cd45542Sraf ulwp.ul_fork,
5458cd45542Sraf ulwp.ul_primarymap,
5468cd45542Sraf ulwp.ul_max_spinners,
5478cd45542Sraf ulwp.ul_door_noreserve);
5487c478bd9Sstevel@tonic-gate
549d4204c85Sraf HD("queue_fifo c'w'defer e'detect' async_safe rt rtqueued");
5507c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
5518cd45542Sraf OFFSET(ul_queue_fifo),
5528cd45542Sraf ulwp.ul_queue_fifo,
5538cd45542Sraf ulwp.ul_cond_wait_defer,
5548cd45542Sraf ulwp.ul_error_detection,
5558cd45542Sraf ulwp.ul_async_safe,
5568cd45542Sraf ulwp.ul_rt,
5578cd45542Sraf ulwp.ul_rtqueued);
5587c478bd9Sstevel@tonic-gate
5597c5714f6Sraf HD("misaligned adapt'spin queue_spin critical sigdefer vfork");
5607c5714f6Sraf mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
5617c5714f6Sraf OFFSET(ul_misaligned),
5627c5714f6Sraf ulwp.ul_misaligned,
5638cd45542Sraf ulwp.ul_adaptive_spin,
5648cd45542Sraf ulwp.ul_queue_spin,
5658cd45542Sraf ulwp.ul_critical,
5668cd45542Sraf ulwp.ul_sigdefer,
5678cd45542Sraf ulwp.ul_vfork);
5687c478bd9Sstevel@tonic-gate
5697c478bd9Sstevel@tonic-gate HD("cancelable c'pending c'disabled c'async save_async mutator");
5707c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
5718cd45542Sraf OFFSET(ul_cancelable),
5728cd45542Sraf ulwp.ul_cancelable,
5738cd45542Sraf ulwp.ul_cancel_pending,
5748cd45542Sraf ulwp.ul_cancel_disabled,
5758cd45542Sraf ulwp.ul_cancel_async,
5768cd45542Sraf ulwp.ul_save_async,
5778cd45542Sraf ulwp.ul_mutator);
5787c478bd9Sstevel@tonic-gate
5797c478bd9Sstevel@tonic-gate HD("created replace nocancel errno errnop");
5807c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %s\n",
5818cd45542Sraf OFFSET(ul_created),
5828cd45542Sraf ulwp.ul_created,
5838cd45542Sraf ulwp.ul_replace,
5848cd45542Sraf ulwp.ul_nocancel,
5858cd45542Sraf ulwp.ul_errno,
5868cd45542Sraf prt_addr(ulwp.ul_errnop, 0));
5877c478bd9Sstevel@tonic-gate
5887c478bd9Sstevel@tonic-gate HD("clnup_hdr schedctl_called schedctl");
5897c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n",
5908cd45542Sraf OFFSET(ul_clnup_hdr),
5918cd45542Sraf prt_addr(ulwp.ul_clnup_hdr, 1),
5928cd45542Sraf prt_addr(ulwp.ul_schedctl_called, 1),
5938cd45542Sraf prt_addr((void *)ulwp.ul_schedctl, 0));
5947c478bd9Sstevel@tonic-gate
595a574db85Sraf HD("bindflags libc_locks stsd &ftsd");
5967c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR,
5978cd45542Sraf OFFSET(ul_bindflags));
5987c478bd9Sstevel@tonic-gate mdb_printf(ulwp.ul_bindflags? "0x%-8x " : "%-10d ",
5998cd45542Sraf ulwp.ul_bindflags);
600a574db85Sraf mdb_printf("%-10d ", ulwp.ul_libc_locks);
6017c478bd9Sstevel@tonic-gate mdb_printf("%s %s\n",
6028cd45542Sraf prt_addr(ulwp.ul_stsd, 1),
6038cd45542Sraf prt_addr((void *)(addr + OFFSET(ul_ftsd[0])), 0));
6047c478bd9Sstevel@tonic-gate
6057c478bd9Sstevel@tonic-gate HD("eventmask[0..1] eventnum eventdata");
6067c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "0x%08x 0x%08x %-21d %s\n",
6078cd45542Sraf OFFSET(ul_td_evbuf.eventmask.event_bits[0]),
6088cd45542Sraf ulwp.ul_td_evbuf.eventmask.event_bits[0],
6098cd45542Sraf ulwp.ul_td_evbuf.eventmask.event_bits[1],
6108cd45542Sraf ulwp.ul_td_evbuf.eventnum,
6118cd45542Sraf prt_addr(ulwp.ul_td_evbuf.eventdata, 0));
6127c478bd9Sstevel@tonic-gate
613e54ab87fSRoger A. Faulkner HD("td'enable sync'reg qtype cv_wake rtld usropts");
614e54ab87fSRoger A. Faulkner mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d ",
6158cd45542Sraf OFFSET(ul_td_events_enable),
6168cd45542Sraf ulwp.ul_td_events_enable,
6178cd45542Sraf ulwp.ul_sync_obj_reg,
6188cd45542Sraf ulwp.ul_qtype,
619e54ab87fSRoger A. Faulkner ulwp.ul_cv_wake,
620e54ab87fSRoger A. Faulkner ulwp.ul_rtld);
6217c478bd9Sstevel@tonic-gate mdb_printf(ulwp.ul_usropts? "0x%x\n" : "%d\n",
6228cd45542Sraf ulwp.ul_usropts);
6237c478bd9Sstevel@tonic-gate
6247c478bd9Sstevel@tonic-gate HD("startpc startarg wchan");
6257c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n",
6268cd45542Sraf OFFSET(ul_startpc),
6278cd45542Sraf prt_addr((void *)ulwp.ul_startpc, 1),
6288cd45542Sraf prt_addr(ulwp.ul_startarg, 1),
6298cd45542Sraf prt_addr(ulwp.ul_wchan, 0));
6307c478bd9Sstevel@tonic-gate
6317c478bd9Sstevel@tonic-gate HD("link sleepq cvmutex");
6327c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n",
6338cd45542Sraf OFFSET(ul_link),
6348cd45542Sraf prt_addr(ulwp.ul_link, 1),
6358cd45542Sraf prt_addr(ulwp.ul_sleepq, 1),
6368cd45542Sraf prt_addr(ulwp.ul_cvmutex, 0));
6377c478bd9Sstevel@tonic-gate
638d4204c85Sraf HD("mxchain save_state");
639d4204c85Sraf mdb_printf(OFFSTR "%s %d\n",
6408cd45542Sraf OFFSET(ul_mxchain),
6418cd45542Sraf prt_addr(ulwp.ul_mxchain, 1),
6428cd45542Sraf ulwp.ul_save_state);
6437c478bd9Sstevel@tonic-gate
644883492d5Sraf HD("rdlockcnt rd_rwlock rd_count");
645883492d5Sraf mdb_printf(OFFSTR "%-21d %s %d\n",
6468cd45542Sraf OFFSET(ul_rdlockcnt),
6478cd45542Sraf ulwp.ul_rdlockcnt,
6488cd45542Sraf prt_addr(ulwp.ul_readlock.single.rd_rwlock, 1),
6498cd45542Sraf ulwp.ul_readlock.single.rd_count);
650883492d5Sraf
651883492d5Sraf HD("heldlockcnt heldlocks tpdp");
652883492d5Sraf mdb_printf(OFFSTR "%-21d %s %s\n",
6538cd45542Sraf OFFSET(ul_heldlockcnt),
6548cd45542Sraf ulwp.ul_heldlockcnt,
6558cd45542Sraf prt_addr(ulwp.ul_heldlocks.single, 1),
6568cd45542Sraf prt_addr(ulwp.ul_tpdp, 0));
6577c478bd9Sstevel@tonic-gate
6587c478bd9Sstevel@tonic-gate HD("siglink s'l'spin s'l'spin2 s'l'sleep s'l'wakeup");
659d4204c85Sraf mdb_printf(OFFSTR "%s %-10d %-10d %-10d %d\n",
6608cd45542Sraf OFFSET(ul_siglink),
6618cd45542Sraf prt_addr(ulwp.ul_siglink, 1),
6628cd45542Sraf ulwp.ul_spin_lock_spin,
6638cd45542Sraf ulwp.ul_spin_lock_spin2,
6648cd45542Sraf ulwp.ul_spin_lock_sleep,
6658cd45542Sraf ulwp.ul_spin_lock_wakeup);
6667c478bd9Sstevel@tonic-gate
667d4204c85Sraf HD("&queue_root rtclassid pilocks");
668d4204c85Sraf mdb_printf(OFFSTR "%s %-10d %d\n",
6698cd45542Sraf OFFSET(ul_queue_root),
6708cd45542Sraf prt_addr((void *)(addr + OFFSET(ul_queue_root)), 1),
6718cd45542Sraf ulwp.ul_rtclassid,
6728cd45542Sraf ulwp.ul_pilocks);
673d4204c85Sraf
6747c478bd9Sstevel@tonic-gate /*
6757c478bd9Sstevel@tonic-gate * The remainder of the ulwp_t structure
6767c478bd9Sstevel@tonic-gate * is invalid if this is a replacement.
6777c478bd9Sstevel@tonic-gate */
6787c478bd9Sstevel@tonic-gate if (ulwp.ul_replace)
6797c478bd9Sstevel@tonic-gate return (DCMD_OK);
6807c478bd9Sstevel@tonic-gate
6817c478bd9Sstevel@tonic-gate HD("sigmask[0..3]");
6827c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "0x%08x 0x%08x 0x%08x 0x%08x\n",
6838cd45542Sraf OFFSET(ul_sigmask.__sigbits[0]),
6848cd45542Sraf ulwp.ul_sigmask.__sigbits[0],
6858cd45542Sraf ulwp.ul_sigmask.__sigbits[1],
6868cd45542Sraf ulwp.ul_sigmask.__sigbits[2],
6878cd45542Sraf ulwp.ul_sigmask.__sigbits[3]);
6887c478bd9Sstevel@tonic-gate
6897c478bd9Sstevel@tonic-gate HD("tmpmask[0..3]");
6907c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "0x%08x 0x%08x 0x%08x 0x%08x\n",
6918cd45542Sraf OFFSET(ul_tmpmask.__sigbits[0]),
6928cd45542Sraf ulwp.ul_tmpmask.__sigbits[0],
6938cd45542Sraf ulwp.ul_tmpmask.__sigbits[1],
6948cd45542Sraf ulwp.ul_tmpmask.__sigbits[2],
6958cd45542Sraf ulwp.ul_tmpmask.__sigbits[3]);
6967c478bd9Sstevel@tonic-gate
6977c478bd9Sstevel@tonic-gate HD("&siginfo &spinlock &fpuenv");
6987c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n",
6998cd45542Sraf OFFSET(ul_siginfo),
7008cd45542Sraf prt_addr((void *)(addr + OFFSET(ul_siginfo)), 1),
7018cd45542Sraf prt_addr((void *)(addr + OFFSET(ul_spinlock)), 1),
7028cd45542Sraf prt_addr((void *)(addr + OFFSET(ul_fpuenv)), 0));
7037c478bd9Sstevel@tonic-gate
7044f364e7cSRobert Mustacchi HD("tmem.size &tmem.roots");
7054f364e7cSRobert Mustacchi mdb_printf(OFFSTR "%-21H %s\n",
7064f364e7cSRobert Mustacchi OFFSET(ul_tmem),
7074f364e7cSRobert Mustacchi ulwp.ul_tmem.tm_size,
7084f364e7cSRobert Mustacchi prt_addr((void *)(addr + OFFSET(ul_tmem) + sizeof (size_t)), 0));
7094f364e7cSRobert Mustacchi
7107c478bd9Sstevel@tonic-gate return (DCMD_OK);
7117c478bd9Sstevel@tonic-gate }
7127c478bd9Sstevel@tonic-gate
7137c478bd9Sstevel@tonic-gate /*
7147c478bd9Sstevel@tonic-gate * Get the address of the unique uberdata_t structure.
7157c478bd9Sstevel@tonic-gate */
7167c478bd9Sstevel@tonic-gate static uintptr_t
uberdata_addr(void)7177c478bd9Sstevel@tonic-gate uberdata_addr(void)
7187c478bd9Sstevel@tonic-gate {
7197c478bd9Sstevel@tonic-gate uintptr_t uaddr;
7207c478bd9Sstevel@tonic-gate uintptr_t addr;
7217c478bd9Sstevel@tonic-gate GElf_Sym sym;
7227c478bd9Sstevel@tonic-gate
7237c478bd9Sstevel@tonic-gate if (mdb_lookup_by_obj("libc.so.1", "_tdb_bootstrap", &sym) != 0) {
7247c478bd9Sstevel@tonic-gate mdb_warn("cannot find libc.so.1`_tdb_bootstrap");
725892ad162SToomas Soome return (0);
7267c478bd9Sstevel@tonic-gate }
7277c478bd9Sstevel@tonic-gate if (mdb_vread(&addr, sizeof (addr), sym.st_value) == sizeof (addr) &&
728892ad162SToomas Soome addr != 0 &&
7297c478bd9Sstevel@tonic-gate mdb_vread(&uaddr, sizeof (uaddr), addr) == sizeof (uaddr) &&
730892ad162SToomas Soome uaddr != 0) {
7317c478bd9Sstevel@tonic-gate return (uaddr);
7327c478bd9Sstevel@tonic-gate }
7337c478bd9Sstevel@tonic-gate if (mdb_lookup_by_obj("libc.so.1", "_uberdata", &sym) != 0) {
7347c478bd9Sstevel@tonic-gate mdb_warn("cannot find libc.so.1`_uberdata");
735892ad162SToomas Soome return (0);
7367c478bd9Sstevel@tonic-gate }
7377c478bd9Sstevel@tonic-gate return ((uintptr_t)sym.st_value);
7387c478bd9Sstevel@tonic-gate }
7397c478bd9Sstevel@tonic-gate
7407c478bd9Sstevel@tonic-gate #undef OFFSET
7417c478bd9Sstevel@tonic-gate #define OFFSET(member) ((size_t)OFFSETOF(uberdata_t, member))
7427c478bd9Sstevel@tonic-gate
7437c478bd9Sstevel@tonic-gate /*ARGSUSED*/
7447c478bd9Sstevel@tonic-gate static int
d_uberdata(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)7457c478bd9Sstevel@tonic-gate d_uberdata(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
7467c478bd9Sstevel@tonic-gate {
7477c478bd9Sstevel@tonic-gate uberdata_t uberdata;
7487c478bd9Sstevel@tonic-gate int i;
7497c478bd9Sstevel@tonic-gate
7507c478bd9Sstevel@tonic-gate if (argc != 0)
7517c478bd9Sstevel@tonic-gate return (DCMD_USAGE);
752892ad162SToomas Soome if (!(flags & DCMD_ADDRSPEC) && (addr = uberdata_addr()) == 0)
7537c478bd9Sstevel@tonic-gate return (DCMD_ERR);
7547c478bd9Sstevel@tonic-gate
7557c478bd9Sstevel@tonic-gate if (mdb_vread(&uberdata, sizeof (uberdata), addr) !=
7567c478bd9Sstevel@tonic-gate sizeof (uberdata)) {
7577c478bd9Sstevel@tonic-gate mdb_warn("failed to read uberdata at 0x%p", addr);
7587c478bd9Sstevel@tonic-gate return (DCMD_ERR);
7597c478bd9Sstevel@tonic-gate }
7607c478bd9Sstevel@tonic-gate
7617c478bd9Sstevel@tonic-gate mdb_printf("%#a\n", addr);
7627c478bd9Sstevel@tonic-gate
7638cd45542Sraf HD("&link_lock &ld_lock &fork_lock");
7647c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n",
7658cd45542Sraf OFFSET(link_lock),
7668cd45542Sraf prt_addr((void *)(addr + OFFSET(link_lock)), 1),
7678cd45542Sraf prt_addr((void *)(addr + OFFSET(ld_lock)), 1),
7688cd45542Sraf prt_addr((void *)(addr + OFFSET(fork_lock)), 0));
7697c478bd9Sstevel@tonic-gate
7708cd45542Sraf HD("&atfork_lock &callout_lock &tdb_hash_lock");
7717c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n",
7728cd45542Sraf OFFSET(atfork_lock),
7738cd45542Sraf prt_addr((void *)(addr + OFFSET(atfork_lock)), 1),
7748cd45542Sraf prt_addr((void *)(addr + OFFSET(callout_lock)), 1),
7758cd45542Sraf prt_addr((void *)(addr + OFFSET(tdb_hash_lock)), 0));
7768cd45542Sraf
7778cd45542Sraf HD("&tdb_hash_lock_stats &siguaction[0]");
7788cd45542Sraf mdb_printf(OFFSTR "%s %s\n",
7798cd45542Sraf OFFSET(tdb_hash_lock_stats),
7808cd45542Sraf prt_addr((void *)(addr + OFFSET(tdb_hash_lock_stats)), 1),
7818cd45542Sraf prt_addr((void *)(addr + OFFSET(siguaction)), 0));
7827c478bd9Sstevel@tonic-gate
7837c478bd9Sstevel@tonic-gate HD("&bucket free_list chunks");
7847c478bd9Sstevel@tonic-gate for (i = 0; i < NBUCKETS; i++) {
7857c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %ld\n",
7868cd45542Sraf OFFSET(bucket[i]),
7878cd45542Sraf prt_addr((void *)(addr + OFFSET(bucket[i])), 1),
7888cd45542Sraf prt_addr(uberdata.bucket[i].free_list, 1),
7898cd45542Sraf uberdata.bucket[i].chunks);
7907c478bd9Sstevel@tonic-gate }
7917c478bd9Sstevel@tonic-gate
7927c478bd9Sstevel@tonic-gate HD("&atexit_root head exit_frame_monitor");
7937c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n",
7948cd45542Sraf OFFSET(atexit_root),
7958cd45542Sraf prt_addr((void *)(addr + OFFSET(atexit_root.exitfns_lock)), 1),
7968cd45542Sraf prt_addr(uberdata.atexit_root.head, 1),
7978cd45542Sraf prt_addr(uberdata.atexit_root.exit_frame_monitor, 0));
7987c478bd9Sstevel@tonic-gate
799fc2512cfSRobert Mustacchi HD("&quickexit_root head");
800fc2512cfSRobert Mustacchi mdb_printf(OFFSTR "%s %s\n",
801fc2512cfSRobert Mustacchi OFFSET(quickexit_root),
802fc2512cfSRobert Mustacchi prt_addr((void *)(addr + OFFSET(quickexit_root.exitfns_lock)), 1),
803fc2512cfSRobert Mustacchi prt_addr(uberdata.quickexit_root.head, 0));
804fc2512cfSRobert Mustacchi
805fc2512cfSRobert Mustacchi
8067c478bd9Sstevel@tonic-gate HD("&tsd_metadata tsdm_nkeys tsdm_nused tsdm_destro");
8077c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %-10d %-10d %s\n",
8088cd45542Sraf OFFSET(tsd_metadata),
8098cd45542Sraf prt_addr((void *)(addr + OFFSET(tsd_metadata.tsdm_lock)), 1),
8108cd45542Sraf uberdata.tsd_metadata.tsdm_nkeys,
8118cd45542Sraf uberdata.tsd_metadata.tsdm_nused,
8128cd45542Sraf prt_addr((void *)uberdata.tsd_metadata.tsdm_destro, 0));
8137c478bd9Sstevel@tonic-gate
8147c478bd9Sstevel@tonic-gate HD("&tls_metadata tls_modinfo.data tls_modinfo.size");
8157c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %ld\n",
8168cd45542Sraf OFFSET(tls_metadata),
8178cd45542Sraf prt_addr((void *)(addr + OFFSET(tls_metadata.tls_lock)), 1),
8188cd45542Sraf prt_addr(uberdata.tls_metadata.tls_modinfo.tls_data, 1),
8198cd45542Sraf uberdata.tls_metadata.tls_modinfo.tls_size);
8207c478bd9Sstevel@tonic-gate
8217c478bd9Sstevel@tonic-gate HD(" static_tls.data static_tls.size");
8227c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %ld\n",
8238cd45542Sraf OFFSET(tls_metadata.static_tls),
8248cd45542Sraf " ",
8258cd45542Sraf prt_addr(uberdata.tls_metadata.static_tls.tls_data, 1),
8268cd45542Sraf uberdata.tls_metadata.static_tls.tls_size);
8277c478bd9Sstevel@tonic-gate
8287c478bd9Sstevel@tonic-gate HD("primary_ma bucket_ini uflags.mt uflags.pad uflags.trs uflags.ted");
8297c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n",
8308cd45542Sraf OFFSET(primary_map),
8318cd45542Sraf uberdata.primary_map,
8328cd45542Sraf uberdata.bucket_init,
8338cd45542Sraf uberdata.uberflags.uf_x.x_mt,
8348cd45542Sraf uberdata.uberflags.uf_x.x_pad,
8358cd45542Sraf uberdata.uberflags.uf_x.x_tdb_register_sync,
8368cd45542Sraf uberdata.uberflags.uf_x.x_thread_error_detection);
8377c478bd9Sstevel@tonic-gate
8387c478bd9Sstevel@tonic-gate HD("queue_head thr_hash_table hash_size hash_mask");
8397c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %-10d 0x%x\n",
8408cd45542Sraf OFFSET(queue_head),
8418cd45542Sraf prt_addr(uberdata.queue_head, 1),
8428cd45542Sraf prt_addr(uberdata.thr_hash_table, 1),
8438cd45542Sraf uberdata.hash_size,
8448cd45542Sraf uberdata.hash_mask);
8457c478bd9Sstevel@tonic-gate
8467c478bd9Sstevel@tonic-gate HD("ulwp_one all_lwps all_zombies");
8477c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n",
8488cd45542Sraf OFFSET(ulwp_one),
8498cd45542Sraf prt_addr(uberdata.ulwp_one, 1),
8508cd45542Sraf prt_addr(uberdata.all_lwps, 1),
8518cd45542Sraf prt_addr(uberdata.all_zombies, 0));
8527c478bd9Sstevel@tonic-gate
8537c478bd9Sstevel@tonic-gate HD("nthreads nzombies ndaemons pid sigacthandler");
8547c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %s\n",
8558cd45542Sraf OFFSET(nthreads),
8568cd45542Sraf uberdata.nthreads,
8578cd45542Sraf uberdata.nzombies,
8588cd45542Sraf uberdata.ndaemons,
8598cd45542Sraf (int)uberdata.pid,
8608cd45542Sraf prt_addr((void *)uberdata.sigacthandler, 0));
8617c478bd9Sstevel@tonic-gate
8627c478bd9Sstevel@tonic-gate HD("lwp_stacks lwp_laststack nfreestack stk_cache");
8637c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %-10d %d\n",
8648cd45542Sraf OFFSET(lwp_stacks),
8658cd45542Sraf prt_addr(uberdata.lwp_stacks, 1),
8668cd45542Sraf prt_addr(uberdata.lwp_laststack, 1),
8678cd45542Sraf uberdata.nfreestack,
8688cd45542Sraf uberdata.thread_stack_cache);
8697c478bd9Sstevel@tonic-gate
8708cd45542Sraf HD("ulwp_freelist ulwp_lastfree ulwp_replace_free");
8718cd45542Sraf mdb_printf(OFFSTR "%s %s %s\n",
8728cd45542Sraf OFFSET(ulwp_freelist),
8738cd45542Sraf prt_addr(uberdata.ulwp_freelist, 1),
8748cd45542Sraf prt_addr(uberdata.ulwp_lastfree, 1),
8758cd45542Sraf prt_addr(uberdata.ulwp_replace_free, 0));
876883492d5Sraf
87709ce0d4aSRoger A. Faulkner HD("ulwp_replace_last atforklist");
87809ce0d4aSRoger A. Faulkner mdb_printf(OFFSTR "%s %s\n",
8798cd45542Sraf OFFSET(ulwp_replace_last),
8808cd45542Sraf prt_addr(uberdata.ulwp_replace_last, 1),
88109ce0d4aSRoger A. Faulkner prt_addr(uberdata.atforklist, 0));
88209ce0d4aSRoger A. Faulkner
88323a1cceaSRoger A. Faulkner HD("robustlocks robustlist progname");
88423a1cceaSRoger A. Faulkner mdb_printf(OFFSTR "%s %s %s\n",
88509ce0d4aSRoger A. Faulkner OFFSET(robustlocks),
88609ce0d4aSRoger A. Faulkner prt_addr(uberdata.robustlocks, 1),
88723a1cceaSRoger A. Faulkner prt_addr(uberdata.robustlist, 1),
88823a1cceaSRoger A. Faulkner prt_addr(uberdata.progname, 0));
8897c478bd9Sstevel@tonic-gate
8907c478bd9Sstevel@tonic-gate HD("tdb_bootstrap tdb_sync_addr_hash tdb_'count tdb_'fail");
8917c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %-10d %d\n",
8928cd45542Sraf OFFSET(tdb_bootstrap),
8938cd45542Sraf prt_addr(uberdata.tdb_bootstrap, 1),
8948cd45542Sraf prt_addr(uberdata.tdb.tdb_sync_addr_hash, 1),
8958cd45542Sraf uberdata.tdb.tdb_register_count,
8968cd45542Sraf uberdata.tdb.tdb_hash_alloc_failed);
8977c478bd9Sstevel@tonic-gate
8987c478bd9Sstevel@tonic-gate HD("tdb_sync_addr_free tdb_sync_addr_last tdb_sync_alloc");
8997c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %ld\n",
9008cd45542Sraf OFFSET(tdb.tdb_sync_addr_free),
9018cd45542Sraf prt_addr(uberdata.tdb.tdb_sync_addr_free, 1),
9028cd45542Sraf prt_addr(uberdata.tdb.tdb_sync_addr_last, 1),
9038cd45542Sraf uberdata.tdb.tdb_sync_alloc);
9047c478bd9Sstevel@tonic-gate
9057c478bd9Sstevel@tonic-gate HD("tdb_ev_global_mask tdb_events");
9067c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "0x%08x 0x%08x %s\n",
9078cd45542Sraf OFFSET(tdb.tdb_ev_global_mask),
9088cd45542Sraf uberdata.tdb.tdb_ev_global_mask.event_bits[0],
9098cd45542Sraf uberdata.tdb.tdb_ev_global_mask.event_bits[1],
9108cd45542Sraf prt_addr((void *)uberdata.tdb.tdb_events, 0));
9117c478bd9Sstevel@tonic-gate
9127c478bd9Sstevel@tonic-gate return (DCMD_OK);
9137c478bd9Sstevel@tonic-gate }
9147c478bd9Sstevel@tonic-gate
9157c478bd9Sstevel@tonic-gate static int
ulwp_walk_init(mdb_walk_state_t * wsp)9167c478bd9Sstevel@tonic-gate ulwp_walk_init(mdb_walk_state_t *wsp)
9177c478bd9Sstevel@tonic-gate {
9187c478bd9Sstevel@tonic-gate uintptr_t addr = wsp->walk_addr;
9197c478bd9Sstevel@tonic-gate uintptr_t uber_addr;
920e0ee3cedSJason King int offset;
921e0ee3cedSJason King
922e0ee3cedSJason King offset = mdb_ctf_offsetof_by_name("uberdata_t", "all_lwps");
923e0ee3cedSJason King if (offset == -1) {
924e0ee3cedSJason King offset = OFFSETOF(uberdata_t, all_lwps);
925e0ee3cedSJason King mdb_warn("CTF data is missing for uberdata_t; using current "
926e0ee3cedSJason King "platform's offset for uberdata.all_lwps");
927e0ee3cedSJason King }
9287c478bd9Sstevel@tonic-gate
929892ad162SToomas Soome if (addr == 0 &&
930892ad162SToomas Soome ((uber_addr = uberdata_addr()) == 0 ||
931e0ee3cedSJason King mdb_vread(&addr, sizeof (addr), uber_addr + offset)
9327c478bd9Sstevel@tonic-gate != sizeof (addr))) {
9337c478bd9Sstevel@tonic-gate mdb_warn("cannot find 'uberdata.all_lwps'");
9347c478bd9Sstevel@tonic-gate return (WALK_ERR);
9357c478bd9Sstevel@tonic-gate }
936892ad162SToomas Soome if (addr == 0)
9377c478bd9Sstevel@tonic-gate return (WALK_DONE);
9387c478bd9Sstevel@tonic-gate wsp->walk_addr = addr;
9397c478bd9Sstevel@tonic-gate wsp->walk_data = (void *)addr;
9407c478bd9Sstevel@tonic-gate return (WALK_NEXT);
9417c478bd9Sstevel@tonic-gate }
9427c478bd9Sstevel@tonic-gate
9437c478bd9Sstevel@tonic-gate static int
ulwp_walk_step(mdb_walk_state_t * wsp)9447c478bd9Sstevel@tonic-gate ulwp_walk_step(mdb_walk_state_t *wsp)
9457c478bd9Sstevel@tonic-gate {
9467c478bd9Sstevel@tonic-gate uintptr_t addr = wsp->walk_addr;
9477c478bd9Sstevel@tonic-gate ulwp_t ulwp;
9487c478bd9Sstevel@tonic-gate
949892ad162SToomas Soome if (addr == 0)
9507c478bd9Sstevel@tonic-gate return (WALK_DONE);
9517c478bd9Sstevel@tonic-gate if (mdb_vread(&ulwp, sizeof (ulwp), addr) != sizeof (ulwp) &&
9527c478bd9Sstevel@tonic-gate (bzero(&ulwp, sizeof (ulwp)),
9537c478bd9Sstevel@tonic-gate mdb_vread(&ulwp, REPLACEMENT_SIZE, addr)) != REPLACEMENT_SIZE) {
9547c478bd9Sstevel@tonic-gate mdb_warn("failed to read ulwp at 0x%p", addr);
9557c478bd9Sstevel@tonic-gate return (WALK_ERR);
9567c478bd9Sstevel@tonic-gate }
9577c478bd9Sstevel@tonic-gate /*
9587c478bd9Sstevel@tonic-gate * If we have looped around to the beginning
9597c478bd9Sstevel@tonic-gate * of the circular linked list, we are done.
9607c478bd9Sstevel@tonic-gate */
9617c478bd9Sstevel@tonic-gate if ((wsp->walk_addr = (uintptr_t)ulwp.ul_forw)
9627c478bd9Sstevel@tonic-gate == (uintptr_t)wsp->walk_data)
963892ad162SToomas Soome wsp->walk_addr = 0;
9647c478bd9Sstevel@tonic-gate return (wsp->walk_callback(addr, &ulwp, wsp->walk_cbdata));
9657c478bd9Sstevel@tonic-gate }
9667c478bd9Sstevel@tonic-gate
967a48fdbefSBryan Cantrill typedef struct lwp_wchan {
968a48fdbefSBryan Cantrill uint8_t wchan_flag[4];
969a48fdbefSBryan Cantrill uint16_t wchan_type;
970a48fdbefSBryan Cantrill uint16_t wchan_magic;
971a48fdbefSBryan Cantrill } lwp_wchan_t;
972a48fdbefSBryan Cantrill
973a48fdbefSBryan Cantrill static int
wchan_walk_init(mdb_walk_state_t * wsp)974a48fdbefSBryan Cantrill wchan_walk_init(mdb_walk_state_t *wsp)
975a48fdbefSBryan Cantrill {
976a48fdbefSBryan Cantrill if (wsp->walk_addr != 0) {
977a48fdbefSBryan Cantrill mdb_warn("wchan walk only supports global walks");
978a48fdbefSBryan Cantrill return (WALK_ERR);
979a48fdbefSBryan Cantrill }
980a48fdbefSBryan Cantrill
981a48fdbefSBryan Cantrill if (mdb_layered_walk("ulwp", wsp) == -1) {
982a48fdbefSBryan Cantrill mdb_warn("couldn't walk ulwp");
983a48fdbefSBryan Cantrill return (WALK_ERR);
984a48fdbefSBryan Cantrill }
985a48fdbefSBryan Cantrill
986a48fdbefSBryan Cantrill return (WALK_NEXT);
987a48fdbefSBryan Cantrill }
988a48fdbefSBryan Cantrill
989a48fdbefSBryan Cantrill static int
wchan_walk_step(mdb_walk_state_t * wsp)990a48fdbefSBryan Cantrill wchan_walk_step(mdb_walk_state_t *wsp)
991a48fdbefSBryan Cantrill {
992a48fdbefSBryan Cantrill uintptr_t addr = (uintptr_t)(((ulwp_t *)wsp->walk_layer)->ul_wchan);
993a48fdbefSBryan Cantrill lwp_wchan_t wchan;
994a48fdbefSBryan Cantrill
995a48fdbefSBryan Cantrill if (addr == (uintptr_t)NULL) {
996a48fdbefSBryan Cantrill return (WALK_NEXT);
997a48fdbefSBryan Cantrill }
998a48fdbefSBryan Cantrill
999a48fdbefSBryan Cantrill if (mdb_vread(&wchan, sizeof (wchan), addr) != sizeof (wchan)) {
1000a48fdbefSBryan Cantrill mdb_warn("failed to read wchan at 0x%p", addr);
1001a48fdbefSBryan Cantrill return (WALK_ERR);
1002a48fdbefSBryan Cantrill }
1003a48fdbefSBryan Cantrill
1004a48fdbefSBryan Cantrill return (wsp->walk_callback(addr, &wchan, wsp->walk_cbdata));
1005a48fdbefSBryan Cantrill }
1006a48fdbefSBryan Cantrill
10074a1c2431SJonathan Adams /* Avoid classifying NULL pointers as part of the main stack on x86 */
10084a1c2431SJonathan Adams #define MIN_STACK_ADDR (0x10000ul)
10094a1c2431SJonathan Adams
10104a1c2431SJonathan Adams static int
whatis_walk_ulwp(uintptr_t addr,const ulwp_t * ulwp,mdb_whatis_t * w)10114a1c2431SJonathan Adams whatis_walk_ulwp(uintptr_t addr, const ulwp_t *ulwp, mdb_whatis_t *w)
10124a1c2431SJonathan Adams {
10134a1c2431SJonathan Adams uintptr_t cur;
10144a1c2431SJonathan Adams lwpid_t id = ulwp->ul_lwpid;
10154a1c2431SJonathan Adams uintptr_t top, base, size;
10164a1c2431SJonathan Adams
10174a1c2431SJonathan Adams while (mdb_whatis_match(w, addr, sizeof (ulwp_t), &cur))
10184a1c2431SJonathan Adams mdb_whatis_report_object(w, cur, addr,
10194a1c2431SJonathan Adams "allocated as thread %#r's ulwp_t\n", id);
10204a1c2431SJonathan Adams
10214a1c2431SJonathan Adams top = (uintptr_t)ulwp->ul_stktop;
10224a1c2431SJonathan Adams size = ulwp->ul_stksiz;
10234a1c2431SJonathan Adams
10244a1c2431SJonathan Adams /*
10254a1c2431SJonathan Adams * The main stack ends up being a little weird, especially if
10264a1c2431SJonathan Adams * the stack ulimit is unlimited. This tries to take that into
10274a1c2431SJonathan Adams * account.
10284a1c2431SJonathan Adams */
10294a1c2431SJonathan Adams if (size > top)
10304a1c2431SJonathan Adams size = top;
10314a1c2431SJonathan Adams if (top > MIN_STACK_ADDR && top - size < MIN_STACK_ADDR)
10324a1c2431SJonathan Adams size = top - MIN_STACK_ADDR;
10334a1c2431SJonathan Adams
10344a1c2431SJonathan Adams base = top - size;
10354a1c2431SJonathan Adams
10364a1c2431SJonathan Adams while (mdb_whatis_match(w, base, size, &cur))
10374a1c2431SJonathan Adams mdb_whatis_report_address(w, cur, "in [ stack tid=%#r ]\n", id);
10384a1c2431SJonathan Adams
10394a1c2431SJonathan Adams if (ulwp->ul_ustack.ss_flags & SS_ONSTACK) {
10404a1c2431SJonathan Adams base = (uintptr_t)ulwp->ul_ustack.ss_sp;
10414a1c2431SJonathan Adams size = ulwp->ul_ustack.ss_size;
10424a1c2431SJonathan Adams
10434a1c2431SJonathan Adams while (mdb_whatis_match(w, base, size, &cur))
10444a1c2431SJonathan Adams mdb_whatis_report_address(w, cur,
10454a1c2431SJonathan Adams "in [ altstack tid=%#r ]\n", id);
10464a1c2431SJonathan Adams }
10474a1c2431SJonathan Adams
10484a1c2431SJonathan Adams return (WHATIS_WALKRET(w));
10494a1c2431SJonathan Adams }
10504a1c2431SJonathan Adams
10514a1c2431SJonathan Adams /*ARGSUSED*/
10524a1c2431SJonathan Adams static int
whatis_run_ulwps(mdb_whatis_t * w,void * arg)10534a1c2431SJonathan Adams whatis_run_ulwps(mdb_whatis_t *w, void *arg)
10544a1c2431SJonathan Adams {
10554a1c2431SJonathan Adams if (mdb_walk("ulwps", (mdb_walk_cb_t)whatis_walk_ulwp, w) == -1) {
10564a1c2431SJonathan Adams mdb_warn("couldn't find ulwps walker");
10574a1c2431SJonathan Adams return (1);
10584a1c2431SJonathan Adams }
10594a1c2431SJonathan Adams return (0);
10604a1c2431SJonathan Adams }
10614a1c2431SJonathan Adams
10627c478bd9Sstevel@tonic-gate /*
10637c478bd9Sstevel@tonic-gate * =======================================================
10647c478bd9Sstevel@tonic-gate * End of thread (previously libthread) interfaces.
10657c478bd9Sstevel@tonic-gate * ==================== threads ==========================
10667c478bd9Sstevel@tonic-gate */
10677c478bd9Sstevel@tonic-gate
1068c9a6ea2eSBryan Cantrill int
stacks_dcmd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1069c9a6ea2eSBryan Cantrill stacks_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1070c9a6ea2eSBryan Cantrill {
1071c9a6ea2eSBryan Cantrill int rval = stacks(addr, flags, argc, argv);
1072c9a6ea2eSBryan Cantrill
1073c9a6ea2eSBryan Cantrill /*
1074c9a6ea2eSBryan Cantrill * For the user-level variant of ::stacks, we don't bother caching
1075c9a6ea2eSBryan Cantrill * state, as even a very large program is unlikely to compare to the
1076c9a6ea2eSBryan Cantrill * kernel in terms of number of threads. (And if you find yourself
1077c9a6ea2eSBryan Cantrill * here in anger, frustrated about how long ::stacks is running on
1078c9a6ea2eSBryan Cantrill * your galactically complicated zillion-thread program, hopefully
1079c9a6ea2eSBryan Cantrill * you will find some solace in the irony. Okay, probably not...)
1080c9a6ea2eSBryan Cantrill */
1081c9a6ea2eSBryan Cantrill stacks_cleanup(B_TRUE);
1082c9a6ea2eSBryan Cantrill return (rval);
1083c9a6ea2eSBryan Cantrill }
1084c9a6ea2eSBryan Cantrill
1085c9a6ea2eSBryan Cantrill typedef struct tid2ulwp_walk {
1086c9a6ea2eSBryan Cantrill lwpid_t t2u_tid;
1087c9a6ea2eSBryan Cantrill uintptr_t t2u_lwp;
1088c9a6ea2eSBryan Cantrill boolean_t t2u_found;
1089c9a6ea2eSBryan Cantrill } tid2ulwp_walk_t;
1090c9a6ea2eSBryan Cantrill
1091c9a6ea2eSBryan Cantrill /*ARGSUSED*/
1092c9a6ea2eSBryan Cantrill static int
tid2ulwp_walk(uintptr_t addr,ulwp_t * ulwp,tid2ulwp_walk_t * t2u)1093c9a6ea2eSBryan Cantrill tid2ulwp_walk(uintptr_t addr, ulwp_t *ulwp, tid2ulwp_walk_t *t2u)
1094c9a6ea2eSBryan Cantrill {
1095c9a6ea2eSBryan Cantrill if (ulwp->ul_lwpid == t2u->t2u_tid) {
1096c9a6ea2eSBryan Cantrill t2u->t2u_lwp = addr;
1097c9a6ea2eSBryan Cantrill t2u->t2u_found = B_TRUE;
1098c9a6ea2eSBryan Cantrill return (WALK_DONE);
1099c9a6ea2eSBryan Cantrill }
1100c9a6ea2eSBryan Cantrill
1101c9a6ea2eSBryan Cantrill return (WALK_NEXT);
1102c9a6ea2eSBryan Cantrill }
1103c9a6ea2eSBryan Cantrill
1104c9a6ea2eSBryan Cantrill static int
tid2ulwp_impl(uintptr_t tid_addr,uintptr_t * ulwp_addrp)110528e4da25SMatthew Ahrens tid2ulwp_impl(uintptr_t tid_addr, uintptr_t *ulwp_addrp)
1106c9a6ea2eSBryan Cantrill {
1107c9a6ea2eSBryan Cantrill tid2ulwp_walk_t t2u;
1108c9a6ea2eSBryan Cantrill
1109c9a6ea2eSBryan Cantrill bzero(&t2u, sizeof (t2u));
111028e4da25SMatthew Ahrens t2u.t2u_tid = (lwpid_t)tid_addr;
1111c9a6ea2eSBryan Cantrill
1112c9a6ea2eSBryan Cantrill if (mdb_walk("ulwp", (mdb_walk_cb_t)tid2ulwp_walk, &t2u) != 0) {
1113c9a6ea2eSBryan Cantrill mdb_warn("can't walk 'ulwp'");
1114c9a6ea2eSBryan Cantrill return (DCMD_ERR);
1115c9a6ea2eSBryan Cantrill }
1116c9a6ea2eSBryan Cantrill
1117c9a6ea2eSBryan Cantrill if (!t2u.t2u_found) {
1118c9a6ea2eSBryan Cantrill mdb_warn("thread ID %d not found", t2u.t2u_tid);
1119c9a6ea2eSBryan Cantrill return (DCMD_ERR);
1120c9a6ea2eSBryan Cantrill }
112128e4da25SMatthew Ahrens *ulwp_addrp = t2u.t2u_lwp;
112228e4da25SMatthew Ahrens return (DCMD_OK);
112328e4da25SMatthew Ahrens }
1124c9a6ea2eSBryan Cantrill
112528e4da25SMatthew Ahrens /*ARGSUSED*/
112628e4da25SMatthew Ahrens static int
tid2ulwp(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)112728e4da25SMatthew Ahrens tid2ulwp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
112828e4da25SMatthew Ahrens {
112928e4da25SMatthew Ahrens uintptr_t ulwp_addr;
113028e4da25SMatthew Ahrens int error;
113128e4da25SMatthew Ahrens
113228e4da25SMatthew Ahrens if (argc != 0)
113328e4da25SMatthew Ahrens return (DCMD_USAGE);
113428e4da25SMatthew Ahrens
113528e4da25SMatthew Ahrens error = tid2ulwp_impl(addr, &ulwp_addr);
113628e4da25SMatthew Ahrens if (error == DCMD_OK)
113728e4da25SMatthew Ahrens mdb_printf("%p\n", ulwp_addr);
113828e4da25SMatthew Ahrens return (error);
113928e4da25SMatthew Ahrens }
114028e4da25SMatthew Ahrens
114107188943SJason King /*
114207188943SJason King * This is used by both d_tsd and d_errno, and contains the sum of all
114307188943SJason King * members used by both commands.
114407188943SJason King */
114528e4da25SMatthew Ahrens typedef struct mdb_libc_ulwp {
114628e4da25SMatthew Ahrens void *ul_ftsd[TSD_NFAST];
114728e4da25SMatthew Ahrens tsd_t *ul_stsd;
114807188943SJason King int *ul_errnop;
114928e4da25SMatthew Ahrens } mdb_libc_ulwp_t;
115028e4da25SMatthew Ahrens
115128e4da25SMatthew Ahrens /*
115228e4da25SMatthew Ahrens * Map from thread pointer to tsd for given key
115328e4da25SMatthew Ahrens */
115428e4da25SMatthew Ahrens static int
d_tsd(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)115528e4da25SMatthew Ahrens d_tsd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
115628e4da25SMatthew Ahrens {
115728e4da25SMatthew Ahrens mdb_libc_ulwp_t u;
115828e4da25SMatthew Ahrens uintptr_t ulwp_addr;
1159892ad162SToomas Soome uintptr_t key = 0;
116028e4da25SMatthew Ahrens void *element = NULL;
116128e4da25SMatthew Ahrens
116228e4da25SMatthew Ahrens if (mdb_getopts(argc, argv, 'k', MDB_OPT_UINTPTR, &key, NULL) != argc)
116328e4da25SMatthew Ahrens return (DCMD_USAGE);
116428e4da25SMatthew Ahrens
1165892ad162SToomas Soome if (!(flags & DCMD_ADDRSPEC) || key == 0)
116628e4da25SMatthew Ahrens return (DCMD_USAGE);
116728e4da25SMatthew Ahrens
116828e4da25SMatthew Ahrens if (tid2ulwp_impl(addr, &ulwp_addr) != DCMD_OK)
116928e4da25SMatthew Ahrens return (DCMD_ERR);
117028e4da25SMatthew Ahrens
117128e4da25SMatthew Ahrens if (mdb_ctf_vread(&u, "ulwp_t", "mdb_libc_ulwp_t", ulwp_addr, 0) == -1)
117228e4da25SMatthew Ahrens return (DCMD_ERR);
117328e4da25SMatthew Ahrens
117428e4da25SMatthew Ahrens if (key < TSD_NFAST) {
117528e4da25SMatthew Ahrens element = u.ul_ftsd[key];
117628e4da25SMatthew Ahrens } else if (u.ul_stsd != NULL) {
117728e4da25SMatthew Ahrens uint_t nalloc;
117828e4da25SMatthew Ahrens /* tsd_t is a union, so we can't use ctf_vread() on it. */
117928e4da25SMatthew Ahrens if (mdb_vread(&nalloc, sizeof (nalloc),
118028e4da25SMatthew Ahrens (uintptr_t)&u.ul_stsd->tsd_nalloc) == -1) {
118128e4da25SMatthew Ahrens mdb_warn("failed to read tsd_t at %p", u.ul_stsd);
118228e4da25SMatthew Ahrens return (DCMD_ERR);
118328e4da25SMatthew Ahrens }
118428e4da25SMatthew Ahrens if (key < nalloc) {
118528e4da25SMatthew Ahrens if (mdb_vread(&element, sizeof (element),
118628e4da25SMatthew Ahrens (uintptr_t)&u.ul_stsd->tsd_data[key]) == -1) {
118728e4da25SMatthew Ahrens mdb_warn("failed to read tsd_t at %p",
118828e4da25SMatthew Ahrens u.ul_stsd);
118928e4da25SMatthew Ahrens return (DCMD_ERR);
119028e4da25SMatthew Ahrens }
119128e4da25SMatthew Ahrens }
119228e4da25SMatthew Ahrens }
119328e4da25SMatthew Ahrens
119428e4da25SMatthew Ahrens if (element == NULL && (flags & DCMD_PIPE))
119528e4da25SMatthew Ahrens return (DCMD_OK);
1196c9a6ea2eSBryan Cantrill
119728e4da25SMatthew Ahrens mdb_printf("%p\n", element);
1198c9a6ea2eSBryan Cantrill return (DCMD_OK);
1199c9a6ea2eSBryan Cantrill }
1200c9a6ea2eSBryan Cantrill
1201542a7b7fSCarlos Neira /*
1202542a7b7fSCarlos Neira * Print percent from 16-bit binary fraction [0 .. 1]
1203542a7b7fSCarlos Neira * Round up .01 to .1 to indicate some small percentage (the 0x7000 below).
1204542a7b7fSCarlos Neira *
1205542a7b7fSCarlos Neira * Note: This routine was copied from elfdump/common/corenote.c and modified.
1206542a7b7fSCarlos Neira *
1207542a7b7fSCarlos Neira */
1208542a7b7fSCarlos Neira static uint_t
pct_value(ushort_t pct)1209542a7b7fSCarlos Neira pct_value(ushort_t pct)
1210542a7b7fSCarlos Neira {
1211542a7b7fSCarlos Neira uint_t value = pct;
1212542a7b7fSCarlos Neira
1213542a7b7fSCarlos Neira value = ((value * 1000) + 0x7000) >> 15; /* [0 .. 1000] */
1214542a7b7fSCarlos Neira if (value >= 1000)
1215542a7b7fSCarlos Neira value = 999;
1216542a7b7fSCarlos Neira
1217542a7b7fSCarlos Neira return (value);
1218542a7b7fSCarlos Neira }
1219542a7b7fSCarlos Neira
1220542a7b7fSCarlos Neira static void
psinfo_raw(psinfo_t psinfo)1221542a7b7fSCarlos Neira psinfo_raw(psinfo_t psinfo)
1222542a7b7fSCarlos Neira {
1223542a7b7fSCarlos Neira const int minspaces = 2;
1224542a7b7fSCarlos Neira const int spbcols = 20;
1225542a7b7fSCarlos Neira char sysname[SYS2STR_MAX];
1226542a7b7fSCarlos Neira uint_t cpu, mem;
1227542a7b7fSCarlos Neira char buff[32];
1228542a7b7fSCarlos Neira int bufflen;
1229542a7b7fSCarlos Neira
1230542a7b7fSCarlos Neira mdb_printf("[ NT_PRPSINFO ]\n");
1231542a7b7fSCarlos Neira
1232542a7b7fSCarlos Neira mdb_printf("\tpr_state: %d\t\t\tpr_sname: %c\n",
1233542a7b7fSCarlos Neira psinfo.pr_lwp.pr_state, psinfo.pr_lwp.pr_sname);
1234542a7b7fSCarlos Neira
1235542a7b7fSCarlos Neira mdb_printf("\tpr_zomb: %d\t\t\tpr_nice: %d\n",
1236542a7b7fSCarlos Neira psinfo.pr_nzomb, psinfo.pr_lwp.pr_nice);
1237542a7b7fSCarlos Neira
1238542a7b7fSCarlos Neira mdb_printf("\tpr_uid: %u\t\t\tpr_gid: %u\n",
1239542a7b7fSCarlos Neira psinfo.pr_uid, psinfo.pr_gid);
1240542a7b7fSCarlos Neira
1241542a7b7fSCarlos Neira mdb_snprintf(buff, sizeof (buff),
1242542a7b7fSCarlos Neira "%d", psinfo.pr_pid);
1243542a7b7fSCarlos Neira
1244542a7b7fSCarlos Neira bufflen = strlen(buff);
1245542a7b7fSCarlos Neira mdb_printf("\tpr_pid: %s%*spr_ppid: %d\n",
1246542a7b7fSCarlos Neira buff, strlen(buff) > spbcols ? minspaces : (spbcols - bufflen), " ",
1247542a7b7fSCarlos Neira psinfo.pr_ppid);
1248542a7b7fSCarlos Neira
1249542a7b7fSCarlos Neira mdb_printf("\tpr_pgid: %u\t\t\tpr_sid: %d\n",
1250542a7b7fSCarlos Neira psinfo.pr_gid, psinfo.pr_sid);
1251542a7b7fSCarlos Neira
1252542a7b7fSCarlos Neira mdb_snprintf(buff, sizeof (buff),
1253542a7b7fSCarlos Neira "0x%lx", (ulong_t)psinfo.pr_addr);
1254542a7b7fSCarlos Neira
1255542a7b7fSCarlos Neira bufflen = strlen(buff);
1256542a7b7fSCarlos Neira
1257542a7b7fSCarlos Neira mdb_printf("\tpr_addr: %s%*spr_size: %#x\n",
1258542a7b7fSCarlos Neira buff, strlen(buff) > spbcols ? minspaces : (spbcols - bufflen), " ",
1259542a7b7fSCarlos Neira (ulong_t)psinfo.pr_size);
1260542a7b7fSCarlos Neira
1261542a7b7fSCarlos Neira mdb_printf("\tpr_rssize: %#lx\t\tpr_wchan: %#lx\n",
1262542a7b7fSCarlos Neira (ulong_t)psinfo.pr_rssize, (ulong_t)psinfo.pr_lwp.pr_wchan);
1263542a7b7fSCarlos Neira
1264542a7b7fSCarlos Neira mdb_printf("\tpr_start:\n\t tv_sec: %ld\t\ttv_nsec: %ld\n",
1265542a7b7fSCarlos Neira psinfo.pr_start.tv_sec, psinfo.pr_start.tv_nsec);
1266542a7b7fSCarlos Neira
1267542a7b7fSCarlos Neira mdb_printf("\tpr_time:\n\t tv_sec: %ld\t\t\ttv_nsec: %ld\n",
1268542a7b7fSCarlos Neira psinfo.pr_time.tv_sec, psinfo.pr_time.tv_nsec);
1269542a7b7fSCarlos Neira
1270542a7b7fSCarlos Neira mdb_printf("\tpr_pri: %d\t\t\tpr_oldpri: %d\n",
1271542a7b7fSCarlos Neira psinfo.pr_lwp.pr_pri, psinfo.pr_lwp.pr_oldpri);
1272542a7b7fSCarlos Neira
1273542a7b7fSCarlos Neira mdb_printf("\tpr_cpu: %d\n", psinfo.pr_lwp.pr_cpu);
1274542a7b7fSCarlos Neira
1275542a7b7fSCarlos Neira mdb_printf("\tpr_clname: %s\n", psinfo.pr_lwp.pr_clname);
1276542a7b7fSCarlos Neira
1277542a7b7fSCarlos Neira mdb_printf("\tpr_fname: %s\n", psinfo.pr_fname);
1278542a7b7fSCarlos Neira
1279542a7b7fSCarlos Neira mdb_printf("\tpr_psargs: %s\n", psinfo.pr_psargs);
1280542a7b7fSCarlos Neira
1281542a7b7fSCarlos Neira
1282542a7b7fSCarlos Neira mdb_printf("\tpr_syscall: [ %s ]\n",
1283542a7b7fSCarlos Neira proc_sysname(psinfo.pr_lwp.pr_syscall, sysname,
1284542a7b7fSCarlos Neira sizeof (sysname)));
1285542a7b7fSCarlos Neira
1286542a7b7fSCarlos Neira mdb_printf("\tpr_ctime:\n\t tv_sec: %ld\t\t\ttv_nsec: %ld\n",
1287542a7b7fSCarlos Neira psinfo.pr_ctime.tv_sec, psinfo.pr_ctime.tv_nsec);
1288542a7b7fSCarlos Neira
1289542a7b7fSCarlos Neira mdb_printf("\tpr_argc: %d\t\t\tpr_argv: 0x%lx\n",
1290542a7b7fSCarlos Neira psinfo.pr_argc, (ulong_t)psinfo.pr_argv);
1291542a7b7fSCarlos Neira
1292542a7b7fSCarlos Neira mdb_snprintf(buff, sizeof (buff), "0x%lx", (ulong_t)psinfo.pr_envp);
1293542a7b7fSCarlos Neira
1294542a7b7fSCarlos Neira bufflen = strlen(buff);
1295542a7b7fSCarlos Neira
1296542a7b7fSCarlos Neira mdb_printf("\tpr_envp: %s%*spr_wstat: %d\n",
1297542a7b7fSCarlos Neira buff, strlen(buff) > spbcols ? minspaces : (spbcols - bufflen), " ",
1298542a7b7fSCarlos Neira psinfo.pr_wstat);
1299542a7b7fSCarlos Neira
1300542a7b7fSCarlos Neira cpu = pct_value(psinfo.pr_pctcpu);
1301542a7b7fSCarlos Neira mem = pct_value(psinfo.pr_pctmem);
1302542a7b7fSCarlos Neira
1303542a7b7fSCarlos Neira mdb_printf("\tpr_pctcpu: %u.%u%%\t\tpr_pctmem: %u.%u%%\n",
1304542a7b7fSCarlos Neira cpu / 10, cpu % 10, mem / 10, mem % 10);
1305542a7b7fSCarlos Neira
1306542a7b7fSCarlos Neira mdb_printf("\tpr_euid: %u\t\t\tpr_egid: %u\n",
1307542a7b7fSCarlos Neira psinfo.pr_euid, psinfo.pr_egid);
1308542a7b7fSCarlos Neira
1309542a7b7fSCarlos Neira mdb_printf("\tpr_dmodel: [%s]\n",
1310542a7b7fSCarlos Neira proc_dmodelname(psinfo.pr_dmodel, buff, sizeof (buff)));
1311542a7b7fSCarlos Neira }
1312542a7b7fSCarlos Neira
1313542a7b7fSCarlos Neira static void
psinfo_sum(psinfo_t psinfo)1314542a7b7fSCarlos Neira psinfo_sum(psinfo_t psinfo)
1315542a7b7fSCarlos Neira {
1316542a7b7fSCarlos Neira const int minspaces = 2;
1317542a7b7fSCarlos Neira const int spbcols = 23;
1318542a7b7fSCarlos Neira char buff[64];
1319542a7b7fSCarlos Neira int bufflen;
1320542a7b7fSCarlos Neira int ms;
1321542a7b7fSCarlos Neira
1322542a7b7fSCarlos Neira mdb_printf("PID: %6d (process id)\t\t"
1323542a7b7fSCarlos Neira "UID: %4u (real user id)\n",
1324542a7b7fSCarlos Neira psinfo.pr_pid, psinfo.pr_uid);
1325542a7b7fSCarlos Neira
1326542a7b7fSCarlos Neira mdb_printf("PPID: %6d (parent process id)\tEUID: %4d"
1327542a7b7fSCarlos Neira " (effective user id)\n", psinfo.pr_ppid, psinfo.pr_euid);
1328542a7b7fSCarlos Neira
1329542a7b7fSCarlos Neira mdb_printf("PGID: %6d (process group id)\tGID: %4u"
1330542a7b7fSCarlos Neira " (real group id)\n", psinfo.pr_pgid, psinfo.pr_gid);
1331542a7b7fSCarlos Neira
1332542a7b7fSCarlos Neira mdb_printf("SID: %6d (session id)\t\tEGID: %4u"
1333542a7b7fSCarlos Neira " (effective group id)\n",
1334542a7b7fSCarlos Neira psinfo.pr_sid, psinfo.pr_egid);
1335542a7b7fSCarlos Neira
1336542a7b7fSCarlos Neira mdb_printf("ZONEID: %6d\t\t\t\tCONTRACT:%4d\n",
1337542a7b7fSCarlos Neira psinfo.pr_zoneid, psinfo.pr_contract);
1338542a7b7fSCarlos Neira
1339542a7b7fSCarlos Neira mdb_printf("PROJECT:%6d \t\t\t\tTASK: %4d\n\n",
1340542a7b7fSCarlos Neira psinfo.pr_projid, psinfo.pr_taskid);
1341542a7b7fSCarlos Neira
1342542a7b7fSCarlos Neira mdb_printf("START: %Y (wall timestamp when the process started)\n",
1343542a7b7fSCarlos Neira psinfo.pr_start);
1344542a7b7fSCarlos Neira
1345542a7b7fSCarlos Neira ms = NSEC2MSEC(psinfo.pr_time.tv_nsec);
1346542a7b7fSCarlos Neira
1347542a7b7fSCarlos Neira mdb_snprintf(buff, sizeof (buff), "%ld.%d seconds",
1348542a7b7fSCarlos Neira psinfo.pr_time.tv_sec, ms);
1349542a7b7fSCarlos Neira
1350542a7b7fSCarlos Neira bufflen = strlen(buff);
1351542a7b7fSCarlos Neira
1352542a7b7fSCarlos Neira mdb_printf("TIME: %s%*s"
1353542a7b7fSCarlos Neira "(CPU time used by this process)\n",
1354542a7b7fSCarlos Neira buff, bufflen > spbcols ? minspaces : (spbcols - bufflen), " ");
1355542a7b7fSCarlos Neira
1356542a7b7fSCarlos Neira ms = NSEC2MSEC(psinfo.pr_ctime.tv_nsec);
1357542a7b7fSCarlos Neira
1358542a7b7fSCarlos Neira mdb_snprintf(buff, sizeof (buff), "%ld.%d seconds",
1359542a7b7fSCarlos Neira psinfo.pr_ctime.tv_sec, ms);
1360542a7b7fSCarlos Neira
1361542a7b7fSCarlos Neira mdb_printf("CTIME: %s%*s"
1362542a7b7fSCarlos Neira "(CPU time used by child processes)\n",
1363542a7b7fSCarlos Neira buff, bufflen > spbcols ? minspaces : (spbcols - bufflen), " ");
1364542a7b7fSCarlos Neira
1365542a7b7fSCarlos Neira mdb_snprintf(buff, sizeof (buff), "%s", psinfo.pr_fname);
1366542a7b7fSCarlos Neira bufflen = strlen(buff);
1367542a7b7fSCarlos Neira
1368542a7b7fSCarlos Neira mdb_printf("FNAME: %s%*s(name of the program executed)\n",
1369542a7b7fSCarlos Neira buff, bufflen > spbcols ? minspaces : (spbcols - bufflen), " ");
1370542a7b7fSCarlos Neira
1371542a7b7fSCarlos Neira mdb_printf("PSARGS: \"%s\"\n", psinfo.pr_psargs);
1372542a7b7fSCarlos Neira }
1373542a7b7fSCarlos Neira
1374542a7b7fSCarlos Neira void
d_psinfo_dcmd_help(void)1375542a7b7fSCarlos Neira d_psinfo_dcmd_help(void)
1376542a7b7fSCarlos Neira {
1377542a7b7fSCarlos Neira mdb_printf(
1378542a7b7fSCarlos Neira "Prints relevant fields from psinfo_t data and\n"
1379542a7b7fSCarlos Neira "most fields from NT_PRPSINFO note section\n\n"
1380542a7b7fSCarlos Neira "Usage: ::psinfo [-v]\n"
1381542a7b7fSCarlos Neira "Options:\n"
1382542a7b7fSCarlos Neira " -v verbose output\n");
1383542a7b7fSCarlos Neira }
1384542a7b7fSCarlos Neira
1385542a7b7fSCarlos Neira static int
d_psinfo(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1386542a7b7fSCarlos Neira d_psinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1387542a7b7fSCarlos Neira {
1388542a7b7fSCarlos Neira psinfo_t psinfo;
1389542a7b7fSCarlos Neira uint_t opt_v = FALSE;
1390542a7b7fSCarlos Neira ssize_t nbytes;
1391542a7b7fSCarlos Neira
1392542a7b7fSCarlos Neira if (mdb_getopts(argc, argv, 'v',
1393542a7b7fSCarlos Neira MDB_OPT_SETBITS, TRUE, &opt_v, NULL) != argc)
1394542a7b7fSCarlos Neira return (DCMD_USAGE);
1395542a7b7fSCarlos Neira
1396542a7b7fSCarlos Neira nbytes = mdb_get_xdata("psinfo", NULL, 0);
1397542a7b7fSCarlos Neira
1398542a7b7fSCarlos Neira if (nbytes <= 0) {
1399542a7b7fSCarlos Neira mdb_warn("information not available for analysis");
1400542a7b7fSCarlos Neira return (DCMD_ERR);
1401542a7b7fSCarlos Neira }
1402542a7b7fSCarlos Neira
1403542a7b7fSCarlos Neira if (mdb_get_xdata("psinfo", &psinfo, nbytes) != nbytes) {
1404542a7b7fSCarlos Neira mdb_warn("failed to read psinfo information");
1405542a7b7fSCarlos Neira return (DCMD_ERR);
1406542a7b7fSCarlos Neira }
1407542a7b7fSCarlos Neira
1408542a7b7fSCarlos Neira if (opt_v) {
1409542a7b7fSCarlos Neira psinfo_raw(psinfo);
1410542a7b7fSCarlos Neira } else {
1411542a7b7fSCarlos Neira psinfo_sum(psinfo);
1412542a7b7fSCarlos Neira }
1413542a7b7fSCarlos Neira
1414542a7b7fSCarlos Neira return (DCMD_OK);
1415542a7b7fSCarlos Neira }
1416542a7b7fSCarlos Neira
1417a48fdbefSBryan Cantrill typedef struct d_mutex_output {
1418a48fdbefSBryan Cantrill char *mo_output;
1419a48fdbefSBryan Cantrill struct d_mutex_output *mo_next;
1420a48fdbefSBryan Cantrill } d_mutex_output_t;
1421a48fdbefSBryan Cantrill
1422a48fdbefSBryan Cantrill static void
d_mutex_output_push(d_mutex_output_t ** head,const char * out)1423a48fdbefSBryan Cantrill d_mutex_output_push(d_mutex_output_t **head, const char *out)
1424a48fdbefSBryan Cantrill {
1425a48fdbefSBryan Cantrill d_mutex_output_t *new;
1426a48fdbefSBryan Cantrill size_t len = strlen(out) + 1;
1427a48fdbefSBryan Cantrill
1428a48fdbefSBryan Cantrill new = mdb_alloc(sizeof (d_mutex_output_t), UM_SLEEP | UM_GC);
1429a48fdbefSBryan Cantrill new->mo_next = *head;
1430a48fdbefSBryan Cantrill new->mo_output = mdb_alloc(len, UM_SLEEP | UM_GC);
1431a48fdbefSBryan Cantrill bcopy(out, new->mo_output, len);
1432a48fdbefSBryan Cantrill
1433a48fdbefSBryan Cantrill *head = new;
1434a48fdbefSBryan Cantrill }
1435a48fdbefSBryan Cantrill
1436a48fdbefSBryan Cantrill void
d_mutex_output_reverse(d_mutex_output_t ** head)1437a48fdbefSBryan Cantrill d_mutex_output_reverse(d_mutex_output_t **head)
1438a48fdbefSBryan Cantrill {
1439a48fdbefSBryan Cantrill d_mutex_output_t *current, *next, *last = NULL;
1440a48fdbefSBryan Cantrill
1441a48fdbefSBryan Cantrill for (current = *head; current != NULL; current = next) {
1442a48fdbefSBryan Cantrill next = current->mo_next;
1443a48fdbefSBryan Cantrill current->mo_next = last;
1444a48fdbefSBryan Cantrill last = current;
1445a48fdbefSBryan Cantrill
1446a48fdbefSBryan Cantrill if (next == NULL) {
1447a48fdbefSBryan Cantrill break;
1448a48fdbefSBryan Cantrill }
1449a48fdbefSBryan Cantrill }
1450a48fdbefSBryan Cantrill
1451a48fdbefSBryan Cantrill *head = current;
1452a48fdbefSBryan Cantrill }
1453a48fdbefSBryan Cantrill
1454a48fdbefSBryan Cantrill typedef struct d_mutex_walkdata {
1455a48fdbefSBryan Cantrill uintptr_t mow_target;
1456a48fdbefSBryan Cantrill d_mutex_output_t *mow_output;
1457a48fdbefSBryan Cantrill } d_mutex_walkdata_t;
1458a48fdbefSBryan Cantrill
1459a48fdbefSBryan Cantrill int
d_mutex_walk(uintptr_t addr,const ulwp_t * ulwp,d_mutex_walkdata_t * wd)1460a48fdbefSBryan Cantrill d_mutex_walk(uintptr_t addr, const ulwp_t *ulwp, d_mutex_walkdata_t *wd)
1461a48fdbefSBryan Cantrill {
1462a48fdbefSBryan Cantrill char buf[256];
1463a48fdbefSBryan Cantrill
1464a48fdbefSBryan Cantrill if ((uintptr_t)ulwp->ul_wchan != wd->mow_target)
1465a48fdbefSBryan Cantrill return (WALK_NEXT);
1466a48fdbefSBryan Cantrill
1467a48fdbefSBryan Cantrill if (mdb_thread_name(ulwp->ul_lwpid, buf, sizeof (buf)) != 0) {
1468a48fdbefSBryan Cantrill mdb_snprintf(buf, sizeof (buf), "0x%p", addr);
1469a48fdbefSBryan Cantrill }
1470a48fdbefSBryan Cantrill
1471a48fdbefSBryan Cantrill d_mutex_output_push(&wd->mow_output, buf);
1472a48fdbefSBryan Cantrill return (WALK_NEXT);
1473a48fdbefSBryan Cantrill }
1474a48fdbefSBryan Cantrill
1475a48fdbefSBryan Cantrill static void
d_mutex_help(void)1476a48fdbefSBryan Cantrill d_mutex_help(void)
1477a48fdbefSBryan Cantrill {
1478a48fdbefSBryan Cantrill mdb_printf("%s\n",
1479a48fdbefSBryan Cantrill "Dump a mutex, optionally decoding flags and displaying waiters.\n");
1480a48fdbefSBryan Cantrill mdb_dec_indent(2);
1481a48fdbefSBryan Cantrill mdb_printf("%<b>OPTIONS%</b>\n");
1482a48fdbefSBryan Cantrill mdb_inc_indent(2);
1483a48fdbefSBryan Cantrill mdb_printf("%s",
1484a48fdbefSBryan Cantrill " -v Dump verbosely, decoding type and flags and showing waiters\n"
1485a48fdbefSBryan Cantrill " -f force printing as a mutex, even if it doesn't appear to be one\n");
1486a48fdbefSBryan Cantrill }
1487a48fdbefSBryan Cantrill
1488a48fdbefSBryan Cantrill static int
d_mutex(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)1489a48fdbefSBryan Cantrill d_mutex(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
1490a48fdbefSBryan Cantrill {
1491a48fdbefSBryan Cantrill lwp_mutex_t mutex;
1492a48fdbefSBryan Cantrill uintptr_t owner;
1493a48fdbefSBryan Cantrill char buf[256];
1494a48fdbefSBryan Cantrill uint_t opt_v = FALSE, opt_f = FALSE, warn;
1495a48fdbefSBryan Cantrill d_mutex_walkdata_t wd;
1496a48fdbefSBryan Cantrill d_mutex_output_t *toutput = NULL, *foutput = NULL;
1497a48fdbefSBryan Cantrill size_t i;
1498a48fdbefSBryan Cantrill
1499a48fdbefSBryan Cantrill
1500a48fdbefSBryan Cantrill if (!(flags & DCMD_ADDRSPEC))
1501a48fdbefSBryan Cantrill return (DCMD_USAGE);
1502a48fdbefSBryan Cantrill
1503a48fdbefSBryan Cantrill if (mdb_getopts(argc, argv,
1504a48fdbefSBryan Cantrill 'v', MDB_OPT_SETBITS, TRUE, &opt_v,
1505a48fdbefSBryan Cantrill 'f', MDB_OPT_SETBITS, TRUE, &opt_f,
1506a48fdbefSBryan Cantrill NULL) != argc) {
1507a48fdbefSBryan Cantrill return (DCMD_USAGE);
1508a48fdbefSBryan Cantrill }
1509a48fdbefSBryan Cantrill
1510a48fdbefSBryan Cantrill if (DCMD_HDRSPEC(flags)) {
1511a48fdbefSBryan Cantrill mdb_printf("%-16s %4s %4s %4s %s\n",
1512a48fdbefSBryan Cantrill "ADDR", "TYPE", "FLAG", "WTRS", "OWNER");
1513a48fdbefSBryan Cantrill }
1514a48fdbefSBryan Cantrill
1515a48fdbefSBryan Cantrill /*
1516a48fdbefSBryan Cantrill * If we aren't in a loop or a pipe, we will warn explicitly when
1517a48fdbefSBryan Cantrill * we can't make sense of a mutex.
1518a48fdbefSBryan Cantrill */
1519a48fdbefSBryan Cantrill warn = (flags & (DCMD_LOOP | DCMD_PIPE)) ? FALSE : TRUE;
1520a48fdbefSBryan Cantrill
1521a48fdbefSBryan Cantrill if (mdb_vread(&mutex, sizeof (mutex), addr) != sizeof (mutex)) {
1522a48fdbefSBryan Cantrill if (warn)
1523a48fdbefSBryan Cantrill mdb_warn("failed to read mutex at 0x%p", addr);
1524a48fdbefSBryan Cantrill
1525a48fdbefSBryan Cantrill return (DCMD_ERR);
1526a48fdbefSBryan Cantrill }
1527a48fdbefSBryan Cantrill
1528a48fdbefSBryan Cantrill /*
1529a48fdbefSBryan Cantrill * It's legal to have a zero'd mutex_t in BSS -- so we can only
1530a48fdbefSBryan Cantrill * rely on the magic to disambiguate a mutex if it is non-zero.
1531a48fdbefSBryan Cantrill */
1532a48fdbefSBryan Cantrill if (!opt_f && mutex.flags.magic != 0 &&
1533a48fdbefSBryan Cantrill mutex.flags.magic != MUTEX_MAGIC) {
1534a48fdbefSBryan Cantrill if (!warn)
1535a48fdbefSBryan Cantrill return (DCMD_ERR);
1536a48fdbefSBryan Cantrill
1537a48fdbefSBryan Cantrill if (mutex.flags.magic == COND_MAGIC) {
1538a48fdbefSBryan Cantrill mdb_warn("0x%p is not a mutex (appears to be a "
1539a48fdbefSBryan Cantrill "condition variable)\n", addr);
1540a48fdbefSBryan Cantrill } else if (mutex.flags.magic == SEMA_MAGIC) {
1541a48fdbefSBryan Cantrill mdb_warn("0x%p is not a mutex (appears to be a "
1542a48fdbefSBryan Cantrill "semaphore)\n", addr);
1543a48fdbefSBryan Cantrill } else if (mutex.flags.magic == RWL_MAGIC) {
1544a48fdbefSBryan Cantrill mdb_warn("0x%p is not a mutex (appears to be a "
1545a48fdbefSBryan Cantrill "readers/writer lock)\n", addr);
1546a48fdbefSBryan Cantrill } else {
1547a48fdbefSBryan Cantrill mdb_warn("0x%p does not appear to be a mutex (expected "
1548a48fdbefSBryan Cantrill "0x%x, found 0x%x)\n", addr, MUTEX_MAGIC,
1549a48fdbefSBryan Cantrill mutex.flags.magic);
1550a48fdbefSBryan Cantrill }
1551a48fdbefSBryan Cantrill
1552a48fdbefSBryan Cantrill return (DCMD_ERR);
1553a48fdbefSBryan Cantrill }
1554a48fdbefSBryan Cantrill
1555a48fdbefSBryan Cantrill if (!opt_f) {
1556a48fdbefSBryan Cantrill /*
1557a48fdbefSBryan Cantrill * Sanity check that if we have an owner, it at least isn't
1558a48fdbefSBryan Cantrill * obviously not a ulwp_t.
1559a48fdbefSBryan Cantrill */
1560a48fdbefSBryan Cantrill uintptr_t owner = mutex.mutex_owner;
1561a48fdbefSBryan Cantrill ulwp_t u;
1562a48fdbefSBryan Cantrill
1563a48fdbefSBryan Cantrill if (owner == (uintptr_t)NULL) {
1564a48fdbefSBryan Cantrill if (mutex.mutex_waiters) {
1565a48fdbefSBryan Cantrill if (!warn)
1566a48fdbefSBryan Cantrill return (DCMD_ERR);
1567a48fdbefSBryan Cantrill
1568a48fdbefSBryan Cantrill mdb_warn("0x%p does not appear to be a mutex "
1569a48fdbefSBryan Cantrill "(waiters, but no owner?)\n", addr);
1570a48fdbefSBryan Cantrill
1571a48fdbefSBryan Cantrill return (DCMD_ERR);
1572a48fdbefSBryan Cantrill }
1573a48fdbefSBryan Cantrill } else if (mdb_vread(&u, sizeof (u), owner) != sizeof (u) ||
1574a48fdbefSBryan Cantrill (uintptr_t)u.ul_self != owner) {
1575a48fdbefSBryan Cantrill if (!warn)
1576a48fdbefSBryan Cantrill return (DCMD_ERR);
1577a48fdbefSBryan Cantrill
1578a48fdbefSBryan Cantrill mdb_warn("0x%p does not appear to be mutex "
1579a48fdbefSBryan Cantrill "(owner 0x%p does not appear to be a ulwp_t)\n",
1580a48fdbefSBryan Cantrill addr, owner);
1581a48fdbefSBryan Cantrill
1582a48fdbefSBryan Cantrill return (DCMD_ERR);
1583a48fdbefSBryan Cantrill }
1584a48fdbefSBryan Cantrill }
1585a48fdbefSBryan Cantrill
1586a48fdbefSBryan Cantrill mdb_printf("%-16p %4x %4x %4s ", addr, mutex.mutex_type,
1587a48fdbefSBryan Cantrill mutex.mutex_flag,
1588a48fdbefSBryan Cantrill mutex.mutex_waiters ? "yes" : "no");
1589a48fdbefSBryan Cantrill
1590a48fdbefSBryan Cantrill if ((owner = mutex.mutex_owner) == (uintptr_t)NULL) {
1591a48fdbefSBryan Cantrill mdb_printf("-\n");
1592a48fdbefSBryan Cantrill } else {
1593a48fdbefSBryan Cantrill ulwp_t u;
1594a48fdbefSBryan Cantrill
1595a48fdbefSBryan Cantrill if (mdb_vread(&u, sizeof (u), owner) != sizeof (u) ||
1596a48fdbefSBryan Cantrill mdb_thread_name(u.ul_lwpid, buf, sizeof (buf)) != 0) {
1597a48fdbefSBryan Cantrill mdb_snprintf(buf, sizeof (buf), "%d", u.ul_lwpid);
1598a48fdbefSBryan Cantrill }
1599a48fdbefSBryan Cantrill
1600a48fdbefSBryan Cantrill mdb_printf("%p %s\n", owner, buf);
1601a48fdbefSBryan Cantrill }
1602a48fdbefSBryan Cantrill
1603a48fdbefSBryan Cantrill if (!opt_v)
1604a48fdbefSBryan Cantrill return (DCMD_OK);
1605a48fdbefSBryan Cantrill
1606a48fdbefSBryan Cantrill static struct {
1607a48fdbefSBryan Cantrill int val;
1608a48fdbefSBryan Cantrill char *str;
1609a48fdbefSBryan Cantrill } tvals[] = {
1610a48fdbefSBryan Cantrill { 0x01, "LOCK_SHARED" },
1611a48fdbefSBryan Cantrill { 0x02, "LOCK_ERRORCHECK" },
1612a48fdbefSBryan Cantrill { 0x04, "LOCK_RECURSIVE" },
1613a48fdbefSBryan Cantrill { 0x10, "LOCK_PRIO_INHERIT" },
1614a48fdbefSBryan Cantrill { 0x20, "LOCK_PRIO_PROTECT" },
1615a48fdbefSBryan Cantrill { 0x40, "LOCK_ROBUST" },
1616a48fdbefSBryan Cantrill /*
1617a48fdbefSBryan Cantrill * This is a defunct type, but an ancient (or corrupt) mutex
1618a48fdbefSBryan Cantrill * might have it set; indicate it if we see it.
1619a48fdbefSBryan Cantrill */
1620a48fdbefSBryan Cantrill { 0x08, "PROCESS_ROBUST" },
1621a48fdbefSBryan Cantrill { 0, "" }
1622a48fdbefSBryan Cantrill };
1623a48fdbefSBryan Cantrill
1624a48fdbefSBryan Cantrill if (!(mutex.mutex_type & LOCK_SHARED)) {
1625a48fdbefSBryan Cantrill d_mutex_output_push(&toutput, "LOCK_NORMAL");
1626a48fdbefSBryan Cantrill }
1627a48fdbefSBryan Cantrill
1628a48fdbefSBryan Cantrill for (i = 0; tvals[i].val != 0; i++) {
1629a48fdbefSBryan Cantrill if ((mutex.mutex_type & tvals[i].val) != 0) {
1630a48fdbefSBryan Cantrill d_mutex_output_push(&toutput, tvals[i].str);
1631a48fdbefSBryan Cantrill }
1632a48fdbefSBryan Cantrill }
1633a48fdbefSBryan Cantrill
1634a48fdbefSBryan Cantrill static struct {
1635a48fdbefSBryan Cantrill int val;
1636a48fdbefSBryan Cantrill char *str;
1637a48fdbefSBryan Cantrill } fvals[] = {
1638a48fdbefSBryan Cantrill { 0x1, "LOCK_OWNERDEAD" },
1639a48fdbefSBryan Cantrill { 0x2, "LOCK_NOTRECOVERABLE" },
1640a48fdbefSBryan Cantrill { 0x4, "LOCK_INITED" },
1641a48fdbefSBryan Cantrill { 0x8, "LOCK_UNMAPPED" },
1642*50718d3eSRobert Mustacchi { 0x10, "LOCK_DEADLOCK" },
1643a48fdbefSBryan Cantrill { 0, "" },
1644a48fdbefSBryan Cantrill };
1645a48fdbefSBryan Cantrill
1646a48fdbefSBryan Cantrill for (i = 0; fvals[i].val != 0; i++) {
1647a48fdbefSBryan Cantrill if ((mutex.mutex_flag & fvals[i].val) != 0) {
1648a48fdbefSBryan Cantrill d_mutex_output_push(&foutput, fvals[i].str);
1649a48fdbefSBryan Cantrill }
1650a48fdbefSBryan Cantrill }
1651a48fdbefSBryan Cantrill
1652a48fdbefSBryan Cantrill wd.mow_target = addr;
1653a48fdbefSBryan Cantrill wd.mow_output = NULL;
1654a48fdbefSBryan Cantrill
1655a48fdbefSBryan Cantrill if (mdb_walk("ulwp", (mdb_walk_cb_t)d_mutex_walk, &wd) != 0) {
1656a48fdbefSBryan Cantrill mdb_warn("can't walk \"ulwp\"");
1657a48fdbefSBryan Cantrill return (DCMD_ERR);
1658a48fdbefSBryan Cantrill }
1659a48fdbefSBryan Cantrill
1660a48fdbefSBryan Cantrill d_mutex_output_t *ooutput = wd.mow_output;
1661a48fdbefSBryan Cantrill d_mutex_output_reverse(&toutput);
1662a48fdbefSBryan Cantrill d_mutex_output_reverse(&foutput);
1663a48fdbefSBryan Cantrill d_mutex_output_reverse(&ooutput);
1664a48fdbefSBryan Cantrill
1665a48fdbefSBryan Cantrill d_mutex_output_t *thead = toutput;
1666a48fdbefSBryan Cantrill d_mutex_output_t *fhead = foutput;
1667a48fdbefSBryan Cantrill d_mutex_output_t *ohead = ooutput;
1668a48fdbefSBryan Cantrill
1669a48fdbefSBryan Cantrill mdb_printf("%21s", toutput != NULL ? "|" : "");
1670a48fdbefSBryan Cantrill mdb_printf("%5s", foutput != NULL ? "|" : "");
1671a48fdbefSBryan Cantrill mdb_printf("%3s\n", ooutput != NULL ? "|" : "");
1672a48fdbefSBryan Cantrill
1673a48fdbefSBryan Cantrill boolean_t needblank = ooutput != NULL;
1674a48fdbefSBryan Cantrill
1675a48fdbefSBryan Cantrill while (toutput != NULL || foutput != NULL || ooutput != NULL) {
1676a48fdbefSBryan Cantrill if (toutput != NULL) {
1677a48fdbefSBryan Cantrill mdb_printf("%17s %s", toutput->mo_output,
1678a48fdbefSBryan Cantrill toutput == thead ? "<-+" : " ");
1679a48fdbefSBryan Cantrill toutput = toutput->mo_next;
1680a48fdbefSBryan Cantrill } else {
1681a48fdbefSBryan Cantrill mdb_printf("%21s", "");
1682a48fdbefSBryan Cantrill }
1683a48fdbefSBryan Cantrill
1684a48fdbefSBryan Cantrill if (foutput != NULL) {
1685a48fdbefSBryan Cantrill if (ooutput != NULL) {
1686a48fdbefSBryan Cantrill mdb_printf("%5s", "|");
1687a48fdbefSBryan Cantrill } else {
1688a48fdbefSBryan Cantrill if (needblank) {
1689a48fdbefSBryan Cantrill mdb_printf("%5s", "|");
1690a48fdbefSBryan Cantrill needblank = B_FALSE;
1691a48fdbefSBryan Cantrill } else {
1692a48fdbefSBryan Cantrill mdb_printf("%7s %s",
1693a48fdbefSBryan Cantrill foutput == fhead ? "+->" : "",
1694a48fdbefSBryan Cantrill foutput->mo_output);
1695a48fdbefSBryan Cantrill foutput = foutput->mo_next;
1696a48fdbefSBryan Cantrill }
1697a48fdbefSBryan Cantrill }
1698a48fdbefSBryan Cantrill } else {
1699a48fdbefSBryan Cantrill mdb_printf("%5s", "");
1700a48fdbefSBryan Cantrill }
1701a48fdbefSBryan Cantrill
1702a48fdbefSBryan Cantrill if (ooutput != NULL) {
1703a48fdbefSBryan Cantrill mdb_printf("%5s %s",
1704a48fdbefSBryan Cantrill ooutput == ohead ? "+->" : "", ooutput->mo_output);
1705a48fdbefSBryan Cantrill ooutput = ooutput->mo_next;
1706a48fdbefSBryan Cantrill }
1707a48fdbefSBryan Cantrill
1708a48fdbefSBryan Cantrill mdb_printf("\n");
1709a48fdbefSBryan Cantrill }
1710a48fdbefSBryan Cantrill
1711a48fdbefSBryan Cantrill return (DCMD_OK);
1712a48fdbefSBryan Cantrill }
1713a48fdbefSBryan Cantrill
171407188943SJason King static int
d_errno(uintptr_t addr,uint_t flags,int argc,const mdb_arg_t * argv)171507188943SJason King d_errno(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
171607188943SJason King {
171707188943SJason King mdb_libc_ulwp_t u;
171807188943SJason King uintptr_t ulwp_addr;
171907188943SJason King int error, errval;
172007188943SJason King
172107188943SJason King if (argc != 0 || (flags & DCMD_ADDRSPEC) == 0)
172207188943SJason King return (DCMD_USAGE);
172307188943SJason King
172407188943SJason King error = tid2ulwp_impl(addr, &ulwp_addr);
172507188943SJason King if (error != DCMD_OK)
172607188943SJason King return (error);
172707188943SJason King
172807188943SJason King /*
172907188943SJason King * For historical compatibility, thread 1's errno value is stored in
173007188943SJason King * a libc global variable 'errno', while each additional thread's
173107188943SJason King * errno value is stored in ulwp_t->ul_errno. In addition,
173207188943SJason King * ulwp_t->ul_errnop is set to the address of the thread's errno value,
173307188943SJason King * (i.e. for tid 1, curthead->ul_errnop = &errno, for tid > 1,
173407188943SJason King * curthread->ul_errnop = &curthread->ul_errno).
173507188943SJason King *
173607188943SJason King * Since errno itself uses *curthread->ul_errnop (see ___errno()) to
173707188943SJason King * return the thread's current errno value, we do the same.
173807188943SJason King */
173907188943SJason King if (mdb_ctf_vread(&u, "ulwp_t", "mdb_libc_ulwp_t", ulwp_addr, 0) == -1)
174007188943SJason King return (DCMD_ERR);
174107188943SJason King
174207188943SJason King if (mdb_vread(&errval, sizeof (errval), (uintptr_t)u.ul_errnop) == -1) {
174307188943SJason King mdb_warn("cannot read error value at 0x%p", u.ul_errnop);
174407188943SJason King return (DCMD_ERR);
174507188943SJason King }
174607188943SJason King
174707188943SJason King mdb_printf("%d\n", errval);
174807188943SJason King return (DCMD_OK);
174907188943SJason King }
175007188943SJason King
17517c478bd9Sstevel@tonic-gate static const mdb_dcmd_t dcmds[] = {
175207188943SJason King { "errno", "?", "print errno of a given TID", d_errno, NULL },
17537c478bd9Sstevel@tonic-gate { "jmp_buf", ":", "print jmp_buf contents", d_jmp_buf, NULL },
1754a48fdbefSBryan Cantrill { "mutex", ":[-f|v]", "dump out a mutex", d_mutex, d_mutex_help },
1755a48fdbefSBryan Cantrill { "psinfo", "[-v]", "prints relevant psinfo_t data", d_psinfo,
1756a48fdbefSBryan Cantrill d_psinfo_dcmd_help },
17577c478bd9Sstevel@tonic-gate { "siginfo", ":", "print siginfo_t structure", d_siginfo, NULL },
1758a48fdbefSBryan Cantrill { "sigjmp_buf", ":", "print sigjmp_buf contents", d_sigjmp_buf, NULL },
1759c9a6ea2eSBryan Cantrill { "stacks", "?[-afiv] [-c func] [-C func] [-m module] [-M module] ",
1760c9a6ea2eSBryan Cantrill "print unique thread stacks", stacks_dcmd, stacks_help },
1761c9a6ea2eSBryan Cantrill { "tid2ulwp", "?", "convert TID to ulwp_t address", tid2ulwp },
1762a48fdbefSBryan Cantrill { "tsd", ":-k key", "print tsd for this thread", d_tsd, NULL },
17637c478bd9Sstevel@tonic-gate { "ucontext", ":", "print ucontext_t structure", d_ucontext, NULL },
17647c478bd9Sstevel@tonic-gate { "ulwp", ":", "print ulwp_t structure", d_ulwp, NULL },
17657c478bd9Sstevel@tonic-gate { "uberdata", ":", "print uberdata_t structure", d_uberdata, NULL },
17667c478bd9Sstevel@tonic-gate { NULL }
17677c478bd9Sstevel@tonic-gate };
17687c478bd9Sstevel@tonic-gate
17697c478bd9Sstevel@tonic-gate static const mdb_walker_t walkers[] = {
17707c478bd9Sstevel@tonic-gate { "ucontext", "walk ucontext_t uc_link list",
17717c478bd9Sstevel@tonic-gate NULL, uc_walk_step, NULL, NULL },
17727c478bd9Sstevel@tonic-gate { "oldcontext", "walk per-lwp oldcontext pointers",
17737c478bd9Sstevel@tonic-gate oldc_walk_init, oldc_walk_step, oldc_walk_fini, NULL },
17747c478bd9Sstevel@tonic-gate { "ulwps", "walk list of ulwp_t pointers",
17757c478bd9Sstevel@tonic-gate ulwp_walk_init, ulwp_walk_step, NULL, NULL },
1776c9a6ea2eSBryan Cantrill { "ulwp", "walk list of ulwp_t pointers",
1777c9a6ea2eSBryan Cantrill ulwp_walk_init, ulwp_walk_step, NULL, NULL },
1778a48fdbefSBryan Cantrill { "wchan", "walk wait channels",
1779a48fdbefSBryan Cantrill wchan_walk_init, wchan_walk_step, NULL, NULL },
17807c478bd9Sstevel@tonic-gate { NULL }
17817c478bd9Sstevel@tonic-gate };
17827c478bd9Sstevel@tonic-gate
17837c478bd9Sstevel@tonic-gate static const mdb_modinfo_t modinfo = { MDB_API_VERSION, dcmds, walkers };
17847c478bd9Sstevel@tonic-gate
17857c478bd9Sstevel@tonic-gate const mdb_modinfo_t *
_mdb_init(void)17867c478bd9Sstevel@tonic-gate _mdb_init(void)
17877c478bd9Sstevel@tonic-gate {
17884a1c2431SJonathan Adams mdb_whatis_register("threads", whatis_run_ulwps, NULL,
17894a1c2431SJonathan Adams WHATIS_PRIO_EARLY, WHATIS_REG_NO_ID);
17904a1c2431SJonathan Adams
17917c478bd9Sstevel@tonic-gate return (&modinfo);
17927c478bd9Sstevel@tonic-gate }
1793