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 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 /* 26 * Copyright (c) 2011 by Delphix. All rights reserved. 27 */ 28 /* 29 * Copyright (c) 2013, Joyent, Inc. All rights reserved. 30 */ 31 32 /* 33 * DTrace print() action 34 * 35 * This file contains the post-processing logic for the print() action. The 36 * print action behaves identically to trace() in that it generates a 37 * DTRACEACT_DIFEXPR action, but the action argument field refers to a CTF type 38 * string stored in the DOF string table (similar to printf formats). We 39 * take the result of the trace action and post-process it in the fashion of 40 * MDB's ::print dcmd. 41 * 42 * This implementation differs from MDB's in the following ways: 43 * 44 * - We do not expose any options or flags. The behavior of print() is 45 * equivalent to "::print -tn". 46 * 47 * - MDB will display "holes" in structures (unused padding between 48 * members). 49 * 50 * - When printing arrays of structures, MDB will leave a trailing ',' 51 * after the last element. 52 * 53 * - MDB will print time_t types as date and time. 54 * 55 * - MDB will detect when an enum is actually the OR of several flags, 56 * and print it out with the constituent flags separated. 57 * 58 * - For large arrays, MDB will print the first few members and then 59 * print a "..." continuation line. 60 * 61 * - MDB will break and wrap arrays at 80 columns. 62 * 63 * - MDB prints out floats and doubles by hand, as it must run in kmdb 64 * context. We're able to leverage the printf() format strings, 65 * but the result is a slightly different format. 66 */ 67 68 #include <sys/sysmacros.h> 69 #include <strings.h> 70 #include <stdlib.h> 71 #include <alloca.h> 72 #include <assert.h> 73 #include <ctype.h> 74 #include <errno.h> 75 #include <limits.h> 76 #include <sys/socket.h> 77 #include <netdb.h> 78 #include <netinet/in.h> 79 #include <arpa/inet.h> 80 #include <arpa/nameser.h> 81 82 #include <dt_module.h> 83 #include <dt_printf.h> 84 #include <dt_string.h> 85 #include <dt_impl.h> 86 87 /* determines whether the given integer CTF encoding is a character */ 88 #define CTF_IS_CHAR(e) \ 89 (((e).cte_format & (CTF_INT_CHAR | CTF_INT_SIGNED)) == \ 90 (CTF_INT_CHAR | CTF_INT_SIGNED) && (e).cte_bits == NBBY) 91 /* determines whether the given CTF kind is a struct or union */ 92 #define CTF_IS_STRUCTLIKE(k) \ 93 ((k) == CTF_K_STRUCT || (k) == CTF_K_UNION) 94 95 /* 96 * Print structure passed down recursively through printing algorithm. 97 */ 98 typedef struct dt_printarg { 99 dtrace_hdl_t *pa_dtp; /* libdtrace handle */ 100 caddr_t pa_addr; /* base address of trace data */ 101 ctf_file_t *pa_ctfp; /* CTF container */ 102 int pa_depth; /* member depth */ 103 int pa_nest; /* nested array depth */ 104 FILE *pa_file; /* output file */ 105 } dt_printarg_t; 106 107 static int dt_print_member(const char *, ctf_id_t, ulong_t, int, void *); 108 109 /* 110 * Safe version of ctf_type_name() that will fall back to just "<ctfid>" if it 111 * can't resolve the type. 112 */ 113 static void 114 dt_print_type_name(ctf_file_t *ctfp, ctf_id_t id, char *buf, size_t buflen) 115 { 116 if (ctf_type_name(ctfp, id, buf, buflen) == NULL) 117 (void) snprintf(buf, buflen, "<%ld>", id); 118 } 119 120 /* 121 * Print any necessary trailing braces for structures or unions. We don't get 122 * invoked when a struct or union ends, so we infer the need to print braces 123 * based on the depth the last time we printed something and the new depth. 124 */ 125 static void 126 dt_print_trailing_braces(dt_printarg_t *pap, int depth) 127 { 128 int d; 129 130 for (d = pap->pa_depth; d > depth; d--) { 131 (void) fprintf(pap->pa_file, "%*s}%s", 132 (d + pap->pa_nest - 1) * 4, "", 133 d == depth + 1 ? "" : "\n"); 134 } 135 } 136 137 /* 138 * Print the appropriate amount of indentation given the current depth and 139 * array nesting. 140 */ 141 static void 142 dt_print_indent(dt_printarg_t *pap) 143 { 144 (void) fprintf(pap->pa_file, "%*s", 145 (pap->pa_depth + pap->pa_nest) * 4, ""); 146 } 147 148 /* 149 * Print a bitfield. It's worth noting that the D compiler support for 150 * bitfields is currently broken; printing "D`user_desc_t" (pulled in by the 151 * various D provider files) will produce incorrect results compared to 152 * "genunix`user_desc_t". 153 */ 154 static void 155 print_bitfield(dt_printarg_t *pap, ulong_t off, ctf_encoding_t *ep) 156 { 157 FILE *fp = pap->pa_file; 158 caddr_t addr = pap->pa_addr + off / NBBY; 159 uint64_t mask = (1ULL << ep->cte_bits) - 1; 160 uint64_t value = 0; 161 size_t size = (ep->cte_bits + (NBBY - 1)) / NBBY; 162 uint8_t *buf = (uint8_t *)&value; 163 uint8_t shift; 164 165 /* 166 * On big-endian machines, we need to adjust the buf pointer to refer 167 * to the lowest 'size' bytes in 'value', and we need to shift based on 168 * the offset from the end of the data, not the offset of the start. 169 */ 170 #ifdef _BIG_ENDIAN 171 buf += sizeof (value) - size; 172 off += ep->cte_bits; 173 #endif 174 bcopy(addr, buf, size); 175 shift = off % NBBY; 176 177 /* 178 * Offsets are counted from opposite ends on little- and 179 * big-endian machines. 180 */ 181 #ifdef _BIG_ENDIAN 182 shift = NBBY - shift; 183 #endif 184 185 /* 186 * If the bits we want do not begin on a byte boundary, shift the data 187 * right so that the value is in the lowest 'cte_bits' of 'value'. 188 */ 189 if (off % NBBY != 0) 190 value >>= shift; 191 value &= mask; 192 193 (void) fprintf(fp, "%#llx", (u_longlong_t)value); 194 } 195 196 /* 197 * Dump the contents of memory as a fixed-size integer in hex. 198 */ 199 static void 200 dt_print_hex(FILE *fp, caddr_t addr, size_t size) 201 { 202 switch (size) { 203 case sizeof (uint8_t): 204 (void) fprintf(fp, "%#x", *(uint8_t *)addr); 205 break; 206 case sizeof (uint16_t): 207 /* LINTED - alignment */ 208 (void) fprintf(fp, "%#x", *(uint16_t *)addr); 209 break; 210 case sizeof (uint32_t): 211 /* LINTED - alignment */ 212 (void) fprintf(fp, "%#x", *(uint32_t *)addr); 213 break; 214 case sizeof (uint64_t): 215 (void) fprintf(fp, "%#llx", 216 /* LINTED - alignment */ 217 (unsigned long long)*(uint64_t *)addr); 218 break; 219 default: 220 (void) fprintf(fp, "<invalid size %u>", (uint_t)size); 221 } 222 } 223 224 /* 225 * Print an integer type. Before dumping the contents via dt_print_hex(), we 226 * first check the encoding to see if it's part of a bitfield or a character. 227 */ 228 static void 229 dt_print_int(ctf_id_t base, ulong_t off, dt_printarg_t *pap) 230 { 231 FILE *fp = pap->pa_file; 232 ctf_file_t *ctfp = pap->pa_ctfp; 233 ctf_encoding_t e; 234 size_t size; 235 caddr_t addr = pap->pa_addr + off / NBBY; 236 237 if (ctf_type_encoding(ctfp, base, &e) == CTF_ERR) { 238 (void) fprintf(fp, "<unknown encoding>"); 239 return; 240 } 241 242 /* 243 * This comes from MDB - it's not clear under what circumstances this 244 * would be found. 245 */ 246 if (e.cte_format & CTF_INT_VARARGS) { 247 (void) fprintf(fp, "..."); 248 return; 249 } 250 251 /* 252 * We print this as a bitfield if the bit encoding indicates it's not 253 * an even power of two byte size, or is larger than 8 bytes. 254 */ 255 size = e.cte_bits / NBBY; 256 if (size > 8 || (e.cte_bits % NBBY) != 0 || (size & (size - 1)) != 0) { 257 print_bitfield(pap, off, &e); 258 return; 259 } 260 261 /* 262 * If this is a character, print it out as such. 263 */ 264 if (CTF_IS_CHAR(e)) { 265 char c = *(char *)addr; 266 if (isprint(c)) 267 (void) fprintf(fp, "'%c'", c); 268 else if (c == 0) 269 (void) fprintf(fp, "'\\0'"); 270 else 271 (void) fprintf(fp, "'\\%03o'", c); 272 return; 273 } 274 275 dt_print_hex(fp, addr, size); 276 } 277 278 /* 279 * Print a floating point (float, double, long double) value. 280 */ 281 /* ARGSUSED */ 282 static void 283 dt_print_float(ctf_id_t base, ulong_t off, dt_printarg_t *pap) 284 { 285 FILE *fp = pap->pa_file; 286 ctf_file_t *ctfp = pap->pa_ctfp; 287 ctf_encoding_t e; 288 caddr_t addr = pap->pa_addr + off / NBBY; 289 290 if (ctf_type_encoding(ctfp, base, &e) == 0) { 291 if (e.cte_format == CTF_FP_SINGLE && 292 e.cte_bits == sizeof (float) * NBBY) { 293 /* LINTED - alignment */ 294 (void) fprintf(fp, "%+.7e", *((float *)addr)); 295 } else if (e.cte_format == CTF_FP_DOUBLE && 296 e.cte_bits == sizeof (double) * NBBY) { 297 /* LINTED - alignment */ 298 (void) fprintf(fp, "%+.7e", *((double *)addr)); 299 } else if (e.cte_format == CTF_FP_LDOUBLE && 300 e.cte_bits == sizeof (long double) * NBBY) { 301 /* LINTED - alignment */ 302 (void) fprintf(fp, "%+.16LE", *((long double *)addr)); 303 } else { 304 (void) fprintf(fp, "<unknown encoding>"); 305 } 306 } 307 } 308 309 /* 310 * A pointer is generally printed as a fixed-size integer. If we have a 311 * function pointer, we try to look up its name. 312 */ 313 static void 314 dt_print_ptr(ctf_id_t base, ulong_t off, dt_printarg_t *pap) 315 { 316 FILE *fp = pap->pa_file; 317 ctf_file_t *ctfp = pap->pa_ctfp; 318 caddr_t addr = pap->pa_addr + off / NBBY; 319 size_t size = ctf_type_size(ctfp, base); 320 ctf_id_t bid = ctf_type_reference(ctfp, base); 321 uint64_t pc; 322 dtrace_syminfo_t dts; 323 GElf_Sym sym; 324 325 if (bid == CTF_ERR || ctf_type_kind(ctfp, bid) != CTF_K_FUNCTION) { 326 dt_print_hex(fp, addr, size); 327 } else { 328 /* LINTED - alignment */ 329 pc = *((uint64_t *)addr); 330 if (dtrace_lookup_by_addr(pap->pa_dtp, pc, &sym, &dts) != 0) { 331 dt_print_hex(fp, addr, size); 332 } else { 333 (void) fprintf(fp, "%s`%s", dts.dts_object, 334 dts.dts_name); 335 } 336 } 337 } 338 339 /* 340 * Print out an array. This is somewhat complex, as we must manually visit 341 * each member, and recursively invoke ctf_type_visit() for each member. If 342 * the members are non-structs, then we print them out directly: 343 * 344 * [ 0x14, 0x2e, 0 ] 345 * 346 * If they are structs, then we print out the necessary leading and trailing 347 * braces, to end up with: 348 * 349 * [ 350 * type { 351 * ... 352 * }, 353 * type { 354 * ... 355 * } 356 * ] 357 * 358 * We also use a heuristic to detect whether the array looks like a character 359 * array. If the encoding indicates it's a character, and we have all 360 * printable characters followed by a null byte, then we display it as a 361 * string: 362 * 363 * [ "string" ] 364 */ 365 static void 366 dt_print_array(ctf_id_t base, ulong_t off, dt_printarg_t *pap) 367 { 368 FILE *fp = pap->pa_file; 369 ctf_file_t *ctfp = pap->pa_ctfp; 370 caddr_t addr = pap->pa_addr + off / NBBY; 371 ctf_arinfo_t car; 372 ssize_t eltsize; 373 ctf_encoding_t e; 374 int i; 375 boolean_t isstring; 376 int kind; 377 ctf_id_t rtype; 378 379 if (ctf_array_info(ctfp, base, &car) == CTF_ERR) { 380 (void) fprintf(fp, "0x%p", (void *)addr); 381 return; 382 } 383 384 if ((eltsize = ctf_type_size(ctfp, car.ctr_contents)) < 0 || 385 (rtype = ctf_type_resolve(ctfp, car.ctr_contents)) == CTF_ERR || 386 (kind = ctf_type_kind(ctfp, rtype)) == CTF_ERR) { 387 (void) fprintf(fp, "<invalid type %lu>", car.ctr_contents); 388 return; 389 } 390 391 /* see if this looks like a string */ 392 isstring = B_FALSE; 393 if (kind == CTF_K_INTEGER && 394 ctf_type_encoding(ctfp, rtype, &e) != CTF_ERR && CTF_IS_CHAR(e)) { 395 char c; 396 for (i = 0; i < car.ctr_nelems; i++) { 397 c = *((char *)addr + eltsize * i); 398 if (!isprint(c) || c == '\0') 399 break; 400 } 401 402 if (i != car.ctr_nelems && c == '\0') 403 isstring = B_TRUE; 404 } 405 406 /* 407 * As a slight aesthetic optimization, if we are a top-level type, then 408 * don't bother printing out the brackets. This lets print("foo") look 409 * like: 410 * 411 * string "foo" 412 * 413 * As D will internally represent this as a char[256] array. 414 */ 415 if (!isstring || pap->pa_depth != 0) 416 (void) fprintf(fp, "[ "); 417 418 if (isstring) 419 (void) fprintf(fp, "\""); 420 421 for (i = 0; i < car.ctr_nelems; i++) { 422 if (isstring) { 423 char c = *((char *)addr + eltsize * i); 424 if (c == '\0') 425 break; 426 (void) fprintf(fp, "%c", c); 427 } else { 428 /* 429 * Recursively invoke ctf_type_visit() on each member. 430 * We setup a new printarg struct with 'pa_nest' set to 431 * indicate that we are within a nested array. 432 */ 433 dt_printarg_t pa = *pap; 434 pa.pa_nest += pap->pa_depth + 1; 435 pa.pa_depth = 0; 436 pa.pa_addr = addr + eltsize * i; 437 (void) ctf_type_visit(ctfp, car.ctr_contents, 438 dt_print_member, &pa); 439 440 dt_print_trailing_braces(&pa, 0); 441 if (i != car.ctr_nelems - 1) 442 (void) fprintf(fp, ", "); 443 else if (CTF_IS_STRUCTLIKE(kind)) 444 (void) fprintf(fp, "\n"); 445 } 446 } 447 448 if (isstring) 449 (void) fprintf(fp, "\""); 450 451 if (!isstring || pap->pa_depth != 0) { 452 if (CTF_IS_STRUCTLIKE(kind)) 453 dt_print_indent(pap); 454 else 455 (void) fprintf(fp, " "); 456 (void) fprintf(fp, "]"); 457 } 458 } 459 460 /* 461 * This isued by both structs and unions to print the leading brace. 462 */ 463 /* ARGSUSED */ 464 static void 465 dt_print_structlike(ctf_id_t id, ulong_t off, dt_printarg_t *pap) 466 { 467 (void) fprintf(pap->pa_file, "{"); 468 } 469 470 /* 471 * For enums, we try to print the enum name, and fall back to the value if it 472 * can't be determined. We do not do any fancy flag processing like mdb. 473 */ 474 /* ARGSUSED */ 475 static void 476 dt_print_enum(ctf_id_t base, ulong_t off, dt_printarg_t *pap) 477 { 478 FILE *fp = pap->pa_file; 479 ctf_file_t *ctfp = pap->pa_ctfp; 480 const char *ename; 481 ssize_t size; 482 caddr_t addr = pap->pa_addr + off / NBBY; 483 int value = 0; 484 485 /* 486 * The C standard says that an enum will be at most the sizeof (int). 487 * But if all the values are less than that, the compiler can use a 488 * smaller size. Thanks standards. 489 */ 490 size = ctf_type_size(ctfp, base); 491 switch (size) { 492 case sizeof (uint8_t): 493 value = *(uint8_t *)addr; 494 break; 495 case sizeof (uint16_t): 496 /* LINTED - alignment */ 497 value = *(uint16_t *)addr; 498 break; 499 case sizeof (int32_t): 500 /* LINTED - alignment */ 501 value = *(int32_t *)addr; 502 break; 503 default: 504 (void) fprintf(fp, "<invalid enum size %u>", (uint_t)size); 505 return; 506 } 507 508 if ((ename = ctf_enum_name(ctfp, base, value)) != NULL) 509 (void) fprintf(fp, "%s", ename); 510 else 511 (void) fprintf(fp, "%d", value); 512 } 513 514 /* 515 * Forward declaration. There's not much to do here without the complete 516 * type information, so just print out this fact and drive on. 517 */ 518 /* ARGSUSED */ 519 static void 520 dt_print_tag(ctf_id_t base, ulong_t off, dt_printarg_t *pap) 521 { 522 (void) fprintf(pap->pa_file, "<forward decl>"); 523 } 524 525 typedef void dt_printarg_f(ctf_id_t, ulong_t, dt_printarg_t *); 526 527 static dt_printarg_f *const dt_printfuncs[] = { 528 dt_print_int, /* CTF_K_INTEGER */ 529 dt_print_float, /* CTF_K_FLOAT */ 530 dt_print_ptr, /* CTF_K_POINTER */ 531 dt_print_array, /* CTF_K_ARRAY */ 532 dt_print_ptr, /* CTF_K_FUNCTION */ 533 dt_print_structlike, /* CTF_K_STRUCT */ 534 dt_print_structlike, /* CTF_K_UNION */ 535 dt_print_enum, /* CTF_K_ENUM */ 536 dt_print_tag /* CTF_K_FORWARD */ 537 }; 538 539 /* 540 * Print one member of a structure. This callback is invoked from 541 * ctf_type_visit() recursively. 542 */ 543 static int 544 dt_print_member(const char *name, ctf_id_t id, ulong_t off, int depth, 545 void *data) 546 { 547 char type[DT_TYPE_NAMELEN]; 548 int kind; 549 dt_printarg_t *pap = data; 550 FILE *fp = pap->pa_file; 551 ctf_file_t *ctfp = pap->pa_ctfp; 552 boolean_t arraymember; 553 boolean_t brief; 554 ctf_encoding_t e; 555 ctf_id_t rtype; 556 557 dt_print_trailing_braces(pap, depth); 558 /* 559 * dt_print_trailing_braces() doesn't include the trailing newline; add 560 * it here if necessary. 561 */ 562 if (depth < pap->pa_depth) 563 (void) fprintf(fp, "\n"); 564 pap->pa_depth = depth; 565 566 if ((rtype = ctf_type_resolve(ctfp, id)) == CTF_ERR || 567 (kind = ctf_type_kind(ctfp, rtype)) == CTF_ERR || 568 kind < CTF_K_INTEGER || kind > CTF_K_FORWARD) { 569 dt_print_indent(pap); 570 (void) fprintf(fp, "%s = <invalid type %lu>", name, id); 571 return (0); 572 } 573 574 dt_print_type_name(ctfp, id, type, sizeof (type)); 575 576 arraymember = (pap->pa_nest != 0 && depth == 0); 577 brief = (arraymember && !CTF_IS_STRUCTLIKE(kind)); 578 579 if (!brief) { 580 /* 581 * If this is a direct array member and a struct (otherwise 582 * brief would be true), then print a trailing newline, as the 583 * array printing code doesn't include it because it might be a 584 * simple type. 585 */ 586 if (arraymember) 587 (void) fprintf(fp, "\n"); 588 dt_print_indent(pap); 589 590 /* always print the type */ 591 (void) fprintf(fp, "%s", type); 592 if (name[0] != '\0') { 593 /* 594 * For aesthetics, we don't include a space between the 595 * type name and member name if the type is a pointer. 596 * This will give us "void *foo =" instead of "void * 597 * foo =". Unions also have the odd behavior that the 598 * type name is returned as "union ", with a trailing 599 * space, so we also avoid printing a space if the type 600 * name already ends with a space. 601 */ 602 if (type[strlen(type) - 1] != '*' && 603 type[strlen(type) -1] != ' ') { 604 (void) fprintf(fp, " "); 605 } 606 (void) fprintf(fp, "%s", name); 607 608 /* 609 * If this looks like a bitfield, or is an integer not 610 * aligned on a byte boundary, print the number of 611 * bits after the name. 612 */ 613 if (kind == CTF_K_INTEGER && 614 ctf_type_encoding(ctfp, id, &e) == 0) { 615 ulong_t bits = e.cte_bits; 616 ulong_t size = bits / NBBY; 617 618 if (bits % NBBY != 0 || 619 off % NBBY != 0 || 620 size > 8 || 621 size != ctf_type_size(ctfp, id)) { 622 (void) fprintf(fp, " :%lu", bits); 623 } 624 } 625 626 (void) fprintf(fp, " ="); 627 } 628 (void) fprintf(fp, " "); 629 } 630 631 dt_printfuncs[kind - 1](rtype, off, pap); 632 633 /* direct simple array members are not separated by newlines */ 634 if (!brief) 635 (void) fprintf(fp, "\n"); 636 637 return (0); 638 } 639 640 /* 641 * Main print function invoked by dt_consume_cpu(). 642 */ 643 int 644 dtrace_print(dtrace_hdl_t *dtp, FILE *fp, const char *typename, 645 caddr_t addr, size_t len) 646 { 647 const char *s; 648 char *object; 649 dt_printarg_t pa; 650 ctf_id_t id; 651 dt_module_t *dmp; 652 ctf_file_t *ctfp; 653 int libid; 654 655 /* 656 * Split the fully-qualified type ID (module`id). This should 657 * always be the format, but if for some reason we don't find the 658 * expected value, return 0 to fall back to the generic trace() 659 * behavior. In the case of userland CTF modules this will actually be 660 * of the format (module`lib`id). This is due to the fact that those 661 * modules have multiple CTF containers which `lib` identifies. 662 */ 663 for (s = typename; *s != '\0' && *s != '`'; s++) 664 ; 665 666 if (*s != '`') 667 return (0); 668 669 object = alloca(s - typename + 1); 670 bcopy(typename, object, s - typename); 671 object[s - typename] = '\0'; 672 dmp = dt_module_lookup_by_name(dtp, object); 673 if (dmp == NULL) 674 return (0); 675 676 if (dmp->dm_pid != 0) { 677 libid = atoi(s + 1); 678 s = strchr(s + 1, '`'); 679 if (s == NULL || libid > dmp->dm_nctflibs) 680 return (0); 681 ctfp = dmp->dm_libctfp[libid]; 682 } else { 683 ctfp = dt_module_getctf(dtp, dmp); 684 } 685 686 id = atoi(s + 1); 687 688 /* 689 * Try to get the CTF kind for this id. If something has gone horribly 690 * wrong and we can't resolve the ID, bail out and let trace() do the 691 * work. 692 */ 693 if (ctfp == NULL || ctf_type_kind(ctfp, id) == CTF_ERR) 694 return (0); 695 696 /* setup the print structure and kick off the main print routine */ 697 pa.pa_dtp = dtp; 698 pa.pa_addr = addr; 699 pa.pa_ctfp = ctfp; 700 pa.pa_nest = 0; 701 pa.pa_depth = 0; 702 pa.pa_file = fp; 703 (void) ctf_type_visit(pa.pa_ctfp, id, dt_print_member, &pa); 704 705 dt_print_trailing_braces(&pa, 0); 706 707 return (len); 708 } 709