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