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 }