Print this page
4471 DTrace count() with histogram
4472 DTrace full width distribution histograms
4473 DTrace frequency trails
*** 22,32 ****
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
! * Copyright (c) 2011, Joyent, Inc. All rights reserved.
* Copyright (c) 2012 by Delphix. All rights reserved.
*/
#include <stdlib.h>
#include <strings.h>
--- 22,32 ----
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
! * Copyright (c) 2013, Joyent, Inc. All rights reserved.
* Copyright (c) 2012 by Delphix. All rights reserved.
*/
#include <stdlib.h>
#include <strings.h>
*** 52,61 ****
--- 52,80 ----
return (-x);
return (x);
}
+ static int
+ dt_ndigits(long long val)
+ {
+ int rval = 1;
+ long long cmp = 10;
+
+ if (val < 0) {
+ val = val == INT64_MIN ? INT64_MAX : -val;
+ rval++;
+ }
+
+ while (val > cmp && cmp > 0) {
+ rval++;
+ cmp *= 10;
+ }
+
+ return (rval < 4 ? 4 : rval);
+ }
+
/*
* 128-bit arithmetic functions needed to support the stddev() aggregating
* action.
*/
static int
*** 480,490 ****
dt_nullrec()
{
return (DTRACE_CONSUME_NEXT);
}
! int
dt_print_quantline(dtrace_hdl_t *dtp, FILE *fp, int64_t val,
uint64_t normal, long double total, char positives, char negatives)
{
long double f;
uint_t depth, len = 40;
--- 499,627 ----
dt_nullrec()
{
return (DTRACE_CONSUME_NEXT);
}
! static void
! dt_quantize_total(dtrace_hdl_t *dtp, int64_t datum, long double *total)
! {
! long double val = dt_fabsl((long double)datum);
!
! if (dtp->dt_options[DTRACEOPT_AGGZOOM] == DTRACEOPT_UNSET) {
! *total += val;
! return;
! }
!
! /*
! * If we're zooming in on an aggregation, we want the height of the
! * highest value to be approximately 95% of total bar height -- so we
! * adjust up by the reciprocal of DTRACE_AGGZOOM_MAX when comparing to
! * our highest value.
! */
! val *= 1 / DTRACE_AGGZOOM_MAX;
!
! if (*total < val)
! *total = val;
! }
!
! static int
! dt_print_quanthdr(dtrace_hdl_t *dtp, FILE *fp, int width)
! {
! return (dt_printf(dtp, fp, "\n%*s %41s %-9s\n",
! width ? width : 16, width ? "key" : "value",
! "------------- Distribution -------------", "count"));
! }
!
! static int
! dt_print_quanthdr_packed(dtrace_hdl_t *dtp, FILE *fp, int width,
! const dtrace_aggdata_t *aggdata, dtrace_actkind_t action)
! {
! int min = aggdata->dtada_minbin, max = aggdata->dtada_maxbin;
! int minwidth, maxwidth, i;
!
! assert(action == DTRACEAGG_QUANTIZE || action == DTRACEAGG_LQUANTIZE);
!
! if (action == DTRACEAGG_QUANTIZE) {
! if (min != 0 && min != DTRACE_QUANTIZE_ZEROBUCKET)
! min--;
!
! if (max < DTRACE_QUANTIZE_NBUCKETS - 1)
! max++;
!
! minwidth = dt_ndigits(DTRACE_QUANTIZE_BUCKETVAL(min));
! maxwidth = dt_ndigits(DTRACE_QUANTIZE_BUCKETVAL(max));
! } else {
! maxwidth = 8;
! minwidth = maxwidth - 1;
! max++;
! }
!
! if (dt_printf(dtp, fp, "\n%*s %*s .",
! width, width > 0 ? "key" : "", minwidth, "min") < 0)
! return (-1);
!
! for (i = min; i <= max; i++) {
! if (dt_printf(dtp, fp, "-") < 0)
! return (-1);
! }
!
! return (dt_printf(dtp, fp, ". %*s | count\n", -maxwidth, "max"));
! }
!
! /*
! * We use a subset of the Unicode Block Elements (U+2588 through U+258F,
! * inclusive) to represent aggregations via UTF-8 -- which are expressed via
! * 3-byte UTF-8 sequences.
! */
! #define DTRACE_AGGUTF8_FULL 0x2588
! #define DTRACE_AGGUTF8_BASE 0x258f
! #define DTRACE_AGGUTF8_LEVELS 8
!
! #define DTRACE_AGGUTF8_BYTE0(val) (0xe0 | ((val) >> 12))
! #define DTRACE_AGGUTF8_BYTE1(val) (0x80 | (((val) >> 6) & 0x3f))
! #define DTRACE_AGGUTF8_BYTE2(val) (0x80 | ((val) & 0x3f))
!
! static int
! dt_print_quantline_utf8(dtrace_hdl_t *dtp, FILE *fp, int64_t val,
! uint64_t normal, long double total)
! {
! uint_t len = 40, i, whole, partial;
! long double f = (dt_fabsl((long double)val) * len) / total;
! const char *spaces = " ";
!
! whole = (uint_t)f;
! partial = (uint_t)((f - (long double)(uint_t)f) *
! (long double)DTRACE_AGGUTF8_LEVELS);
!
! if (dt_printf(dtp, fp, "|") < 0)
! return (-1);
!
! for (i = 0; i < whole; i++) {
! if (dt_printf(dtp, fp, "%c%c%c",
! DTRACE_AGGUTF8_BYTE0(DTRACE_AGGUTF8_FULL),
! DTRACE_AGGUTF8_BYTE1(DTRACE_AGGUTF8_FULL),
! DTRACE_AGGUTF8_BYTE2(DTRACE_AGGUTF8_FULL)) < 0)
! return (-1);
! }
!
! if (partial != 0) {
! partial = DTRACE_AGGUTF8_BASE - (partial - 1);
!
! if (dt_printf(dtp, fp, "%c%c%c",
! DTRACE_AGGUTF8_BYTE0(partial),
! DTRACE_AGGUTF8_BYTE1(partial),
! DTRACE_AGGUTF8_BYTE2(partial)) < 0)
! return (-1);
!
! i++;
! }
!
! return (dt_printf(dtp, fp, "%s %-9lld\n", spaces + i,
! (long long)val / normal));
! }
!
! static int
dt_print_quantline(dtrace_hdl_t *dtp, FILE *fp, int64_t val,
uint64_t normal, long double total, char positives, char negatives)
{
long double f;
uint_t depth, len = 40;
*** 498,507 ****
--- 635,649 ----
assert(!(val > 0 && !positives));
assert(!(val != 0 && total == 0));
if (!negatives) {
if (positives) {
+ if (dtp->dt_encoding == DT_ENCODING_UTF8) {
+ return (dt_print_quantline_utf8(dtp, fp, val,
+ normal, total));
+ }
+
f = (dt_fabsl((long double)val) * len) / total;
depth = (uint_t)(f + 0.5);
} else {
depth = 0;
}
*** 540,549 ****
--- 682,757 ----
ats + len - depth, spaces + depth,
(long long)val / normal));
}
}
+ /*
+ * As with UTF-8 printing of aggregations, we use a subset of the Unicode
+ * Block Elements (U+2581 through U+2588, inclusive) to represent our packed
+ * aggregation.
+ */
+ #define DTRACE_AGGPACK_BASE 0x2581
+ #define DTRACE_AGGPACK_LEVELS 8
+
+ static int
+ dt_print_packed(dtrace_hdl_t *dtp, FILE *fp,
+ long double datum, long double total)
+ {
+ static boolean_t utf8_checked = B_FALSE;
+ static boolean_t utf8;
+ char *ascii = "__xxxxXX";
+ char *neg = "vvvvVV";
+ unsigned int len;
+ long double val;
+
+ if (!utf8_checked) {
+ char *term;
+
+ /*
+ * We want to determine if we can reasonably emit UTF-8 for our
+ * packed aggregation. To do this, we will check for terminals
+ * that are known to be primitive to emit UTF-8 on these.
+ */
+ utf8_checked = B_TRUE;
+
+ if (dtp->dt_encoding == DT_ENCODING_ASCII)
+ utf8 = B_FALSE;
+ else if (dtp->dt_encoding == DT_ENCODING_UTF8)
+ utf8 = B_TRUE;
+ else if ((term = getenv("TERM")) != NULL &&
+ (strcmp(term, "sun") == 0 ||
+ strcmp(term, "sun-color") == 0) ||
+ strcmp(term, "dumb") == 0)
+ utf8 = B_FALSE;
+ else
+ utf8 = B_TRUE;
+ }
+
+ if (datum == 0)
+ return (dt_printf(dtp, fp, " "));
+
+ if (datum < 0) {
+ len = strlen(neg);
+ val = dt_fabsl(datum * (len - 1)) / total;
+ return (dt_printf(dtp, fp, "%c", neg[(uint_t)(val + 0.5)]));
+ }
+
+ if (utf8) {
+ int block = DTRACE_AGGPACK_BASE + (unsigned int)(((datum *
+ (DTRACE_AGGPACK_LEVELS - 1)) / total) + 0.5);
+
+ return (dt_printf(dtp, fp, "%c%c%c",
+ DTRACE_AGGUTF8_BYTE0(block),
+ DTRACE_AGGUTF8_BYTE1(block),
+ DTRACE_AGGUTF8_BYTE2(block)));
+ }
+
+ len = strlen(ascii);
+ val = (datum * (len - 1)) / total;
+ return (dt_printf(dtp, fp, "%c", ascii[(uint_t)(val + 0.5)]));
+ }
+
int
dt_print_quantize(dtrace_hdl_t *dtp, FILE *fp, const void *addr,
size_t size, uint64_t normal)
{
const int64_t *data = addr;
*** 557,569 ****
while (first_bin < DTRACE_QUANTIZE_NBUCKETS - 1 && data[first_bin] == 0)
first_bin++;
if (first_bin == DTRACE_QUANTIZE_NBUCKETS - 1) {
/*
! * There isn't any data. This is possible if (and only if)
! * negative increment values have been used. In this case,
! * we'll print the buckets around 0.
*/
first_bin = DTRACE_QUANTIZE_ZEROBUCKET - 1;
last_bin = DTRACE_QUANTIZE_ZEROBUCKET + 1;
} else {
if (first_bin > 0)
--- 765,777 ----
while (first_bin < DTRACE_QUANTIZE_NBUCKETS - 1 && data[first_bin] == 0)
first_bin++;
if (first_bin == DTRACE_QUANTIZE_NBUCKETS - 1) {
/*
! * There isn't any data. This is possible if the aggregation
! * has been clear()'d or if negative increment values have been
! * used. Regardless, we'll print the buckets around 0.
*/
first_bin = DTRACE_QUANTIZE_ZEROBUCKET - 1;
last_bin = DTRACE_QUANTIZE_ZEROBUCKET + 1;
} else {
if (first_bin > 0)
*** 577,591 ****
}
for (i = first_bin; i <= last_bin; i++) {
positives |= (data[i] > 0);
negatives |= (data[i] < 0);
! total += dt_fabsl((long double)data[i]);
}
! if (dt_printf(dtp, fp, "\n%16s %41s %-9s\n", "value",
! "------------- Distribution -------------", "count") < 0)
return (-1);
for (i = first_bin; i <= last_bin; i++) {
if (dt_printf(dtp, fp, "%16lld ",
(long long)DTRACE_QUANTIZE_BUCKETVAL(i)) < 0)
--- 785,798 ----
}
for (i = first_bin; i <= last_bin; i++) {
positives |= (data[i] > 0);
negatives |= (data[i] < 0);
! dt_quantize_total(dtp, data[i], &total);
}
! if (dt_print_quanthdr(dtp, fp, 0) < 0)
return (-1);
for (i = first_bin; i <= last_bin; i++) {
if (dt_printf(dtp, fp, "%16lld ",
(long long)DTRACE_QUANTIZE_BUCKETVAL(i)) < 0)
*** 598,607 ****
--- 805,856 ----
return (0);
}
int
+ dt_print_quantize_packed(dtrace_hdl_t *dtp, FILE *fp, const void *addr,
+ size_t size, const dtrace_aggdata_t *aggdata)
+ {
+ const int64_t *data = addr;
+ long double total = 0, count = 0;
+ int min = aggdata->dtada_minbin, max = aggdata->dtada_maxbin, i;
+ int64_t minval, maxval;
+
+ if (size != DTRACE_QUANTIZE_NBUCKETS * sizeof (uint64_t))
+ return (dt_set_errno(dtp, EDT_DMISMATCH));
+
+ if (min != 0 && min != DTRACE_QUANTIZE_ZEROBUCKET)
+ min--;
+
+ if (max < DTRACE_QUANTIZE_NBUCKETS - 1)
+ max++;
+
+ minval = DTRACE_QUANTIZE_BUCKETVAL(min);
+ maxval = DTRACE_QUANTIZE_BUCKETVAL(max);
+
+ if (dt_printf(dtp, fp, " %*lld :", dt_ndigits(minval),
+ (long long)minval) < 0)
+ return (-1);
+
+ for (i = min; i <= max; i++) {
+ dt_quantize_total(dtp, data[i], &total);
+ count += data[i];
+ }
+
+ for (i = min; i <= max; i++) {
+ if (dt_print_packed(dtp, fp, data[i], total) < 0)
+ return (-1);
+ }
+
+ if (dt_printf(dtp, fp, ": %*lld | %lld\n",
+ -dt_ndigits(maxval), (long long)maxval, (long long)count) < 0)
+ return (-1);
+
+ return (0);
+ }
+
+ int
dt_print_lquantize(dtrace_hdl_t *dtp, FILE *fp, const void *addr,
size_t size, uint64_t normal)
{
const int64_t *data = addr;
int i, first_bin, last_bin, base;
*** 644,654 ****
}
for (i = first_bin; i <= last_bin; i++) {
positives |= (data[i] > 0);
negatives |= (data[i] < 0);
! total += dt_fabsl((long double)data[i]);
}
if (dt_printf(dtp, fp, "\n%16s %41s %-9s\n", "value",
"------------- Distribution -------------", "count") < 0)
return (-1);
--- 893,903 ----
}
for (i = first_bin; i <= last_bin; i++) {
positives |= (data[i] > 0);
negatives |= (data[i] < 0);
! dt_quantize_total(dtp, data[i], &total);
}
if (dt_printf(dtp, fp, "\n%16s %41s %-9s\n", "value",
"------------- Distribution -------------", "count") < 0)
return (-1);
*** 656,667 ****
for (i = first_bin; i <= last_bin; i++) {
char c[32];
int err;
if (i == 0) {
! (void) snprintf(c, sizeof (c), "< %d",
! base / (uint32_t)normal);
err = dt_printf(dtp, fp, "%16s ", c);
} else if (i == levels + 1) {
(void) snprintf(c, sizeof (c), ">= %d",
base + (levels * step));
err = dt_printf(dtp, fp, "%16s ", c);
--- 905,915 ----
for (i = first_bin; i <= last_bin; i++) {
char c[32];
int err;
if (i == 0) {
! (void) snprintf(c, sizeof (c), "< %d", base);
err = dt_printf(dtp, fp, "%16s ", c);
} else if (i == levels + 1) {
(void) snprintf(c, sizeof (c), ">= %d",
base + (levels * step));
err = dt_printf(dtp, fp, "%16s ", c);
*** 676,685 ****
--- 924,986 ----
}
return (0);
}
+ /*ARGSUSED*/
+ int
+ dt_print_lquantize_packed(dtrace_hdl_t *dtp, FILE *fp, const void *addr,
+ size_t size, const dtrace_aggdata_t *aggdata)
+ {
+ const int64_t *data = addr;
+ long double total = 0, count = 0;
+ int min, max, base, err;
+ uint64_t arg;
+ uint16_t step, levels;
+ char c[32];
+ unsigned int i;
+
+ if (size < sizeof (uint64_t))
+ return (dt_set_errno(dtp, EDT_DMISMATCH));
+
+ arg = *data++;
+ size -= sizeof (uint64_t);
+
+ base = DTRACE_LQUANTIZE_BASE(arg);
+ step = DTRACE_LQUANTIZE_STEP(arg);
+ levels = DTRACE_LQUANTIZE_LEVELS(arg);
+
+ if (size != sizeof (uint64_t) * (levels + 2))
+ return (dt_set_errno(dtp, EDT_DMISMATCH));
+
+ min = 0;
+ max = levels + 1;
+
+ if (min == 0) {
+ (void) snprintf(c, sizeof (c), "< %d", base);
+ err = dt_printf(dtp, fp, "%8s :", c);
+ } else {
+ err = dt_printf(dtp, fp, "%8d :", base + (min - 1) * step);
+ }
+
+ if (err < 0)
+ return (-1);
+
+ for (i = min; i <= max; i++) {
+ dt_quantize_total(dtp, data[i], &total);
+ count += data[i];
+ }
+
+ for (i = min; i <= max; i++) {
+ if (dt_print_packed(dtp, fp, data[i], total) < 0)
+ return (-1);
+ }
+
+ (void) snprintf(c, sizeof (c), ">= %d", base + (levels * step));
+ return (dt_printf(dtp, fp, ": %-8s | %lld\n", c, (long long)count));
+ }
+
int
dt_print_llquantize(dtrace_hdl_t *dtp, FILE *fp, const void *addr,
size_t size, uint64_t normal)
{
int i, first_bin, last_bin, bin = 1, order, levels;
*** 733,743 ****
}
for (i = first_bin; i <= last_bin; i++) {
positives |= (data[i] > 0);
negatives |= (data[i] < 0);
! total += dt_fabsl((long double)data[i]);
}
if (dt_printf(dtp, fp, "\n%16s %41s %-9s\n", "value",
"------------- Distribution -------------", "count") < 0)
return (-1);
--- 1034,1044 ----
}
for (i = first_bin; i <= last_bin; i++) {
positives |= (data[i] > 0);
negatives |= (data[i] < 0);
! dt_quantize_total(dtp, data[i], &total);
}
if (dt_printf(dtp, fp, "\n%16s %41s %-9s\n", "value",
"------------- Distribution -------------", "count") < 0)
return (-1);
*** 816,826 ****
return (dt_printf(dtp, fp, " %16llu", data[0] ?
(unsigned long long) dt_stddev(data, normal) : 0));
}
/*ARGSUSED*/
! int
dt_print_bytes(dtrace_hdl_t *dtp, FILE *fp, caddr_t addr,
size_t nbytes, int width, int quiet, int forceraw)
{
/*
* If the byte stream is a series of printable characters, followed by
--- 1117,1127 ----
return (dt_printf(dtp, fp, " %16llu", data[0] ?
(unsigned long long) dt_stddev(data, normal) : 0));
}
/*ARGSUSED*/
! static int
dt_print_bytes(dtrace_hdl_t *dtp, FILE *fp, caddr_t addr,
size_t nbytes, int width, int quiet, int forceraw)
{
/*
* If the byte stream is a series of printable characters, followed by
*** 869,882 ****
}
if (j != nbytes)
break;
! if (quiet)
return (dt_printf(dtp, fp, "%s", c));
! else
! return (dt_printf(dtp, fp, " %-*s", width, c));
}
break;
}
--- 1170,1185 ----
}
if (j != nbytes)
break;
! if (quiet) {
return (dt_printf(dtp, fp, "%s", c));
! } else {
! return (dt_printf(dtp, fp, " %s%*s",
! width < 0 ? " " : "", width, c));
! }
}
break;
}
*** 1477,1490 ****
return (0);
}
static int
dt_print_datum(dtrace_hdl_t *dtp, FILE *fp, dtrace_recdesc_t *rec,
! caddr_t addr, size_t size, uint64_t normal)
{
! int err;
dtrace_actkind_t act = rec->dtrd_action;
switch (act) {
case DTRACEACT_STACK:
return (dt_print_stack(dtp, fp, NULL, addr,
rec->dtrd_arg, rec->dtrd_size / rec->dtrd_arg));
--- 1780,1866 ----
return (0);
}
static int
dt_print_datum(dtrace_hdl_t *dtp, FILE *fp, dtrace_recdesc_t *rec,
! caddr_t addr, size_t size, const dtrace_aggdata_t *aggdata,
! uint64_t normal, dt_print_aggdata_t *pd)
{
! int err, width;
dtrace_actkind_t act = rec->dtrd_action;
+ boolean_t packed = pd->dtpa_agghist || pd->dtpa_aggpack;
+ dtrace_aggdesc_t *agg = aggdata->dtada_desc;
+
+ static struct {
+ size_t size;
+ int width;
+ int packedwidth;
+ } *fmt, fmttab[] = {
+ { sizeof (uint8_t), 3, 3 },
+ { sizeof (uint16_t), 5, 5 },
+ { sizeof (uint32_t), 8, 8 },
+ { sizeof (uint64_t), 16, 16 },
+ { 0, -50, 16 }
+ };
+
+ if (packed && pd->dtpa_agghisthdr != agg->dtagd_varid) {
+ dtrace_recdesc_t *r;
+
+ width = 0;
+
+ /*
+ * To print our quantization header for either an agghist or
+ * aggpack aggregation, we need to iterate through all of our
+ * of our records to determine their width.
+ */
+ for (r = rec; !DTRACEACT_ISAGG(r->dtrd_action); r++) {
+ for (fmt = fmttab; fmt->size &&
+ fmt->size != r->dtrd_size; fmt++)
+ continue;
+
+ width += fmt->packedwidth + 1;
+ }
+
+ if (pd->dtpa_agghist) {
+ if (dt_print_quanthdr(dtp, fp, width) < 0)
+ return (-1);
+ } else {
+ if (dt_print_quanthdr_packed(dtp, fp,
+ width, aggdata, r->dtrd_action) < 0)
+ return (-1);
+ }
+
+ pd->dtpa_agghisthdr = agg->dtagd_varid;
+ }
+
+ if (pd->dtpa_agghist && DTRACEACT_ISAGG(act)) {
+ char positives = aggdata->dtada_flags & DTRACE_A_HASPOSITIVES;
+ char negatives = aggdata->dtada_flags & DTRACE_A_HASNEGATIVES;
+ int64_t val;
+
+ assert(act == DTRACEAGG_SUM || act == DTRACEAGG_COUNT);
+ val = (long long)*((uint64_t *)addr);
+
+ if (dt_printf(dtp, fp, " ") < 0)
+ return (-1);
+
+ return (dt_print_quantline(dtp, fp, val, normal,
+ aggdata->dtada_total, positives, negatives));
+ }
+
+ if (pd->dtpa_aggpack && DTRACEACT_ISAGG(act)) {
+ switch (act) {
+ case DTRACEAGG_QUANTIZE:
+ return (dt_print_quantize_packed(dtp,
+ fp, addr, size, aggdata));
+ case DTRACEAGG_LQUANTIZE:
+ return (dt_print_lquantize_packed(dtp,
+ fp, addr, size, aggdata));
+ default:
+ break;
+ }
+ }
switch (act) {
case DTRACEACT_STACK:
return (dt_print_stack(dtp, fp, NULL, addr,
rec->dtrd_arg, rec->dtrd_size / rec->dtrd_arg));
*** 1523,1554 ****
default:
break;
}
switch (size) {
case sizeof (uint64_t):
! err = dt_printf(dtp, fp, " %16lld",
/* LINTED - alignment */
(long long)*((uint64_t *)addr) / normal);
break;
case sizeof (uint32_t):
/* LINTED - alignment */
! err = dt_printf(dtp, fp, " %8d", *((uint32_t *)addr) /
(uint32_t)normal);
break;
case sizeof (uint16_t):
/* LINTED - alignment */
! err = dt_printf(dtp, fp, " %5d", *((uint16_t *)addr) /
(uint32_t)normal);
break;
case sizeof (uint8_t):
! err = dt_printf(dtp, fp, " %3d", *((uint8_t *)addr) /
(uint32_t)normal);
break;
default:
! err = dt_print_bytes(dtp, fp, addr, size, 50, 0, 0);
break;
}
return (err);
}
--- 1899,1935 ----
default:
break;
}
+ for (fmt = fmttab; fmt->size && fmt->size != size; fmt++)
+ continue;
+
+ width = packed ? fmt->packedwidth : fmt->width;
+
switch (size) {
case sizeof (uint64_t):
! err = dt_printf(dtp, fp, " %*lld", width,
/* LINTED - alignment */
(long long)*((uint64_t *)addr) / normal);
break;
case sizeof (uint32_t):
/* LINTED - alignment */
! err = dt_printf(dtp, fp, " %*d", width, *((uint32_t *)addr) /
(uint32_t)normal);
break;
case sizeof (uint16_t):
/* LINTED - alignment */
! err = dt_printf(dtp, fp, " %*d", width, *((uint16_t *)addr) /
(uint32_t)normal);
break;
case sizeof (uint8_t):
! err = dt_printf(dtp, fp, " %*d", width, *((uint8_t *)addr) /
(uint32_t)normal);
break;
default:
! err = dt_print_bytes(dtp, fp, addr, size, width, 0, 0);
break;
}
return (err);
}
*** 1565,1574 ****
--- 1946,1958 ----
dtrace_recdesc_t *rec;
dtrace_actkind_t act;
caddr_t addr;
size_t size;
+ pd->dtpa_agghist = (aggdata->dtada_flags & DTRACE_A_TOTAL);
+ pd->dtpa_aggpack = (aggdata->dtada_flags & DTRACE_A_MINMAXBIN);
+
/*
* Iterate over each record description in the key, printing the traced
* data, skipping the first datum (the tuple member created by the
* compiler).
*/
*** 1581,1591 ****
if (DTRACEACT_ISAGG(act)) {
aggact = i;
break;
}
! if (dt_print_datum(dtp, fp, rec, addr, size, 1) < 0)
return (-1);
if (dt_buffered_flush(dtp, NULL, rec, aggdata,
DTRACE_BUFDATA_AGGKEY) < 0)
return (-1);
--- 1965,1976 ----
if (DTRACEACT_ISAGG(act)) {
aggact = i;
break;
}
! if (dt_print_datum(dtp, fp, rec, addr,
! size, aggdata, 1, pd) < 0)
return (-1);
if (dt_buffered_flush(dtp, NULL, rec, aggdata,
DTRACE_BUFDATA_AGGKEY) < 0)
return (-1);
*** 1604,1626 ****
size = rec->dtrd_size;
assert(DTRACEACT_ISAGG(act));
normal = aggdata->dtada_normal;
! if (dt_print_datum(dtp, fp, rec, addr, size, normal) < 0)
return (-1);
if (dt_buffered_flush(dtp, NULL, rec, aggdata,
DTRACE_BUFDATA_AGGVAL) < 0)
return (-1);
if (!pd->dtpa_allunprint)
agg->dtagd_flags |= DTRACE_AGD_PRINTED;
}
if (dt_printf(dtp, fp, "\n") < 0)
return (-1);
if (dt_buffered_flush(dtp, NULL, NULL, aggdata,
DTRACE_BUFDATA_AGGFORMAT | DTRACE_BUFDATA_AGGLAST) < 0)
return (-1);
--- 1989,2014 ----
size = rec->dtrd_size;
assert(DTRACEACT_ISAGG(act));
normal = aggdata->dtada_normal;
! if (dt_print_datum(dtp, fp, rec, addr,
! size, aggdata, normal, pd) < 0)
return (-1);
if (dt_buffered_flush(dtp, NULL, rec, aggdata,
DTRACE_BUFDATA_AGGVAL) < 0)
return (-1);
if (!pd->dtpa_allunprint)
agg->dtagd_flags |= DTRACE_AGD_PRINTED;
}
+ if (!pd->dtpa_agghist && !pd->dtpa_aggpack) {
if (dt_printf(dtp, fp, "\n") < 0)
return (-1);
+ }
if (dt_buffered_flush(dtp, NULL, NULL, aggdata,
DTRACE_BUFDATA_AGGFORMAT | DTRACE_BUFDATA_AGGLAST) < 0)
return (-1);
*** 2073,2083 ****
tracememsize > rec->dtrd_size) {
tracememsize = rec->dtrd_size;
}
n = dt_print_bytes(dtp, fp, addr,
! tracememsize, 33, quiet, 1);
tracememsize = 0;
if (n < 0)
return (-1);
--- 2461,2471 ----
tracememsize > rec->dtrd_size) {
tracememsize = rec->dtrd_size;
}
n = dt_print_bytes(dtp, fp, addr,
! tracememsize, -33, quiet, 1);
tracememsize = 0;
if (n < 0)
return (-1);
*** 2106,2116 ****
n = dt_printf(dtp, fp, quiet ? "%d" : " %3d",
*((uint8_t *)addr));
break;
default:
n = dt_print_bytes(dtp, fp, addr,
! rec->dtrd_size, 33, quiet, 0);
break;
}
if (n < 0)
return (-1); /* errno is set for us */
--- 2494,2504 ----
n = dt_printf(dtp, fp, quiet ? "%d" : " %3d",
*((uint8_t *)addr));
break;
default:
n = dt_print_bytes(dtp, fp, addr,
! rec->dtrd_size, -33, quiet, 0);
break;
}
if (n < 0)
return (-1); /* errno is set for us */