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 2008 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 /* 27 * Copyright 2012 DEY Storage Systems, Inc. All rights reserved. 28 * Copyright (c) 2013, Joyent, Inc. All rights reserved. 29 */ 30 31 #include <stdlib.h> 32 #include <stdio.h> 33 #include <string.h> 34 #include <sys/types.h> 35 #include <unistd.h> 36 #include <sys/corectl.h> 37 #include <msg.h> 38 #include <_elfdump.h> 39 #include <struct_layout.h> 40 #include <conv.h> 41 42 43 /* 44 * This module contains the code that displays data from the note 45 * sections found in Solaris core files. The format of these 46 * note sections are described in the core(4) manpage. 47 */ 48 49 50 51 52 /* 53 * Much of the code in this file uses the "%*s" format to set 54 * the left margin indentation. This macro combines the indent 55 * integer argument and the NULL string that follows it. 56 */ 57 #define INDENT state->ns_indent, MSG_ORIG(MSG_STR_EMPTY) 58 59 /* 60 * Indent unit, used for each nesting 61 */ 62 #define INDENT_STEP 4 63 64 /* 65 * The PRINT_ macros are convenience wrappers on print_num(), 66 * print_subtype(), and print_strbuf(). They reduce code 67 * clutter by hiding the boilerplate arguments. 68 * 69 * Assumptions: 70 * - A variable named "layout" exists in the compilation 71 * environment, referencing the layout information for the 72 * current type. 73 * - The variable "state" references the current note state. 74 */ 75 #define PRINT_DEC(_title, _field) \ 76 print_num(state, _title, &layout->_field, SL_FMT_NUM_DEC) 77 #define PRINT_DEC_2UP(_title1, _field1, _title2, _field2) \ 78 print_num_2up(state, _title1, &layout->_field1, SL_FMT_NUM_DEC, \ 79 _title2, &layout->_field2, SL_FMT_NUM_DEC) 80 #define PRINT_HEX(_title, _field) \ 81 print_num(state, _title, &layout->_field, SL_FMT_NUM_HEX) 82 #define PRINT_HEX_2UP(_title1, _field1, _title2, _field2) \ 83 print_num_2up(state, _title1, &layout->_field1, SL_FMT_NUM_HEX, \ 84 _title2, &layout->_field2, SL_FMT_NUM_HEX) 85 #define PRINT_ZHEX(_title, _field) \ 86 print_num(state, _title, &layout->_field, SL_FMT_NUM_ZHEX) 87 #define PRINT_ZHEX_2UP(_title1, _field1, _title2, _field2) \ 88 print_num_2up(state, _title1, &layout->_field1, SL_FMT_NUM_ZHEX, \ 89 _title2, &layout->_field2, SL_FMT_NUM_ZHEX) 90 #define PRINT_SUBTYPE(_title, _field, _func) \ 91 print_subtype(state, _title, &layout->_field, _func) 92 #define PRINT_STRBUF(_title, _field) \ 93 print_strbuf(state, _title, &layout->_field) 94 95 96 97 /* 98 * Structure used to maintain state data for a core note, or a subregion 99 * (sub-struct) of a core note. These values would otherwise need to be 100 * passed to nearly every routine. 101 */ 102 typedef struct { 103 Half ns_mach; /* ELF machine type of core file */ 104 const sl_arch_layout_t *ns_arch; /* structure layout def for mach */ 105 int ns_swap; /* True if byte swapping is needed */ 106 int ns_indent; /* Left margin indentation */ 107 int ns_vcol; /* Column where value starts */ 108 int ns_t2col; /* Column where 2up title starts */ 109 int ns_v2col; /* Column where 2up value starts */ 110 const char *ns_data; /* Pointer to struct data area */ 111 Word ns_len; /* Length of struct data area */ 112 } note_state_t; 113 114 /* 115 * Standard signature for a dump function used to process a note 116 * or a sub-structure within a note. 117 */ 118 typedef void (* dump_func_t)(note_state_t *state, const char *title); 119 120 121 122 123 124 125 /* 126 * Some core notes contain string buffers of fixed size 127 * that are expected to contain NULL terminated strings. 128 * If the NULL is there, we can print these strings directly. 129 * However, the potential exists for a corrupt file to have 130 * a non-terminated buffer. This routine examines the given 131 * string, and if the string is terminated, the string itself 132 * is returned. Otherwise, it is copied to a static buffer, 133 * and a pointer to the buffer is returned. 134 */ 135 static const char * 136 safe_str(const char *str, size_t n) 137 { 138 static char buf[512]; 139 char *s; 140 size_t i; 141 142 if (n == 0) 143 return (MSG_ORIG(MSG_STR_EMPTY)); 144 145 for (i = 0; i < n; i++) 146 if (str[i] == '\0') 147 return (str); 148 149 i = (n >= sizeof (buf)) ? (sizeof (buf) - 4) : (n - 1); 150 (void) memcpy(buf, str, i); 151 s = buf + i; 152 if (n >= sizeof (buf)) { 153 *s++ = '.'; 154 *s++ = '.'; 155 *s++ = '.'; 156 } 157 *s = '\0'; 158 return (buf); 159 } 160 161 /* 162 * Convenience wrappers on top of the corresponding sl_XXX() functions. 163 */ 164 static Word 165 extract_as_word(note_state_t *state, const sl_field_t *fdesc) 166 { 167 return (sl_extract_as_word(state->ns_data, state->ns_swap, fdesc)); 168 } 169 static Word 170 extract_as_lword(note_state_t *state, const sl_field_t *fdesc) 171 { 172 return (sl_extract_as_lword(state->ns_data, state->ns_swap, fdesc)); 173 } 174 static int 175 extract_as_sword(note_state_t *state, const sl_field_t *fdesc) 176 { 177 return (sl_extract_as_sword(state->ns_data, state->ns_swap, fdesc)); 178 } 179 static const char * 180 fmt_num(note_state_t *state, const sl_field_t *fdesc, 181 sl_fmt_num_t fmt_type, sl_fmtbuf_t buf) 182 { 183 return (sl_fmt_num(state->ns_data, state->ns_swap, fdesc, 184 fmt_type, buf)); 185 } 186 187 188 /* 189 * Return true of the data for the specified field is available. 190 */ 191 inline static int 192 data_present(note_state_t *state, const sl_field_t *fdesc) 193 { 194 return ((fdesc->slf_offset + fdesc->slf_eltlen) <= state->ns_len); 195 } 196 197 /* 198 * indent_enter/exit are used to start/end output for a subitem. 199 * On entry, a title is output, and the indentation level is raised 200 * by one unit. On exit, the indentation level is restrored to its 201 * previous value. 202 */ 203 static void 204 indent_enter(note_state_t *state, const char *title, 205 const sl_field_t *first_fdesc) 206 { 207 /* 208 * If the first field offset and extent fall past the end of the 209 * available data, then return without printing a title. That note 210 * is from an older core file that doesn't have all the fields 211 * that we know about. 212 */ 213 if (data_present(state, first_fdesc)) 214 dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_TITLE), INDENT, title); 215 216 state->ns_indent += INDENT_STEP; 217 } 218 static void 219 indent_exit(note_state_t *state) 220 { 221 state->ns_indent -= INDENT_STEP; 222 } 223 224 225 /* 226 * print_num outputs a field on one line, in the format: 227 * 228 * title: value 229 */ 230 static void 231 print_num(note_state_t *state, const char *title, 232 const sl_field_t *fdesc, sl_fmt_num_t fmt_type) 233 { 234 sl_fmtbuf_t buf; 235 236 /* 237 * If the field offset and extent fall past the end of the 238 * available data, then return without doing anything. That note 239 * is from an older core file that doesn't have all the fields 240 * that we know about. 241 */ 242 if (!data_present(state, fdesc)) 243 return; 244 245 dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE), INDENT, 246 state->ns_vcol - state->ns_indent, title, 247 fmt_num(state, fdesc, fmt_type, buf)); 248 } 249 250 /* 251 * print_num_2up outputs two fields on one line, in the format: 252 * 253 * title1: value1 title2: value2 254 */ 255 static void 256 print_num_2up(note_state_t *state, const char *title1, 257 const sl_field_t *fdesc1, sl_fmt_num_t fmt_type1, const char *title2, 258 const sl_field_t *fdesc2, sl_fmt_num_t fmt_type2) 259 { 260 sl_fmtbuf_t buf1, buf2; 261 262 /* 263 * If the field offset and extent fall past the end of the 264 * available data, then return without doing anything. That note 265 * is from an older core file that doesn't have all the fields 266 * that we know about. 267 */ 268 if (!(data_present(state, fdesc1) && 269 data_present(state, fdesc2))) 270 return; 271 272 dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE_2UP), INDENT, 273 state->ns_vcol - state->ns_indent, title1, 274 state->ns_t2col - state->ns_vcol, 275 fmt_num(state, fdesc1, fmt_type1, buf1), 276 state->ns_v2col - state->ns_t2col, title2, 277 fmt_num(state, fdesc2, fmt_type2, buf2)); 278 } 279 280 /* 281 * print_strbuf outputs a fixed sized character buffer field 282 * on one line, in the format: 283 * 284 * title: value 285 */ 286 static void 287 print_strbuf(note_state_t *state, const char *title, 288 const sl_field_t *fdesc) 289 { 290 Word n; 291 292 /* 293 * If we are past the end of the data area, then return 294 * without doing anything. That note is from an older core 295 * file that doesn't have all the fields that we know about. 296 * 297 * Note that we are willing to accept a partial buffer, 298 * so we don't use data_present() for this test. 299 */ 300 if (fdesc->slf_offset >= state->ns_len) 301 return; 302 303 /* 304 * We expect the full buffer to be present, but if there 305 * is less than that, we will still proceed. The use of safe_str() 306 * protects us from the effect of printing garbage data. 307 */ 308 n = state->ns_len - fdesc->slf_offset; 309 if (n > fdesc->slf_nelts) 310 n = fdesc->slf_nelts; 311 312 dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE), INDENT, 313 state->ns_vcol - state->ns_indent, 314 title, safe_str(fdesc->slf_offset + state->ns_data, n)); 315 } 316 317 /* 318 * print_str outputs an arbitrary string value item 319 * on one line, in the format: 320 * 321 * title: str 322 */ 323 static void 324 print_str(note_state_t *state, const char *title, const char *str) 325 { 326 dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE), INDENT, 327 state->ns_vcol - state->ns_indent, title, str); 328 } 329 330 /* 331 * Used when one dump function needs to call another dump function 332 * in order to display a subitem. This routine constructs a state 333 * block for the sub-region, and then calls the dump function with it. 334 * This limits the amount of data visible to the sub-function to that 335 * for the sub-item. 336 */ 337 static void 338 print_subtype(note_state_t *state, const char *title, 339 const sl_field_t *fdesc, dump_func_t dump_func) 340 { 341 note_state_t sub_state; 342 343 /* 344 * If there is no data for the sub-item, return immediately. 345 * Partial data is left to the dump function to handle, 346 * as that can be a sign of an older core file with less data, 347 * which can still be interpreted. 348 */ 349 if (fdesc->slf_offset >= state->ns_len) 350 return; 351 352 /* 353 * Construct a state block that reflects the sub-item 354 */ 355 sub_state = *state; 356 sub_state.ns_data += fdesc->slf_offset; 357 sub_state.ns_len -= fdesc->slf_offset; 358 if (sub_state.ns_len > fdesc->slf_eltlen) 359 sub_state.ns_len = fdesc->slf_eltlen; 360 361 (* dump_func)(&sub_state, title); 362 } 363 364 365 /* 366 * Output a sequence of array elements, giving each 367 * element an index, in the format: 368 * 369 * [ndx] value 370 * 371 * entry: 372 * state - Current state 373 * base_desc - Field descriptor for 1st element of array 374 * nelts - # of array elements to display 375 * check_nelts - If True (1), nelts is clipped to fdesc->slf_nelts. 376 * If False (1), nelts is not clipped. 377 * title - Name of array 378 */ 379 static void 380 print_array(note_state_t *state, const sl_field_t *base_desc, 381 sl_fmt_num_t fmt_type, int nelts, int check_nelts, const char *title) 382 { 383 char index1[MAXNDXSIZE], index2[MAXNDXSIZE]; 384 int i; 385 sl_field_t fdesc1, fdesc2; 386 387 if (check_nelts && (check_nelts > base_desc->slf_nelts)) 388 nelts = base_desc->slf_nelts; 389 if (nelts == 0) 390 return; 391 392 indent_enter(state, title, base_desc); 393 394 fdesc1 = fdesc2 = *base_desc; 395 for (i = 0; i < nelts; ) { 396 if (i == (nelts - 1)) { 397 /* One final value is left */ 398 if (!data_present(state, &fdesc1)) 399 break; 400 (void) snprintf(index1, sizeof (index1), 401 MSG_ORIG(MSG_FMT_INDEX2), EC_WORD(i)); 402 print_num(state, index1, &fdesc1, fmt_type); 403 fdesc1.slf_offset += fdesc1.slf_eltlen; 404 i++; 405 continue; 406 } 407 408 /* There are at least 2 items left. Show 2 up. */ 409 fdesc2.slf_offset = fdesc1.slf_offset + fdesc1.slf_eltlen; 410 if (!(data_present(state, &fdesc1) && 411 data_present(state, &fdesc2))) 412 break; 413 (void) snprintf(index1, sizeof (index1), 414 MSG_ORIG(MSG_FMT_INDEX2), EC_WORD(i)); 415 (void) snprintf(index2, sizeof (index2), 416 MSG_ORIG(MSG_FMT_INDEX2), EC_WORD(i + 1)); 417 print_num_2up(state, index1, &fdesc1, fmt_type, 418 index2, &fdesc2, fmt_type); 419 fdesc1.slf_offset += 2 * fdesc1.slf_eltlen; 420 i += 2; 421 } 422 423 indent_exit(state); 424 } 425 426 427 /* 428 * Output information from auxv_t structure. 429 */ 430 static void 431 dump_auxv(note_state_t *state, const char *title) 432 { 433 const sl_auxv_layout_t *layout = state->ns_arch->auxv; 434 union { 435 Conv_cap_val_hw1_buf_t hw1; 436 Conv_cap_val_hw2_buf_t hw2; 437 Conv_cnote_auxv_af_buf_t auxv_af; 438 Conv_ehdr_flags_buf_t ehdr_flags; 439 Conv_inv_buf_t inv; 440 } conv_buf; 441 sl_fmtbuf_t buf; 442 int ndx, ndx_start; 443 Word sizeof_auxv; 444 445 sizeof_auxv = layout->sizeof_struct.slf_eltlen; 446 447 indent_enter(state, title, &layout->sizeof_struct); 448 449 /* 450 * Immediate indent_exit() restores the indent level to 451 * that of the title. We include indentation as part of 452 * the index string, which is right justified, and don't 453 * want the usual indentation spacing. 454 */ 455 indent_exit(state); 456 457 ndx = 0; 458 while (state->ns_len > sizeof_auxv) { 459 char index[(MAXNDXSIZE * 2) + 1]; 460 sl_fmt_num_t num_fmt = SL_FMT_NUM_ZHEX; 461 const char *vstr = NULL; 462 Word w; 463 int type; 464 sl_field_t a_type_next; 465 466 type = extract_as_word(state, &layout->a_type); 467 ndx_start = ndx; 468 switch (type) { 469 case AT_NULL: 470 a_type_next = layout->a_type; 471 a_type_next.slf_offset += sizeof_auxv; 472 while ((state->ns_len - sizeof_auxv) >= sizeof_auxv) { 473 type = extract_as_word(state, &a_type_next); 474 if (type != AT_NULL) 475 break; 476 ndx++; 477 state->ns_data += sizeof_auxv; 478 state->ns_len -= sizeof_auxv; 479 } 480 num_fmt = SL_FMT_NUM_HEX; 481 break; 482 483 484 485 case AT_IGNORE: 486 case AT_SUN_IFLUSH: 487 num_fmt = SL_FMT_NUM_HEX; 488 break; 489 490 case AT_EXECFD: 491 case AT_PHENT: 492 case AT_PHNUM: 493 case AT_PAGESZ: 494 case AT_SUN_UID: 495 case AT_SUN_RUID: 496 case AT_SUN_GID: 497 case AT_SUN_RGID: 498 case AT_SUN_LPAGESZ: 499 num_fmt = SL_FMT_NUM_DEC; 500 break; 501 502 case AT_FLAGS: /* processor flags */ 503 w = extract_as_word(state, &layout->a_val); 504 vstr = conv_ehdr_flags(state->ns_mach, w, 505 0, &conv_buf.ehdr_flags); 506 break; 507 508 case AT_SUN_HWCAP: 509 w = extract_as_word(state, &layout->a_val); 510 vstr = conv_cap_val_hw1(w, state->ns_mach, 511 0, &conv_buf.hw1); 512 /* 513 * conv_cap_val_hw1() produces output like: 514 * 515 * 0xfff [ flg1 flg2 0xff] 516 * 517 * where the first hex value is the complete value, 518 * and the second is the leftover bits. We only 519 * want the part in brackets, and failing that, 520 * would rather fall back to formatting the full 521 * value ourselves. 522 */ 523 while ((*vstr != '\0') && (*vstr != '[')) 524 vstr++; 525 if (*vstr != '[') 526 vstr = NULL; 527 num_fmt = SL_FMT_NUM_HEX; 528 break; 529 case AT_SUN_HWCAP2: 530 w = extract_as_word(state, &layout->a_val); 531 vstr = conv_cap_val_hw2(w, state->ns_mach, 532 0, &conv_buf.hw2); 533 /* 534 * conv_cap_val_hw2() produces output like: 535 * 536 * 0xfff [ flg1 flg2 0xff] 537 * 538 * where the first hex value is the complete value, 539 * and the second is the leftover bits. We only 540 * want the part in brackets, and failing that, 541 * would rather fall back to formatting the full 542 * value ourselves. 543 */ 544 while ((*vstr != '\0') && (*vstr != '[')) 545 vstr++; 546 if (*vstr != '[') 547 vstr = NULL; 548 num_fmt = SL_FMT_NUM_HEX; 549 break; 550 551 552 553 case AT_SUN_AUXFLAGS: 554 w = extract_as_word(state, &layout->a_val); 555 vstr = conv_cnote_auxv_af(w, 0, &conv_buf.auxv_af); 556 num_fmt = SL_FMT_NUM_HEX; 557 break; 558 } 559 560 if (ndx == ndx_start) 561 (void) snprintf(index, sizeof (index), 562 MSG_ORIG(MSG_FMT_INDEX2), EC_WORD(ndx)); 563 else 564 (void) snprintf(index, sizeof (index), 565 MSG_ORIG(MSG_FMT_INDEXRNG), 566 EC_WORD(ndx_start), EC_WORD(ndx)); 567 568 if (vstr == NULL) 569 vstr = fmt_num(state, &layout->a_val, num_fmt, buf); 570 dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_AUXVLINE), INDENT, index, 571 state->ns_vcol - state->ns_indent, 572 conv_cnote_auxv_type(type, CONV_FMT_DECIMAL, 573 &conv_buf.inv), vstr); 574 575 state->ns_data += sizeof_auxv; 576 state->ns_len -= sizeof_auxv; 577 ndx++; 578 } 579 } 580 581 582 /* 583 * Output information from fltset_t structure. 584 */ 585 static void 586 dump_fltset(note_state_t *state, const char *title) 587 { 588 #define NELTS 4 589 590 const sl_fltset_layout_t *layout = state->ns_arch->fltset; 591 Conv_cnote_fltset_buf_t buf; 592 sl_field_t fdesc; 593 uint32_t mask[NELTS]; 594 int i, nelts; 595 596 if (!data_present(state, &layout->sizeof_struct)) 597 return; 598 599 fdesc = layout->word; 600 nelts = fdesc.slf_nelts; 601 if (nelts > NELTS) /* Type has grown? Show what we understand */ 602 nelts = NELTS; 603 for (i = 0; i < nelts; i++) { 604 mask[i] = extract_as_word(state, &fdesc); 605 fdesc.slf_offset += fdesc.slf_eltlen; 606 } 607 608 print_str(state, title, conv_cnote_fltset(mask, nelts, 0, &buf)); 609 610 #undef NELTS 611 } 612 613 614 /* 615 * Output information from sigset_t structure. 616 */ 617 static void 618 dump_sigset(note_state_t *state, const char *title) 619 { 620 #define NELTS 4 621 622 const sl_sigset_layout_t *layout = state->ns_arch->sigset; 623 Conv_cnote_sigset_buf_t buf; 624 sl_field_t fdesc; 625 uint32_t mask[NELTS]; 626 int i, nelts; 627 628 if (!data_present(state, &layout->sizeof_struct)) 629 return; 630 631 fdesc = layout->sigbits; 632 nelts = fdesc.slf_nelts; 633 if (nelts > NELTS) /* Type has grown? Show what we understand */ 634 nelts = NELTS; 635 for (i = 0; i < nelts; i++) { 636 mask[i] = extract_as_word(state, &fdesc); 637 fdesc.slf_offset += fdesc.slf_eltlen; 638 } 639 640 print_str(state, title, conv_cnote_sigset(mask, nelts, 0, &buf)); 641 642 #undef NELTS 643 } 644 645 646 /* 647 * Output information from sigaction structure. 648 */ 649 static void 650 dump_sigaction(note_state_t *state, const char *title) 651 { 652 const sl_sigaction_layout_t *layout = state->ns_arch->sigaction; 653 Conv_cnote_sa_flags_buf_t conv_buf; 654 Word w; 655 656 indent_enter(state, title, &layout->sa_flags); 657 658 if (data_present(state, &layout->sa_flags)) { 659 w = extract_as_word(state, &layout->sa_flags); 660 print_str(state, MSG_ORIG(MSG_CNOTE_T_SA_FLAGS), 661 conv_cnote_sa_flags(w, 0, &conv_buf)); 662 } 663 664 PRINT_ZHEX_2UP(MSG_ORIG(MSG_CNOTE_T_SA_HANDLER), sa_hand, 665 MSG_ORIG(MSG_CNOTE_T_SA_SIGACTION), sa_sigact); 666 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_SA_MASK), sa_mask, dump_sigset); 667 668 indent_exit(state); 669 } 670 671 672 /* 673 * Output information from siginfo structure. 674 */ 675 static void 676 dump_siginfo(note_state_t *state, const char *title) 677 { 678 const sl_siginfo_layout_t *layout = state->ns_arch->siginfo; 679 Conv_inv_buf_t inv_buf; 680 Word w; 681 int v_si_code, v_si_signo; 682 683 if (!data_present(state, &layout->sizeof_struct)) 684 return; 685 686 indent_enter(state, title, &layout->f_si_signo); 687 688 v_si_signo = extract_as_sword(state, &layout->f_si_signo); 689 print_str(state, MSG_ORIG(MSG_CNOTE_T_SI_SIGNO), 690 conv_cnote_signal(v_si_signo, CONV_FMT_DECIMAL, &inv_buf)); 691 692 w = extract_as_word(state, &layout->f_si_errno); 693 print_str(state, MSG_ORIG(MSG_CNOTE_T_SI_ERRNO), 694 conv_cnote_errno(w, CONV_FMT_DECIMAL, &inv_buf)); 695 696 v_si_code = extract_as_sword(state, &layout->f_si_code); 697 print_str(state, MSG_ORIG(MSG_CNOTE_T_SI_CODE), 698 conv_cnote_si_code(state->ns_mach, v_si_signo, v_si_code, 699 CONV_FMT_DECIMAL, &inv_buf)); 700 701 if ((v_si_signo == 0) || (v_si_code == SI_NOINFO)) { 702 indent_exit(state); 703 return; 704 } 705 706 /* User generated signals have (si_code <= 0) */ 707 if (v_si_code <= 0) { 708 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_SI_PID), f_si_pid); 709 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_SI_UID), f_si_uid); 710 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_SI_CTID), f_si_ctid); 711 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_SI_ZONEID), f_si_zoneid); 712 switch (v_si_code) { 713 case SI_QUEUE: 714 case SI_TIMER: 715 case SI_ASYNCIO: 716 case SI_MESGQ: 717 indent_enter(state, MSG_ORIG(MSG_CNOTE_T_SI_VALUE), 718 &layout->f_si_value_int); 719 PRINT_ZHEX(MSG_ORIG(MSG_CNOTE_T_SIVAL_INT), 720 f_si_value_int); 721 PRINT_ZHEX(MSG_ORIG(MSG_CNOTE_T_SIVAL_PTR), 722 f_si_value_ptr); 723 indent_exit(state); 724 break; 725 } 726 indent_exit(state); 727 return; 728 } 729 730 /* 731 * Remaining cases are kernel generated signals. Output any 732 * signal or code specific information. 733 */ 734 if (v_si_code == SI_RCTL) 735 PRINT_HEX(MSG_ORIG(MSG_CNOTE_T_SI_ENTITY), f_si_entity); 736 switch (v_si_signo) { 737 case SIGILL: 738 case SIGFPE: 739 case SIGSEGV: 740 case SIGBUS: 741 PRINT_ZHEX(MSG_ORIG(MSG_CNOTE_T_SI_ADDR), f_si_addr); 742 break; 743 case SIGCHLD: 744 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_SI_PID), f_si_pid); 745 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_SI_STATUS), f_si_status); 746 break; 747 case SIGPOLL: 748 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_SI_BAND), f_si_band); 749 break; 750 } 751 752 indent_exit(state); 753 } 754 755 756 /* 757 * Output information from stack_t structure. 758 */ 759 static void 760 dump_stack(note_state_t *state, const char *title) 761 { 762 const sl_stack_layout_t *layout = state->ns_arch->stack; 763 Conv_cnote_ss_flags_buf_t conv_buf; 764 Word w; 765 766 indent_enter(state, title, &layout->ss_size); 767 768 print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_SS_SP), &layout->ss_sp, 769 SL_FMT_NUM_ZHEX, MSG_ORIG(MSG_CNOTE_T_SS_SIZE), &layout->ss_size, 770 SL_FMT_NUM_HEX); 771 772 if (data_present(state, &layout->ss_flags)) { 773 w = extract_as_word(state, &layout->ss_flags); 774 print_str(state, MSG_ORIG(MSG_CNOTE_T_SS_FLAGS), 775 conv_cnote_ss_flags(w, 0, &conv_buf)); 776 } 777 778 indent_exit(state); 779 } 780 781 782 /* 783 * Output information from sysset_t structure. 784 */ 785 static void 786 dump_sysset(note_state_t *state, const char *title) 787 { 788 #define NELTS 16 789 790 const sl_sysset_layout_t *layout = state->ns_arch->sysset; 791 Conv_cnote_sysset_buf_t buf; 792 sl_field_t fdesc; 793 uint32_t mask[NELTS]; 794 int i, nelts; 795 796 if (!data_present(state, &layout->sizeof_struct)) 797 return; 798 799 fdesc = layout->word; 800 nelts = fdesc.slf_nelts; 801 if (nelts > NELTS) /* Type has grown? Show what we understand */ 802 nelts = NELTS; 803 for (i = 0; i < nelts; i++) { 804 mask[i] = extract_as_word(state, &fdesc); 805 fdesc.slf_offset += fdesc.slf_eltlen; 806 } 807 808 print_str(state, title, conv_cnote_sysset(mask, nelts, 0, &buf)); 809 810 #undef NELTS 811 } 812 813 814 /* 815 * Output information from timestruc_t structure. 816 */ 817 static void 818 dump_timestruc(note_state_t *state, const char *title) 819 { 820 const sl_timestruc_layout_t *layout = state->ns_arch->timestruc; 821 822 indent_enter(state, title, &layout->tv_sec); 823 824 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_TV_SEC), tv_sec, 825 MSG_ORIG(MSG_CNOTE_T_TV_NSEC), tv_nsec); 826 827 indent_exit(state); 828 } 829 830 831 /* 832 * Output information from utsname structure. 833 */ 834 static void 835 dump_utsname(note_state_t *state, const char *title) 836 { 837 const sl_utsname_layout_t *layout = state->ns_arch->utsname; 838 839 indent_enter(state, title, &layout->sysname); 840 841 PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_UTS_SYSNAME), sysname); 842 PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_UTS_NODENAME), nodename); 843 PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_UTS_RELEASE), release); 844 PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_UTS_VERSION), version); 845 PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_UTS_MACHINE), machine); 846 847 indent_exit(state); 848 } 849 850 851 /* 852 * Dump register contents 853 */ 854 static void 855 dump_prgregset(note_state_t *state, const char *title) 856 { 857 sl_field_t fdesc1, fdesc2; 858 sl_fmtbuf_t buf1, buf2; 859 Conv_inv_buf_t inv_buf1, inv_buf2; 860 Word w; 861 862 fdesc1 = fdesc2 = state->ns_arch->prgregset->elt0; 863 indent_enter(state, title, &fdesc1); 864 865 for (w = 0; w < fdesc1.slf_nelts; ) { 866 if (w == (fdesc1.slf_nelts - 1)) { 867 /* One last register is left */ 868 if (!data_present(state, &fdesc1)) 869 break; 870 dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE), 871 INDENT, state->ns_vcol - state->ns_indent, 872 conv_cnote_pr_regname(state->ns_mach, w, 873 CONV_FMT_DECIMAL, &inv_buf1), 874 fmt_num(state, &fdesc1, SL_FMT_NUM_ZHEX, buf1)); 875 fdesc1.slf_offset += fdesc1.slf_eltlen; 876 w++; 877 continue; 878 } 879 880 /* There are at least 2 more registers left. Show 2 up */ 881 fdesc2.slf_offset = fdesc1.slf_offset + fdesc1.slf_eltlen; 882 if (!(data_present(state, &fdesc1) && 883 data_present(state, &fdesc2))) 884 break; 885 dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE_2UP), INDENT, 886 state->ns_vcol - state->ns_indent, 887 conv_cnote_pr_regname(state->ns_mach, w, 888 CONV_FMT_DECIMAL, &inv_buf1), 889 state->ns_t2col - state->ns_vcol, 890 fmt_num(state, &fdesc1, SL_FMT_NUM_ZHEX, buf1), 891 state->ns_v2col - state->ns_t2col, 892 conv_cnote_pr_regname(state->ns_mach, w + 1, 893 CONV_FMT_DECIMAL, &inv_buf2), 894 fmt_num(state, &fdesc2, SL_FMT_NUM_ZHEX, buf2)); 895 fdesc1.slf_offset += 2 * fdesc1.slf_eltlen; 896 w += 2; 897 } 898 899 indent_exit(state); 900 } 901 902 /* 903 * Output information from lwpstatus_t structure. 904 */ 905 static void 906 dump_lwpstatus(note_state_t *state, const char *title) 907 { 908 const sl_lwpstatus_layout_t *layout = state->ns_arch->lwpstatus; 909 Word w, w2; 910 int32_t i; 911 union { 912 Conv_inv_buf_t inv; 913 Conv_cnote_pr_flags_buf_t flags; 914 } conv_buf; 915 916 indent_enter(state, title, &layout->pr_flags); 917 918 if (data_present(state, &layout->pr_flags)) { 919 w = extract_as_word(state, &layout->pr_flags); 920 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_FLAGS), 921 conv_cnote_pr_flags(w, 0, &conv_buf.flags)); 922 } 923 924 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_LWPID), pr_lwpid); 925 926 if (data_present(state, &layout->pr_why)) { 927 w = extract_as_word(state, &layout->pr_why); 928 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_WHY), 929 conv_cnote_pr_why(w, 0, &conv_buf.inv)); 930 931 if (data_present(state, &layout->pr_what)) { 932 w2 = extract_as_word(state, &layout->pr_what); 933 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_WHAT), 934 conv_cnote_pr_what(w, w2, 0, &conv_buf.inv)); 935 } 936 } 937 938 if (data_present(state, &layout->pr_cursig)) { 939 w = extract_as_word(state, &layout->pr_cursig); 940 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_CURSIG), 941 conv_cnote_signal(w, CONV_FMT_DECIMAL, &conv_buf.inv)); 942 } 943 944 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_INFO), pr_info, dump_siginfo); 945 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_LWPPEND), pr_lwppend, 946 dump_sigset); 947 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_LWPHOLD), pr_lwphold, 948 dump_sigset); 949 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_ACTION), pr_action, 950 dump_sigaction); 951 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_ALTSTACK), pr_altstack, 952 dump_stack); 953 954 PRINT_ZHEX(MSG_ORIG(MSG_CNOTE_T_PR_OLDCONTEXT), pr_oldcontext); 955 956 if (data_present(state, &layout->pr_syscall)) { 957 w = extract_as_word(state, &layout->pr_syscall); 958 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_SYSCALL), 959 conv_cnote_syscall(w, CONV_FMT_DECIMAL, &conv_buf.inv)); 960 } 961 962 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_NSYSARG), pr_nsysarg); 963 964 if (data_present(state, &layout->pr_errno)) { 965 w = extract_as_word(state, &layout->pr_errno); 966 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_ERRNO), 967 conv_cnote_errno(w, CONV_FMT_DECIMAL, &conv_buf.inv)); 968 } 969 970 if (data_present(state, &layout->pr_nsysarg)) { 971 w2 = extract_as_word(state, &layout->pr_nsysarg); 972 print_array(state, &layout->pr_sysarg, SL_FMT_NUM_ZHEX, w2, 1, 973 MSG_ORIG(MSG_CNOTE_T_PR_SYSARG)); 974 } 975 976 PRINT_HEX_2UP(MSG_ORIG(MSG_CNOTE_T_PR_RVAL1), pr_rval1, 977 MSG_ORIG(MSG_CNOTE_T_PR_RVAL2), pr_rval2); 978 PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_CLNAME), pr_clname); 979 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_TSTAMP), pr_tstamp, 980 dump_timestruc); 981 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_UTIME), pr_utime, dump_timestruc); 982 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_STIME), pr_stime, dump_timestruc); 983 984 if (data_present(state, &layout->pr_errpriv)) { 985 i = extract_as_sword(state, &layout->pr_errpriv); 986 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_ERRPRIV), 987 conv_cnote_priv(i, CONV_FMT_DECIMAL, &conv_buf.inv)); 988 } 989 990 PRINT_ZHEX_2UP(MSG_ORIG(MSG_CNOTE_T_PR_USTACK), pr_ustack, 991 MSG_ORIG(MSG_CNOTE_T_PR_INSTR), pr_instr); 992 993 /* 994 * In order to line up all the values in a single column, 995 * we would have to set vcol to a very high value, which results 996 * in ugly looking output that runs off column 80. So, we use 997 * two levels of vcol, one for the contents so far, and a 998 * higher one for the pr_reg sub-struct. 999 */ 1000 state->ns_vcol += 3; 1001 state->ns_t2col += 3; 1002 state->ns_v2col += 2; 1003 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_REG), pr_reg, dump_prgregset); 1004 state->ns_vcol -= 3; 1005 state->ns_t2col -= 3; 1006 state->ns_v2col -= 2; 1007 1008 /* 1009 * The floating point register state is complex, and highly 1010 * platform dependent. For now, we simply display it as 1011 * a hex dump. This can be replaced if better information 1012 * is required. 1013 */ 1014 if (data_present(state, &layout->pr_fpreg)) { 1015 indent_enter(state, MSG_ORIG(MSG_CNOTE_T_PR_FPREG), 1016 &layout->pr_fpreg); 1017 dump_hex_bytes(layout->pr_fpreg.slf_offset + state->ns_data, 1018 layout->pr_fpreg.slf_eltlen, state->ns_indent, 4, 3); 1019 indent_exit(state); 1020 } 1021 1022 indent_exit(state); 1023 } 1024 1025 1026 /* 1027 * Output information from pstatus_t structure. 1028 */ 1029 static void 1030 dump_pstatus(note_state_t *state, const char *title) 1031 { 1032 const sl_pstatus_layout_t *layout = state->ns_arch->pstatus; 1033 Word w; 1034 union { 1035 Conv_inv_buf_t inv; 1036 Conv_cnote_pr_flags_buf_t flags; 1037 } conv_buf; 1038 1039 indent_enter(state, title, &layout->pr_flags); 1040 1041 if (data_present(state, &layout->pr_flags)) { 1042 w = extract_as_word(state, &layout->pr_flags); 1043 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_FLAGS), 1044 conv_cnote_pr_flags(w, 0, &conv_buf.flags)); 1045 } 1046 1047 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_NLWP), pr_nlwp); 1048 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_PID), pr_pid, 1049 MSG_ORIG(MSG_CNOTE_T_PR_PPID), pr_ppid); 1050 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_PGID), pr_pgid, 1051 MSG_ORIG(MSG_CNOTE_T_PR_SID), pr_sid); 1052 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_ASLWPID), pr_aslwpid, 1053 MSG_ORIG(MSG_CNOTE_T_PR_AGENTID), pr_agentid); 1054 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_SIGPEND), pr_sigpend, 1055 dump_sigset); 1056 print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_BRKBASE), 1057 &layout->pr_brkbase, SL_FMT_NUM_ZHEX, 1058 MSG_ORIG(MSG_CNOTE_T_PR_BRKSIZE), 1059 &layout->pr_brksize, SL_FMT_NUM_HEX); 1060 print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_STKBASE), 1061 &layout->pr_stkbase, SL_FMT_NUM_ZHEX, 1062 MSG_ORIG(MSG_CNOTE_T_PR_STKSIZE), 1063 &layout->pr_stksize, SL_FMT_NUM_HEX); 1064 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_UTIME), pr_utime, dump_timestruc); 1065 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_STIME), pr_stime, dump_timestruc); 1066 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_CUTIME), pr_cutime, 1067 dump_timestruc); 1068 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_CSTIME), pr_cstime, 1069 dump_timestruc); 1070 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_SIGTRACE), pr_sigtrace, 1071 dump_sigset); 1072 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_FLTTRACE), pr_flttrace, 1073 dump_fltset); 1074 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_SYSENTRY), pr_sysentry, 1075 dump_sysset); 1076 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_SYSEXIT), pr_sysexit, 1077 dump_sysset); 1078 1079 if (data_present(state, &layout->pr_dmodel)) { 1080 w = extract_as_word(state, &layout->pr_dmodel); 1081 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_DMODEL), 1082 conv_cnote_pr_dmodel(w, 0, &conv_buf.inv)); 1083 } 1084 1085 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_TASKID), pr_taskid, 1086 MSG_ORIG(MSG_CNOTE_T_PR_PROJID), pr_projid); 1087 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_NZOMB), pr_nzomb, 1088 MSG_ORIG(MSG_CNOTE_T_PR_ZONEID), pr_zoneid); 1089 1090 /* 1091 * In order to line up all the values in a single column, 1092 * we would have to set vcol to a very high value, which results 1093 * in ugly looking output that runs off column 80. So, we use 1094 * two levels of vcol, one for the contents so far, and a 1095 * higher one for the pr_lwp sub-struct. 1096 */ 1097 state->ns_vcol += 5; 1098 state->ns_t2col += 5; 1099 state->ns_v2col += 5; 1100 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_LWP), pr_lwp, dump_lwpstatus); 1101 state->ns_vcol -= 5; 1102 state->ns_t2col -= 5; 1103 state->ns_v2col -= 5; 1104 1105 indent_exit(state); 1106 } 1107 1108 1109 /* 1110 * Output information from prstatus_t (<sys/old_procfs.h>) structure. 1111 */ 1112 static void 1113 dump_prstatus(note_state_t *state, const char *title) 1114 { 1115 const sl_prstatus_layout_t *layout = state->ns_arch->prstatus; 1116 Word w, w2; 1117 int i; 1118 union { 1119 Conv_inv_buf_t inv; 1120 Conv_cnote_old_pr_flags_buf_t flags; 1121 } conv_buf; 1122 1123 indent_enter(state, title, &layout->pr_flags); 1124 1125 if (data_present(state, &layout->pr_flags)) { 1126 w = extract_as_word(state, &layout->pr_flags); 1127 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_FLAGS), 1128 conv_cnote_old_pr_flags(w, 0, &conv_buf.flags)); 1129 } 1130 1131 if (data_present(state, &layout->pr_why)) { 1132 w = extract_as_word(state, &layout->pr_why); 1133 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_WHY), 1134 conv_cnote_pr_why(w, 0, &conv_buf.inv)); 1135 1136 1137 if (data_present(state, &layout->pr_what)) { 1138 w2 = extract_as_word(state, &layout->pr_what); 1139 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_WHAT), 1140 conv_cnote_pr_what(w, w2, 0, &conv_buf.inv)); 1141 } 1142 } 1143 1144 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_INFO), pr_info, dump_siginfo); 1145 1146 if (data_present(state, &layout->pr_cursig)) { 1147 w = extract_as_word(state, &layout->pr_cursig); 1148 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_CURSIG), 1149 conv_cnote_signal(w, CONV_FMT_DECIMAL, &conv_buf.inv)); 1150 } 1151 1152 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_NLWP), pr_nlwp); 1153 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_SIGPEND), pr_sigpend, 1154 dump_sigset); 1155 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_SIGHOLD), pr_sighold, 1156 dump_sigset); 1157 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_ALTSTACK), pr_altstack, 1158 dump_stack); 1159 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_ACTION), pr_action, 1160 dump_sigaction); 1161 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_PID), pr_pid, 1162 MSG_ORIG(MSG_CNOTE_T_PR_PPID), pr_ppid); 1163 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_PGRP), pr_pgrp, 1164 MSG_ORIG(MSG_CNOTE_T_PR_SID), pr_sid); 1165 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_UTIME), pr_utime, dump_timestruc); 1166 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_STIME), pr_stime, dump_timestruc); 1167 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_CUTIME), pr_cutime, 1168 dump_timestruc); 1169 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_CSTIME), pr_cstime, 1170 dump_timestruc); 1171 PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_CLNAME), pr_clname); 1172 1173 if (data_present(state, &layout->pr_syscall)) { 1174 w = extract_as_word(state, &layout->pr_syscall); 1175 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_SYSCALL), 1176 conv_cnote_syscall(w, CONV_FMT_DECIMAL, &conv_buf.inv)); 1177 } 1178 1179 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_NSYSARG), pr_nsysarg); 1180 1181 if (data_present(state, &layout->pr_nsysarg)) { 1182 w2 = extract_as_word(state, &layout->pr_nsysarg); 1183 print_array(state, &layout->pr_sysarg, SL_FMT_NUM_ZHEX, w2, 1, 1184 MSG_ORIG(MSG_CNOTE_T_PR_SYSARG)); 1185 } 1186 1187 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_WHO), pr_who); 1188 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_LWPPEND), pr_sigpend, 1189 dump_sigset); 1190 PRINT_ZHEX(MSG_ORIG(MSG_CNOTE_T_PR_OLDCONTEXT), pr_oldcontext); 1191 print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_BRKBASE), 1192 &layout->pr_brkbase, SL_FMT_NUM_ZHEX, 1193 MSG_ORIG(MSG_CNOTE_T_PR_BRKSIZE), 1194 &layout->pr_brksize, SL_FMT_NUM_HEX); 1195 print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_STKBASE), 1196 &layout->pr_stkbase, SL_FMT_NUM_ZHEX, 1197 MSG_ORIG(MSG_CNOTE_T_PR_STKSIZE), 1198 &layout->pr_stksize, SL_FMT_NUM_HEX); 1199 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_PROCESSOR), pr_processor); 1200 1201 if (data_present(state, &layout->pr_bind)) { 1202 i = extract_as_sword(state, &layout->pr_bind); 1203 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_BIND), 1204 conv_cnote_psetid(i, CONV_FMT_DECIMAL, &conv_buf.inv)); 1205 } 1206 1207 PRINT_ZHEX(MSG_ORIG(MSG_CNOTE_T_PR_INSTR), pr_instr); 1208 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_REG), pr_reg, dump_prgregset); 1209 1210 indent_exit(state); 1211 } 1212 1213 1214 /* 1215 * Print percent from 16-bit binary fraction [0 .. 1] 1216 * Round up .01 to .1 to indicate some small percentage (the 0x7000 below). 1217 * 1218 * Note: This routine was copied from ps(1) and then modified. 1219 */ 1220 static const char * 1221 prtpct_value(note_state_t *state, const sl_field_t *fdesc, 1222 sl_fmtbuf_t buf) 1223 { 1224 uint_t value; /* need 32 bits to compute with */ 1225 1226 value = extract_as_word(state, fdesc); 1227 value = ((value * 1000) + 0x7000) >> 15; /* [0 .. 1000] */ 1228 if (value >= 1000) 1229 value = 999; 1230 1231 (void) snprintf(buf, sizeof (sl_fmtbuf_t), 1232 MSG_ORIG(MSG_CNOTE_FMT_PRTPCT), value / 10, value % 10); 1233 1234 return (buf); 1235 } 1236 1237 1238 1239 /* 1240 * Version of prtpct() used for a 2-up display of two adjacent percentages. 1241 */ 1242 static void 1243 prtpct_2up(note_state_t *state, const sl_field_t *fdesc1, 1244 const char *title1, const sl_field_t *fdesc2, const char *title2) 1245 { 1246 sl_fmtbuf_t buf1, buf2; 1247 1248 if (!(data_present(state, fdesc1) && 1249 data_present(state, fdesc2))) 1250 return; 1251 1252 dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE_2UP), INDENT, 1253 state->ns_vcol - state->ns_indent, title1, 1254 state->ns_t2col - state->ns_vcol, 1255 prtpct_value(state, fdesc1, buf1), 1256 state->ns_v2col - state->ns_t2col, title2, 1257 prtpct_value(state, fdesc2, buf2)); 1258 } 1259 1260 1261 /* 1262 * The psinfo_t and prpsinfo_t structs have pr_state and pr_sname 1263 * fields that we wish to print in a 2up format. The pr_state is 1264 * an integer, while pr_sname is a single character. 1265 */ 1266 static void 1267 print_state_sname_2up(note_state_t *state, 1268 const sl_field_t *state_fdesc, 1269 const sl_field_t *sname_fdesc) 1270 { 1271 sl_fmtbuf_t buf1, buf2; 1272 int sname; 1273 1274 /* 1275 * If the field slf_offset and extent fall past the end of the 1276 * available data, then return without doing anything. That note 1277 * is from an older core file that doesn't have all the fields 1278 * that we know about. 1279 */ 1280 if (!(data_present(state, state_fdesc) && 1281 data_present(state, sname_fdesc))) 1282 return; 1283 1284 sname = extract_as_sword(state, sname_fdesc); 1285 buf2[0] = sname; 1286 buf2[1] = '\0'; 1287 1288 dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE_2UP), INDENT, 1289 state->ns_vcol - state->ns_indent, MSG_ORIG(MSG_CNOTE_T_PR_STATE), 1290 state->ns_t2col - state->ns_vcol, 1291 fmt_num(state, state_fdesc, SL_FMT_NUM_DEC, buf1), 1292 state->ns_v2col - state->ns_t2col, MSG_ORIG(MSG_CNOTE_T_PR_SNAME), 1293 buf2); 1294 } 1295 1296 /* 1297 * Output information from lwpsinfo_t structure. 1298 */ 1299 static void 1300 dump_lwpsinfo(note_state_t *state, const char *title) 1301 { 1302 const sl_lwpsinfo_layout_t *layout = state->ns_arch->lwpsinfo; 1303 Word w; 1304 int32_t i; 1305 union { 1306 Conv_cnote_proc_flag_buf_t proc_flag; 1307 Conv_inv_buf_t inv; 1308 } conv_buf; 1309 1310 indent_enter(state, title, &layout->pr_flag); 1311 1312 if (data_present(state, &layout->pr_flag)) { 1313 w = extract_as_word(state, &layout->pr_flag); 1314 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_FLAG), 1315 conv_cnote_proc_flag(w, 0, &conv_buf.proc_flag)); 1316 } 1317 1318 print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_LWPID), &layout->pr_lwpid, 1319 SL_FMT_NUM_DEC, MSG_ORIG(MSG_CNOTE_T_PR_ADDR), &layout->pr_addr, 1320 SL_FMT_NUM_ZHEX); 1321 PRINT_HEX(MSG_ORIG(MSG_CNOTE_T_PR_WCHAN), pr_wchan); 1322 1323 if (data_present(state, &layout->pr_stype)) { 1324 w = extract_as_word(state, &layout->pr_stype); 1325 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_STYPE), 1326 conv_cnote_pr_stype(w, CONV_FMT_DECIMAL, &conv_buf.inv)); 1327 } 1328 1329 print_state_sname_2up(state, &layout->pr_state, &layout->pr_sname); 1330 1331 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_NICE), pr_nice); 1332 1333 if (data_present(state, &layout->pr_syscall)) { 1334 w = extract_as_word(state, &layout->pr_syscall); 1335 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_SYSCALL), 1336 conv_cnote_syscall(w, CONV_FMT_DECIMAL, &conv_buf.inv)); 1337 } 1338 1339 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_OLDPRI), pr_oldpri, 1340 MSG_ORIG(MSG_CNOTE_T_PR_CPU), pr_cpu); 1341 1342 if (data_present(state, &layout->pr_pri) && 1343 data_present(state, &layout->pr_pctcpu)) { 1344 sl_fmtbuf_t buf1, buf2; 1345 1346 dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE_2UP), INDENT, 1347 state->ns_vcol - state->ns_indent, 1348 MSG_ORIG(MSG_CNOTE_T_PR_PRI), 1349 state->ns_t2col - state->ns_vcol, 1350 fmt_num(state, &layout->pr_pri, SL_FMT_NUM_DEC, buf1), 1351 state->ns_v2col - state->ns_t2col, 1352 MSG_ORIG(MSG_CNOTE_T_PR_PCTCPU), 1353 prtpct_value(state, &layout->pr_pctcpu, buf2)); 1354 } 1355 1356 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_START), pr_start, dump_timestruc); 1357 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_TIME), pr_time, dump_timestruc); 1358 PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_CLNAME), pr_clname); 1359 PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_NAME), pr_name); 1360 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_ONPRO), pr_onpro, 1361 MSG_ORIG(MSG_CNOTE_T_PR_BINDPRO), pr_bindpro); 1362 1363 if (data_present(state, &layout->pr_bindpset)) { 1364 i = extract_as_sword(state, &layout->pr_bindpset); 1365 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_BINDPSET), 1366 conv_cnote_psetid(i, CONV_FMT_DECIMAL, &conv_buf.inv)); 1367 } 1368 1369 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_LGRP), pr_lgrp); 1370 1371 indent_exit(state); 1372 } 1373 1374 1375 /* 1376 * Output information from psinfo_t structure. 1377 */ 1378 static void 1379 dump_psinfo(note_state_t *state, const char *title) 1380 { 1381 const sl_psinfo_layout_t *layout = state->ns_arch->psinfo; 1382 Word w; 1383 union { 1384 Conv_cnote_proc_flag_buf_t proc_flag; 1385 Conv_inv_buf_t inv; 1386 } conv_buf; 1387 1388 indent_enter(state, title, &layout->pr_flag); 1389 1390 if (data_present(state, &layout->pr_flag)) { 1391 w = extract_as_word(state, &layout->pr_flag); 1392 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_FLAG), 1393 conv_cnote_proc_flag(w, 0, &conv_buf.proc_flag)); 1394 } 1395 1396 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_NLWP), pr_nlwp); 1397 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_PID), pr_pid, 1398 MSG_ORIG(MSG_CNOTE_T_PR_PPID), pr_ppid); 1399 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_PGID), pr_pgid, 1400 MSG_ORIG(MSG_CNOTE_T_PR_SID), pr_sid); 1401 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_UID), pr_uid, 1402 MSG_ORIG(MSG_CNOTE_T_PR_EUID), pr_euid); 1403 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_GID), pr_gid, 1404 MSG_ORIG(MSG_CNOTE_T_PR_EGID), pr_egid); 1405 print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_ADDR), &layout->pr_addr, 1406 SL_FMT_NUM_ZHEX, MSG_ORIG(MSG_CNOTE_T_PR_SIZE), &layout->pr_size, 1407 SL_FMT_NUM_HEX); 1408 print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_RSSIZE), 1409 &layout->pr_rssize, SL_FMT_NUM_HEX, MSG_ORIG(MSG_CNOTE_T_PR_TTYDEV), 1410 &layout->pr_ttydev, SL_FMT_NUM_DEC); 1411 prtpct_2up(state, &layout->pr_pctcpu, MSG_ORIG(MSG_CNOTE_T_PR_PCTCPU), 1412 &layout->pr_pctmem, MSG_ORIG(MSG_CNOTE_T_PR_PCTMEM)); 1413 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_START), pr_start, dump_timestruc); 1414 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_TIME), pr_time, dump_timestruc); 1415 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_CTIME), pr_ctime, dump_timestruc); 1416 PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_FNAME), pr_fname); 1417 PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_PSARGS), pr_psargs); 1418 print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_WSTAT), &layout->pr_wstat, 1419 SL_FMT_NUM_HEX, MSG_ORIG(MSG_CNOTE_T_PR_ARGC), &layout->pr_argc, 1420 SL_FMT_NUM_DEC); 1421 PRINT_ZHEX_2UP(MSG_ORIG(MSG_CNOTE_T_PR_ARGV), pr_argv, 1422 MSG_ORIG(MSG_CNOTE_T_PR_ENVP), pr_envp); 1423 1424 if (data_present(state, &layout->pr_dmodel)) { 1425 w = extract_as_word(state, &layout->pr_dmodel); 1426 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_DMODEL), 1427 conv_cnote_pr_dmodel(w, 0, &conv_buf.inv)); 1428 } 1429 1430 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_TASKID), pr_taskid, 1431 MSG_ORIG(MSG_CNOTE_T_PR_PROJID), pr_projid); 1432 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_NZOMB), pr_nzomb, 1433 MSG_ORIG(MSG_CNOTE_T_PR_POOLID), pr_poolid); 1434 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_ZONEID), pr_zoneid, 1435 MSG_ORIG(MSG_CNOTE_T_PR_CONTRACT), pr_contract); 1436 1437 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_LWP), pr_lwp, dump_lwpsinfo); 1438 1439 indent_exit(state); 1440 } 1441 1442 /* 1443 * Output information from prpsinfo_t structure. 1444 */ 1445 static void 1446 dump_prpsinfo(note_state_t *state, const char *title) 1447 { 1448 const sl_prpsinfo_layout_t *layout = state->ns_arch->prpsinfo; 1449 Word w; 1450 union { 1451 Conv_cnote_proc_flag_buf_t proc_flag; 1452 Conv_inv_buf_t inv; 1453 } conv_buf; 1454 1455 indent_enter(state, title, &layout->pr_state); 1456 1457 print_state_sname_2up(state, &layout->pr_state, &layout->pr_sname); 1458 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_ZOMB), pr_zomb, 1459 MSG_ORIG(MSG_CNOTE_T_PR_NICE), pr_nice); 1460 1461 if (data_present(state, &layout->pr_flag)) { 1462 w = extract_as_word(state, &layout->pr_flag); 1463 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_FLAG), 1464 conv_cnote_proc_flag(w, 0, &conv_buf.proc_flag)); 1465 } 1466 1467 1468 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_UID), pr_uid, 1469 MSG_ORIG(MSG_CNOTE_T_PR_GID), pr_gid); 1470 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_PID), pr_pid, 1471 MSG_ORIG(MSG_CNOTE_T_PR_PPID), pr_ppid); 1472 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_PGRP), pr_pgrp, 1473 MSG_ORIG(MSG_CNOTE_T_PR_SID), pr_sid); 1474 print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_ADDR), &layout->pr_addr, 1475 SL_FMT_NUM_ZHEX, MSG_ORIG(MSG_CNOTE_T_PR_SIZE), &layout->pr_size, 1476 SL_FMT_NUM_HEX); 1477 PRINT_HEX_2UP(MSG_ORIG(MSG_CNOTE_T_PR_RSSIZE), pr_rssize, 1478 MSG_ORIG(MSG_CNOTE_T_PR_WCHAN), pr_wchan); 1479 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_START), pr_start, dump_timestruc); 1480 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_TIME), pr_time, dump_timestruc); 1481 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_PRI), pr_pri, 1482 MSG_ORIG(MSG_CNOTE_T_PR_OLDPRI), pr_oldpri); 1483 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_CPU), pr_cpu); 1484 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_OTTYDEV), pr_ottydev, 1485 MSG_ORIG(MSG_CNOTE_T_PR_LTTYDEV), pr_lttydev); 1486 PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_CLNAME), pr_clname); 1487 PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_FNAME), pr_fname); 1488 PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_PSARGS), pr_psargs); 1489 1490 if (data_present(state, &layout->pr_syscall)) { 1491 w = extract_as_word(state, &layout->pr_syscall); 1492 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_SYSCALL), 1493 conv_cnote_syscall(w, CONV_FMT_DECIMAL, &conv_buf.inv)); 1494 } 1495 1496 PRINT_SUBTYPE(MSG_ORIG(MSG_CNOTE_T_PR_CTIME), pr_ctime, dump_timestruc); 1497 PRINT_HEX_2UP(MSG_ORIG(MSG_CNOTE_T_PR_BYSIZE), pr_bysize, 1498 MSG_ORIG(MSG_CNOTE_T_PR_BYRSSIZE), pr_byrssize); 1499 print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_ARGC), &layout->pr_argc, 1500 SL_FMT_NUM_DEC, MSG_ORIG(MSG_CNOTE_T_PR_ARGV), &layout->pr_argv, 1501 SL_FMT_NUM_ZHEX); 1502 print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PR_ENVP), &layout->pr_envp, 1503 SL_FMT_NUM_ZHEX, MSG_ORIG(MSG_CNOTE_T_PR_WSTAT), &layout->pr_wstat, 1504 SL_FMT_NUM_HEX); 1505 prtpct_2up(state, &layout->pr_pctcpu, MSG_ORIG(MSG_CNOTE_T_PR_PCTCPU), 1506 &layout->pr_pctmem, MSG_ORIG(MSG_CNOTE_T_PR_PCTMEM)); 1507 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_EUID), pr_euid, 1508 MSG_ORIG(MSG_CNOTE_T_PR_EGID), pr_egid); 1509 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_ASLWPID), pr_aslwpid); 1510 1511 if (data_present(state, &layout->pr_dmodel)) { 1512 w = extract_as_word(state, &layout->pr_dmodel); 1513 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_DMODEL), 1514 conv_cnote_pr_dmodel(w, 0, &conv_buf.inv)); 1515 } 1516 1517 indent_exit(state); 1518 } 1519 1520 1521 /* 1522 * Output information from prcred_t structure. 1523 */ 1524 static void 1525 dump_prcred(note_state_t *state, const char *title) 1526 { 1527 const sl_prcred_layout_t *layout = state->ns_arch->prcred; 1528 Word ngroups; 1529 1530 indent_enter(state, title, &layout->pr_euid); 1531 1532 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_EUID), pr_euid, 1533 MSG_ORIG(MSG_CNOTE_T_PR_RUID), pr_ruid); 1534 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_SUID), pr_suid, 1535 MSG_ORIG(MSG_CNOTE_T_PR_EGID), pr_egid); 1536 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_RGID), pr_rgid, 1537 MSG_ORIG(MSG_CNOTE_T_PR_SGID), pr_sgid); 1538 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_NGROUPS), pr_ngroups); 1539 1540 if (data_present(state, &layout->pr_ngroups)) { 1541 ngroups = extract_as_word(state, &layout->pr_ngroups); 1542 print_array(state, &layout->pr_groups, SL_FMT_NUM_DEC, ngroups, 1543 0, MSG_ORIG(MSG_CNOTE_T_PR_GROUPS)); 1544 } 1545 1546 indent_exit(state); 1547 } 1548 1549 1550 /* 1551 * Output information from prpriv_t structure. 1552 */ 1553 static void 1554 dump_prpriv(note_state_t *state, const char *title) 1555 { 1556 const sl_prpriv_layout_t *layout = state->ns_arch->prpriv; 1557 Word nsets; 1558 1559 indent_enter(state, title, &layout->pr_nsets); 1560 1561 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_NSETS), pr_nsets); 1562 PRINT_HEX(MSG_ORIG(MSG_CNOTE_T_PR_SETSIZE), pr_setsize); 1563 PRINT_HEX(MSG_ORIG(MSG_CNOTE_T_PR_INFOSIZE), pr_infosize); 1564 1565 if (data_present(state, &layout->pr_nsets)) { 1566 nsets = extract_as_word(state, &layout->pr_nsets); 1567 print_array(state, &layout->pr_sets, SL_FMT_NUM_ZHEX, nsets, 1568 0, MSG_ORIG(MSG_CNOTE_T_PR_SETS)); 1569 } 1570 1571 indent_exit(state); 1572 } 1573 1574 static void 1575 dump_prfdinfo(note_state_t *state, const char *title) 1576 { 1577 const sl_prfdinfo_layout_t *layout = state->ns_arch->prfdinfo; 1578 char buf[1024]; 1579 uint32_t fileflags, mode; 1580 1581 indent_enter(state, title, &layout->pr_fd); 1582 1583 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_FD), pr_fd); 1584 mode = extract_as_word(state, &layout->pr_mode); 1585 1586 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_MODE), 1587 conv_cnote_filemode(mode, 0, buf, sizeof (buf))); 1588 1589 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_UID), pr_uid, 1590 MSG_ORIG(MSG_CNOTE_T_PR_GID), pr_gid); 1591 1592 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_MAJOR), pr_major, 1593 MSG_ORIG(MSG_CNOTE_T_PR_MINOR), pr_minor); 1594 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_RMAJOR), pr_rmajor, 1595 MSG_ORIG(MSG_CNOTE_T_PR_RMINOR), pr_rminor); 1596 1597 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_INO), pr_ino); 1598 1599 PRINT_DEC_2UP(MSG_ORIG(MSG_CNOTE_T_PR_SIZE), pr_size, 1600 MSG_ORIG(MSG_CNOTE_T_PR_OFFSET), pr_offset); 1601 1602 fileflags = extract_as_word(state, &layout->pr_fileflags); 1603 1604 print_str(state, MSG_ORIG(MSG_CNOTE_T_PR_FILEFLAGS), 1605 conv_cnote_fileflags(fileflags, 0, buf, sizeof (buf))); 1606 1607 PRINT_DEC(MSG_ORIG(MSG_CNOTE_T_PR_FDFLAGS), pr_fdflags); 1608 1609 PRINT_STRBUF(MSG_ORIG(MSG_CNOTE_T_PR_PATH), pr_path); 1610 1611 indent_exit(state); 1612 } 1613 1614 /* 1615 * Output information from priv_impl_info_t structure. 1616 */ 1617 static void 1618 dump_priv_impl_info(note_state_t *state, const char *title) 1619 { 1620 const sl_priv_impl_info_layout_t *layout; 1621 1622 layout = state->ns_arch->priv_impl_info; 1623 indent_enter(state, title, &layout->priv_headersize); 1624 1625 PRINT_HEX_2UP(MSG_ORIG(MSG_CNOTE_T_PRIV_HEADERSIZE), priv_headersize, 1626 MSG_ORIG(MSG_CNOTE_T_PRIV_FLAGS), priv_flags); 1627 1628 print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PRIV_NSETS), 1629 &layout->priv_nsets, SL_FMT_NUM_DEC, 1630 MSG_ORIG(MSG_CNOTE_T_PRIV_SETSIZE), &layout->priv_setsize, 1631 SL_FMT_NUM_HEX); 1632 print_num_2up(state, MSG_ORIG(MSG_CNOTE_T_PRIV_MAX), &layout->priv_max, 1633 SL_FMT_NUM_DEC, MSG_ORIG(MSG_CNOTE_T_PRIV_INFOSIZE), 1634 &layout->priv_infosize, SL_FMT_NUM_HEX); 1635 PRINT_HEX(MSG_ORIG(MSG_CNOTE_T_PRIV_GLOBALINFOSIZE), 1636 priv_globalinfosize); 1637 1638 indent_exit(state); 1639 } 1640 1641 1642 /* 1643 * Dump information from an asrset_t array. This data 1644 * structure is specific to sparcv9, and does not appear 1645 * on any other platform. 1646 * 1647 * asrset_t is a simple array, defined in <sys/regset.h> as 1648 * typedef int64_t asrset_t[16]; %asr16 - > %asr31 1649 * 1650 * As such, we do not make use of the struct_layout facilities 1651 * for this routine. 1652 */ 1653 static void 1654 dump_asrset(note_state_t *state, const char *title) 1655 { 1656 static const sl_field_t ftemplate = { 0, sizeof (int64_t), 16, 0 }; 1657 sl_field_t fdesc1, fdesc2; 1658 sl_fmtbuf_t buf1, buf2; 1659 char index1[MAXNDXSIZE * 2], index2[MAXNDXSIZE * 2]; 1660 Word w, nelts; 1661 1662 fdesc1 = fdesc2 = ftemplate; 1663 1664 /* We expect 16 values, but will print whatever is actually there */ 1665 nelts = state->ns_len / ftemplate.slf_eltlen; 1666 if (nelts == 0) 1667 return; 1668 1669 indent_enter(state, title, &fdesc1); 1670 1671 for (w = 0; w < nelts; ) { 1672 (void) snprintf(index1, sizeof (index1), 1673 MSG_ORIG(MSG_FMT_ASRINDEX), w + 16); 1674 1675 if (w == (nelts - 1)) { 1676 /* One last register is left */ 1677 dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE), 1678 INDENT, state->ns_vcol - state->ns_indent, index1, 1679 fmt_num(state, &fdesc1, SL_FMT_NUM_ZHEX, buf1)); 1680 fdesc1.slf_offset += fdesc1.slf_eltlen; 1681 w++; 1682 continue; 1683 } 1684 1685 /* There are at least 2 more registers left. Show 2 up */ 1686 (void) snprintf(index2, sizeof (index2), 1687 MSG_ORIG(MSG_FMT_ASRINDEX), w + 17); 1688 1689 fdesc2.slf_offset = fdesc1.slf_offset + fdesc1.slf_eltlen; 1690 dbg_print(0, MSG_ORIG(MSG_CNOTE_FMT_LINE_2UP), INDENT, 1691 state->ns_vcol - state->ns_indent, index1, 1692 state->ns_t2col - state->ns_vcol, 1693 fmt_num(state, &fdesc1, SL_FMT_NUM_ZHEX, buf1), 1694 state->ns_v2col - state->ns_t2col, index2, 1695 fmt_num(state, &fdesc2, SL_FMT_NUM_ZHEX, buf2)); 1696 fdesc1.slf_offset += 2 * fdesc1.slf_eltlen; 1697 w += 2; 1698 } 1699 1700 indent_exit(state); 1701 } 1702 1703 corenote_ret_t 1704 corenote(Half mach, int do_swap, Word type, 1705 const char *desc, Word descsz) 1706 { 1707 note_state_t state; 1708 1709 /* 1710 * Get the per-architecture layout definition 1711 */ 1712 state.ns_mach = mach; 1713 state.ns_arch = sl_mach(state.ns_mach); 1714 if (sl_mach(state.ns_mach) == NULL) 1715 return (CORENOTE_R_BADARCH); 1716 1717 state.ns_swap = do_swap; 1718 state.ns_indent = 4; 1719 state.ns_t2col = state.ns_v2col = 0; 1720 state.ns_data = desc; 1721 state.ns_len = descsz; 1722 1723 switch (type) { 1724 case NT_PRSTATUS: /* prstatus_t <sys/old_procfs.h> */ 1725 state.ns_vcol = 26; 1726 state.ns_t2col = 46; 1727 state.ns_v2col = 60; 1728 dump_prstatus(&state, MSG_ORIG(MSG_CNOTE_DESC_PRSTATUS_T)); 1729 return (CORENOTE_R_OK); 1730 1731 case NT_PRFPREG: /* prfpregset_t <sys/procfs_isa.h> */ 1732 return (CORENOTE_R_OK_DUMP); 1733 1734 case NT_PRPSINFO: /* prpsinfo_t <sys/old_procfs.h> */ 1735 state.ns_vcol = 20; 1736 state.ns_t2col = 41; 1737 state.ns_v2col = 54; 1738 dump_prpsinfo(&state, MSG_ORIG(MSG_CNOTE_DESC_PRPSINFO_T)); 1739 return (CORENOTE_R_OK); 1740 1741 case NT_PRXREG: /* prxregset_t <sys/procfs_isa.h> */ 1742 return (CORENOTE_R_OK_DUMP); 1743 1744 case NT_PLATFORM: /* string from sysinfo(SI_PLATFORM) */ 1745 dbg_print(0, MSG_ORIG(MSG_NOTE_DESC)); 1746 dbg_print(0, MSG_ORIG(MSG_FMT_INDENT), safe_str(desc, descsz)); 1747 return (CORENOTE_R_OK); 1748 1749 case NT_AUXV: /* auxv_t array <sys/auxv.h> */ 1750 state.ns_vcol = 18; 1751 dump_auxv(&state, MSG_ORIG(MSG_CNOTE_DESC_AUXV_T)); 1752 return (CORENOTE_R_OK); 1753 1754 case NT_GWINDOWS: /* gwindows_t SPARC only */ 1755 return (CORENOTE_R_OK_DUMP); 1756 1757 case NT_ASRS: /* asrset_t <sys/regset> sparcv9 only */ 1758 state.ns_vcol = 18; 1759 state.ns_t2col = 38; 1760 state.ns_v2col = 46; 1761 dump_asrset(&state, MSG_ORIG(MSG_CNOTE_DESC_ASRSET_T)); 1762 return (CORENOTE_R_OK); 1763 1764 case NT_LDT: /* ssd array <sys/sysi86.h> IA32 only */ 1765 return (CORENOTE_R_OK_DUMP); 1766 1767 case NT_PSTATUS: /* pstatus_t <sys/procfs.h> */ 1768 state.ns_vcol = 22; 1769 state.ns_t2col = 42; 1770 state.ns_v2col = 54; 1771 dump_pstatus(&state, MSG_ORIG(MSG_CNOTE_DESC_PSTATUS_T)); 1772 return (CORENOTE_R_OK); 1773 1774 case NT_PSINFO: /* psinfo_t <sys/procfs.h> */ 1775 state.ns_vcol = 25; 1776 state.ns_t2col = 45; 1777 state.ns_v2col = 58; 1778 dump_psinfo(&state, MSG_ORIG(MSG_CNOTE_DESC_PSINFO_T)); 1779 return (CORENOTE_R_OK); 1780 1781 case NT_PRCRED: /* prcred_t <sys/procfs.h> */ 1782 state.ns_vcol = 20; 1783 state.ns_t2col = 34; 1784 state.ns_v2col = 44; 1785 dump_prcred(&state, MSG_ORIG(MSG_CNOTE_DESC_PRCRED_T)); 1786 return (CORENOTE_R_OK); 1787 1788 case NT_UTSNAME: /* struct utsname <sys/utsname.h> */ 1789 state.ns_vcol = 18; 1790 dump_utsname(&state, MSG_ORIG(MSG_CNOTE_DESC_STRUCT_UTSNAME)); 1791 return (CORENOTE_R_OK); 1792 1793 case NT_LWPSTATUS: /* lwpstatus_t <sys/procfs.h> */ 1794 state.ns_vcol = 24; 1795 state.ns_t2col = 44; 1796 state.ns_v2col = 54; 1797 dump_lwpstatus(&state, MSG_ORIG(MSG_CNOTE_DESC_LWPSTATUS_T)); 1798 return (CORENOTE_R_OK); 1799 1800 case NT_LWPSINFO: /* lwpsinfo_t <sys/procfs.h> */ 1801 state.ns_vcol = 22; 1802 state.ns_t2col = 42; 1803 state.ns_v2col = 54; 1804 dump_lwpsinfo(&state, MSG_ORIG(MSG_CNOTE_DESC_LWPSINFO_T)); 1805 return (CORENOTE_R_OK); 1806 1807 case NT_PRPRIV: /* prpriv_t <sys/procfs.h> */ 1808 state.ns_vcol = 21; 1809 state.ns_t2col = 34; 1810 state.ns_v2col = 38; 1811 dump_prpriv(&state, MSG_ORIG(MSG_CNOTE_DESC_PRPRIV_T)); 1812 return (CORENOTE_R_OK); 1813 1814 case NT_PRPRIVINFO: /* priv_impl_info_t <sys/priv.h> */ 1815 state.ns_vcol = 29; 1816 state.ns_t2col = 41; 1817 state.ns_v2col = 56; 1818 dump_priv_impl_info(&state, 1819 MSG_ORIG(MSG_CNOTE_DESC_PRIV_IMPL_INFO_T)); 1820 return (CORENOTE_R_OK); 1821 1822 case NT_CONTENT: /* core_content_t <sys/corectl.h> */ 1823 if (sizeof (core_content_t) > descsz) 1824 return (CORENOTE_R_BADDATA); 1825 { 1826 static sl_field_t fdesc = { 0, 8, 0, 0 }; 1827 Conv_cnote_cc_content_buf_t conv_buf; 1828 core_content_t content; 1829 1830 state.ns_vcol = 8; 1831 indent_enter(&state, 1832 MSG_ORIG(MSG_CNOTE_DESC_CORE_CONTENT_T), 1833 &fdesc); 1834 content = extract_as_lword(&state, &fdesc); 1835 print_str(&state, MSG_ORIG(MSG_STR_EMPTY), 1836 conv_cnote_cc_content(content, 0, &conv_buf)); 1837 indent_exit(&state); 1838 } 1839 return (CORENOTE_R_OK); 1840 1841 case NT_ZONENAME: /* string from getzonenamebyid(3C) */ 1842 dbg_print(0, MSG_ORIG(MSG_NOTE_DESC)); 1843 dbg_print(0, MSG_ORIG(MSG_FMT_INDENT), safe_str(desc, descsz)); 1844 return (CORENOTE_R_OK); 1845 1846 1847 case NT_FDINFO: 1848 state.ns_vcol = 22; 1849 state.ns_t2col = 41; 1850 state.ns_v2col = 54; 1851 dump_prfdinfo(&state, MSG_ORIG(MSG_CNOTE_DESC_PRFDINFO_T)); 1852 return (CORENOTE_R_OK); 1853 1854 case NT_SPYMASTER: 1855 state.ns_vcol = 25; 1856 state.ns_t2col = 45; 1857 state.ns_v2col = 58; 1858 dump_psinfo(&state, MSG_ORIG(MSG_CNOTE_DESC_PSINFO_T)); 1859 return (CORENOTE_R_OK); 1860 } 1861 1862 return (CORENOTE_R_BADTYPE); 1863 } 1864