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.
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.
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]
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
26 * Copyright (c) 2011 by Delphix. All rights reserved.
29 * Copyright (c) 2013, Joyent, Inc. All rights reserved.
33 * DTrace print() action
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
42 * This implementation differs from MDB's in the following ways:
44 * - We do not expose any options or flags. The behavior of print() is
45 * equivalent to "::print -tn".
47 * - MDB will display "holes" in structures (unused padding between
50 * - When printing arrays of structures, MDB will leave a trailing ','
51 * after the last element.
53 * - MDB will print time_t types as date and time.
55 * - MDB will detect when an enum is actually the OR of several flags,
56 * and print it out with the constituent flags separated.
58 * - For large arrays, MDB will print the first few members and then
59 * print a "..." continuation line.
61 * - MDB will break and wrap arrays at 80 columns.
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.
68 #include <sys/sysmacros.h>
76 #include <sys/socket.h>
78 #include <netinet/in.h>
79 #include <arpa/inet.h>
80 #include <arpa/nameser.h>
82 #include <dt_module.h>
83 #include <dt_printf.h>
84 #include <dt_string.h>
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)
96 * Print structure passed down recursively through printing algorithm.
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 */
107 static int dt_print_member(const char *, ctf_id_t, ulong_t, int, void *);
110 * Safe version of ctf_type_name() that will fall back to just "<ctfid>" if it
111 * can't resolve the type.
114 dt_print_type_name(ctf_file_t *ctfp, ctf_id_t id, char *buf, size_t buflen)
116 if (ctf_type_name(ctfp, id, buf, buflen) == NULL)
117 (void) snprintf(buf, buflen, "<%ld>", id);
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.
126 dt_print_trailing_braces(dt_printarg_t *pap, int depth)
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");
138 * Print the appropriate amount of indentation given the current depth and
142 dt_print_indent(dt_printarg_t *pap)
144 (void) fprintf(pap->pa_file, "%*s",
145 (pap->pa_depth + pap->pa_nest) * 4, "");
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".
155 print_bitfield(dt_printarg_t *pap, ulong_t off, ctf_encoding_t *ep)
157 FILE *fp = pap->pa_file;
158 caddr_t addr = pap->pa_addr + off / NBBY;
159 uint64_t mask = (1ULL << ep->cte_bits) - 1;
161 size_t size = (ep->cte_bits + (NBBY - 1)) / NBBY;
162 uint8_t *buf = (uint8_t *)&value;
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.
171 buf += sizeof (value) - size;
174 bcopy(addr, buf, size);
178 * Offsets are counted from opposite ends on little- and
179 * big-endian machines.
182 shift = NBBY - shift;
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'.
193 (void) fprintf(fp, "%#llx", (u_longlong_t)value);
197 * Dump the contents of memory as a fixed-size integer in hex.
200 dt_print_hex(FILE *fp, caddr_t addr, size_t size)
203 case sizeof (uint8_t):
204 (void) fprintf(fp, "%#x", *(uint8_t *)addr);
206 case sizeof (uint16_t):
207 /* LINTED - alignment */
208 (void) fprintf(fp, "%#x", *(uint16_t *)addr);
210 case sizeof (uint32_t):
211 /* LINTED - alignment */
212 (void) fprintf(fp, "%#x", *(uint32_t *)addr);
214 case sizeof (uint64_t):
215 (void) fprintf(fp, "%#llx",
216 /* LINTED - alignment */
217 (unsigned long long)*(uint64_t *)addr);
220 (void) fprintf(fp, "<invalid size %u>", (uint_t)size);
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.
229 dt_print_int(ctf_id_t base, ulong_t off, dt_printarg_t *pap)
231 FILE *fp = pap->pa_file;
232 ctf_file_t *ctfp = pap->pa_ctfp;
235 caddr_t addr = pap->pa_addr + off / NBBY;
237 if (ctf_type_encoding(ctfp, base, &e) == CTF_ERR) {
238 (void) fprintf(fp, "<unknown encoding>");
243 * This comes from MDB - it's not clear under what circumstances this
246 if (e.cte_format & CTF_INT_VARARGS) {
247 (void) fprintf(fp, "...");
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.
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);
262 * If this is a character, print it out as such.
264 if (CTF_IS_CHAR(e)) {
265 char c = *(char *)addr;
267 (void) fprintf(fp, "'%c'", c);
269 (void) fprintf(fp, "'\\0'");
271 (void) fprintf(fp, "'\\%03o'", c);
275 dt_print_hex(fp, addr, size);
279 * Print a floating point (float, double, long double) value.
283 dt_print_float(ctf_id_t base, ulong_t off, dt_printarg_t *pap)
285 FILE *fp = pap->pa_file;
286 ctf_file_t *ctfp = pap->pa_ctfp;
288 caddr_t addr = pap->pa_addr + off / NBBY;
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));
304 (void) fprintf(fp, "<unknown encoding>");
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.
314 dt_print_ptr(ctf_id_t base, ulong_t off, dt_printarg_t *pap)
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);
322 dtrace_syminfo_t dts;
325 if (bid == CTF_ERR || ctf_type_kind(ctfp, bid) != CTF_K_FUNCTION) {
326 dt_print_hex(fp, addr, size);
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);
333 (void) fprintf(fp, "%s`%s", dts.dts_object,
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:
346 * If they are structs, then we print out the necessary leading and trailing
347 * braces, to end up with:
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
366 dt_print_array(ctf_id_t base, ulong_t off, dt_printarg_t *pap)
368 FILE *fp = pap->pa_file;
369 ctf_file_t *ctfp = pap->pa_ctfp;
370 caddr_t addr = pap->pa_addr + off / NBBY;
379 if (ctf_array_info(ctfp, base, &car) == CTF_ERR) {
380 (void) fprintf(fp, "0x%p", (void *)addr);
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);
391 /* see if this looks like a string */
393 if (kind == CTF_K_INTEGER &&
394 ctf_type_encoding(ctfp, rtype, &e) != CTF_ERR && CTF_IS_CHAR(e)) {
396 for (i = 0; i < car.ctr_nelems; i++) {
397 c = *((char *)addr + eltsize * i);
398 if (!isprint(c) || c == '\0')
402 if (i != car.ctr_nelems && c == '\0')
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
413 * As D will internally represent this as a char[256] array.
415 if (!isstring || pap->pa_depth != 0)
416 (void) fprintf(fp, "[ ");
419 (void) fprintf(fp, "\"");
421 for (i = 0; i < car.ctr_nelems; i++) {
423 char c = *((char *)addr + eltsize * i);
426 (void) fprintf(fp, "%c", c);
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.
433 dt_printarg_t pa = *pap;
434 pa.pa_nest += pap->pa_depth + 1;
436 pa.pa_addr = addr + eltsize * i;
437 (void) ctf_type_visit(ctfp, car.ctr_contents,
438 dt_print_member, &pa);
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");
449 (void) fprintf(fp, "\"");
451 if (!isstring || pap->pa_depth != 0) {
452 if (CTF_IS_STRUCTLIKE(kind))
453 dt_print_indent(pap);
455 (void) fprintf(fp, " ");
456 (void) fprintf(fp, "]");
461 * This isued by both structs and unions to print the leading brace.
465 dt_print_structlike(ctf_id_t id, ulong_t off, dt_printarg_t *pap)
467 (void) fprintf(pap->pa_file, "{");
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.
476 dt_print_enum(ctf_id_t base, ulong_t off, dt_printarg_t *pap)
478 FILE *fp = pap->pa_file;
479 ctf_file_t *ctfp = pap->pa_ctfp;
482 caddr_t addr = pap->pa_addr + off / NBBY;
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.
490 size = ctf_type_size(ctfp, base);
492 case sizeof (uint8_t):
493 value = *(uint8_t *)addr;
495 case sizeof (uint16_t):
496 value = *(uint16_t *)addr;
498 case sizeof (int32_t):
499 value = *(int32_t *)addr;
502 (void) fprintf(fp, "<invalid enum size %u>", (uint_t)size);
506 if ((ename = ctf_enum_name(ctfp, base, value)) != NULL)
507 (void) fprintf(fp, "%s", ename);
509 (void) fprintf(fp, "%d", value);
513 * Forward declaration. There's not much to do here without the complete
514 * type information, so just print out this fact and drive on.
518 dt_print_tag(ctf_id_t base, ulong_t off, dt_printarg_t *pap)
520 (void) fprintf(pap->pa_file, "<forward decl>");
523 typedef void dt_printarg_f(ctf_id_t, ulong_t, dt_printarg_t *);
525 static dt_printarg_f *const dt_printfuncs[] = {
526 dt_print_int, /* CTF_K_INTEGER */
527 dt_print_float, /* CTF_K_FLOAT */
528 dt_print_ptr, /* CTF_K_POINTER */
529 dt_print_array, /* CTF_K_ARRAY */
530 dt_print_ptr, /* CTF_K_FUNCTION */
531 dt_print_structlike, /* CTF_K_STRUCT */
532 dt_print_structlike, /* CTF_K_UNION */
533 dt_print_enum, /* CTF_K_ENUM */
534 dt_print_tag /* CTF_K_FORWARD */
538 * Print one member of a structure. This callback is invoked from
539 * ctf_type_visit() recursively.
542 dt_print_member(const char *name, ctf_id_t id, ulong_t off, int depth,
545 char type[DT_TYPE_NAMELEN];
547 dt_printarg_t *pap = data;
548 FILE *fp = pap->pa_file;
549 ctf_file_t *ctfp = pap->pa_ctfp;
550 boolean_t arraymember;
555 dt_print_trailing_braces(pap, depth);
557 * dt_print_trailing_braces() doesn't include the trailing newline; add
558 * it here if necessary.
560 if (depth < pap->pa_depth)
561 (void) fprintf(fp, "\n");
562 pap->pa_depth = depth;
564 if ((rtype = ctf_type_resolve(ctfp, id)) == CTF_ERR ||
565 (kind = ctf_type_kind(ctfp, rtype)) == CTF_ERR ||
566 kind < CTF_K_INTEGER || kind > CTF_K_FORWARD) {
567 dt_print_indent(pap);
568 (void) fprintf(fp, "%s = <invalid type %lu>", name, id);
572 dt_print_type_name(ctfp, id, type, sizeof (type));
574 arraymember = (pap->pa_nest != 0 && depth == 0);
575 brief = (arraymember && !CTF_IS_STRUCTLIKE(kind));
579 * If this is a direct array member and a struct (otherwise
580 * brief would be true), then print a trailing newline, as the
581 * array printing code doesn't include it because it might be a
585 (void) fprintf(fp, "\n");
586 dt_print_indent(pap);
588 /* always print the type */
589 (void) fprintf(fp, "%s", type);
590 if (name[0] != '\0') {
592 * For aesthetics, we don't include a space between the
593 * type name and member name if the type is a pointer.
594 * This will give us "void *foo =" instead of "void *
595 * foo =". Unions also have the odd behavior that the
596 * type name is returned as "union ", with a trailing
597 * space, so we also avoid printing a space if the type
598 * name already ends with a space.
600 if (type[strlen(type) - 1] != '*' &&
601 type[strlen(type) -1] != ' ') {
602 (void) fprintf(fp, " ");
604 (void) fprintf(fp, "%s", name);
607 * If this looks like a bitfield, or is an integer not
608 * aligned on a byte boundary, print the number of
609 * bits after the name.
611 if (kind == CTF_K_INTEGER &&
612 ctf_type_encoding(ctfp, id, &e) == 0) {
613 ulong_t bits = e.cte_bits;
614 ulong_t size = bits / NBBY;
616 if (bits % NBBY != 0 ||
619 size != ctf_type_size(ctfp, id)) {
620 (void) fprintf(fp, " :%lu", bits);
624 (void) fprintf(fp, " =");
626 (void) fprintf(fp, " ");
629 dt_printfuncs[kind - 1](rtype, off, pap);
631 /* direct simple array members are not separated by newlines */
633 (void) fprintf(fp, "\n");
639 * Main print function invoked by dt_consume_cpu().
642 dtrace_print(dtrace_hdl_t *dtp, FILE *fp, const char *typename,
643 caddr_t addr, size_t len)
652 * Split the fully-qualified type ID (module`id). This should
653 * always be the format, but if for some reason we don't find the
654 * expected value, return 0 to fall back to the generic trace()
657 for (s = typename; *s != '\0' && *s != '`'; s++)
663 object = alloca(s - typename + 1);
664 bcopy(typename, object, s - typename);
665 object[s - typename] = '\0';
669 * Try to get the CTF kind for this id. If something has gone horribly
670 * wrong and we can't resolve the ID, bail out and let trace() do the
673 dmp = dt_module_lookup_by_name(dtp, object);
674 if (dmp == NULL || ctf_type_kind(dt_module_getctf(dtp, dmp),
679 /* setup the print structure and kick off the main print routine */
682 pa.pa_ctfp = dt_module_getctf(dtp, dmp);
686 (void) ctf_type_visit(pa.pa_ctfp, id, dt_print_member, &pa);
688 dt_print_trailing_braces(&pa, 0);