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