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.
27 * Copyright (c) 2013, Joyent, Inc. All rights reserved.
28 * Copyright (c) 2012 by Delphix. All rights reserved.
42 #define DT_MASK_LO 0x00000000FFFFFFFFULL
45 * We declare this here because (1) we need it and (2) we want to avoid a
46 * dependency on libm in libdtrace.
49 dt_fabsl(long double x
)
58 dt_ndigits(long long val
)
64 val
= val
== INT64_MIN
? INT64_MAX
: -val
;
68 while (val
> cmp
&& cmp
> 0) {
73 return (rval
< 4 ? 4 : rval
);
77 * 128-bit arithmetic functions needed to support the stddev() aggregating
81 dt_gt_128(uint64_t *a
, uint64_t *b
)
83 return (a
[1] > b
[1] || (a
[1] == b
[1] && a
[0] > b
[0]));
87 dt_ge_128(uint64_t *a
, uint64_t *b
)
89 return (a
[1] > b
[1] || (a
[1] == b
[1] && a
[0] >= b
[0]));
93 dt_le_128(uint64_t *a
, uint64_t *b
)
95 return (a
[1] < b
[1] || (a
[1] == b
[1] && a
[0] <= b
[0]));
99 * Shift the 128-bit value in a by b. If b is positive, shift left.
100 * If b is negative, shift right.
103 dt_shift_128(uint64_t *a
, int b
)
113 a
[0] = a
[1] >> (b
- 64);
117 mask
= 1LL << (64 - b
);
119 a
[0] |= ((a
[1] & mask
) << (64 - b
));
124 a
[1] = a
[0] << (b
- 64);
128 mask
= a
[0] >> (64 - b
);
136 dt_nbits_128(uint64_t *a
)
140 uint64_t zero
[2] = { 0, 0 };
145 dt_shift_128(tmp
, -1);
146 while (dt_gt_128(tmp
, zero
)) {
147 dt_shift_128(tmp
, -1);
155 dt_subtract_128(uint64_t *minuend
, uint64_t *subtrahend
, uint64_t *difference
)
159 result
[0] = minuend
[0] - subtrahend
[0];
160 result
[1] = minuend
[1] - subtrahend
[1] -
161 (minuend
[0] < subtrahend
[0] ? 1 : 0);
163 difference
[0] = result
[0];
164 difference
[1] = result
[1];
168 dt_add_128(uint64_t *addend1
, uint64_t *addend2
, uint64_t *sum
)
172 result
[0] = addend1
[0] + addend2
[0];
173 result
[1] = addend1
[1] + addend2
[1] +
174 (result
[0] < addend1
[0] || result
[0] < addend2
[0] ? 1 : 0);
181 * The basic idea is to break the 2 64-bit values into 4 32-bit values,
182 * use native multiplication on those, and then re-combine into the
183 * resulting 128-bit value.
185 * (hi1 << 32 + lo1) * (hi2 << 32 + lo2) =
192 dt_multiply_128(uint64_t factor1
, uint64_t factor2
, uint64_t *product
)
194 uint64_t hi1
, hi2
, lo1
, lo2
;
200 lo1
= factor1
& DT_MASK_LO
;
201 lo2
= factor2
& DT_MASK_LO
;
203 product
[0] = lo1
* lo2
;
204 product
[1] = hi1
* hi2
;
208 dt_shift_128(tmp
, 32);
209 dt_add_128(product
, tmp
, product
);
213 dt_shift_128(tmp
, 32);
214 dt_add_128(product
, tmp
, product
);
218 * This is long-hand division.
220 * We initialize subtrahend by shifting divisor left as far as possible. We
221 * loop, comparing subtrahend to dividend: if subtrahend is smaller, we
222 * subtract and set the appropriate bit in the result. We then shift
223 * subtrahend right by one bit for the next comparison.
226 dt_divide_128(uint64_t *dividend
, uint64_t divisor
, uint64_t *quotient
)
228 uint64_t result
[2] = { 0, 0 };
229 uint64_t remainder
[2];
230 uint64_t subtrahend
[2];
231 uint64_t divisor_128
[2];
232 uint64_t mask
[2] = { 1, 0 };
235 assert(divisor
!= 0);
237 divisor_128
[0] = divisor
;
240 remainder
[0] = dividend
[0];
241 remainder
[1] = dividend
[1];
243 subtrahend
[0] = divisor
;
246 while (divisor
> 0) {
251 dt_shift_128(subtrahend
, 128 - log
);
252 dt_shift_128(mask
, 128 - log
);
254 while (dt_ge_128(remainder
, divisor_128
)) {
255 if (dt_ge_128(remainder
, subtrahend
)) {
256 dt_subtract_128(remainder
, subtrahend
, remainder
);
257 result
[0] |= mask
[0];
258 result
[1] |= mask
[1];
261 dt_shift_128(subtrahend
, -1);
262 dt_shift_128(mask
, -1);
265 quotient
[0] = result
[0];
266 quotient
[1] = result
[1];
270 * This is the long-hand method of calculating a square root.
271 * The algorithm is as follows:
273 * 1. Group the digits by 2 from the right.
274 * 2. Over the leftmost group, find the largest single-digit number
275 * whose square is less than that group.
276 * 3. Subtract the result of the previous step (2 or 4, depending) and
277 * bring down the next two-digit group.
278 * 4. For the result R we have so far, find the largest single-digit number
279 * x such that 2 * R * 10 * x + x^2 is less than the result from step 3.
280 * (Note that this is doubling R and performing a decimal left-shift by 1
281 * and searching for the appropriate decimal to fill the one's place.)
282 * The value x is the next digit in the square root.
283 * Repeat steps 3 and 4 until the desired precision is reached. (We're
284 * dealing with integers, so the above is sufficient.)
286 * In decimal, the square root of 582,734 would be calculated as so:
290 * -49 (7^2 == 49 => 7 is the first digit in the square root)
292 * 9 27 (Subtract and bring down the next group.)
293 * 146 8 76 (2 * 7 * 10 * 6 + 6^2 == 876 => 6 is the next digit in
294 * ----- the square root)
295 * 51 34 (Subtract and bring down the next group.)
296 * 1523 45 69 (2 * 76 * 10 * 3 + 3^2 == 4569 => 3 is the next digit in
297 * ----- the square root)
300 * The above algorithm applies similarly in binary, but note that the
301 * only possible non-zero value for x in step 4 is 1, so step 4 becomes a
302 * simple decision: is 2 * R * 2 * 1 + 1^2 (aka R << 2 + 1) less than the
303 * preceding difference?
305 * In binary, the square root of 11011011 would be calculated as so:
309 * 01 (0 << 2 + 1 == 1 < 11 => this bit is 1)
312 * 101 1 01 (1 << 2 + 1 == 101 < 1001 => next bit is 1)
315 * 1101 11 01 (11 << 2 + 1 == 1101 < 10010 => next bit is 1)
318 * 11101 1 11 01 (111 << 2 + 1 == 11101 > 10111 => last bit is 0)
322 dt_sqrt_128(uint64_t *square
)
324 uint64_t result
[2] = { 0, 0 };
325 uint64_t diff
[2] = { 0, 0 };
326 uint64_t one
[2] = { 1, 0 };
327 uint64_t next_pair
[2];
328 uint64_t next_try
[2];
329 uint64_t bit_pairs
, pair_shift
;
332 bit_pairs
= dt_nbits_128(square
) / 2;
333 pair_shift
= bit_pairs
* 2;
335 for (i
= 0; i
<= bit_pairs
; i
++) {
337 * Bring down the next pair of bits.
339 next_pair
[0] = square
[0];
340 next_pair
[1] = square
[1];
341 dt_shift_128(next_pair
, -pair_shift
);
345 dt_shift_128(diff
, 2);
346 dt_add_128(diff
, next_pair
, diff
);
349 * next_try = R << 2 + 1
351 next_try
[0] = result
[0];
352 next_try
[1] = result
[1];
353 dt_shift_128(next_try
, 2);
354 dt_add_128(next_try
, one
, next_try
);
356 if (dt_le_128(next_try
, diff
)) {
357 dt_subtract_128(diff
, next_try
, diff
);
358 dt_shift_128(result
, 1);
359 dt_add_128(result
, one
, result
);
361 dt_shift_128(result
, 1);
367 assert(result
[1] == 0);
373 dt_stddev(uint64_t *data
, uint64_t normal
)
375 uint64_t avg_of_squares
[2];
376 uint64_t square_of_avg
[2];
381 * The standard approximation for standard deviation is
382 * sqrt(average(x**2) - average(x)**2), i.e. the square root
383 * of the average of the squares minus the square of the average.
385 dt_divide_128(data
+ 2, normal
, avg_of_squares
);
386 dt_divide_128(avg_of_squares
, data
[0], avg_of_squares
);
388 norm_avg
= (int64_t)data
[1] / (int64_t)normal
/ (int64_t)data
[0];
391 norm_avg
= -norm_avg
;
393 dt_multiply_128((uint64_t)norm_avg
, (uint64_t)norm_avg
, square_of_avg
);
395 dt_subtract_128(avg_of_squares
, square_of_avg
, diff
);
397 return (dt_sqrt_128(diff
));
401 dt_flowindent(dtrace_hdl_t
*dtp
, dtrace_probedata_t
*data
, dtrace_epid_t last
,
402 dtrace_bufdesc_t
*buf
, size_t offs
)
404 dtrace_probedesc_t
*pd
= data
->dtpda_pdesc
, *npd
;
405 dtrace_eprobedesc_t
*epd
= data
->dtpda_edesc
, *nepd
;
406 char *p
= pd
->dtpd_provider
, *n
= pd
->dtpd_name
, *sub
;
407 dtrace_flowkind_t flow
= DTRACEFLOW_NONE
;
408 const char *str
= NULL
;
409 static const char *e_str
[2] = { " -> ", " => " };
410 static const char *r_str
[2] = { " <- ", " <= " };
411 static const char *ent
= "entry", *ret
= "return";
412 static int entlen
= 0, retlen
= 0;
413 dtrace_epid_t next
, id
= epd
->dtepd_epid
;
418 entlen
= strlen(ent
);
419 retlen
= strlen(ret
);
423 * If the name of the probe is "entry" or ends with "-entry", we
424 * treat it as an entry; if it is "return" or ends with "-return",
425 * we treat it as a return. (This allows application-provided probes
426 * like "method-entry" or "function-entry" to participate in flow
427 * indentation -- without accidentally misinterpreting popular probe
428 * names like "carpentry", "gentry" or "Coventry".)
430 if ((sub
= strstr(n
, ent
)) != NULL
&& sub
[entlen
] == '\0' &&
431 (sub
== n
|| sub
[-1] == '-')) {
432 flow
= DTRACEFLOW_ENTRY
;
433 str
= e_str
[strcmp(p
, "syscall") == 0];
434 } else if ((sub
= strstr(n
, ret
)) != NULL
&& sub
[retlen
] == '\0' &&
435 (sub
== n
|| sub
[-1] == '-')) {
436 flow
= DTRACEFLOW_RETURN
;
437 str
= r_str
[strcmp(p
, "syscall") == 0];
441 * If we're going to indent this, we need to check the ID of our last
442 * call. If we're looking at the same probe ID but a different EPID,
443 * we _don't_ want to indent. (Yes, there are some minor holes in
444 * this scheme -- it's a heuristic.)
446 if (flow
== DTRACEFLOW_ENTRY
) {
447 if ((last
!= DTRACE_EPIDNONE
&& id
!= last
&&
448 pd
->dtpd_id
== dtp
->dt_pdesc
[last
]->dtpd_id
))
449 flow
= DTRACEFLOW_NONE
;
453 * If we're going to unindent this, it's more difficult to see if
454 * we don't actually want to unindent it -- we need to look at the
457 if (flow
== DTRACEFLOW_RETURN
) {
458 offs
+= epd
->dtepd_size
;
461 if (offs
>= buf
->dtbd_size
)
464 next
= *(uint32_t *)((uintptr_t)buf
->dtbd_data
+ offs
);
466 if (next
== DTRACE_EPIDNONE
)
468 } while (next
== DTRACE_EPIDNONE
);
470 if ((rval
= dt_epid_lookup(dtp
, next
, &nepd
, &npd
)) != 0)
473 if (next
!= id
&& npd
->dtpd_id
== pd
->dtpd_id
)
474 flow
= DTRACEFLOW_NONE
;
478 if (flow
== DTRACEFLOW_ENTRY
|| flow
== DTRACEFLOW_RETURN
) {
479 data
->dtpda_prefix
= str
;
481 data
->dtpda_prefix
= "| ";
484 if (flow
== DTRACEFLOW_RETURN
&& data
->dtpda_indent
> 0)
485 data
->dtpda_indent
-= 2;
487 data
->dtpda_flow
= flow
;
495 return (DTRACE_CONSUME_THIS
);
501 return (DTRACE_CONSUME_NEXT
);
505 dt_quantize_total(dtrace_hdl_t
*dtp
, int64_t datum
, long double *total
)
507 long double val
= dt_fabsl((long double)datum
);
509 if (dtp
->dt_options
[DTRACEOPT_AGGZOOM
] == DTRACEOPT_UNSET
) {
515 * If we're zooming in on an aggregation, we want the height of the
516 * highest value to be approximately 95% of total bar height -- so we
517 * adjust up by the reciprocal of DTRACE_AGGZOOM_MAX when comparing to
520 val
*= 1 / DTRACE_AGGZOOM_MAX
;
527 dt_print_quanthdr(dtrace_hdl_t
*dtp
, FILE *fp
, int width
)
529 return (dt_printf(dtp
, fp
, "\n%*s %41s %-9s\n",
530 width
? width
: 16, width
? "key" : "value",
531 "------------- Distribution -------------", "count"));
535 dt_print_quanthdr_packed(dtrace_hdl_t
*dtp
, FILE *fp
, int width
,
536 const dtrace_aggdata_t
*aggdata
, dtrace_actkind_t action
)
538 int min
= aggdata
->dtada_minbin
, max
= aggdata
->dtada_maxbin
;
539 int minwidth
, maxwidth
, i
;
541 assert(action
== DTRACEAGG_QUANTIZE
|| action
== DTRACEAGG_LQUANTIZE
);
543 if (action
== DTRACEAGG_QUANTIZE
) {
544 if (min
!= 0 && min
!= DTRACE_QUANTIZE_ZEROBUCKET
)
547 if (max
< DTRACE_QUANTIZE_NBUCKETS
- 1)
550 minwidth
= dt_ndigits(DTRACE_QUANTIZE_BUCKETVAL(min
));
551 maxwidth
= dt_ndigits(DTRACE_QUANTIZE_BUCKETVAL(max
));
554 minwidth
= maxwidth
- 1;
558 if (dt_printf(dtp
, fp
, "\n%*s %*s .",
559 width
, width
> 0 ? "key" : "", minwidth
, "min") < 0)
562 for (i
= min
; i
<= max
; i
++) {
563 if (dt_printf(dtp
, fp
, "-") < 0)
567 return (dt_printf(dtp
, fp
, ". %*s | count\n", -maxwidth
, "max"));
571 * We use a subset of the Unicode Block Elements (U+2588 through U+258F,
572 * inclusive) to represent aggregations via UTF-8 -- which are expressed via
573 * 3-byte UTF-8 sequences.
575 #define DTRACE_AGGUTF8_FULL 0x2588
576 #define DTRACE_AGGUTF8_BASE 0x258f
577 #define DTRACE_AGGUTF8_LEVELS 8
579 #define DTRACE_AGGUTF8_BYTE0(val) (0xe0 | ((val) >> 12))
580 #define DTRACE_AGGUTF8_BYTE1(val) (0x80 | (((val) >> 6) & 0x3f))
581 #define DTRACE_AGGUTF8_BYTE2(val) (0x80 | ((val) & 0x3f))
584 dt_print_quantline_utf8(dtrace_hdl_t
*dtp
, FILE *fp
, int64_t val
,
585 uint64_t normal
, long double total
)
587 uint_t len
= 40, i
, whole
, partial
;
588 long double f
= (dt_fabsl((long double)val
) * len
) / total
;
589 const char *spaces
= " ";
592 partial
= (uint_t
)((f
- (long double)(uint_t
)f
) *
593 (long double)DTRACE_AGGUTF8_LEVELS
);
595 if (dt_printf(dtp
, fp
, "|") < 0)
598 for (i
= 0; i
< whole
; i
++) {
599 if (dt_printf(dtp
, fp
, "%c%c%c",
600 DTRACE_AGGUTF8_BYTE0(DTRACE_AGGUTF8_FULL
),
601 DTRACE_AGGUTF8_BYTE1(DTRACE_AGGUTF8_FULL
),
602 DTRACE_AGGUTF8_BYTE2(DTRACE_AGGUTF8_FULL
)) < 0)
607 partial
= DTRACE_AGGUTF8_BASE
- (partial
- 1);
609 if (dt_printf(dtp
, fp
, "%c%c%c",
610 DTRACE_AGGUTF8_BYTE0(partial
),
611 DTRACE_AGGUTF8_BYTE1(partial
),
612 DTRACE_AGGUTF8_BYTE2(partial
)) < 0)
618 return (dt_printf(dtp
, fp
, "%s %-9lld\n", spaces
+ i
,
619 (long long)val
/ normal
));
623 dt_print_quantline(dtrace_hdl_t
*dtp
, FILE *fp
, int64_t val
,
624 uint64_t normal
, long double total
, char positives
, char negatives
)
627 uint_t depth
, len
= 40;
629 const char *ats
= "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@";
630 const char *spaces
= " ";
632 assert(strlen(ats
) == len
&& strlen(spaces
) == len
);
633 assert(!(total
== 0 && (positives
|| negatives
)));
634 assert(!(val
< 0 && !negatives
));
635 assert(!(val
> 0 && !positives
));
636 assert(!(val
!= 0 && total
== 0));
640 if (dtp
->dt_encoding
== DT_ENCODING_UTF8
) {
641 return (dt_print_quantline_utf8(dtp
, fp
, val
,
645 f
= (dt_fabsl((long double)val
) * len
) / total
;
646 depth
= (uint_t
)(f
+ 0.5);
651 return (dt_printf(dtp
, fp
, "|%s%s %-9lld\n", ats
+ len
- depth
,
652 spaces
+ depth
, (long long)val
/ normal
));
656 f
= (dt_fabsl((long double)val
) * len
) / total
;
657 depth
= (uint_t
)(f
+ 0.5);
659 return (dt_printf(dtp
, fp
, "%s%s| %-9lld\n", spaces
+ depth
,
660 ats
+ len
- depth
, (long long)val
/ normal
));
664 * If we're here, we have both positive and negative bucket values.
665 * To express this graphically, we're going to generate both positive
666 * and negative bars separated by a centerline. These bars are half
667 * the size of normal quantize()/lquantize() bars, so we divide the
668 * length in half before calculating the bar length.
672 spaces
= &spaces
[len
];
674 f
= (dt_fabsl((long double)val
) * len
) / total
;
675 depth
= (uint_t
)(f
+ 0.5);
678 return (dt_printf(dtp
, fp
, "%s%s|%*s %-9lld\n", spaces
+ depth
,
679 ats
+ len
- depth
, len
, "", (long long)val
/ normal
));
681 return (dt_printf(dtp
, fp
, "%20s|%s%s %-9lld\n", "",
682 ats
+ len
- depth
, spaces
+ depth
,
683 (long long)val
/ normal
));
688 * As with UTF-8 printing of aggregations, we use a subset of the Unicode
689 * Block Elements (U+2581 through U+2588, inclusive) to represent our packed
692 #define DTRACE_AGGPACK_BASE 0x2581
693 #define DTRACE_AGGPACK_LEVELS 8
696 dt_print_packed(dtrace_hdl_t
*dtp
, FILE *fp
,
697 long double datum
, long double total
)
699 static boolean_t utf8_checked
= B_FALSE
;
700 static boolean_t utf8
;
701 char *ascii
= "__xxxxXX";
702 char *neg
= "vvvvVV";
710 * We want to determine if we can reasonably emit UTF-8 for our
711 * packed aggregation. To do this, we will check for terminals
712 * that are known to be primitive to emit UTF-8 on these.
714 utf8_checked
= B_TRUE
;
716 if (dtp
->dt_encoding
== DT_ENCODING_ASCII
) {
718 } else if (dtp
->dt_encoding
== DT_ENCODING_UTF8
) {
720 } else if ((term
= getenv("TERM")) != NULL
&&
721 (strcmp(term
, "sun") == 0 ||
722 strcmp(term
, "sun-color") == 0) ||
723 strcmp(term
, "dumb") == 0) {
731 return (dt_printf(dtp
, fp
, " "));
735 val
= dt_fabsl(datum
* (len
- 1)) / total
;
736 return (dt_printf(dtp
, fp
, "%c", neg
[(uint_t
)(val
+ 0.5)]));
740 int block
= DTRACE_AGGPACK_BASE
+ (unsigned int)(((datum
*
741 (DTRACE_AGGPACK_LEVELS
- 1)) / total
) + 0.5);
743 return (dt_printf(dtp
, fp
, "%c%c%c",
744 DTRACE_AGGUTF8_BYTE0(block
),
745 DTRACE_AGGUTF8_BYTE1(block
),
746 DTRACE_AGGUTF8_BYTE2(block
)));
750 val
= (datum
* (len
- 1)) / total
;
751 return (dt_printf(dtp
, fp
, "%c", ascii
[(uint_t
)(val
+ 0.5)]));
755 dt_print_quantize(dtrace_hdl_t
*dtp
, FILE *fp
, const void *addr
,
756 size_t size
, uint64_t normal
)
758 const int64_t *data
= addr
;
759 int i
, first_bin
= 0, last_bin
= DTRACE_QUANTIZE_NBUCKETS
- 1;
760 long double total
= 0;
761 char positives
= 0, negatives
= 0;
763 if (size
!= DTRACE_QUANTIZE_NBUCKETS
* sizeof (uint64_t))
764 return (dt_set_errno(dtp
, EDT_DMISMATCH
));
766 while (first_bin
< DTRACE_QUANTIZE_NBUCKETS
- 1 && data
[first_bin
] == 0)
769 if (first_bin
== DTRACE_QUANTIZE_NBUCKETS
- 1) {
771 * There isn't any data. This is possible if the aggregation
772 * has been clear()'d or if negative increment values have been
773 * used. Regardless, we'll print the buckets around 0.
775 first_bin
= DTRACE_QUANTIZE_ZEROBUCKET
- 1;
776 last_bin
= DTRACE_QUANTIZE_ZEROBUCKET
+ 1;
781 while (last_bin
> 0 && data
[last_bin
] == 0)
784 if (last_bin
< DTRACE_QUANTIZE_NBUCKETS
- 1)
788 for (i
= first_bin
; i
<= last_bin
; i
++) {
789 positives
|= (data
[i
] > 0);
790 negatives
|= (data
[i
] < 0);
791 dt_quantize_total(dtp
, data
[i
], &total
);
794 if (dt_print_quanthdr(dtp
, fp
, 0) < 0)
797 for (i
= first_bin
; i
<= last_bin
; i
++) {
798 if (dt_printf(dtp
, fp
, "%16lld ",
799 (long long)DTRACE_QUANTIZE_BUCKETVAL(i
)) < 0)
802 if (dt_print_quantline(dtp
, fp
, data
[i
], normal
, total
,
803 positives
, negatives
) < 0)
811 dt_print_quantize_packed(dtrace_hdl_t
*dtp
, FILE *fp
, const void *addr
,
812 size_t size
, const dtrace_aggdata_t
*aggdata
)
814 const int64_t *data
= addr
;
815 long double total
= 0, count
= 0;
816 int min
= aggdata
->dtada_minbin
, max
= aggdata
->dtada_maxbin
, i
;
817 int64_t minval
, maxval
;
819 if (size
!= DTRACE_QUANTIZE_NBUCKETS
* sizeof (uint64_t))
820 return (dt_set_errno(dtp
, EDT_DMISMATCH
));
822 if (min
!= 0 && min
!= DTRACE_QUANTIZE_ZEROBUCKET
)
825 if (max
< DTRACE_QUANTIZE_NBUCKETS
- 1)
828 minval
= DTRACE_QUANTIZE_BUCKETVAL(min
);
829 maxval
= DTRACE_QUANTIZE_BUCKETVAL(max
);
831 if (dt_printf(dtp
, fp
, " %*lld :", dt_ndigits(minval
),
832 (long long)minval
) < 0)
835 for (i
= min
; i
<= max
; i
++) {
836 dt_quantize_total(dtp
, data
[i
], &total
);
840 for (i
= min
; i
<= max
; i
++) {
841 if (dt_print_packed(dtp
, fp
, data
[i
], total
) < 0)
845 if (dt_printf(dtp
, fp
, ": %*lld | %lld\n",
846 -dt_ndigits(maxval
), (long long)maxval
, (long long)count
) < 0)
853 dt_print_lquantize(dtrace_hdl_t
*dtp
, FILE *fp
, const void *addr
,
854 size_t size
, uint64_t normal
)
856 const int64_t *data
= addr
;
857 int i
, first_bin
, last_bin
, base
;
859 long double total
= 0;
860 uint16_t step
, levels
;
861 char positives
= 0, negatives
= 0;
863 if (size
< sizeof (uint64_t))
864 return (dt_set_errno(dtp
, EDT_DMISMATCH
));
867 size
-= sizeof (uint64_t);
869 base
= DTRACE_LQUANTIZE_BASE(arg
);
870 step
= DTRACE_LQUANTIZE_STEP(arg
);
871 levels
= DTRACE_LQUANTIZE_LEVELS(arg
);
874 last_bin
= levels
+ 1;
876 if (size
!= sizeof (uint64_t) * (levels
+ 2))
877 return (dt_set_errno(dtp
, EDT_DMISMATCH
));
879 while (first_bin
<= levels
+ 1 && data
[first_bin
] == 0)
882 if (first_bin
> levels
+ 1) {
889 while (last_bin
> 0 && data
[last_bin
] == 0)
892 if (last_bin
< levels
+ 1)
896 for (i
= first_bin
; i
<= last_bin
; i
++) {
897 positives
|= (data
[i
] > 0);
898 negatives
|= (data
[i
] < 0);
899 dt_quantize_total(dtp
, data
[i
], &total
);
902 if (dt_printf(dtp
, fp
, "\n%16s %41s %-9s\n", "value",
903 "------------- Distribution -------------", "count") < 0)
906 for (i
= first_bin
; i
<= last_bin
; i
++) {
911 (void) snprintf(c
, sizeof (c
), "< %d", base
);
912 err
= dt_printf(dtp
, fp
, "%16s ", c
);
913 } else if (i
== levels
+ 1) {
914 (void) snprintf(c
, sizeof (c
), ">= %d",
915 base
+ (levels
* step
));
916 err
= dt_printf(dtp
, fp
, "%16s ", c
);
918 err
= dt_printf(dtp
, fp
, "%16d ",
919 base
+ (i
- 1) * step
);
922 if (err
< 0 || dt_print_quantline(dtp
, fp
, data
[i
], normal
,
923 total
, positives
, negatives
) < 0)
932 dt_print_lquantize_packed(dtrace_hdl_t
*dtp
, FILE *fp
, const void *addr
,
933 size_t size
, const dtrace_aggdata_t
*aggdata
)
935 const int64_t *data
= addr
;
936 long double total
= 0, count
= 0;
937 int min
, max
, base
, err
;
939 uint16_t step
, levels
;
943 if (size
< sizeof (uint64_t))
944 return (dt_set_errno(dtp
, EDT_DMISMATCH
));
947 size
-= sizeof (uint64_t);
949 base
= DTRACE_LQUANTIZE_BASE(arg
);
950 step
= DTRACE_LQUANTIZE_STEP(arg
);
951 levels
= DTRACE_LQUANTIZE_LEVELS(arg
);
953 if (size
!= sizeof (uint64_t) * (levels
+ 2))
954 return (dt_set_errno(dtp
, EDT_DMISMATCH
));
960 (void) snprintf(c
, sizeof (c
), "< %d", base
);
961 err
= dt_printf(dtp
, fp
, "%8s :", c
);
963 err
= dt_printf(dtp
, fp
, "%8d :", base
+ (min
- 1) * step
);
969 for (i
= min
; i
<= max
; i
++) {
970 dt_quantize_total(dtp
, data
[i
], &total
);
974 for (i
= min
; i
<= max
; i
++) {
975 if (dt_print_packed(dtp
, fp
, data
[i
], total
) < 0)
979 (void) snprintf(c
, sizeof (c
), ">= %d", base
+ (levels
* step
));
980 return (dt_printf(dtp
, fp
, ": %-8s | %lld\n", c
, (long long)count
));
984 dt_print_llquantize(dtrace_hdl_t
*dtp
, FILE *fp
, const void *addr
,
985 size_t size
, uint64_t normal
)
987 int i
, first_bin
, last_bin
, bin
= 1, order
, levels
;
988 uint16_t factor
, low
, high
, nsteps
;
989 const int64_t *data
= addr
;
990 int64_t value
= 1, next
, step
;
991 char positives
= 0, negatives
= 0;
992 long double total
= 0;
996 if (size
< sizeof (uint64_t))
997 return (dt_set_errno(dtp
, EDT_DMISMATCH
));
1000 size
-= sizeof (uint64_t);
1002 factor
= DTRACE_LLQUANTIZE_FACTOR(arg
);
1003 low
= DTRACE_LLQUANTIZE_LOW(arg
);
1004 high
= DTRACE_LLQUANTIZE_HIGH(arg
);
1005 nsteps
= DTRACE_LLQUANTIZE_NSTEP(arg
);
1008 * We don't expect to be handed invalid llquantize() parameters here,
1009 * but sanity check them (to a degree) nonetheless.
1011 if (size
> INT32_MAX
|| factor
< 2 || low
>= high
||
1012 nsteps
== 0 || factor
> nsteps
)
1013 return (dt_set_errno(dtp
, EDT_DMISMATCH
));
1015 levels
= (int)size
/ sizeof (uint64_t);
1018 last_bin
= levels
- 1;
1020 while (first_bin
< levels
&& data
[first_bin
] == 0)
1023 if (first_bin
== levels
) {
1030 while (last_bin
> 0 && data
[last_bin
] == 0)
1033 if (last_bin
< levels
- 1)
1037 for (i
= first_bin
; i
<= last_bin
; i
++) {
1038 positives
|= (data
[i
] > 0);
1039 negatives
|= (data
[i
] < 0);
1040 dt_quantize_total(dtp
, data
[i
], &total
);
1043 if (dt_printf(dtp
, fp
, "\n%16s %41s %-9s\n", "value",
1044 "------------- Distribution -------------", "count") < 0)
1047 for (order
= 0; order
< low
; order
++)
1050 next
= value
* factor
;
1051 step
= next
> nsteps
? next
/ nsteps
: 1;
1053 if (first_bin
== 0) {
1054 (void) snprintf(c
, sizeof (c
), "< %lld", value
);
1056 if (dt_printf(dtp
, fp
, "%16s ", c
) < 0)
1059 if (dt_print_quantline(dtp
, fp
, data
[0], normal
,
1060 total
, positives
, negatives
) < 0)
1064 while (order
<= high
) {
1065 if (bin
>= first_bin
&& bin
<= last_bin
) {
1066 if (dt_printf(dtp
, fp
, "%16lld ", (long long)value
) < 0)
1069 if (dt_print_quantline(dtp
, fp
, data
[bin
],
1070 normal
, total
, positives
, negatives
) < 0)
1074 assert(value
< next
);
1077 if ((value
+= step
) != next
)
1080 next
= value
* factor
;
1081 step
= next
> nsteps
? next
/ nsteps
: 1;
1088 assert(last_bin
== bin
);
1089 (void) snprintf(c
, sizeof (c
), ">= %lld", value
);
1091 if (dt_printf(dtp
, fp
, "%16s ", c
) < 0)
1094 return (dt_print_quantline(dtp
, fp
, data
[bin
], normal
,
1095 total
, positives
, negatives
));
1100 dt_print_average(dtrace_hdl_t
*dtp
, FILE *fp
, caddr_t addr
,
1101 size_t size
, uint64_t normal
)
1103 /* LINTED - alignment */
1104 int64_t *data
= (int64_t *)addr
;
1106 return (dt_printf(dtp
, fp
, " %16lld", data
[0] ?
1107 (long long)(data
[1] / (int64_t)normal
/ data
[0]) : 0));
1112 dt_print_stddev(dtrace_hdl_t
*dtp
, FILE *fp
, caddr_t addr
,
1113 size_t size
, uint64_t normal
)
1115 /* LINTED - alignment */
1116 uint64_t *data
= (uint64_t *)addr
;
1118 return (dt_printf(dtp
, fp
, " %16llu", data
[0] ?
1119 (unsigned long long) dt_stddev(data
, normal
) : 0));
1124 dt_print_bytes(dtrace_hdl_t
*dtp
, FILE *fp
, caddr_t addr
,
1125 size_t nbytes
, int width
, int quiet
, int forceraw
)
1128 * If the byte stream is a series of printable characters, followed by
1129 * a terminating byte, we print it out as a string. Otherwise, we
1130 * assume that it's something else and just print the bytes.
1132 int i
, j
, margin
= 5;
1133 char *c
= (char *)addr
;
1141 if (dtp
->dt_options
[DTRACEOPT_RAWBYTES
] != DTRACEOPT_UNSET
)
1144 for (i
= 0; i
< nbytes
; i
++) {
1146 * We define a "printable character" to be one for which
1147 * isprint(3C) returns non-zero, isspace(3C) returns non-zero,
1148 * or a character which is either backspace or the bell.
1149 * Backspace and the bell are regrettably special because
1150 * they fail the first two tests -- and yet they are entirely
1151 * printable. These are the only two control characters that
1152 * have meaning for the terminal and for which isprint(3C) and
1153 * isspace(3C) return 0.
1155 if (isprint(c
[i
]) || isspace(c
[i
]) ||
1156 c
[i
] == '\b' || c
[i
] == '\a')
1159 if (c
[i
] == '\0' && i
> 0) {
1161 * This looks like it might be a string. Before we
1162 * assume that it is indeed a string, check the
1163 * remainder of the byte range; if it contains
1164 * additional non-nul characters, we'll assume that
1165 * it's a binary stream that just happens to look like
1166 * a string, and we'll print out the individual bytes.
1168 for (j
= i
+ 1; j
< nbytes
; j
++) {
1177 return (dt_printf(dtp
, fp
, "%s", c
));
1179 return (dt_printf(dtp
, fp
, " %s%*s",
1180 width
< 0 ? " " : "", width
, c
));
1189 * The byte range is all printable characters, but there is
1190 * no trailing nul byte. We'll assume that it's a string and
1193 char *s
= alloca(nbytes
+ 1);
1194 bcopy(c
, s
, nbytes
);
1196 return (dt_printf(dtp
, fp
, " %-*s", width
, s
));
1200 if (dt_printf(dtp
, fp
, "\n%*s ", margin
, "") < 0)
1203 for (i
= 0; i
< 16; i
++)
1204 if (dt_printf(dtp
, fp
, " %c", "0123456789abcdef"[i
]) < 0)
1207 if (dt_printf(dtp
, fp
, " 0123456789abcdef\n") < 0)
1211 for (i
= 0; i
< nbytes
; i
+= 16) {
1212 if (dt_printf(dtp
, fp
, "%*s%5x:", margin
, "", i
) < 0)
1215 for (j
= i
; j
< i
+ 16 && j
< nbytes
; j
++) {
1216 if (dt_printf(dtp
, fp
, " %02x", (uchar_t
)c
[j
]) < 0)
1221 if (dt_printf(dtp
, fp
, " ") < 0)
1225 if (dt_printf(dtp
, fp
, " ") < 0)
1228 for (j
= i
; j
< i
+ 16 && j
< nbytes
; j
++) {
1229 if (dt_printf(dtp
, fp
, "%c",
1230 c
[j
] < ' ' || c
[j
] > '~' ? '.' : c
[j
]) < 0)
1234 if (dt_printf(dtp
, fp
, "\n") < 0)
1242 dt_print_stack(dtrace_hdl_t
*dtp
, FILE *fp
, const char *format
,
1243 caddr_t addr
, int depth
, int size
)
1245 dtrace_syminfo_t dts
;
1248 char c
[PATH_MAX
* 2];
1251 if (dt_printf(dtp
, fp
, "\n") < 0)
1257 if (dtp
->dt_options
[DTRACEOPT_STACKINDENT
] != DTRACEOPT_UNSET
)
1258 indent
= (int)dtp
->dt_options
[DTRACEOPT_STACKINDENT
];
1260 indent
= _dtrace_stkindent
;
1262 for (i
= 0; i
< depth
; i
++) {
1264 case sizeof (uint32_t):
1265 /* LINTED - alignment */
1266 pc
= *((uint32_t *)addr
);
1269 case sizeof (uint64_t):
1270 /* LINTED - alignment */
1271 pc
= *((uint64_t *)addr
);
1275 return (dt_set_errno(dtp
, EDT_BADSTACKPC
));
1283 if (dt_printf(dtp
, fp
, "%*s", indent
, "") < 0)
1286 if (dtrace_lookup_by_addr(dtp
, pc
, &sym
, &dts
) == 0) {
1287 if (pc
> sym
.st_value
) {
1288 (void) snprintf(c
, sizeof (c
), "%s`%s+0x%llx",
1289 dts
.dts_object
, dts
.dts_name
,
1292 (void) snprintf(c
, sizeof (c
), "%s`%s",
1293 dts
.dts_object
, dts
.dts_name
);
1297 * We'll repeat the lookup, but this time we'll specify
1298 * a NULL GElf_Sym -- indicating that we're only
1299 * interested in the containing module.
1301 if (dtrace_lookup_by_addr(dtp
, pc
, NULL
, &dts
) == 0) {
1302 (void) snprintf(c
, sizeof (c
), "%s`0x%llx",
1303 dts
.dts_object
, pc
);
1305 (void) snprintf(c
, sizeof (c
), "0x%llx", pc
);
1309 if (dt_printf(dtp
, fp
, format
, c
) < 0)
1312 if (dt_printf(dtp
, fp
, "\n") < 0)
1320 dt_print_ustack(dtrace_hdl_t
*dtp
, FILE *fp
, const char *format
,
1321 caddr_t addr
, uint64_t arg
)
1323 /* LINTED - alignment */
1324 uint64_t *pc
= (uint64_t *)addr
;
1325 uint32_t depth
= DTRACE_USTACK_NFRAMES(arg
);
1326 uint32_t strsize
= DTRACE_USTACK_STRSIZE(arg
);
1327 const char *strbase
= addr
+ (depth
+ 1) * sizeof (uint64_t);
1328 const char *str
= strsize
? strbase
: NULL
;
1331 char name
[PATH_MAX
], objname
[PATH_MAX
], c
[PATH_MAX
* 2];
1332 struct ps_prochandle
*P
;
1342 if (dt_printf(dtp
, fp
, "\n") < 0)
1348 if (dtp
->dt_options
[DTRACEOPT_STACKINDENT
] != DTRACEOPT_UNSET
)
1349 indent
= (int)dtp
->dt_options
[DTRACEOPT_STACKINDENT
];
1351 indent
= _dtrace_stkindent
;
1354 * Ultimately, we need to add an entry point in the library vector for
1355 * determining <symbol, offset> from <pid, address>. For now, if
1356 * this is a vector open, we just print the raw address or string.
1358 if (dtp
->dt_vector
== NULL
)
1359 P
= dt_proc_grab(dtp
, pid
, PGRAB_RDONLY
| PGRAB_FORCE
, 0);
1364 dt_proc_lock(dtp
, P
); /* lock handle while we perform lookups */
1366 for (i
= 0; i
< depth
&& pc
[i
] != NULL
; i
++) {
1369 if ((err
= dt_printf(dtp
, fp
, "%*s", indent
, "")) < 0)
1372 if (P
!= NULL
&& Plookup_by_addr(P
, pc
[i
],
1373 name
, sizeof (name
), &sym
) == 0) {
1374 (void) Pobjname(P
, pc
[i
], objname
, sizeof (objname
));
1376 if (pc
[i
] > sym
.st_value
) {
1377 (void) snprintf(c
, sizeof (c
),
1378 "%s`%s+0x%llx", dt_basename(objname
), name
,
1379 (u_longlong_t
)(pc
[i
] - sym
.st_value
));
1381 (void) snprintf(c
, sizeof (c
),
1382 "%s`%s", dt_basename(objname
), name
);
1384 } else if (str
!= NULL
&& str
[0] != '\0' && str
[0] != '@' &&
1385 (P
== NULL
|| (map
= Paddr_to_map(P
, pc
[i
])) == NULL
||
1386 map
->pr_mflags
& MA_WRITE
)) {
1388 * If the current string pointer in the string table
1389 * does not point to an empty string _and_ the program
1390 * counter falls in a writable region, we'll use the
1391 * string from the string table instead of the raw
1392 * address. This last condition is necessary because
1393 * some (broken) ustack helpers will return a string
1394 * even for a program counter that they can't
1395 * identify. If we have a string for a program
1396 * counter that falls in a segment that isn't
1397 * writable, we assume that we have fallen into this
1398 * case and we refuse to use the string. Finally,
1399 * note that if we could not grab the process (e.g.,
1400 * because it exited), the information from the helper
1401 * is better than nothing.
1403 (void) snprintf(c
, sizeof (c
), "%s", str
);
1405 if (P
!= NULL
&& Pobjname(P
, pc
[i
], objname
,
1406 sizeof (objname
)) != NULL
) {
1407 (void) snprintf(c
, sizeof (c
), "%s`0x%llx",
1408 dt_basename(objname
), (u_longlong_t
)pc
[i
]);
1410 (void) snprintf(c
, sizeof (c
), "0x%llx",
1411 (u_longlong_t
)pc
[i
]);
1415 if ((err
= dt_printf(dtp
, fp
, format
, c
)) < 0)
1418 if ((err
= dt_printf(dtp
, fp
, "\n")) < 0)
1421 if (str
!= NULL
&& str
[0] == '@') {
1423 * If the first character of the string is an "at" sign,
1424 * then the string is inferred to be an annotation --
1425 * and it is printed out beneath the frame and offset
1428 if ((err
= dt_printf(dtp
, fp
, "%*s", indent
, "")) < 0)
1431 (void) snprintf(c
, sizeof (c
), " [ %s ]", &str
[1]);
1433 if ((err
= dt_printf(dtp
, fp
, format
, c
)) < 0)
1436 if ((err
= dt_printf(dtp
, fp
, "\n")) < 0)
1441 str
+= strlen(str
) + 1;
1442 if (str
- strbase
>= strsize
)
1448 dt_proc_unlock(dtp
, P
);
1449 dt_proc_release(dtp
, P
);
1456 dt_print_usym(dtrace_hdl_t
*dtp
, FILE *fp
, caddr_t addr
, dtrace_actkind_t act
)
1458 /* LINTED - alignment */
1459 uint64_t pid
= ((uint64_t *)addr
)[0];
1460 /* LINTED - alignment */
1461 uint64_t pc
= ((uint64_t *)addr
)[1];
1462 const char *format
= " %-50s";
1466 if (act
== DTRACEACT_USYM
&& dtp
->dt_vector
== NULL
) {
1467 struct ps_prochandle
*P
;
1469 if ((P
= dt_proc_grab(dtp
, pid
,
1470 PGRAB_RDONLY
| PGRAB_FORCE
, 0)) != NULL
) {
1473 dt_proc_lock(dtp
, P
);
1475 if (Plookup_by_addr(P
, pc
, NULL
, 0, &sym
) == 0)
1478 dt_proc_unlock(dtp
, P
);
1479 dt_proc_release(dtp
, P
);
1486 } while ((len
= dtrace_uaddr2str(dtp
, pid
, pc
, s
, n
)) > n
);
1488 return (dt_printf(dtp
, fp
, format
, s
));
1492 dt_print_umod(dtrace_hdl_t
*dtp
, FILE *fp
, const char *format
, caddr_t addr
)
1494 /* LINTED - alignment */
1495 uint64_t pid
= ((uint64_t *)addr
)[0];
1496 /* LINTED - alignment */
1497 uint64_t pc
= ((uint64_t *)addr
)[1];
1500 char objname
[PATH_MAX
], c
[PATH_MAX
* 2];
1501 struct ps_prochandle
*P
;
1507 * See the comment in dt_print_ustack() for the rationale for
1508 * printing raw addresses in the vectored case.
1510 if (dtp
->dt_vector
== NULL
)
1511 P
= dt_proc_grab(dtp
, pid
, PGRAB_RDONLY
| PGRAB_FORCE
, 0);
1516 dt_proc_lock(dtp
, P
); /* lock handle while we perform lookups */
1518 if (P
!= NULL
&& Pobjname(P
, pc
, objname
, sizeof (objname
)) != NULL
) {
1519 (void) snprintf(c
, sizeof (c
), "%s", dt_basename(objname
));
1521 (void) snprintf(c
, sizeof (c
), "0x%llx", (u_longlong_t
)pc
);
1524 err
= dt_printf(dtp
, fp
, format
, c
);
1527 dt_proc_unlock(dtp
, P
);
1528 dt_proc_release(dtp
, P
);
1535 dt_print_sym(dtrace_hdl_t
*dtp
, FILE *fp
, const char *format
, caddr_t addr
)
1537 /* LINTED - alignment */
1538 uint64_t pc
= *((uint64_t *)addr
);
1539 dtrace_syminfo_t dts
;
1541 char c
[PATH_MAX
* 2];
1546 if (dtrace_lookup_by_addr(dtp
, pc
, &sym
, &dts
) == 0) {
1547 (void) snprintf(c
, sizeof (c
), "%s`%s",
1548 dts
.dts_object
, dts
.dts_name
);
1551 * We'll repeat the lookup, but this time we'll specify a
1552 * NULL GElf_Sym -- indicating that we're only interested in
1553 * the containing module.
1555 if (dtrace_lookup_by_addr(dtp
, pc
, NULL
, &dts
) == 0) {
1556 (void) snprintf(c
, sizeof (c
), "%s`0x%llx",
1557 dts
.dts_object
, (u_longlong_t
)pc
);
1559 (void) snprintf(c
, sizeof (c
), "0x%llx",
1564 if (dt_printf(dtp
, fp
, format
, c
) < 0)
1571 dt_print_mod(dtrace_hdl_t
*dtp
, FILE *fp
, const char *format
, caddr_t addr
)
1573 /* LINTED - alignment */
1574 uint64_t pc
= *((uint64_t *)addr
);
1575 dtrace_syminfo_t dts
;
1576 char c
[PATH_MAX
* 2];
1581 if (dtrace_lookup_by_addr(dtp
, pc
, NULL
, &dts
) == 0) {
1582 (void) snprintf(c
, sizeof (c
), "%s", dts
.dts_object
);
1584 (void) snprintf(c
, sizeof (c
), "0x%llx", (u_longlong_t
)pc
);
1587 if (dt_printf(dtp
, fp
, format
, c
) < 0)
1593 typedef struct dt_normal
{
1594 dtrace_aggvarid_t dtnd_id
;
1595 uint64_t dtnd_normal
;
1599 dt_normalize_agg(const dtrace_aggdata_t
*aggdata
, void *arg
)
1601 dt_normal_t
*normal
= arg
;
1602 dtrace_aggdesc_t
*agg
= aggdata
->dtada_desc
;
1603 dtrace_aggvarid_t id
= normal
->dtnd_id
;
1605 if (agg
->dtagd_nrecs
== 0)
1606 return (DTRACE_AGGWALK_NEXT
);
1608 if (agg
->dtagd_varid
!= id
)
1609 return (DTRACE_AGGWALK_NEXT
);
1611 ((dtrace_aggdata_t
*)aggdata
)->dtada_normal
= normal
->dtnd_normal
;
1612 return (DTRACE_AGGWALK_NORMALIZE
);
1616 dt_normalize(dtrace_hdl_t
*dtp
, caddr_t base
, dtrace_recdesc_t
*rec
)
1622 * We (should) have two records: the aggregation ID followed by the
1623 * normalization value.
1625 addr
= base
+ rec
->dtrd_offset
;
1627 if (rec
->dtrd_size
!= sizeof (dtrace_aggvarid_t
))
1628 return (dt_set_errno(dtp
, EDT_BADNORMAL
));
1630 /* LINTED - alignment */
1631 normal
.dtnd_id
= *((dtrace_aggvarid_t
*)addr
);
1634 if (rec
->dtrd_action
!= DTRACEACT_LIBACT
)
1635 return (dt_set_errno(dtp
, EDT_BADNORMAL
));
1637 if (rec
->dtrd_arg
!= DT_ACT_NORMALIZE
)
1638 return (dt_set_errno(dtp
, EDT_BADNORMAL
));
1640 addr
= base
+ rec
->dtrd_offset
;
1642 switch (rec
->dtrd_size
) {
1643 case sizeof (uint64_t):
1644 /* LINTED - alignment */
1645 normal
.dtnd_normal
= *((uint64_t *)addr
);
1647 case sizeof (uint32_t):
1648 /* LINTED - alignment */
1649 normal
.dtnd_normal
= *((uint32_t *)addr
);
1651 case sizeof (uint16_t):
1652 /* LINTED - alignment */
1653 normal
.dtnd_normal
= *((uint16_t *)addr
);
1655 case sizeof (uint8_t):
1656 normal
.dtnd_normal
= *((uint8_t *)addr
);
1659 return (dt_set_errno(dtp
, EDT_BADNORMAL
));
1662 (void) dtrace_aggregate_walk(dtp
, dt_normalize_agg
, &normal
);
1668 dt_denormalize_agg(const dtrace_aggdata_t
*aggdata
, void *arg
)
1670 dtrace_aggdesc_t
*agg
= aggdata
->dtada_desc
;
1671 dtrace_aggvarid_t id
= *((dtrace_aggvarid_t
*)arg
);
1673 if (agg
->dtagd_nrecs
== 0)
1674 return (DTRACE_AGGWALK_NEXT
);
1676 if (agg
->dtagd_varid
!= id
)
1677 return (DTRACE_AGGWALK_NEXT
);
1679 return (DTRACE_AGGWALK_DENORMALIZE
);
1683 dt_clear_agg(const dtrace_aggdata_t
*aggdata
, void *arg
)
1685 dtrace_aggdesc_t
*agg
= aggdata
->dtada_desc
;
1686 dtrace_aggvarid_t id
= *((dtrace_aggvarid_t
*)arg
);
1688 if (agg
->dtagd_nrecs
== 0)
1689 return (DTRACE_AGGWALK_NEXT
);
1691 if (agg
->dtagd_varid
!= id
)
1692 return (DTRACE_AGGWALK_NEXT
);
1694 return (DTRACE_AGGWALK_CLEAR
);
1697 typedef struct dt_trunc
{
1698 dtrace_aggvarid_t dttd_id
;
1699 uint64_t dttd_remaining
;
1703 dt_trunc_agg(const dtrace_aggdata_t
*aggdata
, void *arg
)
1705 dt_trunc_t
*trunc
= arg
;
1706 dtrace_aggdesc_t
*agg
= aggdata
->dtada_desc
;
1707 dtrace_aggvarid_t id
= trunc
->dttd_id
;
1709 if (agg
->dtagd_nrecs
== 0)
1710 return (DTRACE_AGGWALK_NEXT
);
1712 if (agg
->dtagd_varid
!= id
)
1713 return (DTRACE_AGGWALK_NEXT
);
1715 if (trunc
->dttd_remaining
== 0)
1716 return (DTRACE_AGGWALK_REMOVE
);
1718 trunc
->dttd_remaining
--;
1719 return (DTRACE_AGGWALK_NEXT
);
1723 dt_trunc(dtrace_hdl_t
*dtp
, caddr_t base
, dtrace_recdesc_t
*rec
)
1728 int (*func
)(dtrace_hdl_t
*, dtrace_aggregate_f
*, void *);
1731 * We (should) have two records: the aggregation ID followed by the
1732 * number of aggregation entries after which the aggregation is to be
1735 addr
= base
+ rec
->dtrd_offset
;
1737 if (rec
->dtrd_size
!= sizeof (dtrace_aggvarid_t
))
1738 return (dt_set_errno(dtp
, EDT_BADTRUNC
));
1740 /* LINTED - alignment */
1741 trunc
.dttd_id
= *((dtrace_aggvarid_t
*)addr
);
1744 if (rec
->dtrd_action
!= DTRACEACT_LIBACT
)
1745 return (dt_set_errno(dtp
, EDT_BADTRUNC
));
1747 if (rec
->dtrd_arg
!= DT_ACT_TRUNC
)
1748 return (dt_set_errno(dtp
, EDT_BADTRUNC
));
1750 addr
= base
+ rec
->dtrd_offset
;
1752 switch (rec
->dtrd_size
) {
1753 case sizeof (uint64_t):
1754 /* LINTED - alignment */
1755 remaining
= *((int64_t *)addr
);
1757 case sizeof (uint32_t):
1758 /* LINTED - alignment */
1759 remaining
= *((int32_t *)addr
);
1761 case sizeof (uint16_t):
1762 /* LINTED - alignment */
1763 remaining
= *((int16_t *)addr
);
1765 case sizeof (uint8_t):
1766 remaining
= *((int8_t *)addr
);
1769 return (dt_set_errno(dtp
, EDT_BADNORMAL
));
1772 if (remaining
< 0) {
1773 func
= dtrace_aggregate_walk_valsorted
;
1774 remaining
= -remaining
;
1776 func
= dtrace_aggregate_walk_valrevsorted
;
1779 assert(remaining
>= 0);
1780 trunc
.dttd_remaining
= remaining
;
1782 (void) func(dtp
, dt_trunc_agg
, &trunc
);
1788 dt_print_datum(dtrace_hdl_t
*dtp
, FILE *fp
, dtrace_recdesc_t
*rec
,
1789 caddr_t addr
, size_t size
, const dtrace_aggdata_t
*aggdata
,
1790 uint64_t normal
, dt_print_aggdata_t
*pd
)
1793 dtrace_actkind_t act
= rec
->dtrd_action
;
1794 boolean_t packed
= pd
->dtpa_agghist
|| pd
->dtpa_aggpack
;
1795 dtrace_aggdesc_t
*agg
= aggdata
->dtada_desc
;
1801 } *fmt
, fmttab
[] = {
1802 { sizeof (uint8_t), 3, 3 },
1803 { sizeof (uint16_t), 5, 5 },
1804 { sizeof (uint32_t), 8, 8 },
1805 { sizeof (uint64_t), 16, 16 },
1809 if (packed
&& pd
->dtpa_agghisthdr
!= agg
->dtagd_varid
) {
1810 dtrace_recdesc_t
*r
;
1815 * To print our quantization header for either an agghist or
1816 * aggpack aggregation, we need to iterate through all of our
1817 * of our records to determine their width.
1819 for (r
= rec
; !DTRACEACT_ISAGG(r
->dtrd_action
); r
++) {
1820 for (fmt
= fmttab
; fmt
->size
&&
1821 fmt
->size
!= r
->dtrd_size
; fmt
++)
1824 width
+= fmt
->packedwidth
+ 1;
1827 if (pd
->dtpa_agghist
) {
1828 if (dt_print_quanthdr(dtp
, fp
, width
) < 0)
1831 if (dt_print_quanthdr_packed(dtp
, fp
,
1832 width
, aggdata
, r
->dtrd_action
) < 0)
1836 pd
->dtpa_agghisthdr
= agg
->dtagd_varid
;
1839 if (pd
->dtpa_agghist
&& DTRACEACT_ISAGG(act
)) {
1840 char positives
= aggdata
->dtada_flags
& DTRACE_A_HASPOSITIVES
;
1841 char negatives
= aggdata
->dtada_flags
& DTRACE_A_HASNEGATIVES
;
1844 assert(act
== DTRACEAGG_SUM
|| act
== DTRACEAGG_COUNT
);
1845 val
= (long long)*((uint64_t *)addr
);
1847 if (dt_printf(dtp
, fp
, " ") < 0)
1850 return (dt_print_quantline(dtp
, fp
, val
, normal
,
1851 aggdata
->dtada_total
, positives
, negatives
));
1854 if (pd
->dtpa_aggpack
&& DTRACEACT_ISAGG(act
)) {
1856 case DTRACEAGG_QUANTIZE
:
1857 return (dt_print_quantize_packed(dtp
,
1858 fp
, addr
, size
, aggdata
));
1859 case DTRACEAGG_LQUANTIZE
:
1860 return (dt_print_lquantize_packed(dtp
,
1861 fp
, addr
, size
, aggdata
));
1868 case DTRACEACT_STACK
:
1869 return (dt_print_stack(dtp
, fp
, NULL
, addr
,
1870 rec
->dtrd_arg
, rec
->dtrd_size
/ rec
->dtrd_arg
));
1872 case DTRACEACT_USTACK
:
1873 case DTRACEACT_JSTACK
:
1874 return (dt_print_ustack(dtp
, fp
, NULL
, addr
, rec
->dtrd_arg
));
1876 case DTRACEACT_USYM
:
1877 case DTRACEACT_UADDR
:
1878 return (dt_print_usym(dtp
, fp
, addr
, act
));
1880 case DTRACEACT_UMOD
:
1881 return (dt_print_umod(dtp
, fp
, NULL
, addr
));
1884 return (dt_print_sym(dtp
, fp
, NULL
, addr
));
1887 return (dt_print_mod(dtp
, fp
, NULL
, addr
));
1889 case DTRACEAGG_QUANTIZE
:
1890 return (dt_print_quantize(dtp
, fp
, addr
, size
, normal
));
1892 case DTRACEAGG_LQUANTIZE
:
1893 return (dt_print_lquantize(dtp
, fp
, addr
, size
, normal
));
1895 case DTRACEAGG_LLQUANTIZE
:
1896 return (dt_print_llquantize(dtp
, fp
, addr
, size
, normal
));
1899 return (dt_print_average(dtp
, fp
, addr
, size
, normal
));
1901 case DTRACEAGG_STDDEV
:
1902 return (dt_print_stddev(dtp
, fp
, addr
, size
, normal
));
1908 for (fmt
= fmttab
; fmt
->size
&& fmt
->size
!= size
; fmt
++)
1911 width
= packed
? fmt
->packedwidth
: fmt
->width
;
1914 case sizeof (uint64_t):
1915 err
= dt_printf(dtp
, fp
, " %*lld", width
,
1916 /* LINTED - alignment */
1917 (long long)*((uint64_t *)addr
) / normal
);
1919 case sizeof (uint32_t):
1920 /* LINTED - alignment */
1921 err
= dt_printf(dtp
, fp
, " %*d", width
, *((uint32_t *)addr
) /
1924 case sizeof (uint16_t):
1925 /* LINTED - alignment */
1926 err
= dt_printf(dtp
, fp
, " %*d", width
, *((uint16_t *)addr
) /
1929 case sizeof (uint8_t):
1930 err
= dt_printf(dtp
, fp
, " %*d", width
, *((uint8_t *)addr
) /
1934 err
= dt_print_bytes(dtp
, fp
, addr
, size
, width
, 0, 0);
1942 dt_print_aggs(const dtrace_aggdata_t
**aggsdata
, int naggvars
, void *arg
)
1945 dt_print_aggdata_t
*pd
= arg
;
1946 const dtrace_aggdata_t
*aggdata
= aggsdata
[0];
1947 dtrace_aggdesc_t
*agg
= aggdata
->dtada_desc
;
1948 FILE *fp
= pd
->dtpa_fp
;
1949 dtrace_hdl_t
*dtp
= pd
->dtpa_dtp
;
1950 dtrace_recdesc_t
*rec
;
1951 dtrace_actkind_t act
;
1955 pd
->dtpa_agghist
= (aggdata
->dtada_flags
& DTRACE_A_TOTAL
);
1956 pd
->dtpa_aggpack
= (aggdata
->dtada_flags
& DTRACE_A_MINMAXBIN
);
1959 * Iterate over each record description in the key, printing the traced
1960 * data, skipping the first datum (the tuple member created by the
1963 for (i
= 1; i
< agg
->dtagd_nrecs
; i
++) {
1964 rec
= &agg
->dtagd_rec
[i
];
1965 act
= rec
->dtrd_action
;
1966 addr
= aggdata
->dtada_data
+ rec
->dtrd_offset
;
1967 size
= rec
->dtrd_size
;
1969 if (DTRACEACT_ISAGG(act
)) {
1974 if (dt_print_datum(dtp
, fp
, rec
, addr
,
1975 size
, aggdata
, 1, pd
) < 0)
1978 if (dt_buffered_flush(dtp
, NULL
, rec
, aggdata
,
1979 DTRACE_BUFDATA_AGGKEY
) < 0)
1983 assert(aggact
!= 0);
1985 for (i
= (naggvars
== 1 ? 0 : 1); i
< naggvars
; i
++) {
1988 aggdata
= aggsdata
[i
];
1989 agg
= aggdata
->dtada_desc
;
1990 rec
= &agg
->dtagd_rec
[aggact
];
1991 act
= rec
->dtrd_action
;
1992 addr
= aggdata
->dtada_data
+ rec
->dtrd_offset
;
1993 size
= rec
->dtrd_size
;
1995 assert(DTRACEACT_ISAGG(act
));
1996 normal
= aggdata
->dtada_normal
;
1998 if (dt_print_datum(dtp
, fp
, rec
, addr
,
1999 size
, aggdata
, normal
, pd
) < 0)
2002 if (dt_buffered_flush(dtp
, NULL
, rec
, aggdata
,
2003 DTRACE_BUFDATA_AGGVAL
) < 0)
2006 if (!pd
->dtpa_allunprint
)
2007 agg
->dtagd_flags
|= DTRACE_AGD_PRINTED
;
2010 if (!pd
->dtpa_agghist
&& !pd
->dtpa_aggpack
) {
2011 if (dt_printf(dtp
, fp
, "\n") < 0)
2015 if (dt_buffered_flush(dtp
, NULL
, NULL
, aggdata
,
2016 DTRACE_BUFDATA_AGGFORMAT
| DTRACE_BUFDATA_AGGLAST
) < 0)
2023 dt_print_agg(const dtrace_aggdata_t
*aggdata
, void *arg
)
2025 dt_print_aggdata_t
*pd
= arg
;
2026 dtrace_aggdesc_t
*agg
= aggdata
->dtada_desc
;
2027 dtrace_aggvarid_t aggvarid
= pd
->dtpa_id
;
2029 if (pd
->dtpa_allunprint
) {
2030 if (agg
->dtagd_flags
& DTRACE_AGD_PRINTED
)
2034 * If we're not printing all unprinted aggregations, then the
2035 * aggregation variable ID denotes a specific aggregation
2036 * variable that we should print -- skip any other aggregations
2037 * that we encounter.
2039 if (agg
->dtagd_nrecs
== 0)
2042 if (aggvarid
!= agg
->dtagd_varid
)
2046 return (dt_print_aggs(&aggdata
, 1, arg
));
2050 dt_setopt(dtrace_hdl_t
*dtp
, const dtrace_probedata_t
*data
,
2051 const char *option
, const char *value
)
2056 dtrace_setoptdata_t optdata
;
2058 bzero(&optdata
, sizeof (optdata
));
2059 (void) dtrace_getopt(dtp
, option
, &optdata
.dtsda_oldval
);
2061 if (dtrace_setopt(dtp
, option
, value
) == 0) {
2062 (void) dtrace_getopt(dtp
, option
, &optdata
.dtsda_newval
);
2063 optdata
.dtsda_probe
= data
;
2064 optdata
.dtsda_option
= option
;
2065 optdata
.dtsda_handle
= dtp
;
2067 if ((rval
= dt_handle_setopt(dtp
, &optdata
)) != 0)
2073 errstr
= dtrace_errmsg(dtp
, dtrace_errno(dtp
));
2074 len
= strlen(option
) + strlen(value
) + strlen(errstr
) + 80;
2077 (void) snprintf(msg
, len
, "couldn't set option \"%s\" to \"%s\": %s\n",
2078 option
, value
, errstr
);
2080 if ((rval
= dt_handle_liberr(dtp
, data
, msg
)) == 0)
2087 dt_consume_cpu(dtrace_hdl_t
*dtp
, FILE *fp
, int cpu
,
2088 dtrace_bufdesc_t
*buf
, boolean_t just_one
,
2089 dtrace_consume_probe_f
*efunc
, dtrace_consume_rec_f
*rfunc
, void *arg
)
2093 int flow
= (dtp
->dt_options
[DTRACEOPT_FLOWINDENT
] != DTRACEOPT_UNSET
);
2094 int quiet
= (dtp
->dt_options
[DTRACEOPT_QUIET
] != DTRACEOPT_UNSET
);
2096 uint64_t tracememsize
= 0;
2097 dtrace_probedata_t data
;
2100 bzero(&data
, sizeof (data
));
2101 data
.dtpda_handle
= dtp
;
2102 data
.dtpda_cpu
= cpu
;
2103 data
.dtpda_flow
= dtp
->dt_flow
;
2104 data
.dtpda_indent
= dtp
->dt_indent
;
2105 data
.dtpda_prefix
= dtp
->dt_prefix
;
2107 for (offs
= buf
->dtbd_oldest
; offs
< buf
->dtbd_size
; ) {
2108 dtrace_eprobedesc_t
*epd
;
2111 * We're guaranteed to have an ID.
2113 id
= *(uint32_t *)((uintptr_t)buf
->dtbd_data
+ offs
);
2115 if (id
== DTRACE_EPIDNONE
) {
2117 * This is filler to assure proper alignment of the
2118 * next record; we simply ignore it.
2120 offs
+= sizeof (id
);
2124 if ((rval
= dt_epid_lookup(dtp
, id
, &data
.dtpda_edesc
,
2125 &data
.dtpda_pdesc
)) != 0)
2128 epd
= data
.dtpda_edesc
;
2129 data
.dtpda_data
= buf
->dtbd_data
+ offs
;
2131 if (data
.dtpda_edesc
->dtepd_uarg
!= DT_ECB_DEFAULT
) {
2132 rval
= dt_handle(dtp
, &data
);
2134 if (rval
== DTRACE_CONSUME_NEXT
)
2137 if (rval
== DTRACE_CONSUME_ERROR
)
2142 (void) dt_flowindent(dtp
, &data
, dtp
->dt_last_epid
,
2145 rval
= (*efunc
)(&data
, arg
);
2148 if (data
.dtpda_flow
== DTRACEFLOW_ENTRY
)
2149 data
.dtpda_indent
+= 2;
2152 if (rval
== DTRACE_CONSUME_NEXT
)
2155 if (rval
== DTRACE_CONSUME_ABORT
)
2156 return (dt_set_errno(dtp
, EDT_DIRABORT
));
2158 if (rval
!= DTRACE_CONSUME_THIS
)
2159 return (dt_set_errno(dtp
, EDT_BADRVAL
));
2161 for (i
= 0; i
< epd
->dtepd_nrecs
; i
++) {
2163 dtrace_recdesc_t
*rec
= &epd
->dtepd_rec
[i
];
2164 dtrace_actkind_t act
= rec
->dtrd_action
;
2166 data
.dtpda_data
= buf
->dtbd_data
+ offs
+
2168 addr
= data
.dtpda_data
;
2170 if (act
== DTRACEACT_LIBACT
) {
2171 uint64_t arg
= rec
->dtrd_arg
;
2172 dtrace_aggvarid_t id
;
2176 /* LINTED - alignment */
2177 id
= *((dtrace_aggvarid_t
*)addr
);
2178 (void) dtrace_aggregate_walk(dtp
,
2182 case DT_ACT_DENORMALIZE
:
2183 /* LINTED - alignment */
2184 id
= *((dtrace_aggvarid_t
*)addr
);
2185 (void) dtrace_aggregate_walk(dtp
,
2186 dt_denormalize_agg
, &id
);
2189 case DT_ACT_FTRUNCATE
:
2194 (void) ftruncate(fileno(fp
), 0);
2195 (void) fseeko(fp
, 0, SEEK_SET
);
2198 case DT_ACT_NORMALIZE
:
2199 if (i
== epd
->dtepd_nrecs
- 1)
2200 return (dt_set_errno(dtp
,
2203 if (dt_normalize(dtp
,
2204 buf
->dtbd_data
+ offs
, rec
) != 0)
2210 case DT_ACT_SETOPT
: {
2211 uint64_t *opts
= dtp
->dt_options
;
2212 dtrace_recdesc_t
*valrec
;
2217 if (i
== epd
->dtepd_nrecs
- 1) {
2218 return (dt_set_errno(dtp
,
2222 valrec
= &epd
->dtepd_rec
[++i
];
2223 valsize
= valrec
->dtrd_size
;
2225 if (valrec
->dtrd_action
!= act
||
2226 valrec
->dtrd_arg
!= arg
) {
2227 return (dt_set_errno(dtp
,
2231 if (valsize
> sizeof (uint64_t)) {
2232 val
= buf
->dtbd_data
+ offs
+
2233 valrec
->dtrd_offset
;
2238 rv
= dt_setopt(dtp
, &data
, addr
, val
);
2243 flow
= (opts
[DTRACEOPT_FLOWINDENT
] !=
2245 quiet
= (opts
[DTRACEOPT_QUIET
] !=
2252 if (i
== epd
->dtepd_nrecs
- 1)
2253 return (dt_set_errno(dtp
,
2257 buf
->dtbd_data
+ offs
, rec
) != 0)
2268 if (act
== DTRACEACT_TRACEMEM_DYNSIZE
&&
2269 rec
->dtrd_size
== sizeof (uint64_t)) {
2270 /* LINTED - alignment */
2271 tracememsize
= *((unsigned long long *)addr
);
2275 rval
= (*rfunc
)(&data
, rec
, arg
);
2277 if (rval
== DTRACE_CONSUME_NEXT
)
2280 if (rval
== DTRACE_CONSUME_ABORT
)
2281 return (dt_set_errno(dtp
, EDT_DIRABORT
));
2283 if (rval
!= DTRACE_CONSUME_THIS
)
2284 return (dt_set_errno(dtp
, EDT_BADRVAL
));
2286 if (act
== DTRACEACT_STACK
) {
2287 int depth
= rec
->dtrd_arg
;
2289 if (dt_print_stack(dtp
, fp
, NULL
, addr
, depth
,
2290 rec
->dtrd_size
/ depth
) < 0)
2295 if (act
== DTRACEACT_USTACK
||
2296 act
== DTRACEACT_JSTACK
) {
2297 if (dt_print_ustack(dtp
, fp
, NULL
,
2298 addr
, rec
->dtrd_arg
) < 0)
2303 if (act
== DTRACEACT_SYM
) {
2304 if (dt_print_sym(dtp
, fp
, NULL
, addr
) < 0)
2309 if (act
== DTRACEACT_MOD
) {
2310 if (dt_print_mod(dtp
, fp
, NULL
, addr
) < 0)
2315 if (act
== DTRACEACT_USYM
|| act
== DTRACEACT_UADDR
) {
2316 if (dt_print_usym(dtp
, fp
, addr
, act
) < 0)
2321 if (act
== DTRACEACT_UMOD
) {
2322 if (dt_print_umod(dtp
, fp
, NULL
, addr
) < 0)
2327 if (DTRACEACT_ISPRINTFLIKE(act
)) {
2329 int (*func
)(dtrace_hdl_t
*, FILE *, void *,
2330 const dtrace_probedata_t
*,
2331 const dtrace_recdesc_t
*, uint_t
,
2332 const void *buf
, size_t);
2334 if ((fmtdata
= dt_format_lookup(dtp
,
2335 rec
->dtrd_format
)) == NULL
)
2339 case DTRACEACT_PRINTF
:
2340 func
= dtrace_fprintf
;
2342 case DTRACEACT_PRINTA
:
2343 func
= dtrace_fprinta
;
2345 case DTRACEACT_SYSTEM
:
2346 func
= dtrace_system
;
2348 case DTRACEACT_FREOPEN
:
2349 func
= dtrace_freopen
;
2353 n
= (*func
)(dtp
, fp
, fmtdata
, &data
,
2354 rec
, epd
->dtepd_nrecs
- i
,
2355 (uchar_t
*)buf
->dtbd_data
+ offs
,
2356 buf
->dtbd_size
- offs
);
2359 return (-1); /* errno is set for us */
2367 * If this is a DIF expression, and the record has a
2368 * format set, this indicates we have a CTF type name
2369 * associated with the data and we should try to print
2372 if (act
== DTRACEACT_DIFEXPR
) {
2373 const char *strdata
= dt_strdata_lookup(dtp
,
2375 if (strdata
!= NULL
) {
2376 n
= dtrace_print(dtp
, fp
, strdata
,
2377 addr
, rec
->dtrd_size
);
2380 * dtrace_print() will return -1 on
2381 * error, or return the number of bytes
2382 * consumed. It will return 0 if the
2383 * type couldn't be determined, and we
2384 * should fall through to the normal
2396 if (act
== DTRACEACT_PRINTA
) {
2397 dt_print_aggdata_t pd
;
2398 dtrace_aggvarid_t
*aggvars
;
2399 int j
, naggvars
= 0;
2400 size_t size
= ((epd
->dtepd_nrecs
- i
) *
2401 sizeof (dtrace_aggvarid_t
));
2403 if ((aggvars
= dt_alloc(dtp
, size
)) == NULL
)
2407 * This might be a printa() with multiple
2408 * aggregation variables. We need to scan
2409 * forward through the records until we find
2410 * a record from a different statement.
2412 for (j
= i
; j
< epd
->dtepd_nrecs
; j
++) {
2413 dtrace_recdesc_t
*nrec
;
2416 nrec
= &epd
->dtepd_rec
[j
];
2418 if (nrec
->dtrd_uarg
!= rec
->dtrd_uarg
)
2421 if (nrec
->dtrd_action
!= act
) {
2422 return (dt_set_errno(dtp
,
2426 naddr
= buf
->dtbd_data
+ offs
+
2429 aggvars
[naggvars
++] =
2430 /* LINTED - alignment */
2431 *((dtrace_aggvarid_t
*)naddr
);
2435 bzero(&pd
, sizeof (pd
));
2439 assert(naggvars
>= 1);
2441 if (naggvars
== 1) {
2442 pd
.dtpa_id
= aggvars
[0];
2443 dt_free(dtp
, aggvars
);
2445 if (dt_printf(dtp
, fp
, "\n") < 0 ||
2446 dtrace_aggregate_walk_sorted(dtp
,
2447 dt_print_agg
, &pd
) < 0)
2452 if (dt_printf(dtp
, fp
, "\n") < 0 ||
2453 dtrace_aggregate_walk_joined(dtp
, aggvars
,
2454 naggvars
, dt_print_aggs
, &pd
) < 0) {
2455 dt_free(dtp
, aggvars
);
2459 dt_free(dtp
, aggvars
);
2463 if (act
== DTRACEACT_TRACEMEM
) {
2464 if (tracememsize
== 0 ||
2465 tracememsize
> rec
->dtrd_size
) {
2466 tracememsize
= rec
->dtrd_size
;
2469 n
= dt_print_bytes(dtp
, fp
, addr
,
2470 tracememsize
, -33, quiet
, 1);
2480 switch (rec
->dtrd_size
) {
2481 case sizeof (uint64_t):
2482 n
= dt_printf(dtp
, fp
,
2483 quiet
? "%lld" : " %16lld",
2484 /* LINTED - alignment */
2485 *((unsigned long long *)addr
));
2487 case sizeof (uint32_t):
2488 n
= dt_printf(dtp
, fp
, quiet
? "%d" : " %8d",
2489 /* LINTED - alignment */
2490 *((uint32_t *)addr
));
2492 case sizeof (uint16_t):
2493 n
= dt_printf(dtp
, fp
, quiet
? "%d" : " %5d",
2494 /* LINTED - alignment */
2495 *((uint16_t *)addr
));
2497 case sizeof (uint8_t):
2498 n
= dt_printf(dtp
, fp
, quiet
? "%d" : " %3d",
2499 *((uint8_t *)addr
));
2502 n
= dt_print_bytes(dtp
, fp
, addr
,
2503 rec
->dtrd_size
, -33, quiet
, 0);
2508 return (-1); /* errno is set for us */
2511 if (dt_buffered_flush(dtp
, &data
, rec
, NULL
, 0) < 0)
2512 return (-1); /* errno is set for us */
2516 * Call the record callback with a NULL record to indicate
2517 * that we're done processing this EPID.
2519 rval
= (*rfunc
)(&data
, NULL
, arg
);
2521 offs
+= epd
->dtepd_size
;
2522 dtp
->dt_last_epid
= id
;
2524 buf
->dtbd_oldest
= offs
;
2529 dtp
->dt_flow
= data
.dtpda_flow
;
2530 dtp
->dt_indent
= data
.dtpda_indent
;
2531 dtp
->dt_prefix
= data
.dtpda_prefix
;
2533 if ((drops
= buf
->dtbd_drops
) == 0)
2537 * Explicitly zero the drops to prevent us from processing them again.
2539 buf
->dtbd_drops
= 0;
2541 return (dt_handle_cpudrop(dtp
, cpu
, DTRACEDROP_PRINCIPAL
, drops
));
2545 * Reduce memory usage by shrinking the buffer if it's no more than half full.
2546 * Note, we need to preserve the alignment of the data at dtbd_oldest, which is
2547 * only 4-byte aligned.
2550 dt_realloc_buf(dtrace_hdl_t
*dtp
, dtrace_bufdesc_t
*buf
, int cursize
)
2552 uint64_t used
= buf
->dtbd_size
- buf
->dtbd_oldest
;
2553 if (used
< cursize
/ 2) {
2554 int misalign
= buf
->dtbd_oldest
& (sizeof (uint64_t) - 1);
2555 char *newdata
= dt_alloc(dtp
, used
+ misalign
);
2556 if (newdata
== NULL
)
2558 bzero(newdata
, misalign
);
2559 bcopy(buf
->dtbd_data
+ buf
->dtbd_oldest
,
2560 newdata
+ misalign
, used
);
2561 dt_free(dtp
, buf
->dtbd_data
);
2562 buf
->dtbd_oldest
= misalign
;
2563 buf
->dtbd_size
= used
+ misalign
;
2564 buf
->dtbd_data
= newdata
;
2569 * If the ring buffer has wrapped, the data is not in order. Rearrange it
2570 * so that it is. Note, we need to preserve the alignment of the data at
2571 * dtbd_oldest, which is only 4-byte aligned.
2574 dt_unring_buf(dtrace_hdl_t
*dtp
, dtrace_bufdesc_t
*buf
)
2577 char *newdata
, *ndp
;
2579 if (buf
->dtbd_oldest
== 0)
2582 misalign
= buf
->dtbd_oldest
& (sizeof (uint64_t) - 1);
2583 newdata
= ndp
= dt_alloc(dtp
, buf
->dtbd_size
+ misalign
);
2585 if (newdata
== NULL
)
2588 assert(0 == (buf
->dtbd_size
& (sizeof (uint64_t) - 1)));
2590 bzero(ndp
, misalign
);
2593 bcopy(buf
->dtbd_data
+ buf
->dtbd_oldest
, ndp
,
2594 buf
->dtbd_size
- buf
->dtbd_oldest
);
2595 ndp
+= buf
->dtbd_size
- buf
->dtbd_oldest
;
2597 bcopy(buf
->dtbd_data
, ndp
, buf
->dtbd_oldest
);
2599 dt_free(dtp
, buf
->dtbd_data
);
2600 buf
->dtbd_oldest
= 0;
2601 buf
->dtbd_data
= newdata
;
2602 buf
->dtbd_size
+= misalign
;
2608 dt_put_buf(dtrace_hdl_t
*dtp
, dtrace_bufdesc_t
*buf
)
2610 dt_free(dtp
, buf
->dtbd_data
);
2615 * Returns 0 on success, in which case *cbp will be filled in if we retrieved
2616 * data, or NULL if there is no data for this CPU.
2617 * Returns -1 on failure and sets dt_errno.
2620 dt_get_buf(dtrace_hdl_t
*dtp
, int cpu
, dtrace_bufdesc_t
**bufp
)
2622 dtrace_optval_t size
;
2623 dtrace_bufdesc_t
*buf
= dt_zalloc(dtp
, sizeof (*buf
));
2629 (void) dtrace_getopt(dtp
, "bufsize", &size
);
2630 buf
->dtbd_data
= dt_alloc(dtp
, size
);
2631 if (buf
->dtbd_data
== NULL
) {
2635 buf
->dtbd_size
= size
;
2636 buf
->dtbd_cpu
= cpu
;
2638 if (dt_ioctl(dtp
, DTRACEIOC_BUFSNAP
, buf
) == -1) {
2639 dt_put_buf(dtp
, buf
);
2641 * If we failed with ENOENT, it may be because the
2642 * CPU was unconfigured -- this is okay. Any other
2643 * error, however, is unexpected.
2645 if (errno
== ENOENT
) {
2650 return (dt_set_errno(dtp
, errno
));
2653 error
= dt_unring_buf(dtp
, buf
);
2655 dt_put_buf(dtp
, buf
);
2658 dt_realloc_buf(dtp
, buf
, size
);
2664 typedef struct dt_begin
{
2665 dtrace_consume_probe_f
*dtbgn_probefunc
;
2666 dtrace_consume_rec_f
*dtbgn_recfunc
;
2668 dtrace_handle_err_f
*dtbgn_errhdlr
;
2670 int dtbgn_beginonly
;
2674 dt_consume_begin_probe(const dtrace_probedata_t
*data
, void *arg
)
2676 dt_begin_t
*begin
= arg
;
2677 dtrace_probedesc_t
*pd
= data
->dtpda_pdesc
;
2679 int r1
= (strcmp(pd
->dtpd_provider
, "dtrace") == 0);
2680 int r2
= (strcmp(pd
->dtpd_name
, "BEGIN") == 0);
2682 if (begin
->dtbgn_beginonly
) {
2684 return (DTRACE_CONSUME_NEXT
);
2687 return (DTRACE_CONSUME_NEXT
);
2691 * We have a record that we're interested in. Now call the underlying
2694 return (begin
->dtbgn_probefunc(data
, begin
->dtbgn_arg
));
2698 dt_consume_begin_record(const dtrace_probedata_t
*data
,
2699 const dtrace_recdesc_t
*rec
, void *arg
)
2701 dt_begin_t
*begin
= arg
;
2703 return (begin
->dtbgn_recfunc(data
, rec
, begin
->dtbgn_arg
));
2707 dt_consume_begin_error(const dtrace_errdata_t
*data
, void *arg
)
2709 dt_begin_t
*begin
= (dt_begin_t
*)arg
;
2710 dtrace_probedesc_t
*pd
= data
->dteda_pdesc
;
2712 int r1
= (strcmp(pd
->dtpd_provider
, "dtrace") == 0);
2713 int r2
= (strcmp(pd
->dtpd_name
, "BEGIN") == 0);
2715 if (begin
->dtbgn_beginonly
) {
2717 return (DTRACE_HANDLE_OK
);
2720 return (DTRACE_HANDLE_OK
);
2723 return (begin
->dtbgn_errhdlr(data
, begin
->dtbgn_errarg
));
2727 dt_consume_begin(dtrace_hdl_t
*dtp
, FILE *fp
,
2728 dtrace_consume_probe_f
*pf
, dtrace_consume_rec_f
*rf
, void *arg
)
2731 * There's this idea that the BEGIN probe should be processed before
2732 * everything else, and that the END probe should be processed after
2733 * anything else. In the common case, this is pretty easy to deal
2734 * with. However, a situation may arise where the BEGIN enabling and
2735 * END enabling are on the same CPU, and some enabling in the middle
2736 * occurred on a different CPU. To deal with this (blech!) we need to
2737 * consume the BEGIN buffer up until the end of the BEGIN probe, and
2738 * then set it aside. We will then process every other CPU, and then
2739 * we'll return to the BEGIN CPU and process the rest of the data
2740 * (which will inevitably include the END probe, if any). Making this
2741 * even more complicated (!) is the library's ERROR enabling. Because
2742 * this enabling is processed before we even get into the consume call
2743 * back, any ERROR firing would result in the library's ERROR enabling
2744 * being processed twice -- once in our first pass (for BEGIN probes),
2745 * and again in our second pass (for everything but BEGIN probes). To
2746 * deal with this, we interpose on the ERROR handler to assure that we
2747 * only process ERROR enablings induced by BEGIN enablings in the
2748 * first pass, and that we only process ERROR enablings _not_ induced
2749 * by BEGIN enablings in the second pass.
2753 processorid_t cpu
= dtp
->dt_beganon
;
2755 static int max_ncpus
;
2756 dtrace_bufdesc_t
*buf
;
2758 dtp
->dt_beganon
= -1;
2760 if (dt_get_buf(dtp
, cpu
, &buf
) != 0)
2765 if (!dtp
->dt_stopped
|| buf
->dtbd_cpu
!= dtp
->dt_endedon
) {
2767 * This is the simple case. We're either not stopped, or if
2768 * we are, we actually processed any END probes on another
2769 * CPU. We can simply consume this buffer and return.
2771 rval
= dt_consume_cpu(dtp
, fp
, cpu
, buf
, B_FALSE
,
2773 dt_put_buf(dtp
, buf
);
2777 begin
.dtbgn_probefunc
= pf
;
2778 begin
.dtbgn_recfunc
= rf
;
2779 begin
.dtbgn_arg
= arg
;
2780 begin
.dtbgn_beginonly
= 1;
2783 * We need to interpose on the ERROR handler to be sure that we
2784 * only process ERRORs induced by BEGIN.
2786 begin
.dtbgn_errhdlr
= dtp
->dt_errhdlr
;
2787 begin
.dtbgn_errarg
= dtp
->dt_errarg
;
2788 dtp
->dt_errhdlr
= dt_consume_begin_error
;
2789 dtp
->dt_errarg
= &begin
;
2791 rval
= dt_consume_cpu(dtp
, fp
, cpu
, buf
, B_FALSE
,
2792 dt_consume_begin_probe
, dt_consume_begin_record
, &begin
);
2794 dtp
->dt_errhdlr
= begin
.dtbgn_errhdlr
;
2795 dtp
->dt_errarg
= begin
.dtbgn_errarg
;
2798 dt_put_buf(dtp
, buf
);
2803 max_ncpus
= dt_sysconf(dtp
, _SC_CPUID_MAX
) + 1;
2805 for (i
= 0; i
< max_ncpus
; i
++) {
2806 dtrace_bufdesc_t
*nbuf
;
2810 if (dt_get_buf(dtp
, i
, &nbuf
) != 0) {
2811 dt_put_buf(dtp
, buf
);
2817 rval
= dt_consume_cpu(dtp
, fp
, i
, nbuf
, B_FALSE
,
2819 dt_put_buf(dtp
, nbuf
);
2821 dt_put_buf(dtp
, buf
);
2827 * Okay -- we're done with the other buffers. Now we want to
2828 * reconsume the first buffer -- but this time we're looking for
2829 * everything _but_ BEGIN. And of course, in order to only consume
2830 * those ERRORs _not_ associated with BEGIN, we need to reinstall our
2831 * ERROR interposition function...
2833 begin
.dtbgn_beginonly
= 0;
2835 assert(begin
.dtbgn_errhdlr
== dtp
->dt_errhdlr
);
2836 assert(begin
.dtbgn_errarg
== dtp
->dt_errarg
);
2837 dtp
->dt_errhdlr
= dt_consume_begin_error
;
2838 dtp
->dt_errarg
= &begin
;
2840 rval
= dt_consume_cpu(dtp
, fp
, cpu
, buf
, B_FALSE
,
2841 dt_consume_begin_probe
, dt_consume_begin_record
, &begin
);
2843 dtp
->dt_errhdlr
= begin
.dtbgn_errhdlr
;
2844 dtp
->dt_errarg
= begin
.dtbgn_errarg
;
2851 dt_buf_oldest(void *elem
, void *arg
)
2853 dtrace_bufdesc_t
*buf
= elem
;
2854 size_t offs
= buf
->dtbd_oldest
;
2856 while (offs
< buf
->dtbd_size
) {
2857 dtrace_rechdr_t
*dtrh
=
2858 /* LINTED - alignment */
2859 (dtrace_rechdr_t
*)(buf
->dtbd_data
+ offs
);
2860 if (dtrh
->dtrh_epid
== DTRACE_EPIDNONE
) {
2861 offs
+= sizeof (dtrace_epid_t
);
2863 return (DTRACE_RECORD_LOAD_TIMESTAMP(dtrh
));
2867 /* There are no records left; use the time the buffer was retrieved. */
2868 return (buf
->dtbd_timestamp
);
2872 dtrace_consume(dtrace_hdl_t
*dtp
, FILE *fp
,
2873 dtrace_consume_probe_f
*pf
, dtrace_consume_rec_f
*rf
, void *arg
)
2875 dtrace_optval_t size
;
2876 static int max_ncpus
;
2878 dtrace_optval_t interval
= dtp
->dt_options
[DTRACEOPT_SWITCHRATE
];
2879 hrtime_t now
= gethrtime();
2881 if (dtp
->dt_lastswitch
!= 0) {
2882 if (now
- dtp
->dt_lastswitch
< interval
)
2885 dtp
->dt_lastswitch
+= interval
;
2887 dtp
->dt_lastswitch
= now
;
2890 if (!dtp
->dt_active
)
2891 return (dt_set_errno(dtp
, EINVAL
));
2894 max_ncpus
= dt_sysconf(dtp
, _SC_CPUID_MAX
) + 1;
2897 pf
= (dtrace_consume_probe_f
*)dt_nullprobe
;
2900 rf
= (dtrace_consume_rec_f
*)dt_nullrec
;
2902 if (dtp
->dt_options
[DTRACEOPT_TEMPORAL
] == DTRACEOPT_UNSET
) {
2904 * The output will not be in the order it was traced. Rather,
2905 * we will consume all of the data from each CPU's buffer in
2906 * turn. We apply special handling for the records from BEGIN
2907 * and END probes so that they are consumed first and last,
2910 * If we have just begun, we want to first process the CPU that
2911 * executed the BEGIN probe (if any).
2913 if (dtp
->dt_active
&& dtp
->dt_beganon
!= -1 &&
2914 (rval
= dt_consume_begin(dtp
, fp
, pf
, rf
, arg
)) != 0)
2917 for (i
= 0; i
< max_ncpus
; i
++) {
2918 dtrace_bufdesc_t
*buf
;
2921 * If we have stopped, we want to process the CPU on
2922 * which the END probe was processed only _after_ we
2923 * have processed everything else.
2925 if (dtp
->dt_stopped
&& (i
== dtp
->dt_endedon
))
2928 if (dt_get_buf(dtp
, i
, &buf
) != 0)
2935 dtp
->dt_prefix
= NULL
;
2936 rval
= dt_consume_cpu(dtp
, fp
, i
,
2937 buf
, B_FALSE
, pf
, rf
, arg
);
2938 dt_put_buf(dtp
, buf
);
2942 if (dtp
->dt_stopped
) {
2943 dtrace_bufdesc_t
*buf
;
2945 if (dt_get_buf(dtp
, dtp
->dt_endedon
, &buf
) != 0)
2950 rval
= dt_consume_cpu(dtp
, fp
, dtp
->dt_endedon
,
2951 buf
, B_FALSE
, pf
, rf
, arg
);
2952 dt_put_buf(dtp
, buf
);
2957 * The output will be in the order it was traced (or for
2958 * speculations, when it was committed). We retrieve a buffer
2959 * from each CPU and put it into a priority queue, which sorts
2960 * based on the first entry in the buffer. This is sufficient
2961 * because entries within a buffer are already sorted.
2963 * We then consume records one at a time, always consuming the
2964 * oldest record, as determined by the priority queue. When
2965 * we reach the end of the time covered by these buffers,
2966 * we need to stop and retrieve more records on the next pass.
2967 * The kernel tells us the time covered by each buffer, in
2968 * dtbd_timestamp. The first buffer's timestamp tells us the
2969 * time covered by all buffers, as subsequently retrieved
2970 * buffers will cover to a more recent time.
2973 uint64_t *drops
= alloca(max_ncpus
* sizeof (uint64_t));
2974 uint64_t first_timestamp
= 0;
2976 dtrace_bufdesc_t
*buf
;
2978 bzero(drops
, max_ncpus
* sizeof (uint64_t));
2980 if (dtp
->dt_bufq
== NULL
) {
2981 dtp
->dt_bufq
= dt_pq_init(dtp
, max_ncpus
* 2,
2982 dt_buf_oldest
, NULL
);
2983 if (dtp
->dt_bufq
== NULL
) /* ENOMEM */
2987 /* Retrieve data from each CPU. */
2988 (void) dtrace_getopt(dtp
, "bufsize", &size
);
2989 for (i
= 0; i
< max_ncpus
; i
++) {
2990 dtrace_bufdesc_t
*buf
;
2992 if (dt_get_buf(dtp
, i
, &buf
) != 0)
2995 if (first_timestamp
== 0)
2996 first_timestamp
= buf
->dtbd_timestamp
;
2997 assert(buf
->dtbd_timestamp
>= first_timestamp
);
2999 dt_pq_insert(dtp
->dt_bufq
, buf
);
3000 drops
[i
] = buf
->dtbd_drops
;
3001 buf
->dtbd_drops
= 0;
3005 /* Consume records. */
3007 dtrace_bufdesc_t
*buf
= dt_pq_pop(dtp
->dt_bufq
);
3013 timestamp
= dt_buf_oldest(buf
, dtp
);
3014 assert(timestamp
>= dtp
->dt_last_timestamp
);
3015 dtp
->dt_last_timestamp
= timestamp
;
3017 if (timestamp
== buf
->dtbd_timestamp
) {
3019 * We've reached the end of the time covered
3020 * by this buffer. If this is the oldest
3021 * buffer, we must do another pass
3022 * to retrieve more data.
3024 dt_put_buf(dtp
, buf
);
3025 if (timestamp
== first_timestamp
&&
3031 if ((rval
= dt_consume_cpu(dtp
, fp
,
3032 buf
->dtbd_cpu
, buf
, B_TRUE
, pf
, rf
, arg
)) != 0)
3034 dt_pq_insert(dtp
->dt_bufq
, buf
);
3037 /* Consume drops. */
3038 for (i
= 0; i
< max_ncpus
; i
++) {
3039 if (drops
[i
] != 0) {
3040 int error
= dt_handle_cpudrop(dtp
, i
,
3041 DTRACEDROP_PRINCIPAL
, drops
[i
]);
3048 * Reduce memory usage by re-allocating smaller buffers
3049 * for the "remnants".
3051 while (buf
= dt_pq_walk(dtp
->dt_bufq
, &cookie
))
3052 dt_realloc_buf(dtp
, buf
, buf
->dtbd_size
);