1 0 stevel /* 2 0 stevel * CDDL HEADER START 3 0 stevel * 4 0 stevel * The contents of this file are subject to the terms of the 5 5984 jhaslam * Common Development and Distribution License (the "License"). 6 5984 jhaslam * You may not use this file except in compliance with the License. 7 0 stevel * 8 0 stevel * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 0 stevel * or http://www.opensolaris.org/os/licensing. 10 0 stevel * See the License for the specific language governing permissions 11 0 stevel * and limitations under the License. 12 0 stevel * 13 0 stevel * When distributing Covered Code, include this CDDL HEADER in each 14 0 stevel * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 0 stevel * If applicable, add the following below this CDDL HEADER, with the 16 0 stevel * fields enclosed by brackets "[]" replaced with your own identifying 17 0 stevel * information: Portions Copyright [yyyy] [name of copyright owner] 18 0 stevel * 19 0 stevel * CDDL HEADER END 20 0 stevel */ 21 0 stevel /* 22 10791 Jonathan * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 0 stevel * Use is subject to license terms. 24 0 stevel */ 25 0 stevel 26 0 stevel #include <stdlib.h> 27 0 stevel #include <strings.h> 28 0 stevel #include <errno.h> 29 0 stevel #include <unistd.h> 30 0 stevel #include <limits.h> 31 0 stevel #include <assert.h> 32 0 stevel #include <ctype.h> 33 0 stevel #include <alloca.h> 34 457 bmc #include <dt_impl.h> 35 0 stevel 36 5984 jhaslam #define DT_MASK_LO 0x00000000FFFFFFFFULL 37 5984 jhaslam 38 457 bmc /* 39 457 bmc * We declare this here because (1) we need it and (2) we want to avoid a 40 457 bmc * dependency on libm in libdtrace. 41 457 bmc */ 42 457 bmc static long double 43 457 bmc dt_fabsl(long double x) 44 457 bmc { 45 457 bmc if (x < 0) 46 457 bmc return (-x); 47 457 bmc 48 457 bmc return (x); 49 5984 jhaslam } 50 5984 jhaslam 51 5984 jhaslam /* 52 5984 jhaslam * 128-bit arithmetic functions needed to support the stddev() aggregating 53 5984 jhaslam * action. 54 5984 jhaslam */ 55 5984 jhaslam static int 56 5984 jhaslam dt_gt_128(uint64_t *a, uint64_t *b) 57 5984 jhaslam { 58 5984 jhaslam return (a[1] > b[1] || (a[1] == b[1] && a[0] > b[0])); 59 5984 jhaslam } 60 5984 jhaslam 61 5984 jhaslam static int 62 5984 jhaslam dt_ge_128(uint64_t *a, uint64_t *b) 63 5984 jhaslam { 64 5984 jhaslam return (a[1] > b[1] || (a[1] == b[1] && a[0] >= b[0])); 65 5984 jhaslam } 66 5984 jhaslam 67 5984 jhaslam static int 68 5984 jhaslam dt_le_128(uint64_t *a, uint64_t *b) 69 5984 jhaslam { 70 5984 jhaslam return (a[1] < b[1] || (a[1] == b[1] && a[0] <= b[0])); 71 5984 jhaslam } 72 5984 jhaslam 73 5984 jhaslam /* 74 5984 jhaslam * Shift the 128-bit value in a by b. If b is positive, shift left. 75 5984 jhaslam * If b is negative, shift right. 76 5984 jhaslam */ 77 5984 jhaslam static void 78 5984 jhaslam dt_shift_128(uint64_t *a, int b) 79 5984 jhaslam { 80 5984 jhaslam uint64_t mask; 81 5984 jhaslam 82 5984 jhaslam if (b == 0) 83 5984 jhaslam return; 84 5984 jhaslam 85 5984 jhaslam if (b < 0) { 86 5984 jhaslam b = -b; 87 5984 jhaslam if (b >= 64) { 88 5984 jhaslam a[0] = a[1] >> (b - 64); 89 5984 jhaslam a[1] = 0; 90 5984 jhaslam } else { 91 5984 jhaslam a[0] >>= b; 92 5984 jhaslam mask = 1LL << (64 - b); 93 5984 jhaslam mask -= 1; 94 5984 jhaslam a[0] |= ((a[1] & mask) << (64 - b)); 95 5984 jhaslam a[1] >>= b; 96 5984 jhaslam } 97 5984 jhaslam } else { 98 5984 jhaslam if (b >= 64) { 99 5984 jhaslam a[1] = a[0] << (b - 64); 100 5984 jhaslam a[0] = 0; 101 5984 jhaslam } else { 102 5984 jhaslam a[1] <<= b; 103 5984 jhaslam mask = a[0] >> (64 - b); 104 5984 jhaslam a[1] |= mask; 105 5984 jhaslam a[0] <<= b; 106 5984 jhaslam } 107 5984 jhaslam } 108 5984 jhaslam } 109 5984 jhaslam 110 5984 jhaslam static int 111 5984 jhaslam dt_nbits_128(uint64_t *a) 112 5984 jhaslam { 113 5984 jhaslam int nbits = 0; 114 5984 jhaslam uint64_t tmp[2]; 115 5984 jhaslam uint64_t zero[2] = { 0, 0 }; 116 5984 jhaslam 117 5984 jhaslam tmp[0] = a[0]; 118 5984 jhaslam tmp[1] = a[1]; 119 5984 jhaslam 120 5984 jhaslam dt_shift_128(tmp, -1); 121 5984 jhaslam while (dt_gt_128(tmp, zero)) { 122 5984 jhaslam dt_shift_128(tmp, -1); 123 5984 jhaslam nbits++; 124 5984 jhaslam } 125 5984 jhaslam 126 5984 jhaslam return (nbits); 127 5984 jhaslam } 128 5984 jhaslam 129 5984 jhaslam static void 130 5984 jhaslam dt_subtract_128(uint64_t *minuend, uint64_t *subtrahend, uint64_t *difference) 131 5984 jhaslam { 132 5984 jhaslam uint64_t result[2]; 133 5984 jhaslam 134 5984 jhaslam result[0] = minuend[0] - subtrahend[0]; 135 5984 jhaslam result[1] = minuend[1] - subtrahend[1] - 136 5984 jhaslam (minuend[0] < subtrahend[0] ? 1 : 0); 137 5984 jhaslam 138 5984 jhaslam difference[0] = result[0]; 139 5984 jhaslam difference[1] = result[1]; 140 5984 jhaslam } 141 5984 jhaslam 142 5984 jhaslam static void 143 5984 jhaslam dt_add_128(uint64_t *addend1, uint64_t *addend2, uint64_t *sum) 144 5984 jhaslam { 145 5984 jhaslam uint64_t result[2]; 146 5984 jhaslam 147 5984 jhaslam result[0] = addend1[0] + addend2[0]; 148 5984 jhaslam result[1] = addend1[1] + addend2[1] + 149 5984 jhaslam (result[0] < addend1[0] || result[0] < addend2[0] ? 1 : 0); 150 5984 jhaslam 151 5984 jhaslam sum[0] = result[0]; 152 5984 jhaslam sum[1] = result[1]; 153 5984 jhaslam } 154 5984 jhaslam 155 5984 jhaslam /* 156 5984 jhaslam * The basic idea is to break the 2 64-bit values into 4 32-bit values, 157 5984 jhaslam * use native multiplication on those, and then re-combine into the 158 5984 jhaslam * resulting 128-bit value. 159 5984 jhaslam * 160 5984 jhaslam * (hi1 << 32 + lo1) * (hi2 << 32 + lo2) = 161 5984 jhaslam * hi1 * hi2 << 64 + 162 5984 jhaslam * hi1 * lo2 << 32 + 163 5984 jhaslam * hi2 * lo1 << 32 + 164 5984 jhaslam * lo1 * lo2 165 5984 jhaslam */ 166 5984 jhaslam static void 167 5984 jhaslam dt_multiply_128(uint64_t factor1, uint64_t factor2, uint64_t *product) 168 5984 jhaslam { 169 5984 jhaslam uint64_t hi1, hi2, lo1, lo2; 170 5984 jhaslam uint64_t tmp[2]; 171 5984 jhaslam 172 5984 jhaslam hi1 = factor1 >> 32; 173 5984 jhaslam hi2 = factor2 >> 32; 174 5984 jhaslam 175 5984 jhaslam lo1 = factor1 & DT_MASK_LO; 176 5984 jhaslam lo2 = factor2 & DT_MASK_LO; 177 5984 jhaslam 178 5984 jhaslam product[0] = lo1 * lo2; 179 5984 jhaslam product[1] = hi1 * hi2; 180 5984 jhaslam 181 5984 jhaslam tmp[0] = hi1 * lo2; 182 5984 jhaslam tmp[1] = 0; 183 5984 jhaslam dt_shift_128(tmp, 32); 184 5984 jhaslam dt_add_128(product, tmp, product); 185 5984 jhaslam 186 5984 jhaslam tmp[0] = hi2 * lo1; 187 5984 jhaslam tmp[1] = 0; 188 5984 jhaslam dt_shift_128(tmp, 32); 189 5984 jhaslam dt_add_128(product, tmp, product); 190 5984 jhaslam } 191 5984 jhaslam 192 5984 jhaslam /* 193 5984 jhaslam * This is long-hand division. 194 5984 jhaslam * 195 5984 jhaslam * We initialize subtrahend by shifting divisor left as far as possible. We 196 5984 jhaslam * loop, comparing subtrahend to dividend: if subtrahend is smaller, we 197 5984 jhaslam * subtract and set the appropriate bit in the result. We then shift 198 5984 jhaslam * subtrahend right by one bit for the next comparison. 199 5984 jhaslam */ 200 5984 jhaslam static void 201 5984 jhaslam dt_divide_128(uint64_t *dividend, uint64_t divisor, uint64_t *quotient) 202 5984 jhaslam { 203 5984 jhaslam uint64_t result[2] = { 0, 0 }; 204 5984 jhaslam uint64_t remainder[2]; 205 5984 jhaslam uint64_t subtrahend[2]; 206 5984 jhaslam uint64_t divisor_128[2]; 207 5984 jhaslam uint64_t mask[2] = { 1, 0 }; 208 5984 jhaslam int log = 0; 209 5984 jhaslam 210 5984 jhaslam assert(divisor != 0); 211 5984 jhaslam 212 5984 jhaslam divisor_128[0] = divisor; 213 5984 jhaslam divisor_128[1] = 0; 214 5984 jhaslam 215 5984 jhaslam remainder[0] = dividend[0]; 216 5984 jhaslam remainder[1] = dividend[1]; 217 5984 jhaslam 218 5984 jhaslam subtrahend[0] = divisor; 219 5984 jhaslam subtrahend[1] = 0; 220 5984 jhaslam 221 5984 jhaslam while (divisor > 0) { 222 5984 jhaslam log++; 223 5984 jhaslam divisor >>= 1; 224 5984 jhaslam } 225 5984 jhaslam 226 5984 jhaslam dt_shift_128(subtrahend, 128 - log); 227 5984 jhaslam dt_shift_128(mask, 128 - log); 228 5984 jhaslam 229 5984 jhaslam while (dt_ge_128(remainder, divisor_128)) { 230 5984 jhaslam if (dt_ge_128(remainder, subtrahend)) { 231 5984 jhaslam dt_subtract_128(remainder, subtrahend, remainder); 232 5984 jhaslam result[0] |= mask[0]; 233 5984 jhaslam result[1] |= mask[1]; 234 5984 jhaslam } 235 5984 jhaslam 236 5984 jhaslam dt_shift_128(subtrahend, -1); 237 5984 jhaslam dt_shift_128(mask, -1); 238 5984 jhaslam } 239 5984 jhaslam 240 5984 jhaslam quotient[0] = result[0]; 241 5984 jhaslam quotient[1] = result[1]; 242 5984 jhaslam } 243 5984 jhaslam 244 5984 jhaslam /* 245 5984 jhaslam * This is the long-hand method of calculating a square root. 246 5984 jhaslam * The algorithm is as follows: 247 5984 jhaslam * 248 5984 jhaslam * 1. Group the digits by 2 from the right. 249 5984 jhaslam * 2. Over the leftmost group, find the largest single-digit number 250 5984 jhaslam * whose square is less than that group. 251 5984 jhaslam * 3. Subtract the result of the previous step (2 or 4, depending) and 252 5984 jhaslam * bring down the next two-digit group. 253 5984 jhaslam * 4. For the result R we have so far, find the largest single-digit number 254 5984 jhaslam * x such that 2 * R * 10 * x + x^2 is less than the result from step 3. 255 5984 jhaslam * (Note that this is doubling R and performing a decimal left-shift by 1 256 5984 jhaslam * and searching for the appropriate decimal to fill the one's place.) 257 5984 jhaslam * The value x is the next digit in the square root. 258 5984 jhaslam * Repeat steps 3 and 4 until the desired precision is reached. (We're 259 5984 jhaslam * dealing with integers, so the above is sufficient.) 260 5984 jhaslam * 261 5984 jhaslam * In decimal, the square root of 582,734 would be calculated as so: 262 5984 jhaslam * 263 5984 jhaslam * __7__6__3 264 5984 jhaslam * | 58 27 34 265 5984 jhaslam * -49 (7^2 == 49 => 7 is the first digit in the square root) 266 5984 jhaslam * -- 267 5984 jhaslam * 9 27 (Subtract and bring down the next group.) 268 5984 jhaslam * 146 8 76 (2 * 7 * 10 * 6 + 6^2 == 876 => 6 is the next digit in 269 5984 jhaslam * ----- the square root) 270 5984 jhaslam * 51 34 (Subtract and bring down the next group.) 271 5984 jhaslam * 1523 45 69 (2 * 76 * 10 * 3 + 3^2 == 4569 => 3 is the next digit in 272 5984 jhaslam * ----- the square root) 273 5984 jhaslam * 5 65 (remainder) 274 5984 jhaslam * 275 5984 jhaslam * The above algorithm applies similarly in binary, but note that the 276 5984 jhaslam * only possible non-zero value for x in step 4 is 1, so step 4 becomes a 277 5984 jhaslam * simple decision: is 2 * R * 2 * 1 + 1^2 (aka R << 2 + 1) less than the 278 5984 jhaslam * preceding difference? 279 5984 jhaslam * 280 5984 jhaslam * In binary, the square root of 11011011 would be calculated as so: 281 5984 jhaslam * 282 5984 jhaslam * __1__1__1__0 283 5984 jhaslam * | 11 01 10 11 284 5984 jhaslam * 01 (0 << 2 + 1 == 1 < 11 => this bit is 1) 285 5984 jhaslam * -- 286 5984 jhaslam * 10 01 10 11 287 5984 jhaslam * 101 1 01 (1 << 2 + 1 == 101 < 1001 => next bit is 1) 288 5984 jhaslam * ----- 289 5984 jhaslam * 1 00 10 11 290 5984 jhaslam * 1101 11 01 (11 << 2 + 1 == 1101 < 10010 => next bit is 1) 291 5984 jhaslam * ------- 292 5984 jhaslam * 1 01 11 293 5984 jhaslam * 11101 1 11 01 (111 << 2 + 1 == 11101 > 10111 => last bit is 0) 294 5984 jhaslam * 295 5984 jhaslam */ 296 5984 jhaslam static uint64_t 297 5984 jhaslam dt_sqrt_128(uint64_t *square) 298 5984 jhaslam { 299 5984 jhaslam uint64_t result[2] = { 0, 0 }; 300 5984 jhaslam uint64_t diff[2] = { 0, 0 }; 301 5984 jhaslam uint64_t one[2] = { 1, 0 }; 302 5984 jhaslam uint64_t next_pair[2]; 303 5984 jhaslam uint64_t next_try[2]; 304 5984 jhaslam uint64_t bit_pairs, pair_shift; 305 5984 jhaslam int i; 306 5984 jhaslam 307 5984 jhaslam bit_pairs = dt_nbits_128(square) / 2; 308 5984 jhaslam pair_shift = bit_pairs * 2; 309 5984 jhaslam 310 5984 jhaslam for (i = 0; i <= bit_pairs; i++) { 311 5984 jhaslam /* 312 5984 jhaslam * Bring down the next pair of bits. 313 5984 jhaslam */ 314 5984 jhaslam next_pair[0] = square[0]; 315 5984 jhaslam next_pair[1] = square[1]; 316 5984 jhaslam dt_shift_128(next_pair, -pair_shift); 317 5984 jhaslam next_pair[0] &= 0x3; 318 5984 jhaslam next_pair[1] = 0; 319 5984 jhaslam 320 5984 jhaslam dt_shift_128(diff, 2); 321 5984 jhaslam dt_add_128(diff, next_pair, diff); 322 5984 jhaslam 323 5984 jhaslam /* 324 5984 jhaslam * next_try = R << 2 + 1 325 5984 jhaslam */ 326 5984 jhaslam next_try[0] = result[0]; 327 5984 jhaslam next_try[1] = result[1]; 328 5984 jhaslam dt_shift_128(next_try, 2); 329 5984 jhaslam dt_add_128(next_try, one, next_try); 330 5984 jhaslam 331 5984 jhaslam if (dt_le_128(next_try, diff)) { 332 5984 jhaslam dt_subtract_128(diff, next_try, diff); 333 5984 jhaslam dt_shift_128(result, 1); 334 5984 jhaslam dt_add_128(result, one, result); 335 5984 jhaslam } else { 336 5984 jhaslam dt_shift_128(result, 1); 337 5984 jhaslam } 338 5984 jhaslam 339 5984 jhaslam pair_shift -= 2; 340 5984 jhaslam } 341 5984 jhaslam 342 5984 jhaslam assert(result[1] == 0); 343 5984 jhaslam 344 5984 jhaslam return (result[0]); 345 5984 jhaslam } 346 5984 jhaslam 347 5984 jhaslam uint64_t 348 5984 jhaslam dt_stddev(uint64_t *data, uint64_t normal) 349 5984 jhaslam { 350 5984 jhaslam uint64_t avg_of_squares[2]; 351 5984 jhaslam uint64_t square_of_avg[2]; 352 5984 jhaslam int64_t norm_avg; 353 5984 jhaslam uint64_t diff[2]; 354 5984 jhaslam 355 5984 jhaslam /* 356 5984 jhaslam * The standard approximation for standard deviation is 357 5984 jhaslam * sqrt(average(x**2) - average(x)**2), i.e. the square root 358 5984 jhaslam * of the average of the squares minus the square of the average. 359 5984 jhaslam */ 360 5984 jhaslam dt_divide_128(data + 2, normal, avg_of_squares); 361 5984 jhaslam dt_divide_128(avg_of_squares, data[0], avg_of_squares); 362 5984 jhaslam 363 5984 jhaslam norm_avg = (int64_t)data[1] / (int64_t)normal / (int64_t)data[0]; 364 5984 jhaslam 365 5984 jhaslam if (norm_avg < 0) 366 5984 jhaslam norm_avg = -norm_avg; 367 5984 jhaslam 368 5984 jhaslam dt_multiply_128((uint64_t)norm_avg, (uint64_t)norm_avg, square_of_avg); 369 5984 jhaslam 370 5984 jhaslam dt_subtract_128(avg_of_squares, square_of_avg, diff); 371 5984 jhaslam 372 5984 jhaslam return (dt_sqrt_128(diff)); 373 457 bmc } 374 0 stevel 375 0 stevel static int 376 0 stevel dt_flowindent(dtrace_hdl_t *dtp, dtrace_probedata_t *data, dtrace_epid_t last, 377 0 stevel dtrace_bufdesc_t *buf, size_t offs) 378 0 stevel { 379 0 stevel dtrace_probedesc_t *pd = data->dtpda_pdesc, *npd; 380 0 stevel dtrace_eprobedesc_t *epd = data->dtpda_edesc, *nepd; 381 457 bmc char *p = pd->dtpd_provider, *n = pd->dtpd_name, *sub; 382 0 stevel dtrace_flowkind_t flow = DTRACEFLOW_NONE; 383 0 stevel const char *str = NULL; 384 0 stevel static const char *e_str[2] = { " -> ", " => " }; 385 0 stevel static const char *r_str[2] = { " <- ", " <= " }; 386 457 bmc static const char *ent = "entry", *ret = "return"; 387 457 bmc static int entlen = 0, retlen = 0; 388 0 stevel dtrace_epid_t next, id = epd->dtepd_epid; 389 0 stevel int rval; 390 0 stevel 391 457 bmc if (entlen == 0) { 392 457 bmc assert(retlen == 0); 393 457 bmc entlen = strlen(ent); 394 457 bmc retlen = strlen(ret); 395 457 bmc } 396 457 bmc 397 457 bmc /* 398 457 bmc * If the name of the probe is "entry" or ends with "-entry", we 399 457 bmc * treat it as an entry; if it is "return" or ends with "-return", 400 457 bmc * we treat it as a return. (This allows application-provided probes 401 457 bmc * like "method-entry" or "function-entry" to participate in flow 402 457 bmc * indentation -- without accidentally misinterpreting popular probe 403 457 bmc * names like "carpentry", "gentry" or "Coventry".) 404 457 bmc */ 405 457 bmc if ((sub = strstr(n, ent)) != NULL && sub[entlen] == '\0' && 406 457 bmc (sub == n || sub[-1] == '-')) { 407 0 stevel flow = DTRACEFLOW_ENTRY; 408 0 stevel str = e_str[strcmp(p, "syscall") == 0]; 409 457 bmc } else if ((sub = strstr(n, ret)) != NULL && sub[retlen] == '\0' && 410 457 bmc (sub == n || sub[-1] == '-')) { 411 0 stevel flow = DTRACEFLOW_RETURN; 412 0 stevel str = r_str[strcmp(p, "syscall") == 0]; 413 0 stevel } 414 0 stevel 415 0 stevel /* 416 0 stevel * If we're going to indent this, we need to check the ID of our last 417 0 stevel * call. If we're looking at the same probe ID but a different EPID, 418 0 stevel * we _don't_ want to indent. (Yes, there are some minor holes in 419 0 stevel * this scheme -- it's a heuristic.) 420 0 stevel */ 421 0 stevel if (flow == DTRACEFLOW_ENTRY) { 422 0 stevel if ((last != DTRACE_EPIDNONE && id != last && 423 0 stevel pd->dtpd_id == dtp->dt_pdesc[last]->dtpd_id)) 424 0 stevel flow = DTRACEFLOW_NONE; 425 0 stevel } 426 0 stevel 427 0 stevel /* 428 0 stevel * If we're going to unindent this, it's more difficult to see if 429 0 stevel * we don't actually want to unindent it -- we need to look at the 430 0 stevel * _next_ EPID. 431 0 stevel */ 432 0 stevel if (flow == DTRACEFLOW_RETURN) { 433 0 stevel offs += epd->dtepd_size; 434 0 stevel 435 0 stevel do { 436 0 stevel if (offs >= buf->dtbd_size) { 437 0 stevel /* 438 0 stevel * We're at the end -- maybe. If the oldest 439 0 stevel * record is non-zero, we need to wrap. 440 0 stevel */ 441 0 stevel if (buf->dtbd_oldest != 0) { 442 0 stevel offs = 0; 443 0 stevel } else { 444 0 stevel goto out; 445 0 stevel } 446 0 stevel } 447 0 stevel 448 0 stevel next = *(uint32_t *)((uintptr_t)buf->dtbd_data + offs); 449 0 stevel 450 0 stevel if (next == DTRACE_EPIDNONE) 451 0 stevel offs += sizeof (id); 452 0 stevel } while (next == DTRACE_EPIDNONE); 453 0 stevel 454 0 stevel if ((rval = dt_epid_lookup(dtp, next, &nepd, &npd)) != 0) 455 0 stevel return (rval); 456 0 stevel 457 0 stevel if (next != id && npd->dtpd_id == pd->dtpd_id) 458 0 stevel flow = DTRACEFLOW_NONE; 459 0 stevel } 460 0 stevel 461 0 stevel out: 462 0 stevel if (flow == DTRACEFLOW_ENTRY || flow == DTRACEFLOW_RETURN) { 463 0 stevel data->dtpda_prefix = str; 464 0 stevel } else { 465 0 stevel data->dtpda_prefix = "| "; 466 0 stevel } 467 0 stevel 468 0 stevel if (flow == DTRACEFLOW_RETURN && data->dtpda_indent > 0) 469 0 stevel data->dtpda_indent -= 2; 470 0 stevel 471 0 stevel data->dtpda_flow = flow; 472 0 stevel 473 0 stevel return (0); 474 0 stevel } 475 0 stevel 476 0 stevel static int 477 0 stevel dt_nullprobe() 478 0 stevel { 479 0 stevel return (DTRACE_CONSUME_THIS); 480 0 stevel } 481 0 stevel 482 0 stevel static int 483 0 stevel dt_nullrec() 484 0 stevel { 485 0 stevel return (DTRACE_CONSUME_NEXT); 486 0 stevel } 487 0 stevel 488 0 stevel int 489 457 bmc dt_print_quantline(dtrace_hdl_t *dtp, FILE *fp, int64_t val, 490 457 bmc uint64_t normal, long double total, char positives, char negatives) 491 457 bmc { 492 457 bmc long double f; 493 457 bmc uint_t depth, len = 40; 494 457 bmc 495 457 bmc const char *ats = "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"; 496 457 bmc const char *spaces = " "; 497 457 bmc 498 457 bmc assert(strlen(ats) == len && strlen(spaces) == len); 499 457 bmc assert(!(total == 0 && (positives || negatives))); 500 457 bmc assert(!(val < 0 && !negatives)); 501 457 bmc assert(!(val > 0 && !positives)); 502 457 bmc assert(!(val != 0 && total == 0)); 503 457 bmc 504 457 bmc if (!negatives) { 505 457 bmc if (positives) { 506 457 bmc f = (dt_fabsl((long double)val) * len) / total; 507 457 bmc depth = (uint_t)(f + 0.5); 508 457 bmc } else { 509 457 bmc depth = 0; 510 457 bmc } 511 457 bmc 512 457 bmc return (dt_printf(dtp, fp, "|%s%s %-9lld\n", ats + len - depth, 513 457 bmc spaces + depth, (long long)val / normal)); 514 457 bmc } 515 457 bmc 516 457 bmc if (!positives) { 517 457 bmc f = (dt_fabsl((long double)val) * len) / total; 518 457 bmc depth = (uint_t)(f + 0.5); 519 457 bmc 520 457 bmc return (dt_printf(dtp, fp, "%s%s| %-9lld\n", spaces + depth, 521 457 bmc ats + len - depth, (long long)val / normal)); 522 457 bmc } 523 457 bmc 524 457 bmc /* 525 457 bmc * If we're here, we have both positive and negative bucket values. 526 457 bmc * To express this graphically, we're going to generate both positive 527 457 bmc * and negative bars separated by a centerline. These bars are half 528 457 bmc * the size of normal quantize()/lquantize() bars, so we divide the 529 457 bmc * length in half before calculating the bar length. 530 457 bmc */ 531 457 bmc len /= 2; 532 457 bmc ats = &ats[len]; 533 457 bmc spaces = &spaces[len]; 534 457 bmc 535 457 bmc f = (dt_fabsl((long double)val) * len) / total; 536 457 bmc depth = (uint_t)(f + 0.5); 537 457 bmc 538 457 bmc if (val <= 0) { 539 457 bmc return (dt_printf(dtp, fp, "%s%s|%*s %-9lld\n", spaces + depth, 540 457 bmc ats + len - depth, len, "", (long long)val / normal)); 541 457 bmc } else { 542 457 bmc return (dt_printf(dtp, fp, "%20s|%s%s %-9lld\n", "", 543 457 bmc ats + len - depth, spaces + depth, 544 457 bmc (long long)val / normal)); 545 457 bmc } 546 457 bmc } 547 457 bmc 548 457 bmc int 549 0 stevel dt_print_quantize(dtrace_hdl_t *dtp, FILE *fp, const void *addr, 550 0 stevel size_t size, uint64_t normal) 551 0 stevel { 552 457 bmc const int64_t *data = addr; 553 0 stevel int i, first_bin = 0, last_bin = DTRACE_QUANTIZE_NBUCKETS - 1; 554 457 bmc long double total = 0; 555 457 bmc char positives = 0, negatives = 0; 556 0 stevel 557 0 stevel if (size != DTRACE_QUANTIZE_NBUCKETS * sizeof (uint64_t)) 558 0 stevel return (dt_set_errno(dtp, EDT_DMISMATCH)); 559 0 stevel 560 0 stevel while (first_bin < DTRACE_QUANTIZE_NBUCKETS - 1 && data[first_bin] == 0) 561 0 stevel first_bin++; 562 0 stevel 563 457 bmc if (first_bin == DTRACE_QUANTIZE_NBUCKETS - 1) { 564 457 bmc /* 565 457 bmc * There isn't any data. This is possible if (and only if) 566 457 bmc * negative increment values have been used. In this case, 567 457 bmc * we'll print the buckets around 0. 568 457 bmc */ 569 457 bmc first_bin = DTRACE_QUANTIZE_ZEROBUCKET - 1; 570 457 bmc last_bin = DTRACE_QUANTIZE_ZEROBUCKET + 1; 571 457 bmc } else { 572 457 bmc if (first_bin > 0) 573 457 bmc first_bin--; 574 0 stevel 575 457 bmc while (last_bin > 0 && data[last_bin] == 0) 576 457 bmc last_bin--; 577 0 stevel 578 457 bmc if (last_bin < DTRACE_QUANTIZE_NBUCKETS - 1) 579 457 bmc last_bin++; 580 457 bmc } 581 0 stevel 582 457 bmc for (i = first_bin; i <= last_bin; i++) { 583 457 bmc positives |= (data[i] > 0); 584 457 bmc negatives |= (data[i] < 0); 585 457 bmc total += dt_fabsl((long double)data[i]); 586 457 bmc } 587 0 stevel 588 0 stevel if (dt_printf(dtp, fp, "\n%16s %41s %-9s\n", "value", 589 0 stevel "------------- Distribution -------------", "count") < 0) 590 0 stevel return (-1); 591 0 stevel 592 0 stevel for (i = first_bin; i <= last_bin; i++) { 593 457 bmc if (dt_printf(dtp, fp, "%16lld ", 594 457 bmc (long long)DTRACE_QUANTIZE_BUCKETVAL(i)) < 0) 595 457 bmc return (-1); 596 0 stevel 597 457 bmc if (dt_print_quantline(dtp, fp, data[i], normal, total, 598 457 bmc positives, negatives) < 0) 599 0 stevel return (-1); 600 0 stevel } 601 0 stevel 602 0 stevel return (0); 603 0 stevel } 604 0 stevel 605 0 stevel int 606 0 stevel dt_print_lquantize(dtrace_hdl_t *dtp, FILE *fp, const void *addr, 607 0 stevel size_t size, uint64_t normal) 608 0 stevel { 609 457 bmc const int64_t *data = addr; 610 0 stevel int i, first_bin, last_bin, base; 611 457 bmc uint64_t arg; 612 457 bmc long double total = 0; 613 0 stevel uint16_t step, levels; 614 457 bmc char positives = 0, negatives = 0; 615 0 stevel 616 0 stevel if (size < sizeof (uint64_t)) 617 0 stevel return (dt_set_errno(dtp, EDT_DMISMATCH)); 618 0 stevel 619 0 stevel arg = *data++; 620 0 stevel size -= sizeof (uint64_t); 621 0 stevel 622 0 stevel base = DTRACE_LQUANTIZE_BASE(arg); 623 0 stevel step = DTRACE_LQUANTIZE_STEP(arg); 624 0 stevel levels = DTRACE_LQUANTIZE_LEVELS(arg); 625 0 stevel 626 0 stevel first_bin = 0; 627 0 stevel last_bin = levels + 1; 628 0 stevel 629 0 stevel if (size != sizeof (uint64_t) * (levels + 2)) 630 0 stevel return (dt_set_errno(dtp, EDT_DMISMATCH)); 631 0 stevel 632 491 bmc while (first_bin <= levels + 1 && data[first_bin] == 0) 633 0 stevel first_bin++; 634 0 stevel 635 491 bmc if (first_bin > levels + 1) { 636 457 bmc first_bin = 0; 637 457 bmc last_bin = 2; 638 457 bmc } else { 639 457 bmc if (first_bin > 0) 640 457 bmc first_bin--; 641 0 stevel 642 457 bmc while (last_bin > 0 && data[last_bin] == 0) 643 457 bmc last_bin--; 644 0 stevel 645 457 bmc if (last_bin < levels + 1) 646 457 bmc last_bin++; 647 457 bmc } 648 0 stevel 649 457 bmc for (i = first_bin; i <= last_bin; i++) { 650 457 bmc positives |= (data[i] > 0); 651 457 bmc negatives |= (data[i] < 0); 652 457 bmc total += dt_fabsl((long double)data[i]); 653 457 bmc } 654 0 stevel 655 0 stevel if (dt_printf(dtp, fp, "\n%16s %41s %-9s\n", "value", 656 0 stevel "------------- Distribution -------------", "count") < 0) 657 0 stevel return (-1); 658 0 stevel 659 0 stevel for (i = first_bin; i <= last_bin; i++) { 660 0 stevel char c[32]; 661 0 stevel int err; 662 0 stevel 663 0 stevel if (i == 0) { 664 0 stevel (void) snprintf(c, sizeof (c), "< %d", 665 0 stevel base / (uint32_t)normal); 666 0 stevel err = dt_printf(dtp, fp, "%16s ", c); 667 0 stevel } else if (i == levels + 1) { 668 0 stevel (void) snprintf(c, sizeof (c), ">= %d", 669 0 stevel base + (levels * step)); 670 0 stevel err = dt_printf(dtp, fp, "%16s ", c); 671 0 stevel } else { 672 0 stevel err = dt_printf(dtp, fp, "%16d ", 673 0 stevel base + (i - 1) * step); 674 0 stevel } 675 0 stevel 676 457 bmc if (err < 0 || dt_print_quantline(dtp, fp, data[i], normal, 677 457 bmc total, positives, negatives) < 0) 678 0 stevel return (-1); 679 0 stevel } 680 0 stevel 681 0 stevel return (0); 682 0 stevel } 683 0 stevel 684 0 stevel /*ARGSUSED*/ 685 0 stevel static int 686 0 stevel dt_print_average(dtrace_hdl_t *dtp, FILE *fp, caddr_t addr, 687 0 stevel size_t size, uint64_t normal) 688 0 stevel { 689 0 stevel /* LINTED - alignment */ 690 5984 jhaslam int64_t *data = (int64_t *)addr; 691 5984 jhaslam 692 5984 jhaslam return (dt_printf(dtp, fp, " %16lld", data[0] ? 693 5984 jhaslam (long long)(data[1] / (int64_t)normal / data[0]) : 0)); 694 5984 jhaslam } 695 5984 jhaslam 696 5984 jhaslam /*ARGSUSED*/ 697 5984 jhaslam static int 698 5984 jhaslam dt_print_stddev(dtrace_hdl_t *dtp, FILE *fp, caddr_t addr, 699 5984 jhaslam size_t size, uint64_t normal) 700 5984 jhaslam { 701 5984 jhaslam /* LINTED - alignment */ 702 0 stevel uint64_t *data = (uint64_t *)addr; 703 0 stevel 704 5984 jhaslam return (dt_printf(dtp, fp, " %16llu", data[0] ? 705 5984 jhaslam (unsigned long long) dt_stddev(data, normal) : 0)); 706 0 stevel } 707 0 stevel 708 0 stevel /*ARGSUSED*/ 709 0 stevel int 710 0 stevel dt_print_bytes(dtrace_hdl_t *dtp, FILE *fp, caddr_t addr, 711 0 stevel size_t nbytes, int width, int quiet) 712 0 stevel { 713 0 stevel /* 714 0 stevel * If the byte stream is a series of printable characters, followed by 715 0 stevel * a terminating byte, we print it out as a string. Otherwise, we 716 0 stevel * assume that it's something else and just print the bytes. 717 0 stevel */ 718 0 stevel int i, j, margin = 5; 719 0 stevel char *c = (char *)addr; 720 0 stevel 721 0 stevel if (nbytes == 0) 722 0 stevel return (0); 723 0 stevel 724 0 stevel if (dtp->dt_options[DTRACEOPT_RAWBYTES] != DTRACEOPT_UNSET) 725 0 stevel goto raw; 726 0 stevel 727 0 stevel for (i = 0; i < nbytes; i++) { 728 0 stevel /* 729 0 stevel * We define a "printable character" to be one for which 730 0 stevel * isprint(3C) returns non-zero, isspace(3C) returns non-zero, 731 0 stevel * or a character which is either backspace or the bell. 732 0 stevel * Backspace and the bell are regrettably special because 733 0 stevel * they fail the first two tests -- and yet they are entirely 734 0 stevel * printable. These are the only two control characters that 735 0 stevel * have meaning for the terminal and for which isprint(3C) and 736 0 stevel * isspace(3C) return 0. 737 0 stevel */ 738 0 stevel if (isprint(c[i]) || isspace(c[i]) || 739 0 stevel c[i] == '\b' || c[i] == '\a') 740 0 stevel continue; 741 0 stevel 742 0 stevel if (c[i] == '\0' && i > 0) { 743 0 stevel /* 744 0 stevel * This looks like it might be a string. Before we 745 0 stevel * assume that it is indeed a string, check the 746 0 stevel * remainder of the byte range; if it contains 747 0 stevel * additional non-nul characters, we'll assume that 748 0 stevel * it's a binary stream that just happens to look like 749 0 stevel * a string, and we'll print out the individual bytes. 750 0 stevel */ 751 0 stevel for (j = i + 1; j < nbytes; j++) { 752 0 stevel if (c[j] != '\0') 753 0 stevel break; 754 0 stevel } 755 0 stevel 756 0 stevel if (j != nbytes) 757 0 stevel break; 758 0 stevel 759 0 stevel if (quiet) 760 0 stevel return (dt_printf(dtp, fp, "%s", c)); 761 0 stevel else 762 0 stevel return (dt_printf(dtp, fp, " %-*s", width, c)); 763 0 stevel } 764 0 stevel 765 0 stevel break; 766 0 stevel } 767 0 stevel 768 0 stevel if (i == nbytes) { 769 0 stevel /* 770 0 stevel * The byte range is all printable characters, but there is 771 0 stevel * no trailing nul byte. We'll assume that it's a string and 772 0 stevel * print it as such. 773 0 stevel */ 774 0 stevel char *s = alloca(nbytes + 1); 775 0 stevel bcopy(c, s, nbytes); 776 0 stevel s[nbytes] = '\0'; 777 0 stevel return (dt_printf(dtp, fp, " %-*s", width, s)); 778 0 stevel } 779 0 stevel 780 0 stevel raw: 781 0 stevel if (dt_printf(dtp, fp, "\n%*s ", margin, "") < 0) 782 0 stevel return (-1); 783 0 stevel 784 0 stevel for (i = 0; i < 16; i++) 785 0 stevel if (dt_printf(dtp, fp, " %c", "0123456789abcdef"[i]) < 0) 786 0 stevel return (-1); 787 0 stevel 788 0 stevel if (dt_printf(dtp, fp, " 0123456789abcdef\n") < 0) 789 0 stevel return (-1); 790 0 stevel 791 0 stevel 792 0 stevel for (i = 0; i < nbytes; i += 16) { 793 0 stevel if (dt_printf(dtp, fp, "%*s%5x:", margin, "", i) < 0) 794 0 stevel return (-1); 795 0 stevel 796 0 stevel for (j = i; j < i + 16 && j < nbytes; j++) { 797 0 stevel if (dt_printf(dtp, fp, " %02x", (uchar_t)c[j]) < 0) 798 0 stevel return (-1); 799 0 stevel } 800 0 stevel 801 0 stevel while (j++ % 16) { 802 0 stevel if (dt_printf(dtp, fp, " ") < 0) 803 0 stevel return (-1); 804 0 stevel } 805 0 stevel 806 0 stevel if (dt_printf(dtp, fp, " ") < 0) 807 0 stevel return (-1); 808 0 stevel 809 0 stevel for (j = i; j < i + 16 && j < nbytes; j++) { 810 0 stevel if (dt_printf(dtp, fp, "%c", 811 0 stevel c[j] < ' ' || c[j] > '~' ? '.' : c[j]) < 0) 812 0 stevel return (-1); 813 0 stevel } 814 0 stevel 815 0 stevel if (dt_printf(dtp, fp, "\n") < 0) 816 0 stevel return (-1); 817 0 stevel } 818 0 stevel 819 0 stevel return (0); 820 0 stevel } 821 0 stevel 822 0 stevel int 823 0 stevel dt_print_stack(dtrace_hdl_t *dtp, FILE *fp, const char *format, 824 457 bmc caddr_t addr, int depth, int size) 825 0 stevel { 826 0 stevel dtrace_syminfo_t dts; 827 0 stevel GElf_Sym sym; 828 0 stevel int i, indent; 829 0 stevel char c[PATH_MAX * 2]; 830 457 bmc uint64_t pc; 831 0 stevel 832 0 stevel if (dt_printf(dtp, fp, "\n") < 0) 833 0 stevel return (-1); 834 0 stevel 835 0 stevel if (format == NULL) 836 0 stevel format = "%s"; 837 0 stevel 838 0 stevel if (dtp->dt_options[DTRACEOPT_STACKINDENT] != DTRACEOPT_UNSET) 839 0 stevel indent = (int)dtp->dt_options[DTRACEOPT_STACKINDENT]; 840 0 stevel else 841 0 stevel indent = _dtrace_stkindent; 842 0 stevel 843 457 bmc for (i = 0; i < depth; i++) { 844 457 bmc switch (size) { 845 457 bmc case sizeof (uint32_t): 846 457 bmc /* LINTED - alignment */ 847 457 bmc pc = *((uint32_t *)addr); 848 457 bmc break; 849 457 bmc 850 457 bmc case sizeof (uint64_t): 851 457 bmc /* LINTED - alignment */ 852 457 bmc pc = *((uint64_t *)addr); 853 457 bmc break; 854 457 bmc 855 457 bmc default: 856 457 bmc return (dt_set_errno(dtp, EDT_BADSTACKPC)); 857 457 bmc } 858 457 bmc 859 457 bmc if (pc == NULL) 860 457 bmc break; 861 457 bmc 862 457 bmc addr += size; 863 457 bmc 864 0 stevel if (dt_printf(dtp, fp, "%*s", indent, "") < 0) 865 0 stevel return (-1); 866 0 stevel 867 457 bmc if (dtrace_lookup_by_addr(dtp, pc, &sym, &dts) == 0) { 868 457 bmc if (pc > sym.st_value) { 869 0 stevel (void) snprintf(c, sizeof (c), "%s`%s+0x%llx", 870 0 stevel dts.dts_object, dts.dts_name, 871 457 bmc pc - sym.st_value); 872 0 stevel } else { 873 0 stevel (void) snprintf(c, sizeof (c), "%s`%s", 874 0 stevel dts.dts_object, dts.dts_name); 875 0 stevel } 876 0 stevel } else { 877 0 stevel /* 878 0 stevel * We'll repeat the lookup, but this time we'll specify 879 0 stevel * a NULL GElf_Sym -- indicating that we're only 880 0 stevel * interested in the containing module. 881 0 stevel */ 882 457 bmc if (dtrace_lookup_by_addr(dtp, pc, NULL, &dts) == 0) { 883 0 stevel (void) snprintf(c, sizeof (c), "%s`0x%llx", 884 457 bmc dts.dts_object, pc); 885 0 stevel } else { 886 457 bmc (void) snprintf(c, sizeof (c), "0x%llx", pc); 887 0 stevel } 888 0 stevel } 889 0 stevel 890 0 stevel if (dt_printf(dtp, fp, format, c) < 0) 891 0 stevel return (-1); 892 0 stevel 893 0 stevel if (dt_printf(dtp, fp, "\n") < 0) 894 0 stevel return (-1); 895 0 stevel } 896 0 stevel 897 0 stevel return (0); 898 0 stevel } 899 0 stevel 900 0 stevel int 901 0 stevel dt_print_ustack(dtrace_hdl_t *dtp, FILE *fp, const char *format, 902 0 stevel caddr_t addr, uint64_t arg) 903 0 stevel { 904 457 bmc /* LINTED - alignment */ 905 457 bmc uint64_t *pc = (uint64_t *)addr; 906 0 stevel uint32_t depth = DTRACE_USTACK_NFRAMES(arg); 907 0 stevel uint32_t strsize = DTRACE_USTACK_STRSIZE(arg); 908 0 stevel const char *strbase = addr + (depth + 1) * sizeof (uint64_t); 909 0 stevel const char *str = strsize ? strbase : NULL; 910 0 stevel int err = 0; 911 0 stevel 912 0 stevel char name[PATH_MAX], objname[PATH_MAX], c[PATH_MAX * 2]; 913 0 stevel struct ps_prochandle *P; 914 0 stevel GElf_Sym sym; 915 0 stevel int i, indent; 916 0 stevel pid_t pid; 917 0 stevel 918 0 stevel if (depth == 0) 919 0 stevel return (0); 920 0 stevel 921 0 stevel pid = (pid_t)*pc++; 922 0 stevel 923 0 stevel if (dt_printf(dtp, fp, "\n") < 0) 924 0 stevel return (-1); 925 0 stevel 926 0 stevel if (format == NULL) 927 0 stevel format = "%s"; 928 0 stevel 929 0 stevel if (dtp->dt_options[DTRACEOPT_STACKINDENT] != DTRACEOPT_UNSET) 930 0 stevel indent = (int)dtp->dt_options[DTRACEOPT_STACKINDENT]; 931 0 stevel else 932 0 stevel indent = _dtrace_stkindent; 933 0 stevel 934 0 stevel /* 935 0 stevel * Ultimately, we need to add an entry point in the library vector for 936 0 stevel * determining <symbol, offset> from <pid, address>. For now, if 937 0 stevel * this is a vector open, we just print the raw address or string. 938 0 stevel */ 939 0 stevel if (dtp->dt_vector == NULL) 940 0 stevel P = dt_proc_grab(dtp, pid, PGRAB_RDONLY | PGRAB_FORCE, 0); 941 0 stevel else 942 0 stevel P = NULL; 943 0 stevel 944 0 stevel if (P != NULL) 945 0 stevel dt_proc_lock(dtp, P); /* lock handle while we perform lookups */ 946 0 stevel 947 0 stevel for (i = 0; i < depth && pc[i] != NULL; i++) { 948 457 bmc const prmap_t *map; 949 457 bmc 950 0 stevel if ((err = dt_printf(dtp, fp, "%*s", indent, "")) < 0) 951 0 stevel break; 952 0 stevel 953 0 stevel if (P != NULL && Plookup_by_addr(P, pc[i], 954 0 stevel name, sizeof (name), &sym) == 0) { 955 0 stevel (void) Pobjname(P, pc[i], objname, sizeof (objname)); 956 0 stevel 957 0 stevel if (pc[i] > sym.st_value) { 958 0 stevel (void) snprintf(c, sizeof (c), 959 0 stevel "%s`%s+0x%llx", dt_basename(objname), name, 960 0 stevel (u_longlong_t)(pc[i] - sym.st_value)); 961 0 stevel } else { 962 0 stevel (void) snprintf(c, sizeof (c), 963 0 stevel "%s`%s", dt_basename(objname), name); 964 0 stevel } 965 491 bmc } else if (str != NULL && str[0] != '\0' && str[0] != '@' && 966 457 bmc (P != NULL && ((map = Paddr_to_map(P, pc[i])) == NULL || 967 457 bmc (map->pr_mflags & MA_WRITE)))) { 968 457 bmc /* 969 457 bmc * If the current string pointer in the string table 970 457 bmc * does not point to an empty string _and_ the program 971 457 bmc * counter falls in a writable region, we'll use the 972 457 bmc * string from the string table instead of the raw 973 457 bmc * address. This last condition is necessary because 974 457 bmc * some (broken) ustack helpers will return a string 975 457 bmc * even for a program counter that they can't 976 457 bmc * identify. If we have a string for a program 977 457 bmc * counter that falls in a segment that isn't 978 457 bmc * writable, we assume that we have fallen into this 979 457 bmc * case and we refuse to use the string. 980 457 bmc */ 981 0 stevel (void) snprintf(c, sizeof (c), "%s", str); 982 0 stevel } else { 983 0 stevel if (P != NULL && Pobjname(P, pc[i], objname, 984 0 stevel sizeof (objname)) != NULL) { 985 0 stevel (void) snprintf(c, sizeof (c), "%s`0x%llx", 986 0 stevel dt_basename(objname), (u_longlong_t)pc[i]); 987 0 stevel } else { 988 0 stevel (void) snprintf(c, sizeof (c), "0x%llx", 989 0 stevel (u_longlong_t)pc[i]); 990 0 stevel } 991 0 stevel } 992 0 stevel 993 0 stevel if ((err = dt_printf(dtp, fp, format, c)) < 0) 994 0 stevel break; 995 0 stevel 996 0 stevel if ((err = dt_printf(dtp, fp, "\n")) < 0) 997 0 stevel break; 998 491 bmc 999 491 bmc if (str != NULL && str[0] == '@') { 1000 491 bmc /* 1001 491 bmc * If the first character of the string is an "at" sign, 1002 491 bmc * then the string is inferred to be an annotation -- 1003 491 bmc * and it is printed out beneath the frame and offset 1004 491 bmc * with brackets. 1005 491 bmc */ 1006 491 bmc if ((err = dt_printf(dtp, fp, "%*s", indent, "")) < 0) 1007 491 bmc break; 1008 491 bmc 1009 491 bmc (void) snprintf(c, sizeof (c), " [ %s ]", &str[1]); 1010 491 bmc 1011 491 bmc if ((err = dt_printf(dtp, fp, format, c)) < 0) 1012 491 bmc break; 1013 491 bmc 1014 491 bmc if ((err = dt_printf(dtp, fp, "\n")) < 0) 1015 491 bmc break; 1016 491 bmc } 1017 0 stevel 1018 0 stevel if (str != NULL) { 1019 0 stevel str += strlen(str) + 1; 1020 0 stevel if (str - strbase >= strsize) 1021 0 stevel str = NULL; 1022 0 stevel } 1023 0 stevel } 1024 0 stevel 1025 0 stevel if (P != NULL) { 1026 0 stevel dt_proc_unlock(dtp, P); 1027 0 stevel dt_proc_release(dtp, P); 1028 0 stevel } 1029 0 stevel 1030 0 stevel return (err); 1031 0 stevel } 1032 0 stevel 1033 457 bmc static int 1034 457 bmc dt_print_usym(dtrace_hdl_t *dtp, FILE *fp, caddr_t addr, dtrace_actkind_t act) 1035 457 bmc { 1036 457 bmc /* LINTED - alignment */ 1037 457 bmc uint64_t pid = ((uint64_t *)addr)[0]; 1038 457 bmc /* LINTED - alignment */ 1039 457 bmc uint64_t pc = ((uint64_t *)addr)[1]; 1040 457 bmc const char *format = " %-50s"; 1041 457 bmc char *s; 1042 457 bmc int n, len = 256; 1043 457 bmc 1044 457 bmc if (act == DTRACEACT_USYM && dtp->dt_vector == NULL) { 1045 457 bmc struct ps_prochandle *P; 1046 457 bmc 1047 457 bmc if ((P = dt_proc_grab(dtp, pid, 1048 457 bmc PGRAB_RDONLY | PGRAB_FORCE, 0)) != NULL) { 1049 457 bmc GElf_Sym sym; 1050 457 bmc 1051 457 bmc dt_proc_lock(dtp, P); 1052 457 bmc 1053 457 bmc if (Plookup_by_addr(P, pc, NULL, 0, &sym) == 0) 1054 457 bmc pc = sym.st_value; 1055 457 bmc 1056 457 bmc dt_proc_unlock(dtp, P); 1057 457 bmc dt_proc_release(dtp, P); 1058 457 bmc } 1059 457 bmc } 1060 457 bmc 1061 457 bmc do { 1062 457 bmc n = len; 1063 457 bmc s = alloca(n); 1064 10791 Jonathan } while ((len = dtrace_uaddr2str(dtp, pid, pc, s, n)) > n); 1065 457 bmc 1066 457 bmc return (dt_printf(dtp, fp, format, s)); 1067 457 bmc } 1068 457 bmc 1069 457 bmc int 1070 457 bmc dt_print_umod(dtrace_hdl_t *dtp, FILE *fp, const char *format, caddr_t addr) 1071 457 bmc { 1072 457 bmc /* LINTED - alignment */ 1073 457 bmc uint64_t pid = ((uint64_t *)addr)[0]; 1074 457 bmc /* LINTED - alignment */ 1075 457 bmc uint64_t pc = ((uint64_t *)addr)[1]; 1076 457 bmc int err = 0; 1077 457 bmc 1078 457 bmc char objname[PATH_MAX], c[PATH_MAX * 2]; 1079 457 bmc struct ps_prochandle *P; 1080 457 bmc 1081 457 bmc if (format == NULL) 1082 457 bmc format = " %-50s"; 1083 457 bmc 1084 457 bmc /* 1085 457 bmc * See the comment in dt_print_ustack() for the rationale for 1086 457 bmc * printing raw addresses in the vectored case. 1087 457 bmc */ 1088 457 bmc if (dtp->dt_vector == NULL) 1089 457 bmc P = dt_proc_grab(dtp, pid, PGRAB_RDONLY | PGRAB_FORCE, 0); 1090 457 bmc else 1091 457 bmc P = NULL; 1092 457 bmc 1093 457 bmc if (P != NULL) 1094 457 bmc dt_proc_lock(dtp, P); /* lock handle while we perform lookups */ 1095 457 bmc 1096 457 bmc if (P != NULL && Pobjname(P, pc, objname, sizeof (objname)) != NULL) { 1097 457 bmc (void) snprintf(c, sizeof (c), "%s", dt_basename(objname)); 1098 457 bmc } else { 1099 457 bmc (void) snprintf(c, sizeof (c), "0x%llx", (u_longlong_t)pc); 1100 457 bmc } 1101 457 bmc 1102 457 bmc err = dt_printf(dtp, fp, format, c); 1103 457 bmc 1104 457 bmc if (P != NULL) { 1105 457 bmc dt_proc_unlock(dtp, P); 1106 457 bmc dt_proc_release(dtp, P); 1107 457 bmc } 1108 457 bmc 1109 457 bmc return (err); 1110 457 bmc } 1111 457 bmc 1112 457 bmc static int 1113 457 bmc dt_print_sym(dtrace_hdl_t *dtp, FILE *fp, const char *format, caddr_t addr) 1114 457 bmc { 1115 457 bmc /* LINTED - alignment */ 1116 457 bmc uint64_t pc = *((uint64_t *)addr); 1117 457 bmc dtrace_syminfo_t dts; 1118 457 bmc GElf_Sym sym; 1119 457 bmc char c[PATH_MAX * 2]; 1120 457 bmc 1121 457 bmc if (format == NULL) 1122 457 bmc format = " %-50s"; 1123 457 bmc 1124 457 bmc if (dtrace_lookup_by_addr(dtp, pc, &sym, &dts) == 0) { 1125 457 bmc (void) snprintf(c, sizeof (c), "%s`%s", 1126 457 bmc dts.dts_object, dts.dts_name); 1127 457 bmc } else { 1128 457 bmc /* 1129 457 bmc * We'll repeat the lookup, but this time we'll specify a 1130 457 bmc * NULL GElf_Sym -- indicating that we're only interested in 1131 457 bmc * the containing module. 1132 457 bmc */ 1133 457 bmc if (dtrace_lookup_by_addr(dtp, pc, NULL, &dts) == 0) { 1134 457 bmc (void) snprintf(c, sizeof (c), "%s`0x%llx", 1135 457 bmc dts.dts_object, (u_longlong_t)pc); 1136 457 bmc } else { 1137 457 bmc (void) snprintf(c, sizeof (c), "0x%llx", 1138 457 bmc (u_longlong_t)pc); 1139 457 bmc } 1140 457 bmc } 1141 457 bmc 1142 457 bmc if (dt_printf(dtp, fp, format, c) < 0) 1143 457 bmc return (-1); 1144 457 bmc 1145 457 bmc return (0); 1146 457 bmc } 1147 457 bmc 1148 457 bmc int 1149 457 bmc dt_print_mod(dtrace_hdl_t *dtp, FILE *fp, const char *format, caddr_t addr) 1150 457 bmc { 1151 457 bmc /* LINTED - alignment */ 1152 457 bmc uint64_t pc = *((uint64_t *)addr); 1153 457 bmc dtrace_syminfo_t dts; 1154 457 bmc char c[PATH_MAX * 2]; 1155 457 bmc 1156 457 bmc if (format == NULL) 1157 457 bmc format = " %-50s"; 1158 457 bmc 1159 457 bmc if (dtrace_lookup_by_addr(dtp, pc, NULL, &dts) == 0) { 1160 457 bmc (void) snprintf(c, sizeof (c), "%s", dts.dts_object); 1161 457 bmc } else { 1162 457 bmc (void) snprintf(c, sizeof (c), "0x%llx", (u_longlong_t)pc); 1163 457 bmc } 1164 457 bmc 1165 457 bmc if (dt_printf(dtp, fp, format, c) < 0) 1166 457 bmc return (-1); 1167 457 bmc 1168 457 bmc return (0); 1169 457 bmc } 1170 457 bmc 1171 0 stevel typedef struct dt_normal { 1172 0 stevel dtrace_aggvarid_t dtnd_id; 1173 0 stevel uint64_t dtnd_normal; 1174 0 stevel } dt_normal_t; 1175 0 stevel 1176 0 stevel static int 1177 457 bmc dt_normalize_agg(const dtrace_aggdata_t *aggdata, void *arg) 1178 0 stevel { 1179 0 stevel dt_normal_t *normal = arg; 1180 0 stevel dtrace_aggdesc_t *agg = aggdata->dtada_desc; 1181 0 stevel dtrace_aggvarid_t id = normal->dtnd_id; 1182 0 stevel 1183 0 stevel if (agg->dtagd_nrecs == 0) 1184 0 stevel return (DTRACE_AGGWALK_NEXT); 1185 0 stevel 1186 1017 bmc if (agg->dtagd_varid != id) 1187 0 stevel return (DTRACE_AGGWALK_NEXT); 1188 0 stevel 1189 457 bmc ((dtrace_aggdata_t *)aggdata)->dtada_normal = normal->dtnd_normal; 1190 0 stevel return (DTRACE_AGGWALK_NORMALIZE); 1191 0 stevel } 1192 0 stevel 1193 0 stevel static int 1194 0 stevel dt_normalize(dtrace_hdl_t *dtp, caddr_t base, dtrace_recdesc_t *rec) 1195 0 stevel { 1196 0 stevel dt_normal_t normal; 1197 0 stevel caddr_t addr; 1198 0 stevel 1199 0 stevel /* 1200 0 stevel * We (should) have two records: the aggregation ID followed by the 1201 0 stevel * normalization value. 1202 0 stevel */ 1203 0 stevel addr = base + rec->dtrd_offset; 1204 0 stevel 1205 0 stevel if (rec->dtrd_size != sizeof (dtrace_aggvarid_t)) 1206 0 stevel return (dt_set_errno(dtp, EDT_BADNORMAL)); 1207 0 stevel 1208 0 stevel /* LINTED - alignment */ 1209 0 stevel normal.dtnd_id = *((dtrace_aggvarid_t *)addr); 1210 0 stevel rec++; 1211 0 stevel 1212 0 stevel if (rec->dtrd_action != DTRACEACT_LIBACT) 1213 0 stevel return (dt_set_errno(dtp, EDT_BADNORMAL)); 1214 0 stevel 1215 0 stevel if (rec->dtrd_arg != DT_ACT_NORMALIZE) 1216 0 stevel return (dt_set_errno(dtp, EDT_BADNORMAL)); 1217 0 stevel 1218 0 stevel addr = base + rec->dtrd_offset; 1219 0 stevel 1220 0 stevel switch (rec->dtrd_size) { 1221 0 stevel case sizeof (uint64_t): 1222 0 stevel /* LINTED - alignment */ 1223 0 stevel normal.dtnd_normal = *((uint64_t *)addr); 1224 0 stevel break; 1225 0 stevel case sizeof (uint32_t): 1226 0 stevel /* LINTED - alignment */ 1227 0 stevel normal.dtnd_normal = *((uint32_t *)addr); 1228 0 stevel break; 1229 0 stevel case sizeof (uint16_t): 1230 0 stevel /* LINTED - alignment */ 1231 0 stevel normal.dtnd_normal = *((uint16_t *)addr); 1232 0 stevel break; 1233 0 stevel case sizeof (uint8_t): 1234 0 stevel normal.dtnd_normal = *((uint8_t *)addr); 1235 0 stevel break; 1236 0 stevel default: 1237 0 stevel return (dt_set_errno(dtp, EDT_BADNORMAL)); 1238 0 stevel } 1239 0 stevel 1240 0 stevel (void) dtrace_aggregate_walk(dtp, dt_normalize_agg, &normal); 1241 0 stevel 1242 0 stevel return (0); 1243 0 stevel } 1244 0 stevel 1245 0 stevel static int 1246 457 bmc dt_denormalize_agg(const dtrace_aggdata_t *aggdata, void *arg) 1247 0 stevel { 1248 0 stevel dtrace_aggdesc_t *agg = aggdata->dtada_desc; 1249 0 stevel dtrace_aggvarid_t id = *((dtrace_aggvarid_t *)arg); 1250 0 stevel 1251 0 stevel if (agg->dtagd_nrecs == 0) 1252 0 stevel return (DTRACE_AGGWALK_NEXT); 1253 0 stevel 1254 1017 bmc if (agg->dtagd_varid != id) 1255 0 stevel return (DTRACE_AGGWALK_NEXT); 1256 0 stevel 1257 0 stevel return (DTRACE_AGGWALK_DENORMALIZE); 1258 0 stevel } 1259 0 stevel 1260 0 stevel static int 1261 457 bmc dt_clear_agg(const dtrace_aggdata_t *aggdata, void *arg) 1262 0 stevel { 1263 0 stevel dtrace_aggdesc_t *agg = aggdata->dtada_desc; 1264 0 stevel dtrace_aggvarid_t id = *((dtrace_aggvarid_t *)arg); 1265 0 stevel 1266 0 stevel if (agg->dtagd_nrecs == 0) 1267 0 stevel return (DTRACE_AGGWALK_NEXT); 1268 0 stevel 1269 1017 bmc if (agg->dtagd_varid != id) 1270 0 stevel return (DTRACE_AGGWALK_NEXT); 1271 0 stevel 1272 0 stevel return (DTRACE_AGGWALK_CLEAR); 1273 0 stevel } 1274 0 stevel 1275 0 stevel typedef struct dt_trunc { 1276 0 stevel dtrace_aggvarid_t dttd_id; 1277 0 stevel uint64_t dttd_remaining; 1278 0 stevel } dt_trunc_t; 1279 0 stevel 1280 0 stevel static int 1281 457 bmc dt_trunc_agg(const dtrace_aggdata_t *aggdata, void *arg) 1282 0 stevel { 1283 0 stevel dt_trunc_t *trunc = arg; 1284 0 stevel dtrace_aggdesc_t *agg = aggdata->dtada_desc; 1285 0 stevel dtrace_aggvarid_t id = trunc->dttd_id; 1286 0 stevel 1287 0 stevel if (agg->dtagd_nrecs == 0) 1288 0 stevel return (DTRACE_AGGWALK_NEXT); 1289 0 stevel 1290 1017 bmc if (agg->dtagd_varid != id) 1291 0 stevel return (DTRACE_AGGWALK_NEXT); 1292 0 stevel 1293 0 stevel if (trunc->dttd_remaining == 0) 1294 0 stevel return (DTRACE_AGGWALK_REMOVE); 1295 0 stevel 1296 0 stevel trunc->dttd_remaining--; 1297 0 stevel return (DTRACE_AGGWALK_NEXT); 1298 0 stevel } 1299 0 stevel 1300 0 stevel static int 1301 0 stevel dt_trunc(dtrace_hdl_t *dtp, caddr_t base, dtrace_recdesc_t *rec) 1302 0 stevel { 1303 0 stevel dt_trunc_t trunc; 1304 0 stevel caddr_t addr; 1305 0 stevel int64_t remaining; 1306 0 stevel int (*func)(dtrace_hdl_t *, dtrace_aggregate_f *, void *); 1307 0 stevel 1308 0 stevel /* 1309 0 stevel * We (should) have two records: the aggregation ID followed by the 1310 0 stevel * number of aggregation entries after which the aggregation is to be 1311 0 stevel * truncated. 1312 0 stevel */ 1313 0 stevel addr = base + rec->dtrd_offset; 1314 0 stevel 1315 0 stevel if (rec->dtrd_size != sizeof (dtrace_aggvarid_t)) 1316 0 stevel return (dt_set_errno(dtp, EDT_BADTRUNC)); 1317 0 stevel 1318 0 stevel /* LINTED - alignment */ 1319 0 stevel trunc.dttd_id = *((dtrace_aggvarid_t *)addr); 1320 0 stevel rec++; 1321 0 stevel 1322 0 stevel if (rec->dtrd_action != DTRACEACT_LIBACT) 1323 0 stevel return (dt_set_errno(dtp, EDT_BADTRUNC)); 1324 0 stevel 1325 0 stevel if (rec->dtrd_arg != DT_ACT_TRUNC) 1326 0 stevel return (dt_set_errno(dtp, EDT_BADTRUNC)); 1327 0 stevel 1328 0 stevel addr = base + rec->dtrd_offset; 1329 0 stevel 1330 0 stevel switch (rec->dtrd_size) { 1331 0 stevel case sizeof (uint64_t): 1332 0 stevel /* LINTED - alignment */ 1333 0 stevel remaining = *((int64_t *)addr); 1334 0 stevel break; 1335 0 stevel case sizeof (uint32_t): 1336 0 stevel /* LINTED - alignment */ 1337 0 stevel remaining = *((int32_t *)addr); 1338 0 stevel break; 1339 0 stevel case sizeof (uint16_t): 1340 0 stevel /* LINTED - alignment */ 1341 0 stevel remaining = *((int16_t *)addr); 1342 0 stevel break; 1343 0 stevel case sizeof (uint8_t): 1344 0 stevel remaining = *((int8_t *)addr); 1345 0 stevel break; 1346 0 stevel default: 1347 0 stevel return (dt_set_errno(dtp, EDT_BADNORMAL)); 1348 0 stevel } 1349 0 stevel 1350 0 stevel if (remaining < 0) { 1351 0 stevel func = dtrace_aggregate_walk_valsorted; 1352 0 stevel remaining = -remaining; 1353 0 stevel } else { 1354 0 stevel func = dtrace_aggregate_walk_valrevsorted; 1355 0 stevel } 1356 0 stevel 1357 0 stevel assert(remaining >= 0); 1358 0 stevel trunc.dttd_remaining = remaining; 1359 0 stevel 1360 0 stevel (void) func(dtp, dt_trunc_agg, &trunc); 1361 0 stevel 1362 0 stevel return (0); 1363 0 stevel } 1364 0 stevel 1365 1017 bmc static int 1366 1017 bmc dt_print_datum(dtrace_hdl_t *dtp, FILE *fp, dtrace_recdesc_t *rec, 1367 1017 bmc caddr_t addr, size_t size, uint64_t normal) 1368 1017 bmc { 1369 1017 bmc int err; 1370 1017 bmc dtrace_actkind_t act = rec->dtrd_action; 1371 1017 bmc 1372 1017 bmc switch (act) { 1373 1017 bmc case DTRACEACT_STACK: 1374 1017 bmc return (dt_print_stack(dtp, fp, NULL, addr, 1375 1017 bmc rec->dtrd_arg, rec->dtrd_size / rec->dtrd_arg)); 1376 1017 bmc 1377 1017 bmc case DTRACEACT_USTACK: 1378 1017 bmc case DTRACEACT_JSTACK: 1379 1017 bmc return (dt_print_ustack(dtp, fp, NULL, addr, rec->dtrd_arg)); 1380 1017 bmc 1381 1017 bmc case DTRACEACT_USYM: 1382 1017 bmc case DTRACEACT_UADDR: 1383 1017 bmc return (dt_print_usym(dtp, fp, addr, act)); 1384 1017 bmc 1385 1017 bmc case DTRACEACT_UMOD: 1386 1017 bmc return (dt_print_umod(dtp, fp, NULL, addr)); 1387 1017 bmc 1388 1017 bmc case DTRACEACT_SYM: 1389 1017 bmc return (dt_print_sym(dtp, fp, NULL, addr)); 1390 1017 bmc 1391 1017 bmc case DTRACEACT_MOD: 1392 1017 bmc return (dt_print_mod(dtp, fp, NULL, addr)); 1393 1017 bmc 1394 1017 bmc case DTRACEAGG_QUANTIZE: 1395 1017 bmc return (dt_print_quantize(dtp, fp, addr, size, normal)); 1396 1017 bmc 1397 1017 bmc case DTRACEAGG_LQUANTIZE: 1398 1017 bmc return (dt_print_lquantize(dtp, fp, addr, size, normal)); 1399 1017 bmc 1400 1017 bmc case DTRACEAGG_AVG: 1401 1017 bmc return (dt_print_average(dtp, fp, addr, size, normal)); 1402 5984 jhaslam 1403 5984 jhaslam case DTRACEAGG_STDDEV: 1404 5984 jhaslam return (dt_print_stddev(dtp, fp, addr, size, normal)); 1405 1017 bmc 1406 1017 bmc default: 1407 1017 bmc break; 1408 1017 bmc } 1409 1017 bmc 1410 1017 bmc switch (size) { 1411 1017 bmc case sizeof (uint64_t): 1412 1017 bmc err = dt_printf(dtp, fp, " %16lld", 1413 1017 bmc /* LINTED - alignment */ 1414 1017 bmc (long long)*((uint64_t *)addr) / normal); 1415 1017 bmc break; 1416 1017 bmc case sizeof (uint32_t): 1417 1017 bmc /* LINTED - alignment */ 1418 1017 bmc err = dt_printf(dtp, fp, " %8d", *((uint32_t *)addr) / 1419 1017 bmc (uint32_t)normal); 1420 1017 bmc break; 1421 1017 bmc case sizeof (uint16_t): 1422 1017 bmc /* LINTED - alignment */ 1423 1017 bmc err = dt_printf(dtp, fp, " %5d", *((uint16_t *)addr) / 1424 1017 bmc (uint32_t)normal); 1425 1017 bmc break; 1426 1017 bmc case sizeof (uint8_t): 1427 1017 bmc err = dt_printf(dtp, fp, " %3d", *((uint8_t *)addr) / 1428 1017 bmc (uint32_t)normal); 1429 1017 bmc break; 1430 1017 bmc default: 1431 1017 bmc err = dt_print_bytes(dtp, fp, addr, size, 50, 0); 1432 1017 bmc break; 1433 1017 bmc } 1434 1017 bmc 1435 1017 bmc return (err); 1436 1017 bmc } 1437 1017 bmc 1438 1017 bmc int 1439 1017 bmc dt_print_aggs(const dtrace_aggdata_t **aggsdata, int naggvars, void *arg) 1440 1017 bmc { 1441 1017 bmc int i, aggact = 0; 1442 1017 bmc dt_print_aggdata_t *pd = arg; 1443 1017 bmc const dtrace_aggdata_t *aggdata = aggsdata[0]; 1444 1017 bmc dtrace_aggdesc_t *agg = aggdata->dtada_desc; 1445 1017 bmc FILE *fp = pd->dtpa_fp; 1446 1017 bmc dtrace_hdl_t *dtp = pd->dtpa_dtp; 1447 1017 bmc dtrace_recdesc_t *rec; 1448 1017 bmc dtrace_actkind_t act; 1449 1017 bmc caddr_t addr; 1450 1017 bmc size_t size; 1451 1017 bmc 1452 1017 bmc /* 1453 1017 bmc * Iterate over each record description in the key, printing the traced 1454 1017 bmc * data, skipping the first datum (the tuple member created by the 1455 1017 bmc * compiler). 1456 1017 bmc */ 1457 1017 bmc for (i = 1; i < agg->dtagd_nrecs; i++) { 1458 1017 bmc rec = &agg->dtagd_rec[i]; 1459 1017 bmc act = rec->dtrd_action; 1460 1017 bmc addr = aggdata->dtada_data + rec->dtrd_offset; 1461 1017 bmc size = rec->dtrd_size; 1462 1017 bmc 1463 1017 bmc if (DTRACEACT_ISAGG(act)) { 1464 1017 bmc aggact = i; 1465 1017 bmc break; 1466 1017 bmc } 1467 1017 bmc 1468 1017 bmc if (dt_print_datum(dtp, fp, rec, addr, size, 1) < 0) 1469 1017 bmc return (-1); 1470 1017 bmc 1471 1017 bmc if (dt_buffered_flush(dtp, NULL, rec, aggdata, 1472 1017 bmc DTRACE_BUFDATA_AGGKEY) < 0) 1473 1017 bmc return (-1); 1474 1017 bmc } 1475 1017 bmc 1476 1017 bmc assert(aggact != 0); 1477 1017 bmc 1478 1017 bmc for (i = (naggvars == 1 ? 0 : 1); i < naggvars; i++) { 1479 1017 bmc uint64_t normal; 1480 1017 bmc 1481 1017 bmc aggdata = aggsdata[i]; 1482 1017 bmc agg = aggdata->dtada_desc; 1483 1017 bmc rec = &agg->dtagd_rec[aggact]; 1484 1017 bmc act = rec->dtrd_action; 1485 1017 bmc addr = aggdata->dtada_data + rec->dtrd_offset; 1486 1017 bmc size = rec->dtrd_size; 1487 1017 bmc 1488 1017 bmc assert(DTRACEACT_ISAGG(act)); 1489 1017 bmc normal = aggdata->dtada_normal; 1490 1017 bmc 1491 1017 bmc if (dt_print_datum(dtp, fp, rec, addr, size, normal) < 0) 1492 1017 bmc return (-1); 1493 1017 bmc 1494 1017 bmc if (dt_buffered_flush(dtp, NULL, rec, aggdata, 1495 1017 bmc DTRACE_BUFDATA_AGGVAL) < 0) 1496 1017 bmc return (-1); 1497 1017 bmc 1498 1017 bmc if (!pd->dtpa_allunprint) 1499 1017 bmc agg->dtagd_flags |= DTRACE_AGD_PRINTED; 1500 1017 bmc } 1501 1017 bmc 1502 1017 bmc if (dt_printf(dtp, fp, "\n") < 0) 1503 1017 bmc return (-1); 1504 1017 bmc 1505 1017 bmc if (dt_buffered_flush(dtp, NULL, NULL, aggdata, 1506 1017 bmc DTRACE_BUFDATA_AGGFORMAT | DTRACE_BUFDATA_AGGLAST) < 0) 1507 1017 bmc return (-1); 1508 1017 bmc 1509 1017 bmc return (0); 1510 1017 bmc } 1511 1017 bmc 1512 0 stevel int 1513 457 bmc dt_print_agg(const dtrace_aggdata_t *aggdata, void *arg) 1514 0 stevel { 1515 0 stevel dt_print_aggdata_t *pd = arg; 1516 0 stevel dtrace_aggdesc_t *agg = aggdata->dtada_desc; 1517 0 stevel dtrace_aggvarid_t aggvarid = pd->dtpa_id; 1518 0 stevel 1519 0 stevel if (pd->dtpa_allunprint) { 1520 0 stevel if (agg->dtagd_flags & DTRACE_AGD_PRINTED) 1521 0 stevel return (0); 1522 0 stevel } else { 1523 0 stevel /* 1524 0 stevel * If we're not printing all unprinted aggregations, then the 1525 0 stevel * aggregation variable ID denotes a specific aggregation 1526 0 stevel * variable that we should print -- skip any other aggregations 1527 0 stevel * that we encounter. 1528 0 stevel */ 1529 0 stevel if (agg->dtagd_nrecs == 0) 1530 0 stevel return (0); 1531 0 stevel 1532 1017 bmc if (aggvarid != agg->dtagd_varid) 1533 0 stevel return (0); 1534 0 stevel } 1535 0 stevel 1536 1017 bmc return (dt_print_aggs(&aggdata, 1, arg)); 1537 457 bmc } 1538 457 bmc 1539 457 bmc int 1540 457 bmc dt_setopt(dtrace_hdl_t *dtp, const dtrace_probedata_t *data, 1541 457 bmc const char *option, const char *value) 1542 457 bmc { 1543 457 bmc int len, rval; 1544 457 bmc char *msg; 1545 457 bmc const char *errstr; 1546 457 bmc dtrace_setoptdata_t optdata; 1547 457 bmc 1548 457 bmc bzero(&optdata, sizeof (optdata)); 1549 457 bmc (void) dtrace_getopt(dtp, option, &optdata.dtsda_oldval); 1550 457 bmc 1551 457 bmc if (dtrace_setopt(dtp, option, value) == 0) { 1552 457 bmc (void) dtrace_getopt(dtp, option, &optdata.dtsda_newval); 1553 457 bmc optdata.dtsda_probe = data; 1554 457 bmc optdata.dtsda_option = option; 1555 457 bmc optdata.dtsda_handle = dtp; 1556 457 bmc 1557 457 bmc if ((rval = dt_handle_setopt(dtp, &optdata)) != 0) 1558 457 bmc return (rval); 1559 457 bmc 1560 457 bmc return (0); 1561 457 bmc } 1562 457 bmc 1563 457 bmc errstr = dtrace_errmsg(dtp, dtrace_errno(dtp)); 1564 457 bmc len = strlen(option) + strlen(value) + strlen(errstr) + 80; 1565 457 bmc msg = alloca(len); 1566 457 bmc 1567 457 bmc (void) snprintf(msg, len, "couldn't set option \"%s\" to \"%s\": %s\n", 1568 457 bmc option, value, errstr); 1569 457 bmc 1570 457 bmc if ((rval = dt_handle_liberr(dtp, data, msg)) == 0) 1571 457 bmc return (0); 1572 457 bmc 1573 457 bmc return (rval); 1574 0 stevel } 1575 0 stevel 1576 0 stevel static int 1577 0 stevel dt_consume_cpu(dtrace_hdl_t *dtp, FILE *fp, int cpu, dtrace_bufdesc_t *buf, 1578 0 stevel dtrace_consume_probe_f *efunc, dtrace_consume_rec_f *rfunc, void *arg) 1579 0 stevel { 1580 0 stevel dtrace_epid_t id; 1581 0 stevel size_t offs, start = buf->dtbd_oldest, end = buf->dtbd_size; 1582 0 stevel int flow = (dtp->dt_options[DTRACEOPT_FLOWINDENT] != DTRACEOPT_UNSET); 1583 0 stevel int quiet = (dtp->dt_options[DTRACEOPT_QUIET] != DTRACEOPT_UNSET); 1584 0 stevel int rval, i, n; 1585 0 stevel dtrace_epid_t last = DTRACE_EPIDNONE; 1586 0 stevel dtrace_probedata_t data; 1587 0 stevel uint64_t drops; 1588 0 stevel caddr_t addr; 1589 0 stevel 1590 0 stevel bzero(&data, sizeof (data)); 1591 0 stevel data.dtpda_handle = dtp; 1592 0 stevel data.dtpda_cpu = cpu; 1593 0 stevel 1594 0 stevel again: 1595 0 stevel for (offs = start; offs < end; ) { 1596 0 stevel dtrace_eprobedesc_t *epd; 1597 0 stevel 1598 0 stevel /* 1599 0 stevel * We're guaranteed to have an ID. 1600 0 stevel */ 1601 0 stevel id = *(uint32_t *)((uintptr_t)buf->dtbd_data + offs); 1602 0 stevel 1603 0 stevel if (id == DTRACE_EPIDNONE) { 1604 0 stevel /* 1605 0 stevel * This is filler to assure proper alignment of the 1606 0 stevel * next record; we simply ignore it. 1607 0 stevel */ 1608 0 stevel offs += sizeof (id); 1609 0 stevel continue; 1610 0 stevel } 1611 0 stevel 1612 0 stevel if ((rval = dt_epid_lookup(dtp, id, &data.dtpda_edesc, 1613 0 stevel &data.dtpda_pdesc)) != 0) 1614 0 stevel return (rval); 1615 0 stevel 1616 0 stevel epd = data.dtpda_edesc; 1617 0 stevel data.dtpda_data = buf->dtbd_data + offs; 1618 0 stevel 1619 0 stevel if (data.dtpda_edesc->dtepd_uarg != DT_ECB_DEFAULT) { 1620 0 stevel rval = dt_handle(dtp, &data); 1621 0 stevel 1622 0 stevel if (rval == DTRACE_CONSUME_NEXT) 1623 0 stevel goto nextepid; 1624 0 stevel 1625 0 stevel if (rval == DTRACE_CONSUME_ERROR) 1626 0 stevel return (-1); 1627 0 stevel } 1628 0 stevel 1629 0 stevel if (flow) 1630 0 stevel (void) dt_flowindent(dtp, &data, last, buf, offs); 1631 0 stevel 1632 0 stevel rval = (*efunc)(&data, arg); 1633 0 stevel 1634 0 stevel if (flow) { 1635 0 stevel if (data.dtpda_flow == DTRACEFLOW_ENTRY) 1636 0 stevel data.dtpda_indent += 2; 1637 0 stevel } 1638 0 stevel 1639 0 stevel if (rval == DTRACE_CONSUME_NEXT) 1640 0 stevel goto nextepid; 1641 0 stevel 1642 0 stevel if (rval == DTRACE_CONSUME_ABORT) 1643 0 stevel return (dt_set_errno(dtp, EDT_DIRABORT)); 1644 0 stevel 1645 0 stevel if (rval != DTRACE_CONSUME_THIS) 1646 0 stevel return (dt_set_errno(dtp, EDT_BADRVAL)); 1647 0 stevel 1648 0 stevel for (i = 0; i < epd->dtepd_nrecs; i++) { 1649 0 stevel dtrace_recdesc_t *rec = &epd->dtepd_rec[i]; 1650 0 stevel dtrace_actkind_t act = rec->dtrd_action; 1651 0 stevel 1652 0 stevel data.dtpda_data = buf->dtbd_data + offs + 1653 0 stevel rec->dtrd_offset; 1654 0 stevel addr = data.dtpda_data; 1655 0 stevel 1656 0 stevel if (act == DTRACEACT_LIBACT) { 1657 457 bmc uint64_t arg = rec->dtrd_arg; 1658 457 bmc dtrace_aggvarid_t id; 1659 0 stevel 1660 457 bmc switch (arg) { 1661 457 bmc case DT_ACT_CLEAR: 1662 0 stevel /* LINTED - alignment */ 1663 0 stevel id = *((dtrace_aggvarid_t *)addr); 1664 0 stevel (void) dtrace_aggregate_walk(dtp, 1665 0 stevel dt_clear_agg, &id); 1666 0 stevel continue; 1667 0 stevel 1668 457 bmc case DT_ACT_DENORMALIZE: 1669 0 stevel /* LINTED - alignment */ 1670 0 stevel id = *((dtrace_aggvarid_t *)addr); 1671 0 stevel (void) dtrace_aggregate_walk(dtp, 1672 0 stevel dt_denormalize_agg, &id); 1673 0 stevel continue; 1674 0 stevel 1675 457 bmc case DT_ACT_FTRUNCATE: 1676 457 bmc if (fp == NULL) 1677 457 bmc continue; 1678 457 bmc 1679 457 bmc (void) fflush(fp); 1680 457 bmc (void) ftruncate(fileno(fp), 0); 1681 457 bmc (void) fseeko(fp, 0, SEEK_SET); 1682 457 bmc continue; 1683 457 bmc 1684 457 bmc case DT_ACT_NORMALIZE: 1685 0 stevel if (i == epd->dtepd_nrecs - 1) 1686 0 stevel return (dt_set_errno(dtp, 1687 0 stevel EDT_BADNORMAL)); 1688 0 stevel 1689 0 stevel if (dt_normalize(dtp, 1690 0 stevel buf->dtbd_data + offs, rec) != 0) 1691 0 stevel return (-1); 1692 0 stevel 1693 0 stevel i++; 1694 0 stevel continue; 1695 457 bmc 1696 457 bmc case DT_ACT_SETOPT: { 1697 457 bmc uint64_t *opts = dtp->dt_options; 1698 457 bmc dtrace_recdesc_t *valrec; 1699 457 bmc uint32_t valsize; 1700 457 bmc caddr_t val; 1701 457 bmc int rv; 1702 457 bmc 1703 457 bmc if (i == epd->dtepd_nrecs - 1) { 1704 457 bmc return (dt_set_errno(dtp, 1705 457 bmc EDT_BADSETOPT)); 1706 457 bmc } 1707 457 bmc 1708 457 bmc valrec = &epd->dtepd_rec[++i]; 1709 457 bmc valsize = valrec->dtrd_size; 1710 457 bmc 1711 457 bmc if (valrec->dtrd_action != act || 1712 457 bmc valrec->dtrd_arg != arg) { 1713 457 bmc return (dt_set_errno(dtp, 1714 457 bmc EDT_BADSETOPT)); 1715 457 bmc } 1716 457 bmc 1717 457 bmc if (valsize > sizeof (uint64_t)) { 1718 457 bmc val = buf->dtbd_data + offs + 1719 457 bmc valrec->dtrd_offset; 1720 457 bmc } else { 1721 457 bmc val = "1"; 1722 457 bmc } 1723 457 bmc 1724 457 bmc rv = dt_setopt(dtp, &data, addr, val); 1725 457 bmc 1726 457 bmc if (rv != 0) 1727 457 bmc return (-1); 1728 457 bmc 1729 457 bmc flow = (opts[DTRACEOPT_FLOWINDENT] != 1730 457 bmc DTRACEOPT_UNSET); 1731 457 bmc quiet = (opts[DTRACEOPT_QUIET] != 1732 457 bmc DTRACEOPT_UNSET); 1733 457 bmc 1734 457 bmc continue; 1735 0 stevel } 1736 0 stevel 1737 457 bmc case DT_ACT_TRUNC: 1738 0 stevel if (i == epd->dtepd_nrecs - 1) 1739 0 stevel return (dt_set_errno(dtp, 1740 0 stevel EDT_BADTRUNC)); 1741 0 stevel 1742 0 stevel if (dt_trunc(dtp, 1743 0 stevel buf->dtbd_data + offs, rec) != 0) 1744 0 stevel return (-1); 1745 0 stevel 1746 0 stevel i++; 1747 0 stevel continue; 1748 0 stevel 1749 457 bmc default: 1750 0 stevel continue; 1751 0 stevel } 1752 0 stevel } 1753 0 stevel 1754 0 stevel rval = (*rfunc)(&data, rec, arg); 1755 0 stevel 1756 0 stevel if (rval == DTRACE_CONSUME_NEXT) 1757 0 stevel continue; 1758 0 stevel 1759 0 stevel if (rval == DTRACE_CONSUME_ABORT) 1760 0 stevel return (dt_set_errno(dtp, EDT_DIRABORT)); 1761 0 stevel 1762 0 stevel if (rval != DTRACE_CONSUME_THIS) 1763 0 stevel return (dt_set_errno(dtp, EDT_BADRVAL)); 1764 0 stevel 1765 0 stevel if (act == DTRACEACT_STACK) { 1766 457 bmc int depth = rec->dtrd_arg; 1767 457 bmc 1768 457 bmc if (dt_print_stack(dtp, fp, NULL, addr, depth, 1769 457 bmc rec->dtrd_size / depth) < 0) 1770 0 stevel return (-1); 1771 0 stevel goto nextrec; 1772 0 stevel } 1773 0 stevel 1774 0 stevel if (act == DTRACEACT_USTACK || 1775 0 stevel act == DTRACEACT_JSTACK) { 1776 0 stevel if (dt_print_ustack(dtp, fp, NULL, 1777 0 stevel addr, rec->dtrd_arg) < 0) 1778 457 bmc return (-1); 1779 457 bmc goto nextrec; 1780 457 bmc } 1781 457 bmc 1782 457 bmc if (act == DTRACEACT_SYM) { 1783 457 bmc if (dt_print_sym(dtp, fp, NULL, addr) < 0) 1784 457 bmc return (-1); 1785 457 bmc goto nextrec; 1786 457 bmc } 1787 457 bmc 1788 457 bmc if (act == DTRACEACT_MOD) { 1789 457 bmc if (dt_print_mod(dtp, fp, NULL, addr) < 0) 1790 457 bmc return (-1); 1791 457 bmc goto nextrec; 1792 457 bmc } 1793 457 bmc 1794 457 bmc if (act == DTRACEACT_USYM || act == DTRACEACT_UADDR) { 1795 457 bmc if (dt_print_usym(dtp, fp, addr, act) < 0) 1796 457 bmc return (-1); 1797 457 bmc goto nextrec; 1798 457 bmc } 1799 457 bmc 1800 457 bmc if (act == DTRACEACT_UMOD) { 1801 457 bmc if (dt_print_umod(dtp, fp, NULL, addr) < 0) 1802 0 stevel return (-1); 1803 0 stevel goto nextrec; 1804 0 stevel } 1805 0 stevel 1806 0 stevel if (DTRACEACT_ISPRINTFLIKE(act)) { 1807 0 stevel void *fmtdata; 1808 0 stevel int (*func)(dtrace_hdl_t *, FILE *, void *, 1809 0 stevel const dtrace_probedata_t *, 1810 0 stevel const dtrace_recdesc_t *, uint_t, 1811 0 stevel const void *buf, size_t); 1812 0 stevel 1813 0 stevel if ((fmtdata = dt_format_lookup(dtp, 1814 0 stevel rec->dtrd_format)) == NULL) 1815 0 stevel goto nofmt; 1816 0 stevel 1817 0 stevel switch (act) { 1818 0 stevel case DTRACEACT_PRINTF: 1819 0 stevel func = dtrace_fprintf; 1820 0 stevel break; 1821 0 stevel case DTRACEACT_PRINTA: 1822 0 stevel func = dtrace_fprinta; 1823 0 stevel break; 1824 0 stevel case DTRACEACT_SYSTEM: 1825 0 stevel func = dtrace_system; 1826 0 stevel break; 1827 0 stevel case DTRACEACT_FREOPEN: 1828 0 stevel func = dtrace_freopen; 1829 0 stevel break; 1830 0 stevel } 1831 0 stevel 1832 0 stevel n = (*func)(dtp, fp, fmtdata, &data, 1833 0 stevel rec, epd->dtepd_nrecs - i, 1834 0 stevel (uchar_t *)buf->dtbd_data + offs, 1835 0 stevel buf->dtbd_size - offs); 1836 0 stevel 1837 0 stevel if (n < 0) 1838 0 stevel return (-1); /* errno is set for us */ 1839 0 stevel 1840 0 stevel if (n > 0) 1841 0 stevel i += n - 1; 1842 0 stevel goto nextrec; 1843 0 stevel } 1844 0 stevel 1845 0 stevel nofmt: 1846 0 stevel if (act == DTRACEACT_PRINTA) { 1847 0 stevel dt_print_aggdata_t pd; 1848 1017 bmc dtrace_aggvarid_t *aggvars; 1849 1017 bmc int j, naggvars = 0; 1850 1017 bmc size_t size = ((epd->dtepd_nrecs - i) * 1851 1017 bmc sizeof (dtrace_aggvarid_t)); 1852 0 stevel 1853 1017 bmc if ((aggvars = dt_alloc(dtp, size)) == NULL) 1854 1017 bmc return (-1); 1855 1017 bmc 1856 1017 bmc /* 1857 1017 bmc * This might be a printa() with multiple 1858 1017 bmc * aggregation variables. We need to scan 1859 1017 bmc * forward through the records until we find 1860 1017 bmc * a record from a different statement. 1861 1017 bmc */ 1862 1017 bmc for (j = i; j < epd->dtepd_nrecs; j++) { 1863 1017 bmc dtrace_recdesc_t *nrec; 1864 1017 bmc caddr_t naddr; 1865 1017 bmc 1866 1017 bmc nrec = &epd->dtepd_rec[j]; 1867 1017 bmc 1868 1017 bmc if (nrec->dtrd_uarg != rec->dtrd_uarg) 1869 1017 bmc break; 1870 1017 bmc 1871 1017 bmc if (nrec->dtrd_action != act) { 1872 1017 bmc return (dt_set_errno(dtp, 1873 1017 bmc EDT_BADAGG)); 1874 1017 bmc } 1875 1017 bmc 1876 1017 bmc naddr = buf->dtbd_data + offs + 1877 1017 bmc nrec->dtrd_offset; 1878 1017 bmc 1879 1017 bmc aggvars[naggvars++] = 1880 1017 bmc /* LINTED - alignment */ 1881 1017 bmc *((dtrace_aggvarid_t *)naddr); 1882 1017 bmc } 1883 1017 bmc 1884 1017 bmc i = j - 1; 1885 0 stevel bzero(&pd, sizeof (pd)); 1886 0 stevel pd.dtpa_dtp = dtp; 1887 0 stevel pd.dtpa_fp = fp; 1888 1017 bmc 1889 1017 bmc assert(naggvars >= 1); 1890 1017 bmc 1891 1017 bmc if (naggvars == 1) { 1892 1017 bmc pd.dtpa_id = aggvars[0]; 1893 1017 bmc dt_free(dtp, aggvars); 1894 1017 bmc 1895 1017 bmc if (dt_printf(dtp, fp, "\n") < 0 || 1896 1017 bmc dtrace_aggregate_walk_sorted(dtp, 1897 1017 bmc dt_print_agg, &pd) < 0) 1898 1017 bmc return (-1); 1899 1017 bmc goto nextrec; 1900 1017 bmc } 1901 0 stevel 1902 0 stevel if (dt_printf(dtp, fp, "\n") < 0 || 1903 1017 bmc dtrace_aggregate_walk_joined(dtp, aggvars, 1904 1017 bmc naggvars, dt_print_aggs, &pd) < 0) { 1905 1017 bmc dt_free(dtp, aggvars); 1906 0 stevel return (-1); 1907 1017 bmc } 1908 0 stevel 1909 1017 bmc dt_free(dtp, aggvars); 1910 0 stevel goto nextrec; 1911 0 stevel } 1912 0 stevel 1913 0 stevel switch (rec->dtrd_size) { 1914 0 stevel case sizeof (uint64_t): 1915 0 stevel n = dt_printf(dtp, fp, 1916 0 stevel quiet ? "%lld" : " %16lld", 1917 0 stevel /* LINTED - alignment */ 1918 0 stevel *((unsigned long long *)addr)); 1919 0 stevel break; 1920 0 stevel case sizeof (uint32_t): 1921 0 stevel n = dt_printf(dtp, fp, quiet ? "%d" : " %8d", 1922 0 stevel /* LINTED - alignment */ 1923 0 stevel *((uint32_t *)addr)); 1924 0 stevel break; 1925 0 stevel case sizeof (uint16_t): 1926 0 stevel n = dt_printf(dtp, fp, quiet ? "%d" : " %5d", 1927 0 stevel /* LINTED - alignment */ 1928 0 stevel *((uint16_t *)addr)); 1929 0 stevel break; 1930 0 stevel case sizeof (uint8_t): 1931 0 stevel n = dt_printf(dtp, fp, quiet ? "%d" : " %3d", 1932 0 stevel *((uint8_t *)addr)); 1933 0 stevel break; 1934 0 stevel default: 1935 0 stevel n = dt_print_bytes(dtp, fp, addr, 1936 0 stevel rec->dtrd_size, 33, quiet); 1937 0 stevel break; 1938 0 stevel } 1939 0 stevel 1940 0 stevel if (n < 0) 1941 0 stevel return (-1); /* errno is set for us */ 1942 0 stevel 1943 0 stevel nextrec: 1944 1017 bmc if (dt_buffered_flush(dtp, &data, rec, NULL, 0) < 0) 1945 0 stevel return (-1); /* errno is set for us */ 1946 0 stevel } 1947 0 stevel 1948 0 stevel /* 1949 0 stevel * Call the record callback with a NULL record to indicate 1950 0 stevel * that we're done processing this EPID. 1951 0 stevel */ 1952 0 stevel rval = (*rfunc)(&data, NULL, arg); 1953 0 stevel nextepid: 1954 0 stevel offs += epd->dtepd_size; 1955 0 stevel last = id; 1956 0 stevel } 1957 0 stevel 1958 0 stevel if (buf->dtbd_oldest != 0 && start == buf->dtbd_oldest) { 1959 0 stevel end = buf->dtbd_oldest; 1960 0 stevel start = 0; 1961 0 stevel goto again; 1962 0 stevel } 1963 0 stevel 1964 0 stevel if ((drops = buf->dtbd_drops) == 0) 1965 0 stevel return (0); 1966 0 stevel 1967 0 stevel /* 1968 0 stevel * Explicitly zero the drops to prevent us from processing them again. 1969 0 stevel */ 1970 0 stevel buf->dtbd_drops = 0; 1971 0 stevel 1972 0 stevel return (dt_handle_cpudrop(dtp, cpu, DTRACEDROP_PRINCIPAL, drops)); 1973 0 stevel } 1974 0 stevel 1975 0 stevel typedef struct dt_begin { 1976 0 stevel dtrace_consume_probe_f *dtbgn_probefunc; 1977 0 stevel dtrace_consume_rec_f *dtbgn_recfunc; 1978 0 stevel void *dtbgn_arg; 1979 0 stevel dtrace_handle_err_f *dtbgn_errhdlr; 1980 0 stevel void *dtbgn_errarg; 1981 0 stevel int dtbgn_beginonly; 1982 0 stevel } dt_begin_t; 1983 0 stevel 1984 0 stevel static int 1985 0 stevel dt_consume_begin_probe(const dtrace_probedata_t *data, void *arg) 1986 0 stevel { 1987 0 stevel dt_begin_t *begin = (dt_begin_t *)arg; 1988 0 stevel dtrace_probedesc_t *pd = data->dtpda_pdesc; 1989 0 stevel 1990 0 stevel int r1 = (strcmp(pd->dtpd_provider, "dtrace") == 0); 1991 0 stevel int r2 = (strcmp(pd->dtpd_name, "BEGIN") == 0); 1992 0 stevel 1993 0 stevel if (begin->dtbgn_beginonly) { 1994 0 stevel if (!(r1 && r2)) 1995 0 stevel return (DTRACE_CONSUME_NEXT); 1996 0 stevel } else { 1997 0 stevel if (r1 && r2) 1998 0 stevel return (DTRACE_CONSUME_NEXT); 1999 0 stevel } 2000 0 stevel 2001 0 stevel /* 2002 0 stevel * We have a record that we're interested in. Now call the underlying 2003 0 stevel * probe function... 2004 0 stevel */ 2005 0 stevel return (begin->dtbgn_probefunc(data, begin->dtbgn_arg)); 2006 0 stevel } 2007 0 stevel 2008 0 stevel static int 2009 0 stevel dt_consume_begin_record(const dtrace_probedata_t *data, 2010 0 stevel const dtrace_recdesc_t *rec, void *arg) 2011 0 stevel { 2012 0 stevel dt_begin_t *begin = (dt_begin_t *)arg; 2013 0 stevel 2014 0 stevel return (begin->dtbgn_recfunc(data, rec, begin->dtbgn_arg)); 2015 0 stevel } 2016 0 stevel 2017 0 stevel static int 2018 457 bmc dt_consume_begin_error(const dtrace_errdata_t *data, void *arg) 2019 0 stevel { 2020 0 stevel dt_begin_t *begin = (dt_begin_t *)arg; 2021 0 stevel dtrace_probedesc_t *pd = data->dteda_pdesc; 2022 0 stevel 2023 0 stevel int r1 = (strcmp(pd->dtpd_provider, "dtrace") == 0); 2024 0 stevel int r2 = (strcmp(pd->dtpd_name, "BEGIN") == 0); 2025 0 stevel 2026 0 stevel if (begin->dtbgn_beginonly) { 2027 0 stevel if (!(r1 && r2)) 2028 0 stevel return (DTRACE_HANDLE_OK); 2029 0 stevel } else { 2030 0 stevel if (r1 && r2) 2031 0 stevel return (DTRACE_HANDLE_OK); 2032 0 stevel } 2033 0 stevel 2034 0 stevel return (begin->dtbgn_errhdlr(data, begin->dtbgn_errarg)); 2035 0 stevel } 2036 0 stevel 2037 0 stevel static int 2038 0 stevel dt_consume_begin(dtrace_hdl_t *dtp, FILE *fp, dtrace_bufdesc_t *buf, 2039 0 stevel dtrace_consume_probe_f *pf, dtrace_consume_rec_f *rf, void *arg) 2040 0 stevel { 2041 0 stevel /* 2042 0 stevel * There's this idea that the BEGIN probe should be processed before 2043 0 stevel * everything else, and that the END probe should be processed after 2044 0 stevel * anything else. In the common case, this is pretty easy to deal 2045 0 stevel * with. However, a situation may arise where the BEGIN enabling and 2046 0 stevel * END enabling are on the same CPU, and some enabling in the middle 2047 0 stevel * occurred on a different CPU. To deal with this (blech!) we need to 2048 0 stevel * consume the BEGIN buffer up until the end of the BEGIN probe, and 2049 0 stevel * then set it aside. We will then process every other CPU, and then 2050 0 stevel * we'll return to the BEGIN CPU and process the rest of the data 2051 0 stevel * (which will inevitably include the END probe, if any). Making this 2052 0 stevel * even more complicated (!) is the library's ERROR enabling. Because 2053 0 stevel * this enabling is processed before we even get into the consume call 2054 0 stevel * back, any ERROR firing would result in the library's ERROR enabling 2055 0 stevel * being processed twice -- once in our first pass (for BEGIN probes), 2056 0 stevel * and again in our second pass (for everything but BEGIN probes). To 2057 0 stevel * deal with this, we interpose on the ERROR handler to assure that we 2058 0 stevel * only process ERROR enablings induced by BEGIN enablings in the 2059 0 stevel * first pass, and that we only process ERROR enablings _not_ induced 2060 0 stevel * by BEGIN enablings in the second pass. 2061 0 stevel */ 2062 0 stevel dt_begin_t begin; 2063 0 stevel processorid_t cpu = dtp->dt_beganon; 2064 0 stevel dtrace_bufdesc_t nbuf; 2065 0 stevel int rval, i; 2066 0 stevel static int max_ncpus; 2067 0 stevel dtrace_optval_t size; 2068 0 stevel 2069 0 stevel dtp->dt_beganon = -1; 2070 0 stevel 2071 0 stevel if (dt_ioctl(dtp, DTRACEIOC_BUFSNAP, buf) == -1) { 2072 0 stevel /* 2073 0 stevel * We really don't expect this to fail, but it is at least 2074 0 stevel * technically possible for this to fail with ENOENT. In this 2075 0 stevel * case, we just drive on... 2076 0 stevel */ 2077 0 stevel if (errno == ENOENT) 2078 0 stevel return (0); 2079 0 stevel 2080 0 stevel return (dt_set_errno(dtp, errno)); 2081 0 stevel } 2082 0 stevel 2083 0 stevel if (!dtp->dt_stopped || buf->dtbd_cpu != dtp->dt_endedon) { 2084 0 stevel /* 2085 0 stevel * This is the simple case. We're either not stopped, or if 2086 0 stevel * we are, we actually processed any END probes on another 2087 0 stevel * CPU. We can simply consume this buffer and return. 2088 0 stevel */ 2089 0 stevel return (dt_consume_cpu(dtp, fp, cpu, buf, pf, rf, arg)); 2090 0 stevel } 2091 0 stevel 2092 0 stevel begin.dtbgn_probefunc = pf; 2093 0 stevel begin.dtbgn_recfunc = rf; 2094 0 stevel begin.dtbgn_arg = arg; 2095 0 stevel begin.dtbgn_beginonly = 1; 2096 0 stevel 2097 0 stevel /* 2098 0 stevel * We need to interpose on the ERROR handler to be sure that we 2099 0 stevel * only process ERRORs induced by BEGIN. 2100 0 stevel */ 2101 0 stevel begin.dtbgn_errhdlr = dtp->dt_errhdlr; 2102 0 stevel begin.dtbgn_errarg = dtp->dt_errarg; 2103 0 stevel dtp->dt_errhdlr = dt_consume_begin_error; 2104 0 stevel dtp->dt_errarg = &begin; 2105 0 stevel 2106 0 stevel rval = dt_consume_cpu(dtp, fp, cpu, buf, dt_consume_begin_probe, 2107 0 stevel dt_consume_begin_record, &begin); 2108 0 stevel 2109 0 stevel dtp->dt_errhdlr = begin.dtbgn_errhdlr; 2110 0 stevel dtp->dt_errarg = begin.dtbgn_errarg; 2111 0 stevel 2112 0 stevel if (rval != 0) 2113 0 stevel return (rval); 2114 0 stevel 2115 0 stevel /* 2116 0 stevel * Now allocate a new buffer. We'll use this to deal with every other 2117 0 stevel * CPU. 2118 0 stevel */ 2119 0 stevel bzero(&nbuf, sizeof (dtrace_bufdesc_t)); 2120 0 stevel (void) dtrace_getopt(dtp, "bufsize", &size); 2121 0 stevel if ((nbuf.dtbd_data = malloc(size)) == NULL) 2122 0 stevel return (dt_set_errno(dtp, EDT_NOMEM)); 2123 0 stevel 2124 0 stevel if (max_ncpus == 0) 2125 0 stevel max_ncpus = dt_sysconf(dtp, _SC_CPUID_MAX) + 1; 2126 0 stevel 2127 0 stevel for (i = 0; i < max_ncpus; i++) { 2128 0 stevel nbuf.dtbd_cpu = i; 2129 0 stevel 2130 0 stevel if (i == cpu) 2131 0 stevel continue; 2132 0 stevel 2133 0 stevel if (dt_ioctl(dtp, DTRACEIOC_BUFSNAP, &nbuf) == -1) { 2134 0 stevel /* 2135 0 stevel * If we failed with ENOENT, it may be because the 2136 0 stevel * CPU was unconfigured -- this is okay. Any other 2137 0 stevel * error, however, is unexpected. 2138 0 stevel */ 2139 0 stevel if (errno == ENOENT) 2140 0 stevel continue; 2141 0 stevel 2142 0 stevel free(nbuf.dtbd_data); 2143 0 stevel 2144 0 stevel return (dt_set_errno(dtp, errno)); 2145 0 stevel } 2146 0 stevel 2147 0 stevel if ((rval = dt_consume_cpu(dtp, fp, 2148 0 stevel i, &nbuf, pf, rf, arg)) != 0) { 2149 0 stevel free(nbuf.dtbd_data); 2150 0 stevel return (rval); 2151 0 stevel } 2152 0 stevel } 2153 0 stevel 2154 0 stevel free(nbuf.dtbd_data); 2155 0 stevel 2156 0 stevel /* 2157 0 stevel * Okay -- we're done with the other buffers. Now we want to 2158 0 stevel * reconsume the first buffer -- but this time we're looking for 2159 0 stevel * everything _but_ BEGIN. And of course, in order to only consume 2160 0 stevel * those ERRORs _not_ associated with BEGIN, we need to reinstall our 2161 0 stevel * ERROR interposition function... 2162 0 stevel */ 2163 0 stevel begin.dtbgn_beginonly = 0; 2164 0 stevel 2165 0 stevel assert(begin.dtbgn_errhdlr == dtp->dt_errhdlr); 2166 0 stevel assert(begin.dtbgn_errarg == dtp->dt_errarg); 2167 0 stevel dtp->dt_errhdlr = dt_consume_begin_error; 2168 0 stevel dtp->dt_errarg = &begin; 2169 0 stevel 2170 0 stevel rval = dt_consume_cpu(dtp, fp, cpu, buf, dt_consume_begin_probe, 2171 0 stevel dt_consume_begin_record, &begin); 2172 0 stevel 2173 0 stevel dtp->dt_errhdlr = begin.dtbgn_errhdlr; 2174 0 stevel dtp->dt_errarg = begin.dtbgn_errarg; 2175 0 stevel 2176 0 stevel return (rval); 2177 0 stevel } 2178 0 stevel 2179 0 stevel int 2180 0 stevel dtrace_consume(dtrace_hdl_t *dtp, FILE *fp, 2181 0 stevel dtrace_consume_probe_f *pf, dtrace_consume_rec_f *rf, void *arg) 2182 0 stevel { 2183 0 stevel dtrace_bufdesc_t *buf = &dtp->dt_buf; 2184 0 stevel dtrace_optval_t size; 2185 0 stevel static int max_ncpus; 2186 0 stevel int i, rval; 2187 0 stevel dtrace_optval_t interval = dtp->dt_options[DTRACEOPT_SWITCHRATE]; 2188 0 stevel hrtime_t now = gethrtime(); 2189 0 stevel 2190 0 stevel if (dtp->dt_lastswitch != 0) { 2191 0 stevel if (now - dtp->dt_lastswitch < interval) 2192 0 stevel return (0); 2193 0 stevel 2194 0 stevel dtp->dt_lastswitch += interval; 2195 0 stevel } else { 2196 0 stevel dtp->dt_lastswitch = now; 2197 0 stevel } 2198 0 stevel 2199 0 stevel if (!dtp->dt_active) 2200 0 stevel return (dt_set_errno(dtp, EINVAL)); 2201 0 stevel 2202 0 stevel if (max_ncpus == 0) 2203 0 stevel max_ncpus = dt_sysconf(dtp, _SC_CPUID_MAX) + 1; 2204 0 stevel 2205 0 stevel if (pf == NULL) 2206 0 stevel pf = (dtrace_consume_probe_f *)dt_nullprobe; 2207 0 stevel 2208 0 stevel if (rf == NULL) 2209 0 stevel rf = (dtrace_consume_rec_f *)dt_nullrec; 2210 0 stevel 2211 0 stevel if (buf->dtbd_data == NULL) { 2212 0 stevel (void) dtrace_getopt(dtp, "bufsize", &size); 2213 0 stevel if ((buf->dtbd_data = malloc(size)) == NULL) 2214 0 stevel return (dt_set_errno(dtp, EDT_NOMEM)); 2215 0 stevel 2216 0 stevel buf->dtbd_size = size; 2217 0 stevel } 2218 0 stevel 2219 0 stevel /* 2220 0 stevel * If we have just begun, we want to first process the CPU that 2221 0 stevel * executed the BEGIN probe (if any). 2222 0 stevel */ 2223 0 stevel if (dtp->dt_active && dtp->dt_beganon != -1) { 2224 0 stevel buf->dtbd_cpu = dtp->dt_beganon; 2225 0 stevel if ((rval = dt_consume_begin(dtp, fp, buf, pf, rf, arg)) != 0) 2226 0 stevel return (rval); 2227 0 stevel } 2228 0 stevel 2229 0 stevel for (i = 0; i < max_ncpus; i++) { 2230 0 stevel buf->dtbd_cpu = i; 2231 0 stevel 2232 0 stevel /* 2233 0 stevel * If we have stopped, we want to process the CPU on which the 2234 0 stevel * END probe was processed only _after_ we have processed 2235 0 stevel * everything else. 2236 0 stevel */ 2237 0 stevel if (dtp->dt_stopped && (i == dtp->dt_endedon)) 2238 0 stevel continue; 2239 0 stevel 2240 0 stevel if (dt_ioctl(dtp, DTRACEIOC_BUFSNAP, buf) == -1) { 2241 0 stevel /* 2242 0 stevel * If we failed with ENOENT, it may be because the 2243 0 stevel * CPU was unconfigured -- this is okay. Any other 2244 0 stevel * error, however, is unexpected. 2245 0 stevel */ 2246 0 stevel if (errno == ENOENT) 2247 0 stevel continue; 2248 0 stevel 2249 0 stevel return (dt_set_errno(dtp, errno)); 2250 0 stevel } 2251 0 stevel 2252 0 stevel if ((rval = dt_consume_cpu(dtp, fp, i, buf, pf, rf, arg)) != 0) 2253 0 stevel return (rval); 2254 0 stevel } 2255 0 stevel 2256 0 stevel if (!dtp->dt_stopped) 2257 0 stevel return (0); 2258 0 stevel 2259 0 stevel buf->dtbd_cpu = dtp->dt_endedon; 2260 0 stevel 2261 0 stevel if (dt_ioctl(dtp, DTRACEIOC_BUFSNAP, buf) == -1) { 2262 0 stevel /* 2263 0 stevel * This _really_ shouldn't fail, but it is strictly speaking 2264 0 stevel * possible for this to return ENOENT if the CPU that called 2265 0 stevel * the END enabling somehow managed to become unconfigured. 2266 0 stevel * It's unclear how the user can possibly expect anything 2267 0 stevel * rational to happen in this case -- the state has been thrown 2268 0 stevel * out along with the unconfigured CPU -- so we'll just drive 2269 0 stevel * on... 2270 0 stevel */ 2271 0 stevel if (errno == ENOENT) 2272 0 stevel return (0); 2273 0 stevel 2274 0 stevel return (dt_set_errno(dtp, errno)); 2275 0 stevel } 2276 0 stevel 2277 0 stevel return (dt_consume_cpu(dtp, fp, dtp->dt_endedon, buf, pf, rf, arg)); 2278 0 stevel } 2279
Indexes created Fri Nov 27 18:53:17 UTC 2009
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
Copyright © 1995-2008 Sun Microsystems, Inc.