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. 27*07188943SJason King * Copyright 2019 Joyent, Inc. 284f364e7cSRobert Mustacchi */ 297c478bd9Sstevel@tonic-gate 307c478bd9Sstevel@tonic-gate #include <sys/mdb_modapi.h> 314a1c2431SJonathan Adams #include <mdb/mdb_whatis.h> 3228e4da25SMatthew Ahrens #include <mdb/mdb_ctf.h> 337c478bd9Sstevel@tonic-gate #include <procfs.h> 347c478bd9Sstevel@tonic-gate #include <ucontext.h> 357c478bd9Sstevel@tonic-gate #include <siginfo.h> 367c478bd9Sstevel@tonic-gate #include <signal.h> 377c478bd9Sstevel@tonic-gate #include <setjmp.h> 387c478bd9Sstevel@tonic-gate #include <string.h> 397c478bd9Sstevel@tonic-gate #include <thr_uberdata.h> 40c9a6ea2eSBryan Cantrill #include "findstack.h" 41542a7b7fSCarlos Neira #include <libproc.h> 427c478bd9Sstevel@tonic-gate 437c478bd9Sstevel@tonic-gate static const char * 447c478bd9Sstevel@tonic-gate stack_flags(const stack_t *sp) 457c478bd9Sstevel@tonic-gate { 467c478bd9Sstevel@tonic-gate static char buf[32]; 477c478bd9Sstevel@tonic-gate 487c478bd9Sstevel@tonic-gate if (sp->ss_flags == 0) 497c478bd9Sstevel@tonic-gate (void) strcpy(buf, " 0"); 507c478bd9Sstevel@tonic-gate else if (sp->ss_flags & ~(SS_ONSTACK | SS_DISABLE)) 517c478bd9Sstevel@tonic-gate (void) mdb_snprintf(buf, sizeof (buf), " 0x%x", sp->ss_flags); 527c478bd9Sstevel@tonic-gate else { 537c478bd9Sstevel@tonic-gate buf[0] = '\0'; 547c478bd9Sstevel@tonic-gate if (sp->ss_flags & SS_ONSTACK) 557c478bd9Sstevel@tonic-gate (void) strcat(buf, "|ONSTACK"); 567c478bd9Sstevel@tonic-gate if (sp->ss_flags & SS_DISABLE) 577c478bd9Sstevel@tonic-gate (void) strcat(buf, "|DISABLE"); 587c478bd9Sstevel@tonic-gate } 597c478bd9Sstevel@tonic-gate 607c478bd9Sstevel@tonic-gate return (buf + 1); 617c478bd9Sstevel@tonic-gate } 627c478bd9Sstevel@tonic-gate 637c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 647c478bd9Sstevel@tonic-gate static int 657c478bd9Sstevel@tonic-gate d_jmp_buf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 667c478bd9Sstevel@tonic-gate { 677c478bd9Sstevel@tonic-gate jmp_buf jb; 687c478bd9Sstevel@tonic-gate const ulong_t *b = (const ulong_t *)jb; 697c478bd9Sstevel@tonic-gate 707c478bd9Sstevel@tonic-gate if (argc != 0) 717c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 727c478bd9Sstevel@tonic-gate 737c478bd9Sstevel@tonic-gate if (mdb_vread(&jb, sizeof (jb), addr) != sizeof (jb)) { 747c478bd9Sstevel@tonic-gate mdb_warn("failed to read jmp_buf at %p", addr); 757c478bd9Sstevel@tonic-gate return (DCMD_ERR); 767c478bd9Sstevel@tonic-gate } 777c478bd9Sstevel@tonic-gate 787c478bd9Sstevel@tonic-gate #if defined(__sparc) 797c478bd9Sstevel@tonic-gate mdb_printf(" %%sp = 0x%lx\n", b[1]); 807c478bd9Sstevel@tonic-gate mdb_printf(" %%pc = 0x%lx %lA\n", b[2], b[2]); 817c478bd9Sstevel@tonic-gate mdb_printf(" %%fp = 0x%lx\n", b[3]); 827c478bd9Sstevel@tonic-gate mdb_printf(" %%i7 = 0x%lx %lA\n", b[4], b[4]); 837c478bd9Sstevel@tonic-gate #elif defined(__amd64) 847c478bd9Sstevel@tonic-gate mdb_printf(" %%rbx = 0x%lx\n", b[0]); 857c478bd9Sstevel@tonic-gate mdb_printf(" %%r12 = 0x%lx\n", b[1]); 867c478bd9Sstevel@tonic-gate mdb_printf(" %%r13 = 0x%lx\n", b[2]); 877c478bd9Sstevel@tonic-gate mdb_printf(" %%r14 = 0x%lx\n", b[3]); 887c478bd9Sstevel@tonic-gate mdb_printf(" %%r15 = 0x%lx\n", b[4]); 897c478bd9Sstevel@tonic-gate mdb_printf(" %%rbp = 0x%lx\n", b[5]); 907c478bd9Sstevel@tonic-gate mdb_printf(" %%rsp = 0x%lx\n", b[6]); 917c478bd9Sstevel@tonic-gate mdb_printf(" %%rip = 0x%lx %lA\n", b[7], b[7]); 927c478bd9Sstevel@tonic-gate #elif defined(__i386) 937c478bd9Sstevel@tonic-gate mdb_printf(" %%ebx = 0x%lx\n", b[0]); 947c478bd9Sstevel@tonic-gate mdb_printf(" %%esi = 0x%lx\n", b[1]); 957c478bd9Sstevel@tonic-gate mdb_printf(" %%edi = 0x%lx\n", b[2]); 967c478bd9Sstevel@tonic-gate mdb_printf(" %%ebp = 0x%lx\n", b[3]); 977c478bd9Sstevel@tonic-gate mdb_printf(" %%esp = 0x%lx\n", b[4]); 987c478bd9Sstevel@tonic-gate mdb_printf(" %%eip = 0x%lx %lA\n", b[5], b[5]); 997c478bd9Sstevel@tonic-gate #endif 1007c478bd9Sstevel@tonic-gate return (DCMD_OK); 1017c478bd9Sstevel@tonic-gate } 1027c478bd9Sstevel@tonic-gate 1038f88a51fSJoshua M. Clulow const mdb_bitmask_t uc_flags_bits[] = { 1048f88a51fSJoshua M. Clulow { "UC_SIGMASK", UC_SIGMASK, UC_SIGMASK }, 1058f88a51fSJoshua M. Clulow { "UC_STACK", UC_STACK, UC_STACK }, 1068f88a51fSJoshua M. Clulow { "UC_CPU", UC_CPU, UC_CPU }, 1078f88a51fSJoshua M. Clulow { "UC_FPU", UC_FPU, UC_FPU }, 1088f88a51fSJoshua M. Clulow #if defined(UC_INTR) 1098f88a51fSJoshua M. Clulow { "UC_INTR", UC_INTR, UC_INTR }, 1108f88a51fSJoshua M. Clulow #endif 1118f88a51fSJoshua M. Clulow #if defined(UC_ASR) 1128f88a51fSJoshua M. Clulow { "UC_ASR", UC_ASR, UC_ASR }, 1138f88a51fSJoshua M. Clulow #endif 1148f88a51fSJoshua M. Clulow { NULL, 0, 0 } 1158f88a51fSJoshua M. Clulow }; 1168f88a51fSJoshua M. Clulow 1177c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1187c478bd9Sstevel@tonic-gate static int 1197c478bd9Sstevel@tonic-gate d_ucontext(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1207c478bd9Sstevel@tonic-gate { 1217c478bd9Sstevel@tonic-gate ucontext_t uc; 1227c478bd9Sstevel@tonic-gate 1237c478bd9Sstevel@tonic-gate if (argc != 0) 1247c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 1257c478bd9Sstevel@tonic-gate 1267c478bd9Sstevel@tonic-gate if (mdb_vread(&uc, sizeof (uc), addr) != sizeof (uc)) { 1277c478bd9Sstevel@tonic-gate mdb_warn("failed to read ucontext at %p", addr); 1287c478bd9Sstevel@tonic-gate return (DCMD_ERR); 1297c478bd9Sstevel@tonic-gate } 1307c478bd9Sstevel@tonic-gate 1318f88a51fSJoshua M. Clulow mdb_printf(" flags = 0x%lx <%b>\n", uc.uc_flags, 1328f88a51fSJoshua M. Clulow (uint_t)uc.uc_flags, uc_flags_bits); 1337c478bd9Sstevel@tonic-gate mdb_printf(" link = 0x%p\n", uc.uc_link); 1347c478bd9Sstevel@tonic-gate mdb_printf(" sigmask = 0x%08x 0x%08x 0x%08x 0x%08x\n", 1357c478bd9Sstevel@tonic-gate uc.uc_sigmask.__sigbits[0], uc.uc_sigmask.__sigbits[1], 1367c478bd9Sstevel@tonic-gate uc.uc_sigmask.__sigbits[2], uc.uc_sigmask.__sigbits[3]); 1377c478bd9Sstevel@tonic-gate mdb_printf(" stack = sp 0x%p size 0x%lx flags %s\n", 1387c478bd9Sstevel@tonic-gate uc.uc_stack.ss_sp, uc.uc_stack.ss_size, stack_flags(&uc.uc_stack)); 1397c478bd9Sstevel@tonic-gate mdb_printf(" mcontext = 0x%p\n", 1407c478bd9Sstevel@tonic-gate addr + OFFSETOF(ucontext_t, uc_mcontext)); 1417c478bd9Sstevel@tonic-gate 1427c478bd9Sstevel@tonic-gate return (DCMD_OK); 1437c478bd9Sstevel@tonic-gate } 1447c478bd9Sstevel@tonic-gate 1457c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1467c478bd9Sstevel@tonic-gate static int 1477c478bd9Sstevel@tonic-gate d_sigjmp_buf(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1487c478bd9Sstevel@tonic-gate { 1497c478bd9Sstevel@tonic-gate #if defined(__sparc) 1507c478bd9Sstevel@tonic-gate struct { 1517c478bd9Sstevel@tonic-gate int sjs_flags; 1527c478bd9Sstevel@tonic-gate greg_t sjs_sp; 1537c478bd9Sstevel@tonic-gate greg_t sjs_pc; 1547c478bd9Sstevel@tonic-gate greg_t sjs_fp; 1557c478bd9Sstevel@tonic-gate greg_t sjs_i7; 1567c478bd9Sstevel@tonic-gate ucontext_t *sjs_uclink; 1577c478bd9Sstevel@tonic-gate ulong_t sjs_pad[_JBLEN - 6]; 1587c478bd9Sstevel@tonic-gate sigset_t sjs_sigmask; 1597c478bd9Sstevel@tonic-gate #if defined(_LP64) 1603cd8a1a6SRoger A. Faulkner greg_t sjs_asi; 1613cd8a1a6SRoger A. Faulkner greg_t sjs_fprs; 1627c478bd9Sstevel@tonic-gate #endif 1637c478bd9Sstevel@tonic-gate stack_t sjs_stack; 1647c478bd9Sstevel@tonic-gate } s; 1657c478bd9Sstevel@tonic-gate 1667c478bd9Sstevel@tonic-gate if (argc != 0) 1677c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 1687c478bd9Sstevel@tonic-gate 1697c478bd9Sstevel@tonic-gate if (mdb_vread(&s, sizeof (s), addr) != sizeof (s)) { 1707c478bd9Sstevel@tonic-gate mdb_warn("failed to read sigjmp_buf at %p", addr); 1717c478bd9Sstevel@tonic-gate return (DCMD_ERR); 1727c478bd9Sstevel@tonic-gate } 1737c478bd9Sstevel@tonic-gate 1747c478bd9Sstevel@tonic-gate mdb_printf(" flags = 0x%x\n", s.sjs_flags); 1757c478bd9Sstevel@tonic-gate mdb_printf(" %%sp = 0x%lx %lA\n", s.sjs_sp, s.sjs_sp); 1767c478bd9Sstevel@tonic-gate mdb_printf(" %%pc = 0x%lx %lA\n", s.sjs_pc, s.sjs_pc); 1777c478bd9Sstevel@tonic-gate mdb_printf(" %%fp = 0x%lx %lA\n", s.sjs_fp, s.sjs_fp); 1787c478bd9Sstevel@tonic-gate mdb_printf(" %%i7 = 0x%lx %lA\n", s.sjs_i7, s.sjs_i7); 1797c478bd9Sstevel@tonic-gate mdb_printf(" uclink = %p\n", s.sjs_uclink); 1807c478bd9Sstevel@tonic-gate mdb_printf(" sigset = 0x%08x 0x%08x 0x%08x 0x%08x\n", 1817c478bd9Sstevel@tonic-gate s.sjs_sigmask.__sigbits[0], s.sjs_sigmask.__sigbits[1], 1827c478bd9Sstevel@tonic-gate s.sjs_sigmask.__sigbits[2], s.sjs_sigmask.__sigbits[3]); 1833cd8a1a6SRoger A. Faulkner #if defined(_LP64) 1843cd8a1a6SRoger A. Faulkner mdb_printf(" %%asi = 0x%lx\n", s.sjs_asi); 1853cd8a1a6SRoger A. Faulkner mdb_printf(" %%fprs = 0x%lx\n", s.sjs_fprs); 1863cd8a1a6SRoger A. Faulkner #endif 1877c478bd9Sstevel@tonic-gate mdb_printf(" stack = sp 0x%p size 0x%lx flags %s\n", 1887c478bd9Sstevel@tonic-gate s.sjs_stack.ss_sp, s.sjs_stack.ss_size, stack_flags(&s.sjs_stack)); 1897c478bd9Sstevel@tonic-gate 1907c478bd9Sstevel@tonic-gate return (DCMD_OK); 1917c478bd9Sstevel@tonic-gate 1927c478bd9Sstevel@tonic-gate #elif defined(__i386) || defined(__amd64) 1937c478bd9Sstevel@tonic-gate return (d_ucontext(addr, flags, argc, argv)); 1947c478bd9Sstevel@tonic-gate #endif 1957c478bd9Sstevel@tonic-gate } 1967c478bd9Sstevel@tonic-gate 1977c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1987c478bd9Sstevel@tonic-gate static int 1997c478bd9Sstevel@tonic-gate d_siginfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2007c478bd9Sstevel@tonic-gate { 2017c478bd9Sstevel@tonic-gate static const char *const msname[] = { 2027c478bd9Sstevel@tonic-gate "USER", "SYSTEM", "TRAP", "TFAULT", "DFAULT", "KFAULT", 2037c478bd9Sstevel@tonic-gate "USER_LOCK", "SLEEP", "WAIT_CPU", "STOPPED" 2047c478bd9Sstevel@tonic-gate }; 2057c478bd9Sstevel@tonic-gate 2067c478bd9Sstevel@tonic-gate char signame[SIG2STR_MAX]; 2077c478bd9Sstevel@tonic-gate siginfo_t si; 2087c478bd9Sstevel@tonic-gate int i; 2097c478bd9Sstevel@tonic-gate 2107c478bd9Sstevel@tonic-gate if (argc != 0) 2117c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 2127c478bd9Sstevel@tonic-gate 2137c478bd9Sstevel@tonic-gate if (mdb_vread(&si, sizeof (si), addr) != sizeof (si)) { 2147c478bd9Sstevel@tonic-gate mdb_warn("failed to read siginfo at %p", addr); 2157c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2167c478bd9Sstevel@tonic-gate } 2177c478bd9Sstevel@tonic-gate 2187c478bd9Sstevel@tonic-gate if (sig2str(si.si_signo, signame) == -1) 2197c478bd9Sstevel@tonic-gate (void) strcpy(signame, "unknown"); 2207c478bd9Sstevel@tonic-gate 2217c478bd9Sstevel@tonic-gate mdb_printf(" signal %5d (%s)\n", si.si_signo, signame); 2227c478bd9Sstevel@tonic-gate mdb_printf(" code %5d (", si.si_code); 2237c478bd9Sstevel@tonic-gate 2247c478bd9Sstevel@tonic-gate switch (si.si_code) { 2257c478bd9Sstevel@tonic-gate case SI_NOINFO: 2267c478bd9Sstevel@tonic-gate mdb_printf("no info"); 2277c478bd9Sstevel@tonic-gate break; 2287c478bd9Sstevel@tonic-gate case SI_DTRACE: 2297c478bd9Sstevel@tonic-gate mdb_printf("from DTrace raise() action"); 2307c478bd9Sstevel@tonic-gate break; 2317c478bd9Sstevel@tonic-gate case SI_RCTL: 2327c478bd9Sstevel@tonic-gate mdb_printf("from rctl action"); 2337c478bd9Sstevel@tonic-gate break; 2347c478bd9Sstevel@tonic-gate case SI_USER: 2357c478bd9Sstevel@tonic-gate mdb_printf("user generated via kill"); 2367c478bd9Sstevel@tonic-gate break; 2377c478bd9Sstevel@tonic-gate case SI_LWP: 2387c478bd9Sstevel@tonic-gate mdb_printf("user generated via lwp_kill"); 2397c478bd9Sstevel@tonic-gate break; 2407c478bd9Sstevel@tonic-gate case SI_QUEUE: 2417c478bd9Sstevel@tonic-gate mdb_printf("user generated via sigqueue"); 2427c478bd9Sstevel@tonic-gate break; 2437c478bd9Sstevel@tonic-gate case SI_TIMER: 2447c478bd9Sstevel@tonic-gate mdb_printf("from timer expiration"); 2457c478bd9Sstevel@tonic-gate break; 2467c478bd9Sstevel@tonic-gate case SI_ASYNCIO: 2477c478bd9Sstevel@tonic-gate mdb_printf("from async i/o completion"); 2487c478bd9Sstevel@tonic-gate break; 2497c478bd9Sstevel@tonic-gate case SI_MESGQ: 2507c478bd9Sstevel@tonic-gate mdb_printf("from message arrival"); 2517c478bd9Sstevel@tonic-gate break; 2527c478bd9Sstevel@tonic-gate default: 2537c478bd9Sstevel@tonic-gate if (SI_FROMUSER(&si)) 2547c478bd9Sstevel@tonic-gate mdb_printf("from user process"); 2557c478bd9Sstevel@tonic-gate else 2567c478bd9Sstevel@tonic-gate mdb_printf("from kernel"); 2577c478bd9Sstevel@tonic-gate } 2587c478bd9Sstevel@tonic-gate 2597c478bd9Sstevel@tonic-gate mdb_printf(")\n errno %5d (%s)\n", 2607c478bd9Sstevel@tonic-gate si.si_errno, strerror(si.si_errno)); 2617c478bd9Sstevel@tonic-gate 2627c478bd9Sstevel@tonic-gate if (si.si_code == SI_USER || si.si_code == SI_QUEUE) { 2637c478bd9Sstevel@tonic-gate mdb_printf(" signal sent from PID %d (uid %d)\n", 2647c478bd9Sstevel@tonic-gate si.si_pid, si.si_uid); 2657c478bd9Sstevel@tonic-gate } 2667c478bd9Sstevel@tonic-gate 2677c478bd9Sstevel@tonic-gate if (si.si_code == SI_QUEUE) { 2687c478bd9Sstevel@tonic-gate mdb_printf(" signal value = 0t%d / %p\n", 2697c478bd9Sstevel@tonic-gate si.si_value.sival_int, si.si_value.sival_ptr); 2707c478bd9Sstevel@tonic-gate } 2717c478bd9Sstevel@tonic-gate 2727c478bd9Sstevel@tonic-gate switch (si.si_signo) { 2737c478bd9Sstevel@tonic-gate case SIGCLD: 2747c478bd9Sstevel@tonic-gate mdb_printf(" signal sent from child PID %d (uid %d)\n", 2757c478bd9Sstevel@tonic-gate si.si_pid, si.si_uid); 2767c478bd9Sstevel@tonic-gate mdb_printf(" usr time = 0t%ld ticks, sys time = 0t%ld ticks\n", 2777c478bd9Sstevel@tonic-gate si.si_utime, si.si_stime); 2787c478bd9Sstevel@tonic-gate mdb_printf(" wait status = 0x%x\n", si.si_status); 2797c478bd9Sstevel@tonic-gate break; 2807c478bd9Sstevel@tonic-gate 2817c478bd9Sstevel@tonic-gate case SIGSEGV: 2827c478bd9Sstevel@tonic-gate case SIGBUS: 2837c478bd9Sstevel@tonic-gate case SIGILL: 2847c478bd9Sstevel@tonic-gate case SIGTRAP: 2857c478bd9Sstevel@tonic-gate case SIGFPE: 2867c478bd9Sstevel@tonic-gate mdb_printf(" fault address = 0x%p\n trapno = %d\n", 2877c478bd9Sstevel@tonic-gate si.si_addr, si.si_trapno); 2887c478bd9Sstevel@tonic-gate mdb_printf(" instruction address = 0x%p %lA\n", 2897c478bd9Sstevel@tonic-gate si.si_pc, si.si_pc); 2907c478bd9Sstevel@tonic-gate break; 2917c478bd9Sstevel@tonic-gate 2927c478bd9Sstevel@tonic-gate case SIGPOLL: 2937c478bd9Sstevel@tonic-gate case SIGXFSZ: 2947c478bd9Sstevel@tonic-gate mdb_printf(" fd = %d band = 0x%lx\n", 2957c478bd9Sstevel@tonic-gate si.si_fd, si.si_band); 2967c478bd9Sstevel@tonic-gate break; 2977c478bd9Sstevel@tonic-gate 2987c478bd9Sstevel@tonic-gate case SIGPROF: 2997c478bd9Sstevel@tonic-gate mdb_printf(" last fault address = 0x%p fault type = %d\n", 3007c478bd9Sstevel@tonic-gate si.si_faddr, si.si_fault); 3017c478bd9Sstevel@tonic-gate mdb_printf(" timestamp = 0t%ld sec 0t%ld nsec\n", 3027c478bd9Sstevel@tonic-gate si.si_tstamp.tv_sec, si.si_tstamp.tv_nsec); 3037c478bd9Sstevel@tonic-gate 3047c478bd9Sstevel@tonic-gate if (si.__data.__prof.__syscall != 0) { 3057c478bd9Sstevel@tonic-gate mdb_printf(" system call %d (", si.si_syscall); 3067c478bd9Sstevel@tonic-gate if (si.si_nsysarg > 0) { 3077c478bd9Sstevel@tonic-gate mdb_printf("%lx", si.si_sysarg[0]); 3087c478bd9Sstevel@tonic-gate for (i = 1; i < si.si_nsysarg; i++) 3097c478bd9Sstevel@tonic-gate mdb_printf(", %lx", si.si_sysarg[i]); 3107c478bd9Sstevel@tonic-gate } 3117c478bd9Sstevel@tonic-gate mdb_printf(" )\n"); 3127c478bd9Sstevel@tonic-gate } 3137c478bd9Sstevel@tonic-gate 3147c478bd9Sstevel@tonic-gate for (i = 0; i < sizeof (msname) / sizeof (msname[0]); i++) { 3157c478bd9Sstevel@tonic-gate mdb_printf(" mstate[\"%s\"] = %d\n", 3167c478bd9Sstevel@tonic-gate msname[i], si.si_mstate[i]); 3177c478bd9Sstevel@tonic-gate } 3187c478bd9Sstevel@tonic-gate break; 3197c478bd9Sstevel@tonic-gate } 3207c478bd9Sstevel@tonic-gate 3217c478bd9Sstevel@tonic-gate return (DCMD_OK); 3227c478bd9Sstevel@tonic-gate } 3237c478bd9Sstevel@tonic-gate 3247c478bd9Sstevel@tonic-gate static int 3257c478bd9Sstevel@tonic-gate uc_walk_step(mdb_walk_state_t *wsp) 3267c478bd9Sstevel@tonic-gate { 3277c478bd9Sstevel@tonic-gate uintptr_t addr = wsp->walk_addr; 3287c478bd9Sstevel@tonic-gate ucontext_t uc; 3297c478bd9Sstevel@tonic-gate 330892ad162SToomas Soome if (addr == 0) 3317c478bd9Sstevel@tonic-gate return (WALK_DONE); 3327c478bd9Sstevel@tonic-gate 3337c478bd9Sstevel@tonic-gate if (mdb_vread(&uc, sizeof (uc), addr) != sizeof (uc)) { 3347c478bd9Sstevel@tonic-gate mdb_warn("failed to read ucontext at %p", addr); 3357c478bd9Sstevel@tonic-gate return (WALK_ERR); 3367c478bd9Sstevel@tonic-gate } 3377c478bd9Sstevel@tonic-gate 3387c478bd9Sstevel@tonic-gate wsp->walk_addr = (uintptr_t)uc.uc_link; 3397c478bd9Sstevel@tonic-gate return (wsp->walk_callback(addr, &uc, wsp->walk_cbdata)); 3407c478bd9Sstevel@tonic-gate } 3417c478bd9Sstevel@tonic-gate 3427c478bd9Sstevel@tonic-gate static int 3437c478bd9Sstevel@tonic-gate oldc_walk_init(mdb_walk_state_t *wsp) 3447c478bd9Sstevel@tonic-gate { 3457c478bd9Sstevel@tonic-gate ssize_t nbytes = mdb_get_xdata("lwpstatus", NULL, 0); 3467c478bd9Sstevel@tonic-gate 3477c478bd9Sstevel@tonic-gate if (nbytes <= 0) { 3487c478bd9Sstevel@tonic-gate mdb_warn("lwpstatus information not available"); 3497c478bd9Sstevel@tonic-gate return (WALK_ERR); 3507c478bd9Sstevel@tonic-gate } 3517c478bd9Sstevel@tonic-gate 352892ad162SToomas Soome if (wsp->walk_addr != 0) { 3537c478bd9Sstevel@tonic-gate mdb_warn("walker only supports global walk\n"); 3547c478bd9Sstevel@tonic-gate return (WALK_ERR); 3557c478bd9Sstevel@tonic-gate } 3567c478bd9Sstevel@tonic-gate 3577c478bd9Sstevel@tonic-gate wsp->walk_addr = nbytes; /* Use walk_addr to track size */ 3587c478bd9Sstevel@tonic-gate wsp->walk_data = mdb_alloc(nbytes, UM_SLEEP); 3597c478bd9Sstevel@tonic-gate 3607c478bd9Sstevel@tonic-gate if (mdb_get_xdata("lwpstatus", wsp->walk_data, nbytes) != nbytes) { 3617c478bd9Sstevel@tonic-gate mdb_warn("failed to read lwpstatus information"); 3627c478bd9Sstevel@tonic-gate mdb_free(wsp->walk_data, nbytes); 3637c478bd9Sstevel@tonic-gate return (WALK_ERR); 3647c478bd9Sstevel@tonic-gate } 3657c478bd9Sstevel@tonic-gate 3667c478bd9Sstevel@tonic-gate wsp->walk_arg = wsp->walk_data; /* Use walk_arg to track pointer */ 3677c478bd9Sstevel@tonic-gate return (WALK_NEXT); 3687c478bd9Sstevel@tonic-gate } 3697c478bd9Sstevel@tonic-gate 3707c478bd9Sstevel@tonic-gate static int 3717c478bd9Sstevel@tonic-gate oldc_walk_step(mdb_walk_state_t *wsp) 3727c478bd9Sstevel@tonic-gate { 3737c478bd9Sstevel@tonic-gate const lwpstatus_t *lsp, *end; 3747c478bd9Sstevel@tonic-gate 3757c478bd9Sstevel@tonic-gate end = (const lwpstatus_t *)((uintptr_t)wsp->walk_data + wsp->walk_addr); 3767c478bd9Sstevel@tonic-gate lsp = wsp->walk_arg; 3777c478bd9Sstevel@tonic-gate 3787c478bd9Sstevel@tonic-gate wsp->walk_arg = (void *)(lsp + 1); 3797c478bd9Sstevel@tonic-gate 3807c478bd9Sstevel@tonic-gate if (lsp < end) { 3817c478bd9Sstevel@tonic-gate uintptr_t addr = lsp->pr_oldcontext; 3827c478bd9Sstevel@tonic-gate ucontext_t uc; 3837c478bd9Sstevel@tonic-gate 384892ad162SToomas Soome if (addr == 0) 3857c478bd9Sstevel@tonic-gate return (WALK_NEXT); 3867c478bd9Sstevel@tonic-gate 3877c478bd9Sstevel@tonic-gate if (mdb_vread(&uc, sizeof (uc), addr) != sizeof (uc)) { 3887c478bd9Sstevel@tonic-gate mdb_warn("failed to read ucontext at %p", addr); 3897c478bd9Sstevel@tonic-gate return (WALK_NEXT); 3907c478bd9Sstevel@tonic-gate } 3917c478bd9Sstevel@tonic-gate 3927c478bd9Sstevel@tonic-gate return (wsp->walk_callback(addr, &uc, wsp->walk_cbdata)); 3937c478bd9Sstevel@tonic-gate } 3947c478bd9Sstevel@tonic-gate 3957c478bd9Sstevel@tonic-gate return (WALK_DONE); 3967c478bd9Sstevel@tonic-gate } 3977c478bd9Sstevel@tonic-gate 3987c478bd9Sstevel@tonic-gate static void 3997c478bd9Sstevel@tonic-gate oldc_walk_fini(mdb_walk_state_t *wsp) 4007c478bd9Sstevel@tonic-gate { 4017c478bd9Sstevel@tonic-gate mdb_free(wsp->walk_data, wsp->walk_addr); /* walk_addr has size */ 4027c478bd9Sstevel@tonic-gate } 4037c478bd9Sstevel@tonic-gate 4047c478bd9Sstevel@tonic-gate /* 4057c478bd9Sstevel@tonic-gate * ==================== threads ========================== 4067c478bd9Sstevel@tonic-gate * These are the interfaces that used to require libthread. 4077c478bd9Sstevel@tonic-gate * Now, libthread has been folded into libc. 4087c478bd9Sstevel@tonic-gate * ======================================================= 4097c478bd9Sstevel@tonic-gate */ 4107c478bd9Sstevel@tonic-gate 4117c478bd9Sstevel@tonic-gate /* 4127c478bd9Sstevel@tonic-gate * prt_addr() is called up to three times to generate arguments for 4137c478bd9Sstevel@tonic-gate * one call to mdb_printf(). We must return at least three different 4147c478bd9Sstevel@tonic-gate * pointers to static storage for consecutive calls to prt_addr(). 4157c478bd9Sstevel@tonic-gate */ 4167c478bd9Sstevel@tonic-gate static const char * 4177c478bd9Sstevel@tonic-gate prt_addr(void *addr, int pad) 4187c478bd9Sstevel@tonic-gate { 4197c478bd9Sstevel@tonic-gate static char buffer[4][24]; 4207c478bd9Sstevel@tonic-gate static int ix = 0; 4217c478bd9Sstevel@tonic-gate char *buf; 4227c478bd9Sstevel@tonic-gate 4237c478bd9Sstevel@tonic-gate if (ix == 4) /* use buffers in sequence: 0, 1, 2, 3 */ 4247c478bd9Sstevel@tonic-gate ix = 0; 4257c478bd9Sstevel@tonic-gate buf = buffer[ix++]; 4267c478bd9Sstevel@tonic-gate if (addr == NULL) 4277c478bd9Sstevel@tonic-gate return (pad? "<NULL> " : "<NULL>"); 4287c478bd9Sstevel@tonic-gate else { 4297c478bd9Sstevel@tonic-gate #ifdef _LP64 4307c478bd9Sstevel@tonic-gate (void) mdb_snprintf(buf, sizeof (buffer[0]), "0x%016lx", addr); 4317c478bd9Sstevel@tonic-gate if (pad) 4327c478bd9Sstevel@tonic-gate (void) strcpy(buf + 18, " "); 4337c478bd9Sstevel@tonic-gate #else 4347c478bd9Sstevel@tonic-gate (void) mdb_snprintf(buf, sizeof (buffer[0]), "0x%08lx", addr); 4357c478bd9Sstevel@tonic-gate if (pad) 4367c478bd9Sstevel@tonic-gate (void) strcpy(buf + 10, " "); 4377c478bd9Sstevel@tonic-gate #endif /* _LP64 */ 4387c478bd9Sstevel@tonic-gate return (buf); 4397c478bd9Sstevel@tonic-gate } 4407c478bd9Sstevel@tonic-gate } 4417c478bd9Sstevel@tonic-gate 4427c478bd9Sstevel@tonic-gate #define HD(str) mdb_printf(" " str "\n") 4437c478bd9Sstevel@tonic-gate #define OFFSTR "+0x%-7lx " 4447c478bd9Sstevel@tonic-gate #define OFFSET(member) ((size_t)OFFSETOF(ulwp_t, member)) 4457c478bd9Sstevel@tonic-gate 4467c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4477c478bd9Sstevel@tonic-gate static int 4487c478bd9Sstevel@tonic-gate d_ulwp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 4497c478bd9Sstevel@tonic-gate { 4507c478bd9Sstevel@tonic-gate ulwp_t ulwp; 4517c478bd9Sstevel@tonic-gate 4527c478bd9Sstevel@tonic-gate if (argc != 0 || !(flags & DCMD_ADDRSPEC)) 4537c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 4547c478bd9Sstevel@tonic-gate 4557c478bd9Sstevel@tonic-gate if (mdb_vread(&ulwp, sizeof (ulwp), addr) != sizeof (ulwp) && 4567c478bd9Sstevel@tonic-gate (bzero(&ulwp, sizeof (ulwp)), 4577c478bd9Sstevel@tonic-gate mdb_vread(&ulwp, REPLACEMENT_SIZE, addr)) != REPLACEMENT_SIZE) { 4587c478bd9Sstevel@tonic-gate mdb_warn("failed to read ulwp at 0x%p", addr); 4597c478bd9Sstevel@tonic-gate return (DCMD_ERR); 4607c478bd9Sstevel@tonic-gate } 4617c478bd9Sstevel@tonic-gate 4627c478bd9Sstevel@tonic-gate mdb_printf("%#a\n", addr); 4637c478bd9Sstevel@tonic-gate 4647c478bd9Sstevel@tonic-gate HD("self uberdata"); 4657c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s\n", 4668cd45542Sraf OFFSET(ul_self), 4678cd45542Sraf prt_addr(ulwp.ul_self, 1), 4688cd45542Sraf prt_addr(ulwp.ul_uberdata, 0)); 4697c478bd9Sstevel@tonic-gate 4707c478bd9Sstevel@tonic-gate HD("tlsent ntlsent"); 4717c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %ld\n", 4728cd45542Sraf OFFSET(ul_tlsent), 4738cd45542Sraf prt_addr(ulwp.ul_tlsent, 1), 4748cd45542Sraf ulwp.ul_ntlsent); 4757c478bd9Sstevel@tonic-gate 4767c478bd9Sstevel@tonic-gate HD("forw back next"); 4777c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n", 4788cd45542Sraf OFFSET(ul_forw), 4798cd45542Sraf prt_addr(ulwp.ul_forw, 1), 4808cd45542Sraf prt_addr(ulwp.ul_back, 1), 4818cd45542Sraf prt_addr(ulwp.ul_next, 0)); 4827c478bd9Sstevel@tonic-gate 4837c478bd9Sstevel@tonic-gate HD("hash rval stk"); 4847c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n", 4858cd45542Sraf OFFSET(ul_hash), 4868cd45542Sraf prt_addr(ulwp.ul_hash, 1), 4878cd45542Sraf prt_addr(ulwp.ul_rval, 1), 4888cd45542Sraf prt_addr(ulwp.ul_stk, 0)); 4897c478bd9Sstevel@tonic-gate 4907c478bd9Sstevel@tonic-gate HD("mapsiz guardsize stktop stksiz"); 4917c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10ld %-10ld %s %ld\n", 4928cd45542Sraf OFFSET(ul_mapsiz), 4938cd45542Sraf ulwp.ul_mapsiz, 4948cd45542Sraf ulwp.ul_guardsize, 4958cd45542Sraf prt_addr((void *)ulwp.ul_stktop, 1), 4968cd45542Sraf ulwp.ul_stksiz); 4977c478bd9Sstevel@tonic-gate 4987c478bd9Sstevel@tonic-gate HD("ustack.ss_sp ustack.ss_size ustack.ss_flags"); 4997c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %-21ld %s\n", 5008cd45542Sraf OFFSET(ul_ustack.ss_sp), 5018cd45542Sraf prt_addr(ulwp.ul_ustack.ss_sp, 1), 5028cd45542Sraf ulwp.ul_ustack.ss_size, 5038cd45542Sraf stack_flags(&ulwp.ul_ustack)); 5047c478bd9Sstevel@tonic-gate 505d4204c85Sraf HD("ix lwpid pri epri policy cid"); 5067c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n", 5078cd45542Sraf OFFSET(ul_ix), 5088cd45542Sraf ulwp.ul_ix, 5098cd45542Sraf ulwp.ul_lwpid, 5108cd45542Sraf ulwp.ul_pri, 5118cd45542Sraf ulwp.ul_epri, 5128cd45542Sraf ulwp.ul_policy, 5138cd45542Sraf ulwp.ul_cid); 5147c478bd9Sstevel@tonic-gate 5157c478bd9Sstevel@tonic-gate HD("cursig pleasestop stop signalled dead unwind"); 5167c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10d ", 5178cd45542Sraf OFFSET(ul_cursig), 5188cd45542Sraf ulwp.ul_cursig); 5197c478bd9Sstevel@tonic-gate mdb_printf(ulwp.ul_pleasestop? "0x%-8x " : "%-10d ", 5208cd45542Sraf ulwp.ul_pleasestop); 5217c478bd9Sstevel@tonic-gate mdb_printf(ulwp.ul_stop? "0x%-8x " : "%-10d ", 5228cd45542Sraf ulwp.ul_stop); 5237c478bd9Sstevel@tonic-gate mdb_printf("%-10d %-10d %d\n", 5248cd45542Sraf ulwp.ul_signalled, 5258cd45542Sraf ulwp.ul_dead, 5268cd45542Sraf ulwp.ul_unwind); 5277c478bd9Sstevel@tonic-gate 52834709573Sraf HD("detached writer stopping can'prolog preempt savpreempt"); 5297c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n", 5308cd45542Sraf OFFSET(ul_detached), 5318cd45542Sraf ulwp.ul_detached, 5328cd45542Sraf ulwp.ul_writer, 5338cd45542Sraf ulwp.ul_stopping, 5348cd45542Sraf ulwp.ul_cancel_prologue, 5358cd45542Sraf ulwp.ul_preempt, 5368cd45542Sraf ulwp.ul_savpreempt); 5377c478bd9Sstevel@tonic-gate 5387c478bd9Sstevel@tonic-gate HD("sigsuspend main fork primarymap m'spinners d'noreserv"); 5397c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n", 5408cd45542Sraf OFFSET(ul_sigsuspend), 5418cd45542Sraf ulwp.ul_sigsuspend, 5428cd45542Sraf ulwp.ul_main, 5438cd45542Sraf ulwp.ul_fork, 5448cd45542Sraf ulwp.ul_primarymap, 5458cd45542Sraf ulwp.ul_max_spinners, 5468cd45542Sraf ulwp.ul_door_noreserve); 5477c478bd9Sstevel@tonic-gate 548d4204c85Sraf HD("queue_fifo c'w'defer e'detect' async_safe rt rtqueued"); 5497c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n", 5508cd45542Sraf OFFSET(ul_queue_fifo), 5518cd45542Sraf ulwp.ul_queue_fifo, 5528cd45542Sraf ulwp.ul_cond_wait_defer, 5538cd45542Sraf ulwp.ul_error_detection, 5548cd45542Sraf ulwp.ul_async_safe, 5558cd45542Sraf ulwp.ul_rt, 5568cd45542Sraf ulwp.ul_rtqueued); 5577c478bd9Sstevel@tonic-gate 5587c5714f6Sraf HD("misaligned adapt'spin queue_spin critical sigdefer vfork"); 5597c5714f6Sraf mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n", 5607c5714f6Sraf OFFSET(ul_misaligned), 5617c5714f6Sraf ulwp.ul_misaligned, 5628cd45542Sraf ulwp.ul_adaptive_spin, 5638cd45542Sraf ulwp.ul_queue_spin, 5648cd45542Sraf ulwp.ul_critical, 5658cd45542Sraf ulwp.ul_sigdefer, 5668cd45542Sraf ulwp.ul_vfork); 5677c478bd9Sstevel@tonic-gate 5687c478bd9Sstevel@tonic-gate HD("cancelable c'pending c'disabled c'async save_async mutator"); 5697c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n", 5708cd45542Sraf OFFSET(ul_cancelable), 5718cd45542Sraf ulwp.ul_cancelable, 5728cd45542Sraf ulwp.ul_cancel_pending, 5738cd45542Sraf ulwp.ul_cancel_disabled, 5748cd45542Sraf ulwp.ul_cancel_async, 5758cd45542Sraf ulwp.ul_save_async, 5768cd45542Sraf ulwp.ul_mutator); 5777c478bd9Sstevel@tonic-gate 5787c478bd9Sstevel@tonic-gate HD("created replace nocancel errno errnop"); 5797c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %s\n", 5808cd45542Sraf OFFSET(ul_created), 5818cd45542Sraf ulwp.ul_created, 5828cd45542Sraf ulwp.ul_replace, 5838cd45542Sraf ulwp.ul_nocancel, 5848cd45542Sraf ulwp.ul_errno, 5858cd45542Sraf prt_addr(ulwp.ul_errnop, 0)); 5867c478bd9Sstevel@tonic-gate 5877c478bd9Sstevel@tonic-gate HD("clnup_hdr schedctl_called schedctl"); 5887c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n", 5898cd45542Sraf OFFSET(ul_clnup_hdr), 5908cd45542Sraf prt_addr(ulwp.ul_clnup_hdr, 1), 5918cd45542Sraf prt_addr(ulwp.ul_schedctl_called, 1), 5928cd45542Sraf prt_addr((void *)ulwp.ul_schedctl, 0)); 5937c478bd9Sstevel@tonic-gate 594a574db85Sraf HD("bindflags libc_locks stsd &ftsd"); 5957c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR, 5968cd45542Sraf OFFSET(ul_bindflags)); 5977c478bd9Sstevel@tonic-gate mdb_printf(ulwp.ul_bindflags? "0x%-8x " : "%-10d ", 5988cd45542Sraf ulwp.ul_bindflags); 599a574db85Sraf mdb_printf("%-10d ", ulwp.ul_libc_locks); 6007c478bd9Sstevel@tonic-gate mdb_printf("%s %s\n", 6018cd45542Sraf prt_addr(ulwp.ul_stsd, 1), 6028cd45542Sraf prt_addr((void *)(addr + OFFSET(ul_ftsd[0])), 0)); 6037c478bd9Sstevel@tonic-gate 6047c478bd9Sstevel@tonic-gate HD("eventmask[0..1] eventnum eventdata"); 6057c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "0x%08x 0x%08x %-21d %s\n", 6068cd45542Sraf OFFSET(ul_td_evbuf.eventmask.event_bits[0]), 6078cd45542Sraf ulwp.ul_td_evbuf.eventmask.event_bits[0], 6088cd45542Sraf ulwp.ul_td_evbuf.eventmask.event_bits[1], 6098cd45542Sraf ulwp.ul_td_evbuf.eventnum, 6108cd45542Sraf prt_addr(ulwp.ul_td_evbuf.eventdata, 0)); 6117c478bd9Sstevel@tonic-gate 612e54ab87fSRoger A. Faulkner HD("td'enable sync'reg qtype cv_wake rtld usropts"); 613e54ab87fSRoger A. Faulkner mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d ", 6148cd45542Sraf OFFSET(ul_td_events_enable), 6158cd45542Sraf ulwp.ul_td_events_enable, 6168cd45542Sraf ulwp.ul_sync_obj_reg, 6178cd45542Sraf ulwp.ul_qtype, 618e54ab87fSRoger A. Faulkner ulwp.ul_cv_wake, 619e54ab87fSRoger A. Faulkner ulwp.ul_rtld); 6207c478bd9Sstevel@tonic-gate mdb_printf(ulwp.ul_usropts? "0x%x\n" : "%d\n", 6218cd45542Sraf ulwp.ul_usropts); 6227c478bd9Sstevel@tonic-gate 6237c478bd9Sstevel@tonic-gate HD("startpc startarg wchan"); 6247c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n", 6258cd45542Sraf OFFSET(ul_startpc), 6268cd45542Sraf prt_addr((void *)ulwp.ul_startpc, 1), 6278cd45542Sraf prt_addr(ulwp.ul_startarg, 1), 6288cd45542Sraf prt_addr(ulwp.ul_wchan, 0)); 6297c478bd9Sstevel@tonic-gate 6307c478bd9Sstevel@tonic-gate HD("link sleepq cvmutex"); 6317c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n", 6328cd45542Sraf OFFSET(ul_link), 6338cd45542Sraf prt_addr(ulwp.ul_link, 1), 6348cd45542Sraf prt_addr(ulwp.ul_sleepq, 1), 6358cd45542Sraf prt_addr(ulwp.ul_cvmutex, 0)); 6367c478bd9Sstevel@tonic-gate 637d4204c85Sraf HD("mxchain save_state"); 638d4204c85Sraf mdb_printf(OFFSTR "%s %d\n", 6398cd45542Sraf OFFSET(ul_mxchain), 6408cd45542Sraf prt_addr(ulwp.ul_mxchain, 1), 6418cd45542Sraf ulwp.ul_save_state); 6427c478bd9Sstevel@tonic-gate 643883492d5Sraf HD("rdlockcnt rd_rwlock rd_count"); 644883492d5Sraf mdb_printf(OFFSTR "%-21d %s %d\n", 6458cd45542Sraf OFFSET(ul_rdlockcnt), 6468cd45542Sraf ulwp.ul_rdlockcnt, 6478cd45542Sraf prt_addr(ulwp.ul_readlock.single.rd_rwlock, 1), 6488cd45542Sraf ulwp.ul_readlock.single.rd_count); 649883492d5Sraf 650883492d5Sraf HD("heldlockcnt heldlocks tpdp"); 651883492d5Sraf mdb_printf(OFFSTR "%-21d %s %s\n", 6528cd45542Sraf OFFSET(ul_heldlockcnt), 6538cd45542Sraf ulwp.ul_heldlockcnt, 6548cd45542Sraf prt_addr(ulwp.ul_heldlocks.single, 1), 6558cd45542Sraf prt_addr(ulwp.ul_tpdp, 0)); 6567c478bd9Sstevel@tonic-gate 6577c478bd9Sstevel@tonic-gate HD("siglink s'l'spin s'l'spin2 s'l'sleep s'l'wakeup"); 658d4204c85Sraf mdb_printf(OFFSTR "%s %-10d %-10d %-10d %d\n", 6598cd45542Sraf OFFSET(ul_siglink), 6608cd45542Sraf prt_addr(ulwp.ul_siglink, 1), 6618cd45542Sraf ulwp.ul_spin_lock_spin, 6628cd45542Sraf ulwp.ul_spin_lock_spin2, 6638cd45542Sraf ulwp.ul_spin_lock_sleep, 6648cd45542Sraf ulwp.ul_spin_lock_wakeup); 6657c478bd9Sstevel@tonic-gate 666d4204c85Sraf HD("&queue_root rtclassid pilocks"); 667d4204c85Sraf mdb_printf(OFFSTR "%s %-10d %d\n", 6688cd45542Sraf OFFSET(ul_queue_root), 6698cd45542Sraf prt_addr((void *)(addr + OFFSET(ul_queue_root)), 1), 6708cd45542Sraf ulwp.ul_rtclassid, 6718cd45542Sraf ulwp.ul_pilocks); 672d4204c85Sraf 6737c478bd9Sstevel@tonic-gate /* 6747c478bd9Sstevel@tonic-gate * The remainder of the ulwp_t structure 6757c478bd9Sstevel@tonic-gate * is invalid if this is a replacement. 6767c478bd9Sstevel@tonic-gate */ 6777c478bd9Sstevel@tonic-gate if (ulwp.ul_replace) 6787c478bd9Sstevel@tonic-gate return (DCMD_OK); 6797c478bd9Sstevel@tonic-gate 6807c478bd9Sstevel@tonic-gate HD("sigmask[0..3]"); 6817c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "0x%08x 0x%08x 0x%08x 0x%08x\n", 6828cd45542Sraf OFFSET(ul_sigmask.__sigbits[0]), 6838cd45542Sraf ulwp.ul_sigmask.__sigbits[0], 6848cd45542Sraf ulwp.ul_sigmask.__sigbits[1], 6858cd45542Sraf ulwp.ul_sigmask.__sigbits[2], 6868cd45542Sraf ulwp.ul_sigmask.__sigbits[3]); 6877c478bd9Sstevel@tonic-gate 6887c478bd9Sstevel@tonic-gate HD("tmpmask[0..3]"); 6897c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "0x%08x 0x%08x 0x%08x 0x%08x\n", 6908cd45542Sraf OFFSET(ul_tmpmask.__sigbits[0]), 6918cd45542Sraf ulwp.ul_tmpmask.__sigbits[0], 6928cd45542Sraf ulwp.ul_tmpmask.__sigbits[1], 6938cd45542Sraf ulwp.ul_tmpmask.__sigbits[2], 6948cd45542Sraf ulwp.ul_tmpmask.__sigbits[3]); 6957c478bd9Sstevel@tonic-gate 6967c478bd9Sstevel@tonic-gate HD("&siginfo &spinlock &fpuenv"); 6977c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n", 6988cd45542Sraf OFFSET(ul_siginfo), 6998cd45542Sraf prt_addr((void *)(addr + OFFSET(ul_siginfo)), 1), 7008cd45542Sraf prt_addr((void *)(addr + OFFSET(ul_spinlock)), 1), 7018cd45542Sraf prt_addr((void *)(addr + OFFSET(ul_fpuenv)), 0)); 7027c478bd9Sstevel@tonic-gate 7034f364e7cSRobert Mustacchi HD("tmem.size &tmem.roots"); 7044f364e7cSRobert Mustacchi mdb_printf(OFFSTR "%-21H %s\n", 7054f364e7cSRobert Mustacchi OFFSET(ul_tmem), 7064f364e7cSRobert Mustacchi ulwp.ul_tmem.tm_size, 7074f364e7cSRobert Mustacchi prt_addr((void *)(addr + OFFSET(ul_tmem) + sizeof (size_t)), 0)); 7084f364e7cSRobert Mustacchi 7097c478bd9Sstevel@tonic-gate return (DCMD_OK); 7107c478bd9Sstevel@tonic-gate } 7117c478bd9Sstevel@tonic-gate 7127c478bd9Sstevel@tonic-gate /* 7137c478bd9Sstevel@tonic-gate * Get the address of the unique uberdata_t structure. 7147c478bd9Sstevel@tonic-gate */ 7157c478bd9Sstevel@tonic-gate static uintptr_t 7167c478bd9Sstevel@tonic-gate uberdata_addr(void) 7177c478bd9Sstevel@tonic-gate { 7187c478bd9Sstevel@tonic-gate uintptr_t uaddr; 7197c478bd9Sstevel@tonic-gate uintptr_t addr; 7207c478bd9Sstevel@tonic-gate GElf_Sym sym; 7217c478bd9Sstevel@tonic-gate 7227c478bd9Sstevel@tonic-gate if (mdb_lookup_by_obj("libc.so.1", "_tdb_bootstrap", &sym) != 0) { 7237c478bd9Sstevel@tonic-gate mdb_warn("cannot find libc.so.1`_tdb_bootstrap"); 724892ad162SToomas Soome return (0); 7257c478bd9Sstevel@tonic-gate } 7267c478bd9Sstevel@tonic-gate if (mdb_vread(&addr, sizeof (addr), sym.st_value) == sizeof (addr) && 727892ad162SToomas Soome addr != 0 && 7287c478bd9Sstevel@tonic-gate mdb_vread(&uaddr, sizeof (uaddr), addr) == sizeof (uaddr) && 729892ad162SToomas Soome uaddr != 0) { 7307c478bd9Sstevel@tonic-gate return (uaddr); 7317c478bd9Sstevel@tonic-gate } 7327c478bd9Sstevel@tonic-gate if (mdb_lookup_by_obj("libc.so.1", "_uberdata", &sym) != 0) { 7337c478bd9Sstevel@tonic-gate mdb_warn("cannot find libc.so.1`_uberdata"); 734892ad162SToomas Soome return (0); 7357c478bd9Sstevel@tonic-gate } 7367c478bd9Sstevel@tonic-gate return ((uintptr_t)sym.st_value); 7377c478bd9Sstevel@tonic-gate } 7387c478bd9Sstevel@tonic-gate 7397c478bd9Sstevel@tonic-gate #undef OFFSET 7407c478bd9Sstevel@tonic-gate #define OFFSET(member) ((size_t)OFFSETOF(uberdata_t, member)) 7417c478bd9Sstevel@tonic-gate 7427c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 7437c478bd9Sstevel@tonic-gate static int 7447c478bd9Sstevel@tonic-gate d_uberdata(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 7457c478bd9Sstevel@tonic-gate { 7467c478bd9Sstevel@tonic-gate uberdata_t uberdata; 7477c478bd9Sstevel@tonic-gate int i; 7487c478bd9Sstevel@tonic-gate 7497c478bd9Sstevel@tonic-gate if (argc != 0) 7507c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 751892ad162SToomas Soome if (!(flags & DCMD_ADDRSPEC) && (addr = uberdata_addr()) == 0) 7527c478bd9Sstevel@tonic-gate return (DCMD_ERR); 7537c478bd9Sstevel@tonic-gate 7547c478bd9Sstevel@tonic-gate if (mdb_vread(&uberdata, sizeof (uberdata), addr) != 7557c478bd9Sstevel@tonic-gate sizeof (uberdata)) { 7567c478bd9Sstevel@tonic-gate mdb_warn("failed to read uberdata at 0x%p", addr); 7577c478bd9Sstevel@tonic-gate return (DCMD_ERR); 7587c478bd9Sstevel@tonic-gate } 7597c478bd9Sstevel@tonic-gate 7607c478bd9Sstevel@tonic-gate mdb_printf("%#a\n", addr); 7617c478bd9Sstevel@tonic-gate 7628cd45542Sraf HD("&link_lock &ld_lock &fork_lock"); 7637c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n", 7648cd45542Sraf OFFSET(link_lock), 7658cd45542Sraf prt_addr((void *)(addr + OFFSET(link_lock)), 1), 7668cd45542Sraf prt_addr((void *)(addr + OFFSET(ld_lock)), 1), 7678cd45542Sraf prt_addr((void *)(addr + OFFSET(fork_lock)), 0)); 7687c478bd9Sstevel@tonic-gate 7698cd45542Sraf HD("&atfork_lock &callout_lock &tdb_hash_lock"); 7707c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n", 7718cd45542Sraf OFFSET(atfork_lock), 7728cd45542Sraf prt_addr((void *)(addr + OFFSET(atfork_lock)), 1), 7738cd45542Sraf prt_addr((void *)(addr + OFFSET(callout_lock)), 1), 7748cd45542Sraf prt_addr((void *)(addr + OFFSET(tdb_hash_lock)), 0)); 7758cd45542Sraf 7768cd45542Sraf HD("&tdb_hash_lock_stats &siguaction[0]"); 7778cd45542Sraf mdb_printf(OFFSTR "%s %s\n", 7788cd45542Sraf OFFSET(tdb_hash_lock_stats), 7798cd45542Sraf prt_addr((void *)(addr + OFFSET(tdb_hash_lock_stats)), 1), 7808cd45542Sraf prt_addr((void *)(addr + OFFSET(siguaction)), 0)); 7817c478bd9Sstevel@tonic-gate 7827c478bd9Sstevel@tonic-gate HD("&bucket free_list chunks"); 7837c478bd9Sstevel@tonic-gate for (i = 0; i < NBUCKETS; i++) { 7847c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %ld\n", 7858cd45542Sraf OFFSET(bucket[i]), 7868cd45542Sraf prt_addr((void *)(addr + OFFSET(bucket[i])), 1), 7878cd45542Sraf prt_addr(uberdata.bucket[i].free_list, 1), 7888cd45542Sraf uberdata.bucket[i].chunks); 7897c478bd9Sstevel@tonic-gate } 7907c478bd9Sstevel@tonic-gate 7917c478bd9Sstevel@tonic-gate HD("&atexit_root head exit_frame_monitor"); 7927c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n", 7938cd45542Sraf OFFSET(atexit_root), 7948cd45542Sraf prt_addr((void *)(addr + OFFSET(atexit_root.exitfns_lock)), 1), 7958cd45542Sraf prt_addr(uberdata.atexit_root.head, 1), 7968cd45542Sraf prt_addr(uberdata.atexit_root.exit_frame_monitor, 0)); 7977c478bd9Sstevel@tonic-gate 798fc2512cfSRobert Mustacchi HD("&quickexit_root head"); 799fc2512cfSRobert Mustacchi mdb_printf(OFFSTR "%s %s\n", 800fc2512cfSRobert Mustacchi OFFSET(quickexit_root), 801fc2512cfSRobert Mustacchi prt_addr((void *)(addr + OFFSET(quickexit_root.exitfns_lock)), 1), 802fc2512cfSRobert Mustacchi prt_addr(uberdata.quickexit_root.head, 0)); 803fc2512cfSRobert Mustacchi 804fc2512cfSRobert Mustacchi 8057c478bd9Sstevel@tonic-gate HD("&tsd_metadata tsdm_nkeys tsdm_nused tsdm_destro"); 8067c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %-10d %-10d %s\n", 8078cd45542Sraf OFFSET(tsd_metadata), 8088cd45542Sraf prt_addr((void *)(addr + OFFSET(tsd_metadata.tsdm_lock)), 1), 8098cd45542Sraf uberdata.tsd_metadata.tsdm_nkeys, 8108cd45542Sraf uberdata.tsd_metadata.tsdm_nused, 8118cd45542Sraf prt_addr((void *)uberdata.tsd_metadata.tsdm_destro, 0)); 8127c478bd9Sstevel@tonic-gate 8137c478bd9Sstevel@tonic-gate HD("&tls_metadata tls_modinfo.data tls_modinfo.size"); 8147c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %ld\n", 8158cd45542Sraf OFFSET(tls_metadata), 8168cd45542Sraf prt_addr((void *)(addr + OFFSET(tls_metadata.tls_lock)), 1), 8178cd45542Sraf prt_addr(uberdata.tls_metadata.tls_modinfo.tls_data, 1), 8188cd45542Sraf uberdata.tls_metadata.tls_modinfo.tls_size); 8197c478bd9Sstevel@tonic-gate 8207c478bd9Sstevel@tonic-gate HD(" static_tls.data static_tls.size"); 8217c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %ld\n", 8228cd45542Sraf OFFSET(tls_metadata.static_tls), 8238cd45542Sraf " ", 8248cd45542Sraf prt_addr(uberdata.tls_metadata.static_tls.tls_data, 1), 8258cd45542Sraf uberdata.tls_metadata.static_tls.tls_size); 8267c478bd9Sstevel@tonic-gate 8277c478bd9Sstevel@tonic-gate HD("primary_ma bucket_ini uflags.mt uflags.pad uflags.trs uflags.ted"); 8287c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %-10d %d\n", 8298cd45542Sraf OFFSET(primary_map), 8308cd45542Sraf uberdata.primary_map, 8318cd45542Sraf uberdata.bucket_init, 8328cd45542Sraf uberdata.uberflags.uf_x.x_mt, 8338cd45542Sraf uberdata.uberflags.uf_x.x_pad, 8348cd45542Sraf uberdata.uberflags.uf_x.x_tdb_register_sync, 8358cd45542Sraf uberdata.uberflags.uf_x.x_thread_error_detection); 8367c478bd9Sstevel@tonic-gate 8377c478bd9Sstevel@tonic-gate HD("queue_head thr_hash_table hash_size hash_mask"); 8387c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %-10d 0x%x\n", 8398cd45542Sraf OFFSET(queue_head), 8408cd45542Sraf prt_addr(uberdata.queue_head, 1), 8418cd45542Sraf prt_addr(uberdata.thr_hash_table, 1), 8428cd45542Sraf uberdata.hash_size, 8438cd45542Sraf uberdata.hash_mask); 8447c478bd9Sstevel@tonic-gate 8457c478bd9Sstevel@tonic-gate HD("ulwp_one all_lwps all_zombies"); 8467c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %s\n", 8478cd45542Sraf OFFSET(ulwp_one), 8488cd45542Sraf prt_addr(uberdata.ulwp_one, 1), 8498cd45542Sraf prt_addr(uberdata.all_lwps, 1), 8508cd45542Sraf prt_addr(uberdata.all_zombies, 0)); 8517c478bd9Sstevel@tonic-gate 8527c478bd9Sstevel@tonic-gate HD("nthreads nzombies ndaemons pid sigacthandler"); 8537c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%-10d %-10d %-10d %-10d %s\n", 8548cd45542Sraf OFFSET(nthreads), 8558cd45542Sraf uberdata.nthreads, 8568cd45542Sraf uberdata.nzombies, 8578cd45542Sraf uberdata.ndaemons, 8588cd45542Sraf (int)uberdata.pid, 8598cd45542Sraf prt_addr((void *)uberdata.sigacthandler, 0)); 8607c478bd9Sstevel@tonic-gate 8617c478bd9Sstevel@tonic-gate HD("lwp_stacks lwp_laststack nfreestack stk_cache"); 8627c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %-10d %d\n", 8638cd45542Sraf OFFSET(lwp_stacks), 8648cd45542Sraf prt_addr(uberdata.lwp_stacks, 1), 8658cd45542Sraf prt_addr(uberdata.lwp_laststack, 1), 8668cd45542Sraf uberdata.nfreestack, 8678cd45542Sraf uberdata.thread_stack_cache); 8687c478bd9Sstevel@tonic-gate 8698cd45542Sraf HD("ulwp_freelist ulwp_lastfree ulwp_replace_free"); 8708cd45542Sraf mdb_printf(OFFSTR "%s %s %s\n", 8718cd45542Sraf OFFSET(ulwp_freelist), 8728cd45542Sraf prt_addr(uberdata.ulwp_freelist, 1), 8738cd45542Sraf prt_addr(uberdata.ulwp_lastfree, 1), 8748cd45542Sraf prt_addr(uberdata.ulwp_replace_free, 0)); 875883492d5Sraf 87609ce0d4aSRoger A. Faulkner HD("ulwp_replace_last atforklist"); 87709ce0d4aSRoger A. Faulkner mdb_printf(OFFSTR "%s %s\n", 8788cd45542Sraf OFFSET(ulwp_replace_last), 8798cd45542Sraf prt_addr(uberdata.ulwp_replace_last, 1), 88009ce0d4aSRoger A. Faulkner prt_addr(uberdata.atforklist, 0)); 88109ce0d4aSRoger A. Faulkner 88223a1cceaSRoger A. Faulkner HD("robustlocks robustlist progname"); 88323a1cceaSRoger A. Faulkner mdb_printf(OFFSTR "%s %s %s\n", 88409ce0d4aSRoger A. Faulkner OFFSET(robustlocks), 88509ce0d4aSRoger A. Faulkner prt_addr(uberdata.robustlocks, 1), 88623a1cceaSRoger A. Faulkner prt_addr(uberdata.robustlist, 1), 88723a1cceaSRoger A. Faulkner prt_addr(uberdata.progname, 0)); 8887c478bd9Sstevel@tonic-gate 8897c478bd9Sstevel@tonic-gate HD("tdb_bootstrap tdb_sync_addr_hash tdb_'count tdb_'fail"); 8907c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %-10d %d\n", 8918cd45542Sraf OFFSET(tdb_bootstrap), 8928cd45542Sraf prt_addr(uberdata.tdb_bootstrap, 1), 8938cd45542Sraf prt_addr(uberdata.tdb.tdb_sync_addr_hash, 1), 8948cd45542Sraf uberdata.tdb.tdb_register_count, 8958cd45542Sraf uberdata.tdb.tdb_hash_alloc_failed); 8967c478bd9Sstevel@tonic-gate 8977c478bd9Sstevel@tonic-gate HD("tdb_sync_addr_free tdb_sync_addr_last tdb_sync_alloc"); 8987c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "%s %s %ld\n", 8998cd45542Sraf OFFSET(tdb.tdb_sync_addr_free), 9008cd45542Sraf prt_addr(uberdata.tdb.tdb_sync_addr_free, 1), 9018cd45542Sraf prt_addr(uberdata.tdb.tdb_sync_addr_last, 1), 9028cd45542Sraf uberdata.tdb.tdb_sync_alloc); 9037c478bd9Sstevel@tonic-gate 9047c478bd9Sstevel@tonic-gate HD("tdb_ev_global_mask tdb_events"); 9057c478bd9Sstevel@tonic-gate mdb_printf(OFFSTR "0x%08x 0x%08x %s\n", 9068cd45542Sraf OFFSET(tdb.tdb_ev_global_mask), 9078cd45542Sraf uberdata.tdb.tdb_ev_global_mask.event_bits[0], 9088cd45542Sraf uberdata.tdb.tdb_ev_global_mask.event_bits[1], 9098cd45542Sraf prt_addr((void *)uberdata.tdb.tdb_events, 0)); 9107c478bd9Sstevel@tonic-gate 9117c478bd9Sstevel@tonic-gate return (DCMD_OK); 9127c478bd9Sstevel@tonic-gate } 9137c478bd9Sstevel@tonic-gate 9147c478bd9Sstevel@tonic-gate static int 9157c478bd9Sstevel@tonic-gate ulwp_walk_init(mdb_walk_state_t *wsp) 9167c478bd9Sstevel@tonic-gate { 9177c478bd9Sstevel@tonic-gate uintptr_t addr = wsp->walk_addr; 9187c478bd9Sstevel@tonic-gate uintptr_t uber_addr; 919e0ee3cedSJason King int offset; 920e0ee3cedSJason King 921e0ee3cedSJason King offset = mdb_ctf_offsetof_by_name("uberdata_t", "all_lwps"); 922e0ee3cedSJason King if (offset == -1) { 923e0ee3cedSJason King offset = OFFSETOF(uberdata_t, all_lwps); 924e0ee3cedSJason King mdb_warn("CTF data is missing for uberdata_t; using current " 925e0ee3cedSJason King "platform's offset for uberdata.all_lwps"); 926e0ee3cedSJason King } 9277c478bd9Sstevel@tonic-gate 928892ad162SToomas Soome if (addr == 0 && 929892ad162SToomas Soome ((uber_addr = uberdata_addr()) == 0 || 930e0ee3cedSJason King mdb_vread(&addr, sizeof (addr), uber_addr + offset) 9317c478bd9Sstevel@tonic-gate != sizeof (addr))) { 9327c478bd9Sstevel@tonic-gate mdb_warn("cannot find 'uberdata.all_lwps'"); 9337c478bd9Sstevel@tonic-gate return (WALK_ERR); 9347c478bd9Sstevel@tonic-gate } 935892ad162SToomas Soome if (addr == 0) 9367c478bd9Sstevel@tonic-gate return (WALK_DONE); 9377c478bd9Sstevel@tonic-gate wsp->walk_addr = addr; 9387c478bd9Sstevel@tonic-gate wsp->walk_data = (void *)addr; 9397c478bd9Sstevel@tonic-gate return (WALK_NEXT); 9407c478bd9Sstevel@tonic-gate } 9417c478bd9Sstevel@tonic-gate 9427c478bd9Sstevel@tonic-gate static int 9437c478bd9Sstevel@tonic-gate ulwp_walk_step(mdb_walk_state_t *wsp) 9447c478bd9Sstevel@tonic-gate { 9457c478bd9Sstevel@tonic-gate uintptr_t addr = wsp->walk_addr; 9467c478bd9Sstevel@tonic-gate ulwp_t ulwp; 9477c478bd9Sstevel@tonic-gate 948892ad162SToomas Soome if (addr == 0) 9497c478bd9Sstevel@tonic-gate return (WALK_DONE); 9507c478bd9Sstevel@tonic-gate if (mdb_vread(&ulwp, sizeof (ulwp), addr) != sizeof (ulwp) && 9517c478bd9Sstevel@tonic-gate (bzero(&ulwp, sizeof (ulwp)), 9527c478bd9Sstevel@tonic-gate mdb_vread(&ulwp, REPLACEMENT_SIZE, addr)) != REPLACEMENT_SIZE) { 9537c478bd9Sstevel@tonic-gate mdb_warn("failed to read ulwp at 0x%p", addr); 9547c478bd9Sstevel@tonic-gate return (WALK_ERR); 9557c478bd9Sstevel@tonic-gate } 9567c478bd9Sstevel@tonic-gate /* 9577c478bd9Sstevel@tonic-gate * If we have looped around to the beginning 9587c478bd9Sstevel@tonic-gate * of the circular linked list, we are done. 9597c478bd9Sstevel@tonic-gate */ 9607c478bd9Sstevel@tonic-gate if ((wsp->walk_addr = (uintptr_t)ulwp.ul_forw) 9617c478bd9Sstevel@tonic-gate == (uintptr_t)wsp->walk_data) 962892ad162SToomas Soome wsp->walk_addr = 0; 9637c478bd9Sstevel@tonic-gate return (wsp->walk_callback(addr, &ulwp, wsp->walk_cbdata)); 9647c478bd9Sstevel@tonic-gate } 9657c478bd9Sstevel@tonic-gate 9664a1c2431SJonathan Adams /* Avoid classifying NULL pointers as part of the main stack on x86 */ 9674a1c2431SJonathan Adams #define MIN_STACK_ADDR (0x10000ul) 9684a1c2431SJonathan Adams 9694a1c2431SJonathan Adams static int 9704a1c2431SJonathan Adams whatis_walk_ulwp(uintptr_t addr, const ulwp_t *ulwp, mdb_whatis_t *w) 9714a1c2431SJonathan Adams { 9724a1c2431SJonathan Adams uintptr_t cur; 9734a1c2431SJonathan Adams lwpid_t id = ulwp->ul_lwpid; 9744a1c2431SJonathan Adams uintptr_t top, base, size; 9754a1c2431SJonathan Adams 9764a1c2431SJonathan Adams while (mdb_whatis_match(w, addr, sizeof (ulwp_t), &cur)) 9774a1c2431SJonathan Adams mdb_whatis_report_object(w, cur, addr, 9784a1c2431SJonathan Adams "allocated as thread %#r's ulwp_t\n", id); 9794a1c2431SJonathan Adams 9804a1c2431SJonathan Adams top = (uintptr_t)ulwp->ul_stktop; 9814a1c2431SJonathan Adams size = ulwp->ul_stksiz; 9824a1c2431SJonathan Adams 9834a1c2431SJonathan Adams /* 9844a1c2431SJonathan Adams * The main stack ends up being a little weird, especially if 9854a1c2431SJonathan Adams * the stack ulimit is unlimited. This tries to take that into 9864a1c2431SJonathan Adams * account. 9874a1c2431SJonathan Adams */ 9884a1c2431SJonathan Adams if (size > top) 9894a1c2431SJonathan Adams size = top; 9904a1c2431SJonathan Adams if (top > MIN_STACK_ADDR && top - size < MIN_STACK_ADDR) 9914a1c2431SJonathan Adams size = top - MIN_STACK_ADDR; 9924a1c2431SJonathan Adams 9934a1c2431SJonathan Adams base = top - size; 9944a1c2431SJonathan Adams 9954a1c2431SJonathan Adams while (mdb_whatis_match(w, base, size, &cur)) 9964a1c2431SJonathan Adams mdb_whatis_report_address(w, cur, "in [ stack tid=%#r ]\n", id); 9974a1c2431SJonathan Adams 9984a1c2431SJonathan Adams if (ulwp->ul_ustack.ss_flags & SS_ONSTACK) { 9994a1c2431SJonathan Adams base = (uintptr_t)ulwp->ul_ustack.ss_sp; 10004a1c2431SJonathan Adams size = ulwp->ul_ustack.ss_size; 10014a1c2431SJonathan Adams 10024a1c2431SJonathan Adams while (mdb_whatis_match(w, base, size, &cur)) 10034a1c2431SJonathan Adams mdb_whatis_report_address(w, cur, 10044a1c2431SJonathan Adams "in [ altstack tid=%#r ]\n", id); 10054a1c2431SJonathan Adams } 10064a1c2431SJonathan Adams 10074a1c2431SJonathan Adams return (WHATIS_WALKRET(w)); 10084a1c2431SJonathan Adams } 10094a1c2431SJonathan Adams 10104a1c2431SJonathan Adams /*ARGSUSED*/ 10114a1c2431SJonathan Adams static int 10124a1c2431SJonathan Adams whatis_run_ulwps(mdb_whatis_t *w, void *arg) 10134a1c2431SJonathan Adams { 10144a1c2431SJonathan Adams if (mdb_walk("ulwps", (mdb_walk_cb_t)whatis_walk_ulwp, w) == -1) { 10154a1c2431SJonathan Adams mdb_warn("couldn't find ulwps walker"); 10164a1c2431SJonathan Adams return (1); 10174a1c2431SJonathan Adams } 10184a1c2431SJonathan Adams return (0); 10194a1c2431SJonathan Adams } 10204a1c2431SJonathan Adams 10217c478bd9Sstevel@tonic-gate /* 10227c478bd9Sstevel@tonic-gate * ======================================================= 10237c478bd9Sstevel@tonic-gate * End of thread (previously libthread) interfaces. 10247c478bd9Sstevel@tonic-gate * ==================== threads ========================== 10257c478bd9Sstevel@tonic-gate */ 10267c478bd9Sstevel@tonic-gate 1027c9a6ea2eSBryan Cantrill int 1028c9a6ea2eSBryan Cantrill stacks_dcmd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1029c9a6ea2eSBryan Cantrill { 1030c9a6ea2eSBryan Cantrill int rval = stacks(addr, flags, argc, argv); 1031c9a6ea2eSBryan Cantrill 1032c9a6ea2eSBryan Cantrill /* 1033c9a6ea2eSBryan Cantrill * For the user-level variant of ::stacks, we don't bother caching 1034c9a6ea2eSBryan Cantrill * state, as even a very large program is unlikely to compare to the 1035c9a6ea2eSBryan Cantrill * kernel in terms of number of threads. (And if you find yourself 1036c9a6ea2eSBryan Cantrill * here in anger, frustrated about how long ::stacks is running on 1037c9a6ea2eSBryan Cantrill * your galactically complicated zillion-thread program, hopefully 1038c9a6ea2eSBryan Cantrill * you will find some solace in the irony. Okay, probably not...) 1039c9a6ea2eSBryan Cantrill */ 1040c9a6ea2eSBryan Cantrill stacks_cleanup(B_TRUE); 1041c9a6ea2eSBryan Cantrill return (rval); 1042c9a6ea2eSBryan Cantrill } 1043c9a6ea2eSBryan Cantrill 1044c9a6ea2eSBryan Cantrill typedef struct tid2ulwp_walk { 1045c9a6ea2eSBryan Cantrill lwpid_t t2u_tid; 1046c9a6ea2eSBryan Cantrill uintptr_t t2u_lwp; 1047c9a6ea2eSBryan Cantrill boolean_t t2u_found; 1048c9a6ea2eSBryan Cantrill } tid2ulwp_walk_t; 1049c9a6ea2eSBryan Cantrill 1050c9a6ea2eSBryan Cantrill /*ARGSUSED*/ 1051c9a6ea2eSBryan Cantrill static int 1052c9a6ea2eSBryan Cantrill tid2ulwp_walk(uintptr_t addr, ulwp_t *ulwp, tid2ulwp_walk_t *t2u) 1053c9a6ea2eSBryan Cantrill { 1054c9a6ea2eSBryan Cantrill if (ulwp->ul_lwpid == t2u->t2u_tid) { 1055c9a6ea2eSBryan Cantrill t2u->t2u_lwp = addr; 1056c9a6ea2eSBryan Cantrill t2u->t2u_found = B_TRUE; 1057c9a6ea2eSBryan Cantrill return (WALK_DONE); 1058c9a6ea2eSBryan Cantrill } 1059c9a6ea2eSBryan Cantrill 1060c9a6ea2eSBryan Cantrill return (WALK_NEXT); 1061c9a6ea2eSBryan Cantrill } 1062c9a6ea2eSBryan Cantrill 1063c9a6ea2eSBryan Cantrill static int 106428e4da25SMatthew Ahrens tid2ulwp_impl(uintptr_t tid_addr, uintptr_t *ulwp_addrp) 1065c9a6ea2eSBryan Cantrill { 1066c9a6ea2eSBryan Cantrill tid2ulwp_walk_t t2u; 1067c9a6ea2eSBryan Cantrill 1068c9a6ea2eSBryan Cantrill bzero(&t2u, sizeof (t2u)); 106928e4da25SMatthew Ahrens t2u.t2u_tid = (lwpid_t)tid_addr; 1070c9a6ea2eSBryan Cantrill 1071c9a6ea2eSBryan Cantrill if (mdb_walk("ulwp", (mdb_walk_cb_t)tid2ulwp_walk, &t2u) != 0) { 1072c9a6ea2eSBryan Cantrill mdb_warn("can't walk 'ulwp'"); 1073c9a6ea2eSBryan Cantrill return (DCMD_ERR); 1074c9a6ea2eSBryan Cantrill } 1075c9a6ea2eSBryan Cantrill 1076c9a6ea2eSBryan Cantrill if (!t2u.t2u_found) { 1077c9a6ea2eSBryan Cantrill mdb_warn("thread ID %d not found", t2u.t2u_tid); 1078c9a6ea2eSBryan Cantrill return (DCMD_ERR); 1079c9a6ea2eSBryan Cantrill } 108028e4da25SMatthew Ahrens *ulwp_addrp = t2u.t2u_lwp; 108128e4da25SMatthew Ahrens return (DCMD_OK); 108228e4da25SMatthew Ahrens } 1083c9a6ea2eSBryan Cantrill 108428e4da25SMatthew Ahrens /*ARGSUSED*/ 108528e4da25SMatthew Ahrens static int 108628e4da25SMatthew Ahrens tid2ulwp(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 108728e4da25SMatthew Ahrens { 108828e4da25SMatthew Ahrens uintptr_t ulwp_addr; 108928e4da25SMatthew Ahrens int error; 109028e4da25SMatthew Ahrens 109128e4da25SMatthew Ahrens if (argc != 0) 109228e4da25SMatthew Ahrens return (DCMD_USAGE); 109328e4da25SMatthew Ahrens 109428e4da25SMatthew Ahrens error = tid2ulwp_impl(addr, &ulwp_addr); 109528e4da25SMatthew Ahrens if (error == DCMD_OK) 109628e4da25SMatthew Ahrens mdb_printf("%p\n", ulwp_addr); 109728e4da25SMatthew Ahrens return (error); 109828e4da25SMatthew Ahrens } 109928e4da25SMatthew Ahrens 1100*07188943SJason King /* 1101*07188943SJason King * This is used by both d_tsd and d_errno, and contains the sum of all 1102*07188943SJason King * members used by both commands. 1103*07188943SJason King */ 110428e4da25SMatthew Ahrens typedef struct mdb_libc_ulwp { 110528e4da25SMatthew Ahrens void *ul_ftsd[TSD_NFAST]; 110628e4da25SMatthew Ahrens tsd_t *ul_stsd; 1107*07188943SJason King int *ul_errnop; 110828e4da25SMatthew Ahrens } mdb_libc_ulwp_t; 110928e4da25SMatthew Ahrens 111028e4da25SMatthew Ahrens /* 111128e4da25SMatthew Ahrens * Map from thread pointer to tsd for given key 111228e4da25SMatthew Ahrens */ 111328e4da25SMatthew Ahrens static int 111428e4da25SMatthew Ahrens d_tsd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 111528e4da25SMatthew Ahrens { 111628e4da25SMatthew Ahrens mdb_libc_ulwp_t u; 111728e4da25SMatthew Ahrens uintptr_t ulwp_addr; 1118892ad162SToomas Soome uintptr_t key = 0; 111928e4da25SMatthew Ahrens void *element = NULL; 112028e4da25SMatthew Ahrens 112128e4da25SMatthew Ahrens if (mdb_getopts(argc, argv, 'k', MDB_OPT_UINTPTR, &key, NULL) != argc) 112228e4da25SMatthew Ahrens return (DCMD_USAGE); 112328e4da25SMatthew Ahrens 1124892ad162SToomas Soome if (!(flags & DCMD_ADDRSPEC) || key == 0) 112528e4da25SMatthew Ahrens return (DCMD_USAGE); 112628e4da25SMatthew Ahrens 112728e4da25SMatthew Ahrens if (tid2ulwp_impl(addr, &ulwp_addr) != DCMD_OK) 112828e4da25SMatthew Ahrens return (DCMD_ERR); 112928e4da25SMatthew Ahrens 113028e4da25SMatthew Ahrens if (mdb_ctf_vread(&u, "ulwp_t", "mdb_libc_ulwp_t", ulwp_addr, 0) == -1) 113128e4da25SMatthew Ahrens return (DCMD_ERR); 113228e4da25SMatthew Ahrens 113328e4da25SMatthew Ahrens if (key < TSD_NFAST) { 113428e4da25SMatthew Ahrens element = u.ul_ftsd[key]; 113528e4da25SMatthew Ahrens } else if (u.ul_stsd != NULL) { 113628e4da25SMatthew Ahrens uint_t nalloc; 113728e4da25SMatthew Ahrens /* tsd_t is a union, so we can't use ctf_vread() on it. */ 113828e4da25SMatthew Ahrens if (mdb_vread(&nalloc, sizeof (nalloc), 113928e4da25SMatthew Ahrens (uintptr_t)&u.ul_stsd->tsd_nalloc) == -1) { 114028e4da25SMatthew Ahrens mdb_warn("failed to read tsd_t at %p", u.ul_stsd); 114128e4da25SMatthew Ahrens return (DCMD_ERR); 114228e4da25SMatthew Ahrens } 114328e4da25SMatthew Ahrens if (key < nalloc) { 114428e4da25SMatthew Ahrens if (mdb_vread(&element, sizeof (element), 114528e4da25SMatthew Ahrens (uintptr_t)&u.ul_stsd->tsd_data[key]) == -1) { 114628e4da25SMatthew Ahrens mdb_warn("failed to read tsd_t at %p", 114728e4da25SMatthew Ahrens u.ul_stsd); 114828e4da25SMatthew Ahrens return (DCMD_ERR); 114928e4da25SMatthew Ahrens } 115028e4da25SMatthew Ahrens } 115128e4da25SMatthew Ahrens } 115228e4da25SMatthew Ahrens 115328e4da25SMatthew Ahrens if (element == NULL && (flags & DCMD_PIPE)) 115428e4da25SMatthew Ahrens return (DCMD_OK); 1155c9a6ea2eSBryan Cantrill 115628e4da25SMatthew Ahrens mdb_printf("%p\n", element); 1157c9a6ea2eSBryan Cantrill return (DCMD_OK); 1158c9a6ea2eSBryan Cantrill } 1159c9a6ea2eSBryan Cantrill 1160542a7b7fSCarlos Neira /* 1161542a7b7fSCarlos Neira * Print percent from 16-bit binary fraction [0 .. 1] 1162542a7b7fSCarlos Neira * Round up .01 to .1 to indicate some small percentage (the 0x7000 below). 1163542a7b7fSCarlos Neira * 1164542a7b7fSCarlos Neira * Note: This routine was copied from elfdump/common/corenote.c and modified. 1165542a7b7fSCarlos Neira * 1166542a7b7fSCarlos Neira */ 1167542a7b7fSCarlos Neira static uint_t 1168542a7b7fSCarlos Neira pct_value(ushort_t pct) 1169542a7b7fSCarlos Neira { 1170542a7b7fSCarlos Neira uint_t value = pct; 1171542a7b7fSCarlos Neira 1172542a7b7fSCarlos Neira value = ((value * 1000) + 0x7000) >> 15; /* [0 .. 1000] */ 1173542a7b7fSCarlos Neira if (value >= 1000) 1174542a7b7fSCarlos Neira value = 999; 1175542a7b7fSCarlos Neira 1176542a7b7fSCarlos Neira return (value); 1177542a7b7fSCarlos Neira } 1178542a7b7fSCarlos Neira 1179542a7b7fSCarlos Neira static void 1180542a7b7fSCarlos Neira psinfo_raw(psinfo_t psinfo) 1181542a7b7fSCarlos Neira { 1182542a7b7fSCarlos Neira const int minspaces = 2; 1183542a7b7fSCarlos Neira const int spbcols = 20; 1184542a7b7fSCarlos Neira char sysname[SYS2STR_MAX]; 1185542a7b7fSCarlos Neira uint_t cpu, mem; 1186542a7b7fSCarlos Neira char buff[32]; 1187542a7b7fSCarlos Neira int bufflen; 1188542a7b7fSCarlos Neira 1189542a7b7fSCarlos Neira mdb_printf("[ NT_PRPSINFO ]\n"); 1190542a7b7fSCarlos Neira 1191542a7b7fSCarlos Neira mdb_printf("\tpr_state: %d\t\t\tpr_sname: %c\n", 1192542a7b7fSCarlos Neira psinfo.pr_lwp.pr_state, psinfo.pr_lwp.pr_sname); 1193542a7b7fSCarlos Neira 1194542a7b7fSCarlos Neira mdb_printf("\tpr_zomb: %d\t\t\tpr_nice: %d\n", 1195542a7b7fSCarlos Neira psinfo.pr_nzomb, psinfo.pr_lwp.pr_nice); 1196542a7b7fSCarlos Neira 1197542a7b7fSCarlos Neira mdb_printf("\tpr_uid: %u\t\t\tpr_gid: %u\n", 1198542a7b7fSCarlos Neira psinfo.pr_uid, psinfo.pr_gid); 1199542a7b7fSCarlos Neira 1200542a7b7fSCarlos Neira mdb_snprintf(buff, sizeof (buff), 1201542a7b7fSCarlos Neira "%d", psinfo.pr_pid); 1202542a7b7fSCarlos Neira 1203542a7b7fSCarlos Neira bufflen = strlen(buff); 1204542a7b7fSCarlos Neira mdb_printf("\tpr_pid: %s%*spr_ppid: %d\n", 1205542a7b7fSCarlos Neira buff, strlen(buff) > spbcols ? minspaces : (spbcols - bufflen), " ", 1206542a7b7fSCarlos Neira psinfo.pr_ppid); 1207542a7b7fSCarlos Neira 1208542a7b7fSCarlos Neira mdb_printf("\tpr_pgid: %u\t\t\tpr_sid: %d\n", 1209542a7b7fSCarlos Neira psinfo.pr_gid, psinfo.pr_sid); 1210542a7b7fSCarlos Neira 1211542a7b7fSCarlos Neira mdb_snprintf(buff, sizeof (buff), 1212542a7b7fSCarlos Neira "0x%lx", (ulong_t)psinfo.pr_addr); 1213542a7b7fSCarlos Neira 1214542a7b7fSCarlos Neira bufflen = strlen(buff); 1215542a7b7fSCarlos Neira 1216542a7b7fSCarlos Neira mdb_printf("\tpr_addr: %s%*spr_size: %#x\n", 1217542a7b7fSCarlos Neira buff, strlen(buff) > spbcols ? minspaces : (spbcols - bufflen), " ", 1218542a7b7fSCarlos Neira (ulong_t)psinfo.pr_size); 1219542a7b7fSCarlos Neira 1220542a7b7fSCarlos Neira mdb_printf("\tpr_rssize: %#lx\t\tpr_wchan: %#lx\n", 1221542a7b7fSCarlos Neira (ulong_t)psinfo.pr_rssize, (ulong_t)psinfo.pr_lwp.pr_wchan); 1222542a7b7fSCarlos Neira 1223542a7b7fSCarlos Neira mdb_printf("\tpr_start:\n\t tv_sec: %ld\t\ttv_nsec: %ld\n", 1224542a7b7fSCarlos Neira psinfo.pr_start.tv_sec, psinfo.pr_start.tv_nsec); 1225542a7b7fSCarlos Neira 1226542a7b7fSCarlos Neira mdb_printf("\tpr_time:\n\t tv_sec: %ld\t\t\ttv_nsec: %ld\n", 1227542a7b7fSCarlos Neira psinfo.pr_time.tv_sec, psinfo.pr_time.tv_nsec); 1228542a7b7fSCarlos Neira 1229542a7b7fSCarlos Neira mdb_printf("\tpr_pri: %d\t\t\tpr_oldpri: %d\n", 1230542a7b7fSCarlos Neira psinfo.pr_lwp.pr_pri, psinfo.pr_lwp.pr_oldpri); 1231542a7b7fSCarlos Neira 1232542a7b7fSCarlos Neira mdb_printf("\tpr_cpu: %d\n", psinfo.pr_lwp.pr_cpu); 1233542a7b7fSCarlos Neira 1234542a7b7fSCarlos Neira mdb_printf("\tpr_clname: %s\n", psinfo.pr_lwp.pr_clname); 1235542a7b7fSCarlos Neira 1236542a7b7fSCarlos Neira mdb_printf("\tpr_fname: %s\n", psinfo.pr_fname); 1237542a7b7fSCarlos Neira 1238542a7b7fSCarlos Neira mdb_printf("\tpr_psargs: %s\n", psinfo.pr_psargs); 1239542a7b7fSCarlos Neira 1240542a7b7fSCarlos Neira 1241542a7b7fSCarlos Neira mdb_printf("\tpr_syscall: [ %s ]\n", 1242542a7b7fSCarlos Neira proc_sysname(psinfo.pr_lwp.pr_syscall, sysname, 1243542a7b7fSCarlos Neira sizeof (sysname))); 1244542a7b7fSCarlos Neira 1245542a7b7fSCarlos Neira mdb_printf("\tpr_ctime:\n\t tv_sec: %ld\t\t\ttv_nsec: %ld\n", 1246542a7b7fSCarlos Neira psinfo.pr_ctime.tv_sec, psinfo.pr_ctime.tv_nsec); 1247542a7b7fSCarlos Neira 1248542a7b7fSCarlos Neira mdb_printf("\tpr_argc: %d\t\t\tpr_argv: 0x%lx\n", 1249542a7b7fSCarlos Neira psinfo.pr_argc, (ulong_t)psinfo.pr_argv); 1250542a7b7fSCarlos Neira 1251542a7b7fSCarlos Neira mdb_snprintf(buff, sizeof (buff), "0x%lx", (ulong_t)psinfo.pr_envp); 1252542a7b7fSCarlos Neira 1253542a7b7fSCarlos Neira bufflen = strlen(buff); 1254542a7b7fSCarlos Neira 1255542a7b7fSCarlos Neira mdb_printf("\tpr_envp: %s%*spr_wstat: %d\n", 1256542a7b7fSCarlos Neira buff, strlen(buff) > spbcols ? minspaces : (spbcols - bufflen), " ", 1257542a7b7fSCarlos Neira psinfo.pr_wstat); 1258542a7b7fSCarlos Neira 1259542a7b7fSCarlos Neira cpu = pct_value(psinfo.pr_pctcpu); 1260542a7b7fSCarlos Neira mem = pct_value(psinfo.pr_pctmem); 1261542a7b7fSCarlos Neira 1262542a7b7fSCarlos Neira mdb_printf("\tpr_pctcpu: %u.%u%%\t\tpr_pctmem: %u.%u%%\n", 1263542a7b7fSCarlos Neira cpu / 10, cpu % 10, mem / 10, mem % 10); 1264542a7b7fSCarlos Neira 1265542a7b7fSCarlos Neira mdb_printf("\tpr_euid: %u\t\t\tpr_egid: %u\n", 1266542a7b7fSCarlos Neira psinfo.pr_euid, psinfo.pr_egid); 1267542a7b7fSCarlos Neira 1268542a7b7fSCarlos Neira mdb_printf("\tpr_dmodel: [%s]\n", 1269542a7b7fSCarlos Neira proc_dmodelname(psinfo.pr_dmodel, buff, sizeof (buff))); 1270542a7b7fSCarlos Neira } 1271542a7b7fSCarlos Neira 1272542a7b7fSCarlos Neira static void 1273542a7b7fSCarlos Neira psinfo_sum(psinfo_t psinfo) 1274542a7b7fSCarlos Neira { 1275542a7b7fSCarlos Neira const int minspaces = 2; 1276542a7b7fSCarlos Neira const int spbcols = 23; 1277542a7b7fSCarlos Neira char buff[64]; 1278542a7b7fSCarlos Neira int bufflen; 1279542a7b7fSCarlos Neira int ms; 1280542a7b7fSCarlos Neira 1281542a7b7fSCarlos Neira mdb_printf("PID: %6d (process id)\t\t" 1282542a7b7fSCarlos Neira "UID: %4u (real user id)\n", 1283542a7b7fSCarlos Neira psinfo.pr_pid, psinfo.pr_uid); 1284542a7b7fSCarlos Neira 1285542a7b7fSCarlos Neira mdb_printf("PPID: %6d (parent process id)\tEUID: %4d" 1286542a7b7fSCarlos Neira " (effective user id)\n", psinfo.pr_ppid, psinfo.pr_euid); 1287542a7b7fSCarlos Neira 1288542a7b7fSCarlos Neira mdb_printf("PGID: %6d (process group id)\tGID: %4u" 1289542a7b7fSCarlos Neira " (real group id)\n", psinfo.pr_pgid, psinfo.pr_gid); 1290542a7b7fSCarlos Neira 1291542a7b7fSCarlos Neira mdb_printf("SID: %6d (session id)\t\tEGID: %4u" 1292542a7b7fSCarlos Neira " (effective group id)\n", 1293542a7b7fSCarlos Neira psinfo.pr_sid, psinfo.pr_egid); 1294542a7b7fSCarlos Neira 1295542a7b7fSCarlos Neira mdb_printf("ZONEID: %6d\t\t\t\tCONTRACT:%4d\n", 1296542a7b7fSCarlos Neira psinfo.pr_zoneid, psinfo.pr_contract); 1297542a7b7fSCarlos Neira 1298542a7b7fSCarlos Neira mdb_printf("PROJECT:%6d \t\t\t\tTASK: %4d\n\n", 1299542a7b7fSCarlos Neira psinfo.pr_projid, psinfo.pr_taskid); 1300542a7b7fSCarlos Neira 1301542a7b7fSCarlos Neira mdb_printf("START: %Y (wall timestamp when the process started)\n", 1302542a7b7fSCarlos Neira psinfo.pr_start); 1303542a7b7fSCarlos Neira 1304542a7b7fSCarlos Neira ms = NSEC2MSEC(psinfo.pr_time.tv_nsec); 1305542a7b7fSCarlos Neira 1306542a7b7fSCarlos Neira mdb_snprintf(buff, sizeof (buff), "%ld.%d seconds", 1307542a7b7fSCarlos Neira psinfo.pr_time.tv_sec, ms); 1308542a7b7fSCarlos Neira 1309542a7b7fSCarlos Neira bufflen = strlen(buff); 1310542a7b7fSCarlos Neira 1311542a7b7fSCarlos Neira mdb_printf("TIME: %s%*s" 1312542a7b7fSCarlos Neira "(CPU time used by this process)\n", 1313542a7b7fSCarlos Neira buff, bufflen > spbcols ? minspaces : (spbcols - bufflen), " "); 1314542a7b7fSCarlos Neira 1315542a7b7fSCarlos Neira ms = NSEC2MSEC(psinfo.pr_ctime.tv_nsec); 1316542a7b7fSCarlos Neira 1317542a7b7fSCarlos Neira mdb_snprintf(buff, sizeof (buff), "%ld.%d seconds", 1318542a7b7fSCarlos Neira psinfo.pr_ctime.tv_sec, ms); 1319542a7b7fSCarlos Neira 1320542a7b7fSCarlos Neira mdb_printf("CTIME: %s%*s" 1321542a7b7fSCarlos Neira "(CPU time used by child processes)\n", 1322542a7b7fSCarlos Neira buff, bufflen > spbcols ? minspaces : (spbcols - bufflen), " "); 1323542a7b7fSCarlos Neira 1324542a7b7fSCarlos Neira mdb_snprintf(buff, sizeof (buff), "%s", psinfo.pr_fname); 1325542a7b7fSCarlos Neira bufflen = strlen(buff); 1326542a7b7fSCarlos Neira 1327542a7b7fSCarlos Neira mdb_printf("FNAME: %s%*s(name of the program executed)\n", 1328542a7b7fSCarlos Neira buff, bufflen > spbcols ? minspaces : (spbcols - bufflen), " "); 1329542a7b7fSCarlos Neira 1330542a7b7fSCarlos Neira mdb_printf("PSARGS: \"%s\"\n", psinfo.pr_psargs); 1331542a7b7fSCarlos Neira } 1332542a7b7fSCarlos Neira 1333542a7b7fSCarlos Neira void 1334542a7b7fSCarlos Neira d_psinfo_dcmd_help(void) 1335542a7b7fSCarlos Neira { 1336542a7b7fSCarlos Neira mdb_printf( 1337542a7b7fSCarlos Neira "Prints relevant fields from psinfo_t data and\n" 1338542a7b7fSCarlos Neira "most fields from NT_PRPSINFO note section\n\n" 1339542a7b7fSCarlos Neira "Usage: ::psinfo [-v]\n" 1340542a7b7fSCarlos Neira "Options:\n" 1341542a7b7fSCarlos Neira " -v verbose output\n"); 1342542a7b7fSCarlos Neira } 1343542a7b7fSCarlos Neira 1344542a7b7fSCarlos Neira static int 1345542a7b7fSCarlos Neira d_psinfo(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1346542a7b7fSCarlos Neira { 1347542a7b7fSCarlos Neira psinfo_t psinfo; 1348542a7b7fSCarlos Neira uint_t opt_v = FALSE; 1349542a7b7fSCarlos Neira ssize_t nbytes; 1350542a7b7fSCarlos Neira 1351542a7b7fSCarlos Neira if (mdb_getopts(argc, argv, 'v', 1352542a7b7fSCarlos Neira MDB_OPT_SETBITS, TRUE, &opt_v, NULL) != argc) 1353542a7b7fSCarlos Neira return (DCMD_USAGE); 1354542a7b7fSCarlos Neira 1355542a7b7fSCarlos Neira nbytes = mdb_get_xdata("psinfo", NULL, 0); 1356542a7b7fSCarlos Neira 1357542a7b7fSCarlos Neira if (nbytes <= 0) { 1358542a7b7fSCarlos Neira mdb_warn("information not available for analysis"); 1359542a7b7fSCarlos Neira return (DCMD_ERR); 1360542a7b7fSCarlos Neira } 1361542a7b7fSCarlos Neira 1362542a7b7fSCarlos Neira if (mdb_get_xdata("psinfo", &psinfo, nbytes) != nbytes) { 1363542a7b7fSCarlos Neira mdb_warn("failed to read psinfo information"); 1364542a7b7fSCarlos Neira return (DCMD_ERR); 1365542a7b7fSCarlos Neira } 1366542a7b7fSCarlos Neira 1367542a7b7fSCarlos Neira if (opt_v) { 1368542a7b7fSCarlos Neira psinfo_raw(psinfo); 1369542a7b7fSCarlos Neira } else { 1370542a7b7fSCarlos Neira psinfo_sum(psinfo); 1371542a7b7fSCarlos Neira } 1372542a7b7fSCarlos Neira 1373542a7b7fSCarlos Neira return (DCMD_OK); 1374542a7b7fSCarlos Neira } 1375542a7b7fSCarlos Neira 1376*07188943SJason King static int 1377*07188943SJason King d_errno(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1378*07188943SJason King { 1379*07188943SJason King mdb_libc_ulwp_t u; 1380*07188943SJason King uintptr_t ulwp_addr; 1381*07188943SJason King int error, errval; 1382*07188943SJason King 1383*07188943SJason King if (argc != 0 || (flags & DCMD_ADDRSPEC) == 0) 1384*07188943SJason King return (DCMD_USAGE); 1385*07188943SJason King 1386*07188943SJason King error = tid2ulwp_impl(addr, &ulwp_addr); 1387*07188943SJason King if (error != DCMD_OK) 1388*07188943SJason King return (error); 1389*07188943SJason King 1390*07188943SJason King /* 1391*07188943SJason King * For historical compatibility, thread 1's errno value is stored in 1392*07188943SJason King * a libc global variable 'errno', while each additional thread's 1393*07188943SJason King * errno value is stored in ulwp_t->ul_errno. In addition, 1394*07188943SJason King * ulwp_t->ul_errnop is set to the address of the thread's errno value, 1395*07188943SJason King * (i.e. for tid 1, curthead->ul_errnop = &errno, for tid > 1, 1396*07188943SJason King * curthread->ul_errnop = &curthread->ul_errno). 1397*07188943SJason King * 1398*07188943SJason King * Since errno itself uses *curthread->ul_errnop (see ___errno()) to 1399*07188943SJason King * return the thread's current errno value, we do the same. 1400*07188943SJason King */ 1401*07188943SJason King if (mdb_ctf_vread(&u, "ulwp_t", "mdb_libc_ulwp_t", ulwp_addr, 0) == -1) 1402*07188943SJason King return (DCMD_ERR); 1403*07188943SJason King 1404*07188943SJason King if (mdb_vread(&errval, sizeof (errval), (uintptr_t)u.ul_errnop) == -1) { 1405*07188943SJason King mdb_warn("cannot read error value at 0x%p", u.ul_errnop); 1406*07188943SJason King return (DCMD_ERR); 1407*07188943SJason King } 1408*07188943SJason King 1409*07188943SJason King mdb_printf("%d\n", errval); 1410*07188943SJason King return (DCMD_OK); 1411*07188943SJason King } 1412*07188943SJason King 14137c478bd9Sstevel@tonic-gate static const mdb_dcmd_t dcmds[] = { 1414*07188943SJason King { "errno", "?", "print errno of a given TID", d_errno, NULL }, 14157c478bd9Sstevel@tonic-gate { "jmp_buf", ":", "print jmp_buf contents", d_jmp_buf, NULL }, 14167c478bd9Sstevel@tonic-gate { "sigjmp_buf", ":", "print sigjmp_buf contents", d_sigjmp_buf, NULL }, 14177c478bd9Sstevel@tonic-gate { "siginfo", ":", "print siginfo_t structure", d_siginfo, NULL }, 1418c9a6ea2eSBryan Cantrill { "stacks", "?[-afiv] [-c func] [-C func] [-m module] [-M module] ", 1419c9a6ea2eSBryan Cantrill "print unique thread stacks", stacks_dcmd, stacks_help }, 1420c9a6ea2eSBryan Cantrill { "tid2ulwp", "?", "convert TID to ulwp_t address", tid2ulwp }, 14217c478bd9Sstevel@tonic-gate { "ucontext", ":", "print ucontext_t structure", d_ucontext, NULL }, 14227c478bd9Sstevel@tonic-gate { "ulwp", ":", "print ulwp_t structure", d_ulwp, NULL }, 14237c478bd9Sstevel@tonic-gate { "uberdata", ":", "print uberdata_t structure", d_uberdata, NULL }, 142428e4da25SMatthew Ahrens { "tsd", ":-k key", "print tsd for this thread", d_tsd, NULL }, 1425542a7b7fSCarlos Neira { "psinfo", "[-v]", "prints relevant psinfo_t data", d_psinfo, 1426542a7b7fSCarlos Neira d_psinfo_dcmd_help }, 14277c478bd9Sstevel@tonic-gate { NULL } 14287c478bd9Sstevel@tonic-gate }; 14297c478bd9Sstevel@tonic-gate 14307c478bd9Sstevel@tonic-gate static const mdb_walker_t walkers[] = { 14317c478bd9Sstevel@tonic-gate { "ucontext", "walk ucontext_t uc_link list", 14327c478bd9Sstevel@tonic-gate NULL, uc_walk_step, NULL, NULL }, 14337c478bd9Sstevel@tonic-gate { "oldcontext", "walk per-lwp oldcontext pointers", 14347c478bd9Sstevel@tonic-gate oldc_walk_init, oldc_walk_step, oldc_walk_fini, NULL }, 14357c478bd9Sstevel@tonic-gate { "ulwps", "walk list of ulwp_t pointers", 14367c478bd9Sstevel@tonic-gate ulwp_walk_init, ulwp_walk_step, NULL, NULL }, 1437c9a6ea2eSBryan Cantrill { "ulwp", "walk list of ulwp_t pointers", 1438c9a6ea2eSBryan Cantrill ulwp_walk_init, ulwp_walk_step, NULL, NULL }, 14397c478bd9Sstevel@tonic-gate { NULL } 14407c478bd9Sstevel@tonic-gate }; 14417c478bd9Sstevel@tonic-gate 14427c478bd9Sstevel@tonic-gate static const mdb_modinfo_t modinfo = { MDB_API_VERSION, dcmds, walkers }; 14437c478bd9Sstevel@tonic-gate 14447c478bd9Sstevel@tonic-gate const mdb_modinfo_t * 14457c478bd9Sstevel@tonic-gate _mdb_init(void) 14467c478bd9Sstevel@tonic-gate { 14474a1c2431SJonathan Adams mdb_whatis_register("threads", whatis_run_ulwps, NULL, 14484a1c2431SJonathan Adams WHATIS_PRIO_EARLY, WHATIS_REG_NO_ID); 14494a1c2431SJonathan Adams 14507c478bd9Sstevel@tonic-gate return (&modinfo); 14517c478bd9Sstevel@tonic-gate } 1452