cddl/contrib/opensolaris/lib/libdtrace/common/dt_print.c

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