1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #if defined(sun) 28 #include <sys/sysmacros.h> 29 #endif 30 31 #include <strings.h> 32 #include <unistd.h> 33 #include <stdarg.h> 34 #include <stddef.h> 35 #include <stdlib.h> 36 #include <stdio.h> 37 #include <errno.h> 38 #include <ctype.h> 39 #if defined(sun) 40 #include <alloca.h> 41 #else 42 #include <sys/sysctl.h> 43 #endif 44 #include <assert.h> 45 #include <libgen.h> 46 #include <limits.h> 47 48 #include <dt_impl.h> 49 50 static const struct { 51 size_t dtps_offset; 52 size_t dtps_len; 53 } dtrace_probespecs[] = { 54 { offsetof(dtrace_probedesc_t, dtpd_provider), DTRACE_PROVNAMELEN }, 55 { offsetof(dtrace_probedesc_t, dtpd_mod), DTRACE_MODNAMELEN }, 56 { offsetof(dtrace_probedesc_t, dtpd_func), DTRACE_FUNCNAMELEN }, 57 { offsetof(dtrace_probedesc_t, dtpd_name), DTRACE_NAMELEN } 58 }; 59 60 int 61 dtrace_xstr2desc(dtrace_hdl_t *dtp, dtrace_probespec_t spec, 62 const char *s, int argc, char *const argv[], dtrace_probedesc_t *pdp) 63 { 64 size_t off, len, vlen, wlen; 65 const char *p, *q, *v, *w; 66 67 char buf[32]; /* for id_t as %d (see below) */ 68 69 if (spec < DTRACE_PROBESPEC_NONE || spec > DTRACE_PROBESPEC_NAME) 70 return (dt_set_errno(dtp, EINVAL)); 71 72 bzero(pdp, sizeof (dtrace_probedesc_t)); 73 p = s + strlen(s) - 1; 74 75 do { 76 for (len = 0; p >= s && *p != ':'; len++) 77 p--; /* move backward until we find a delimiter */ 78 79 q = p + 1; 80 vlen = 0; 81 w = NULL; 82 wlen = 0; 83 84 if ((v = strchr(q, '$')) != NULL && v < q + len) { 85 /* 86 * Set vlen to the length of the variable name and then 87 * reset len to the length of the text prior to '$'. If 88 * the name begins with a digit, interpret it using the 89 * the argv[] array. Otherwise we look in dt_macros. 90 * For the moment, all dt_macros variables are of type 91 * id_t (see dtrace_update() for more details on that). 92 */ 93 vlen = (size_t)(q + len - v); 94 len = (size_t)(v - q); 95 96 /* 97 * If the variable string begins with $$, skip past the 98 * leading dollar sign since $ and $$ are equivalent 99 * macro reference operators in a probe description. 100 */ 101 if (vlen > 2 && v[1] == '$') { 102 vlen--; 103 v++; 104 } 105 106 if (isdigit(v[1])) { 107 long i; 108 109 errno = 0; 110 i = strtol(v + 1, (char **)&w, 10); 111 112 wlen = vlen - (w - v); 113 114 if (i < 0 || i >= argc || errno != 0) 115 return (dt_set_errno(dtp, EDT_BADSPCV)); 116 117 v = argv[i]; 118 vlen = strlen(v); 119 120 if (yypcb != NULL && yypcb->pcb_sargv == argv) 121 yypcb->pcb_sflagv[i] |= DT_IDFLG_REF; 122 123 } else if (vlen > 1) { 124 char *vstr = alloca(vlen); 125 dt_ident_t *idp; 126 127 (void) strncpy(vstr, v + 1, vlen - 1); 128 vstr[vlen - 1] = '\0'; 129 idp = dt_idhash_lookup(dtp->dt_macros, vstr); 130 131 if (idp == NULL) 132 return (dt_set_errno(dtp, EDT_BADSPCV)); 133 134 v = buf; 135 vlen = snprintf(buf, 32, "%d", idp->di_id); 136 137 } else 138 return (dt_set_errno(dtp, EDT_BADSPCV)); 139 } 140 141 if (spec == DTRACE_PROBESPEC_NONE) 142 return (dt_set_errno(dtp, EDT_BADSPEC)); 143 144 if (len + vlen >= dtrace_probespecs[spec].dtps_len) 145 return (dt_set_errno(dtp, ENAMETOOLONG)); 146 147 off = dtrace_probespecs[spec--].dtps_offset; 148 bcopy(q, (char *)pdp + off, len); 149 bcopy(v, (char *)pdp + off + len, vlen); 150 bcopy(w, (char *)pdp + off + len + vlen, wlen); 151 } while (--p >= s); 152 153 pdp->dtpd_id = DTRACE_IDNONE; 154 return (0); 155 } 156 157 int 158 dtrace_str2desc(dtrace_hdl_t *dtp, dtrace_probespec_t spec, 159 const char *s, dtrace_probedesc_t *pdp) 160 { 161 return (dtrace_xstr2desc(dtp, spec, s, 0, NULL, pdp)); 162 } 163 164 int 165 dtrace_id2desc(dtrace_hdl_t *dtp, dtrace_id_t id, dtrace_probedesc_t *pdp) 166 { 167 bzero(pdp, sizeof (dtrace_probedesc_t)); 168 pdp->dtpd_id = id; 169 170 if (dt_ioctl(dtp, DTRACEIOC_PROBES, pdp) == -1 || 171 pdp->dtpd_id != id) 172 return (dt_set_errno(dtp, EDT_BADID)); 173 174 return (0); 175 } 176 177 char * 178 dtrace_desc2str(const dtrace_probedesc_t *pdp, char *buf, size_t len) 179 { 180 if (pdp->dtpd_id == 0) { 181 (void) snprintf(buf, len, "%s:%s:%s:%s", pdp->dtpd_provider, 182 pdp->dtpd_mod, pdp->dtpd_func, pdp->dtpd_name); 183 } else 184 (void) snprintf(buf, len, "%u", pdp->dtpd_id); 185 186 return (buf); 187 } 188 189 char * 190 dtrace_attr2str(dtrace_attribute_t attr, char *buf, size_t len) 191 { 192 const char *name = dtrace_stability_name(attr.dtat_name); 193 const char *data = dtrace_stability_name(attr.dtat_data); 194 const char *class = dtrace_class_name(attr.dtat_class); 195 196 if (name == NULL || data == NULL || class == NULL) 197 return (NULL); /* one or more invalid attributes */ 198 199 (void) snprintf(buf, len, "%s/%s/%s", name, data, class); 200 return (buf); 201 } 202 203 static char * 204 dt_getstrattr(char *p, char **qp) 205 { 206 char *q; 207 208 if (*p == '\0') 209 return (NULL); 210 211 if ((q = strchr(p, '/')) == NULL) 212 q = p + strlen(p); 213 else 214 *q++ = '\0'; 215 216 *qp = q; 217 return (p); 218 } 219 220 int 221 dtrace_str2attr(const char *str, dtrace_attribute_t *attr) 222 { 223 dtrace_stability_t s; 224 dtrace_class_t c; 225 char *p, *q; 226 227 if (str == NULL || attr == NULL) 228 return (-1); /* invalid function arguments */ 229 230 *attr = _dtrace_maxattr; 231 p = alloca(strlen(str) + 1); 232 (void) strcpy(p, str); 233 234 if ((p = dt_getstrattr(p, &q)) == NULL) 235 return (0); 236 237 for (s = 0; s <= DTRACE_STABILITY_MAX; s++) { 238 if (strcasecmp(p, dtrace_stability_name(s)) == 0) { 239 attr->dtat_name = s; 240 break; 241 } 242 } 243 244 if (s > DTRACE_STABILITY_MAX) 245 return (-1); 246 247 if ((p = dt_getstrattr(q, &q)) == NULL) 248 return (0); 249 250 for (s = 0; s <= DTRACE_STABILITY_MAX; s++) { 251 if (strcasecmp(p, dtrace_stability_name(s)) == 0) { 252 attr->dtat_data = s; 253 break; 254 } 255 } 256 257 if (s > DTRACE_STABILITY_MAX) 258 return (-1); 259 260 if ((p = dt_getstrattr(q, &q)) == NULL) 261 return (0); 262 263 for (c = 0; c <= DTRACE_CLASS_MAX; c++) { 264 if (strcasecmp(p, dtrace_class_name(c)) == 0) { 265 attr->dtat_class = c; 266 break; 267 } 268 } 269 270 if (c > DTRACE_CLASS_MAX || (p = dt_getstrattr(q, &q)) != NULL) 271 return (-1); 272 273 return (0); 274 } 275 276 const char * 277 dtrace_stability_name(dtrace_stability_t s) 278 { 279 switch (s) { 280 case DTRACE_STABILITY_INTERNAL: return ("Internal"); 281 case DTRACE_STABILITY_PRIVATE: return ("Private"); 282 case DTRACE_STABILITY_OBSOLETE: return ("Obsolete"); 283 case DTRACE_STABILITY_EXTERNAL: return ("External"); 284 case DTRACE_STABILITY_UNSTABLE: return ("Unstable"); 285 case DTRACE_STABILITY_EVOLVING: return ("Evolving"); 286 case DTRACE_STABILITY_STABLE: return ("Stable"); 287 case DTRACE_STABILITY_STANDARD: return ("Standard"); 288 default: return (NULL); 289 } 290 } 291 292 const char * 293 dtrace_class_name(dtrace_class_t c) 294 { 295 switch (c) { 296 case DTRACE_CLASS_UNKNOWN: return ("Unknown"); 297 case DTRACE_CLASS_CPU: return ("CPU"); 298 case DTRACE_CLASS_PLATFORM: return ("Platform"); 299 case DTRACE_CLASS_GROUP: return ("Group"); 300 case DTRACE_CLASS_ISA: return ("ISA"); 301 case DTRACE_CLASS_COMMON: return ("Common"); 302 default: return (NULL); 303 } 304 } 305 306 dtrace_attribute_t 307 dt_attr_min(dtrace_attribute_t a1, dtrace_attribute_t a2) 308 { 309 dtrace_attribute_t am; 310 311 am.dtat_name = MIN(a1.dtat_name, a2.dtat_name); 312 am.dtat_data = MIN(a1.dtat_data, a2.dtat_data); 313 am.dtat_class = MIN(a1.dtat_class, a2.dtat_class); 314 315 return (am); 316 } 317 318 dtrace_attribute_t 319 dt_attr_max(dtrace_attribute_t a1, dtrace_attribute_t a2) 320 { 321 dtrace_attribute_t am; 322 323 am.dtat_name = MAX(a1.dtat_name, a2.dtat_name); 324 am.dtat_data = MAX(a1.dtat_data, a2.dtat_data); 325 am.dtat_class = MAX(a1.dtat_class, a2.dtat_class); 326 327 return (am); 328 } 329 330 /* 331 * Compare two attributes and return an integer value in the following ranges: 332 * 333 * <0 if any of a1's attributes are less than a2's attributes 334 * =0 if all of a1's attributes are equal to a2's attributes 335 * >0 if all of a1's attributes are greater than or equal to a2's attributes 336 * 337 * To implement this function efficiently, we subtract a2's attributes from 338 * a1's to obtain a negative result if an a1 attribute is less than its a2 339 * counterpart. We then OR the intermediate results together, relying on the 340 * twos-complement property that if any result is negative, the bitwise union 341 * will also be negative since the highest bit will be set in the result. 342 */ 343 int 344 dt_attr_cmp(dtrace_attribute_t a1, dtrace_attribute_t a2) 345 { 346 return (((int)a1.dtat_name - a2.dtat_name) | 347 ((int)a1.dtat_data - a2.dtat_data) | 348 ((int)a1.dtat_class - a2.dtat_class)); 349 } 350 351 char * 352 dt_attr_str(dtrace_attribute_t a, char *buf, size_t len) 353 { 354 static const char stability[] = "ipoxuesS"; 355 static const char class[] = "uCpgIc"; 356 357 if (a.dtat_name < sizeof (stability) && 358 a.dtat_data < sizeof (stability) && a.dtat_class < sizeof (class)) { 359 (void) snprintf(buf, len, "[%c/%c/%c]", stability[a.dtat_name], 360 stability[a.dtat_data], class[a.dtat_class]); 361 } else { 362 (void) snprintf(buf, len, "[%u/%u/%u]", 363 a.dtat_name, a.dtat_data, a.dtat_class); 364 } 365 366 return (buf); 367 } 368 369 char * 370 dt_version_num2str(dt_version_t v, char *buf, size_t len) 371 { 372 uint_t M = DT_VERSION_MAJOR(v); 373 uint_t m = DT_VERSION_MINOR(v); 374 uint_t u = DT_VERSION_MICRO(v); 375 376 if (u == 0) 377 (void) snprintf(buf, len, "%u.%u", M, m); 378 else 379 (void) snprintf(buf, len, "%u.%u.%u", M, m, u); 380 381 return (buf); 382 } 383 384 int 385 dt_version_str2num(const char *s, dt_version_t *vp) 386 { 387 int i = 0, n[3] = { 0, 0, 0 }; 388 char c; 389 390 while ((c = *s++) != '\0') { 391 if (isdigit(c)) 392 n[i] = n[i] * 10 + c - '0'; 393 else if (c != '.' || i++ >= sizeof (n) / sizeof (n[0]) - 1) 394 return (-1); 395 } 396 397 if (n[0] > DT_VERSION_MAJMAX || 398 n[1] > DT_VERSION_MINMAX || 399 n[2] > DT_VERSION_MICMAX) 400 return (-1); 401 402 if (vp != NULL) 403 *vp = DT_VERSION_NUMBER(n[0], n[1], n[2]); 404 405 return (0); 406 } 407 408 int 409 dt_version_defined(dt_version_t v) 410 { 411 int i; 412 413 for (i = 0; _dtrace_versions[i] != 0; i++) { 414 if (_dtrace_versions[i] == v) 415 return (1); 416 } 417 418 return (0); 419 } 420 421 char * 422 dt_cpp_add_arg(dtrace_hdl_t *dtp, const char *str) 423 { 424 char *arg; 425 426 if (dtp->dt_cpp_argc == dtp->dt_cpp_args) { 427 int olds = dtp->dt_cpp_args; 428 int news = olds * 2; 429 char **argv = realloc(dtp->dt_cpp_argv, sizeof (char *) * news); 430 431 if (argv == NULL) 432 return (NULL); 433 434 bzero(&argv[olds], sizeof (char *) * olds); 435 dtp->dt_cpp_argv = argv; 436 dtp->dt_cpp_args = news; 437 } 438 439 if ((arg = strdup(str)) == NULL) 440 return (NULL); 441 442 assert(dtp->dt_cpp_argc < dtp->dt_cpp_args); 443 dtp->dt_cpp_argv[dtp->dt_cpp_argc++] = arg; 444 return (arg); 445 } 446 447 char * 448 dt_cpp_pop_arg(dtrace_hdl_t *dtp) 449 { 450 char *arg; 451 452 if (dtp->dt_cpp_argc <= 1) 453 return (NULL); /* dt_cpp_argv[0] cannot be popped */ 454 455 arg = dtp->dt_cpp_argv[--dtp->dt_cpp_argc]; 456 dtp->dt_cpp_argv[dtp->dt_cpp_argc] = NULL; 457 458 return (arg); 459 } 460 461 /*PRINTFLIKE1*/ 462 void 463 dt_dprintf(const char *format, ...) 464 { 465 if (_dtrace_debug) { 466 va_list alist; 467 468 va_start(alist, format); 469 (void) fputs("libdtrace DEBUG: ", stderr); 470 (void) vfprintf(stderr, format, alist); 471 va_end(alist); 472 } 473 } 474 475 int 476 #if defined(sun) 477 dt_ioctl(dtrace_hdl_t *dtp, int val, void *arg) 478 #else 479 dt_ioctl(dtrace_hdl_t *dtp, u_long val, void *arg) 480 #endif 481 { 482 const dtrace_vector_t *v = dtp->dt_vector; 483 484 #if !defined(sun) 485 /* Avoid sign extension. */ 486 val &= 0xffffffff; 487 #endif 488 489 if (v != NULL) 490 return (v->dtv_ioctl(dtp->dt_varg, val, arg)); 491 492 if (dtp->dt_fd >= 0) 493 return (ioctl(dtp->dt_fd, val, arg)); 494 495 errno = EBADF; 496 return (-1); 497 } 498 499 int 500 dt_status(dtrace_hdl_t *dtp, processorid_t cpu) 501 { 502 const dtrace_vector_t *v = dtp->dt_vector; 503 504 if (v == NULL) { 505 #if defined(sun) 506 return (p_online(cpu, P_STATUS)); 507 #else 508 int maxid = 0; 509 size_t len = sizeof(maxid); 510 if (sysctlbyname("kern.smp.maxid", &maxid, &len, NULL, 0) != 0) 511 return (cpu == 0 ? 1 : -1); 512 else 513 return (cpu <= maxid ? 1 : -1); 514 #endif 515 } 516 517 return (v->dtv_status(dtp->dt_varg, cpu)); 518 } 519 520 long 521 dt_sysconf(dtrace_hdl_t *dtp, int name) 522 { 523 const dtrace_vector_t *v = dtp->dt_vector; 524 525 if (v == NULL) 526 return (sysconf(name)); 527 528 return (v->dtv_sysconf(dtp->dt_varg, name)); 529 } 530 531 /* 532 * Wrapper around write(2) to handle partial writes. For maximum safety of 533 * output files and proper error reporting, we continuing writing in the 534 * face of partial writes until write(2) fails or 'buf' is completely written. 535 * We also record any errno in the specified dtrace_hdl_t as well as 'errno'. 536 */ 537 ssize_t 538 dt_write(dtrace_hdl_t *dtp, int fd, const void *buf, size_t n) 539 { 540 ssize_t resid = n; 541 ssize_t len; 542 543 while (resid != 0) { 544 if ((len = write(fd, buf, resid)) <= 0) 545 break; 546 547 resid -= len; 548 buf = (char *)buf + len; 549 } 550 551 if (resid == n && n != 0) 552 return (dt_set_errno(dtp, errno)); 553 554 return (n - resid); 555 } 556 557 /* 558 * This function handles all output from libdtrace, as well as the 559 * dtrace_sprintf() case. If we're here due to dtrace_sprintf(), then 560 * dt_sprintf_buflen will be non-zero; in this case, we sprintf into the 561 * specified buffer and return. Otherwise, if output is buffered (denoted by 562 * a NULL fp), we sprintf the desired output into the buffered buffer 563 * (expanding the buffer if required). If we don't satisfy either of these 564 * conditions (that is, if we are to actually generate output), then we call 565 * fprintf with the specified fp. In this case, we need to deal with one of 566 * the more annoying peculiarities of libc's printf routines: any failed 567 * write persistently sets an error flag inside the FILE causing every 568 * subsequent write to fail, but only the caller that initiated the error gets 569 * the errno. Since libdtrace clients often intercept SIGINT, this case is 570 * particularly frustrating since we don't want the EINTR on one attempt to 571 * write to the output file to preclude later attempts to write. This 572 * function therefore does a clearerr() if any error occurred, and saves the 573 * errno for the caller inside the specified dtrace_hdl_t. 574 */ 575 /*PRINTFLIKE3*/ 576 int 577 dt_printf(dtrace_hdl_t *dtp, FILE *fp, const char *format, ...) 578 { 579 va_list ap; 580 int n; 581 582 #if !defined(sun) 583 /* 584 * On FreeBSD, check if output is currently being re-directed 585 * to another file. If so, output to that file instead of the 586 * one the caller has specified. 587 */ 588 if (dtp->dt_freopen_fp != NULL) 589 fp = dtp->dt_freopen_fp; 590 #endif 591 592 va_start(ap, format); 593 594 if (dtp->dt_sprintf_buflen != 0) { 595 int len; 596 char *buf; 597 598 assert(dtp->dt_sprintf_buf != NULL); 599 600 buf = &dtp->dt_sprintf_buf[len = strlen(dtp->dt_sprintf_buf)]; 601 len = dtp->dt_sprintf_buflen - len; 602 assert(len >= 0); 603 604 if ((n = vsnprintf(buf, len, format, ap)) < 0) 605 n = dt_set_errno(dtp, errno); 606 607 va_end(ap); 608 609 return (n); 610 } 611 612 if (fp == NULL) { 613 int needed, rval; 614 size_t avail; 615 616 /* 617 * It's not legal to use buffered ouput if there is not a 618 * handler for buffered output. 619 */ 620 if (dtp->dt_bufhdlr == NULL) { 621 va_end(ap); 622 return (dt_set_errno(dtp, EDT_NOBUFFERED)); 623 } 624 625 if (dtp->dt_buffered_buf == NULL) { 626 assert(dtp->dt_buffered_size == 0); 627 dtp->dt_buffered_size = 1; 628 dtp->dt_buffered_buf = malloc(dtp->dt_buffered_size); 629 630 if (dtp->dt_buffered_buf == NULL) { 631 va_end(ap); 632 return (dt_set_errno(dtp, EDT_NOMEM)); 633 } 634 635 dtp->dt_buffered_offs = 0; 636 dtp->dt_buffered_buf[0] = '\0'; 637 } 638 639 if ((needed = vsnprintf(NULL, 0, format, ap)) < 0) { 640 rval = dt_set_errno(dtp, errno); 641 va_end(ap); 642 return (rval); 643 } 644 645 if (needed == 0) { 646 va_end(ap); 647 return (0); 648 } 649 650 for (;;) { 651 char *newbuf; 652 653 assert(dtp->dt_buffered_offs < dtp->dt_buffered_size); 654 avail = dtp->dt_buffered_size - dtp->dt_buffered_offs; 655 656 if (needed + 1 < avail) 657 break; 658 659 if ((newbuf = realloc(dtp->dt_buffered_buf, 660 dtp->dt_buffered_size << 1)) == NULL) { 661 va_end(ap); 662 return (dt_set_errno(dtp, EDT_NOMEM)); 663 } 664 665 dtp->dt_buffered_buf = newbuf; 666 dtp->dt_buffered_size <<= 1; 667 } 668 669 if (vsnprintf(&dtp->dt_buffered_buf[dtp->dt_buffered_offs], 670 avail, format, ap) < 0) { 671 rval = dt_set_errno(dtp, errno); 672 va_end(ap); 673 return (rval); 674 } 675 676 dtp->dt_buffered_offs += needed; 677 assert(dtp->dt_buffered_buf[dtp->dt_buffered_offs] == '\0'); 678 return (0); 679 } 680 681 n = vfprintf(fp, format, ap); 682 fflush(fp); 683 va_end(ap); 684 685 if (n < 0) { 686 clearerr(fp); 687 return (dt_set_errno(dtp, errno)); 688 } 689 690 return (n); 691 } 692 693 int 694 dt_buffered_flush(dtrace_hdl_t *dtp, dtrace_probedata_t *pdata, 695 const dtrace_recdesc_t *rec, const dtrace_aggdata_t *agg, uint32_t flags) 696 { 697 dtrace_bufdata_t data; 698 699 if (dtp->dt_buffered_offs == 0) 700 return (0); 701 702 data.dtbda_handle = dtp; 703 data.dtbda_buffered = dtp->dt_buffered_buf; 704 data.dtbda_probe = pdata; 705 data.dtbda_recdesc = rec; 706 data.dtbda_aggdata = agg; 707 data.dtbda_flags = flags; 708 709 if ((*dtp->dt_bufhdlr)(&data, dtp->dt_bufarg) == DTRACE_HANDLE_ABORT) 710 return (dt_set_errno(dtp, EDT_DIRABORT)); 711 712 dtp->dt_buffered_offs = 0; 713 dtp->dt_buffered_buf[0] = '\0'; 714 715 return (0); 716 } 717 718 void 719 dt_buffered_destroy(dtrace_hdl_t *dtp) 720 { 721 free(dtp->dt_buffered_buf); 722 dtp->dt_buffered_buf = NULL; 723 dtp->dt_buffered_offs = 0; 724 dtp->dt_buffered_size = 0; 725 } 726 727 void * 728 dt_zalloc(dtrace_hdl_t *dtp, size_t size) 729 { 730 void *data; 731 732 if (size > 16 * 1024 * 1024) { 733 (void) dt_set_errno(dtp, EDT_NOMEM); 734 return (NULL); 735 } 736 737 if ((data = malloc(size)) == NULL) 738 (void) dt_set_errno(dtp, EDT_NOMEM); 739 else 740 bzero(data, size); 741 742 return (data); 743 } 744 745 void * 746 dt_alloc(dtrace_hdl_t *dtp, size_t size) 747 { 748 void *data; 749 750 if (size > 16 * 1024 * 1024) { 751 (void) dt_set_errno(dtp, EDT_NOMEM); 752 return (NULL); 753 } 754 755 if ((data = malloc(size)) == NULL) 756 (void) dt_set_errno(dtp, EDT_NOMEM); 757 758 return (data); 759 } 760 761 void 762 dt_free(dtrace_hdl_t *dtp, void *data) 763 { 764 assert(dtp != NULL); /* ensure sane use of this interface */ 765 free(data); 766 } 767 768 void 769 dt_difo_free(dtrace_hdl_t *dtp, dtrace_difo_t *dp) 770 { 771 if (dp == NULL) 772 return; /* simplify caller code */ 773 774 dt_free(dtp, dp->dtdo_buf); 775 dt_free(dtp, dp->dtdo_inttab); 776 dt_free(dtp, dp->dtdo_strtab); 777 dt_free(dtp, dp->dtdo_vartab); 778 dt_free(dtp, dp->dtdo_kreltab); 779 dt_free(dtp, dp->dtdo_ureltab); 780 dt_free(dtp, dp->dtdo_xlmtab); 781 782 dt_free(dtp, dp); 783 } 784 785 /* 786 * dt_gmatch() is similar to gmatch(3GEN) and dtrace(7D) globbing, but also 787 * implements the behavior that an empty pattern matches any string. 788 */ 789 int 790 dt_gmatch(const char *s, const char *p) 791 { 792 return (p == NULL || *p == '\0' || gmatch(s, p)); 793 } 794 795 char * 796 dt_basename(char *str) 797 { 798 char *last = strrchr(str, '/'); 799 800 if (last == NULL) 801 return (str); 802 803 return (last + 1); 804 } 805 806 /* 807 * dt_popc() is a fast implementation of population count. The algorithm is 808 * from "Hacker's Delight" by Henry Warren, Jr with a 64-bit equivalent added. 809 */ 810 ulong_t 811 dt_popc(ulong_t x) 812 { 813 #ifdef _ILP32 814 x = x - ((x >> 1) & 0x55555555UL); 815 x = (x & 0x33333333UL) + ((x >> 2) & 0x33333333UL); 816 x = (x + (x >> 4)) & 0x0F0F0F0FUL; 817 x = x + (x >> 8); 818 x = x + (x >> 16); 819 return (x & 0x3F); 820 #endif 821 #ifdef _LP64 822 x = x - ((x >> 1) & 0x5555555555555555ULL); 823 x = (x & 0x3333333333333333ULL) + ((x >> 2) & 0x3333333333333333ULL); 824 x = (x + (x >> 4)) & 0x0F0F0F0F0F0F0F0FULL; 825 x = x + (x >> 8); 826 x = x + (x >> 16); 827 x = x + (x >> 32); 828 return (x & 0x7F); 829 #endif 830 } 831 832 /* 833 * dt_popcb() is a bitmap-based version of population count that returns the 834 * number of one bits in the specified bitmap 'bp' at bit positions below 'n'. 835 */ 836 ulong_t 837 dt_popcb(const ulong_t *bp, ulong_t n) 838 { 839 ulong_t maxb = n & BT_ULMASK; 840 ulong_t maxw = n >> BT_ULSHIFT; 841 ulong_t w, popc = 0; 842 843 if (n == 0) 844 return (0); 845 846 for (w = 0; w < maxw; w++) 847 popc += dt_popc(bp[w]); 848 849 return (popc + dt_popc(bp[maxw] & ((1UL << maxb) - 1))); 850 } 851 852 static int 853 dt_string2str(char *s, char *str, int nbytes) 854 { 855 int len = strlen(s); 856 857 if (nbytes == 0) { 858 /* 859 * Like snprintf(3C), we don't check the value of str if the 860 * number of bytes is 0. 861 */ 862 return (len); 863 } 864 865 if (nbytes <= len) { 866 (void) strncpy(str, s, nbytes - 1); 867 /* 868 * Like snprintf(3C) (and unlike strncpy(3C)), we guarantee 869 * that the string is null-terminated. 870 */ 871 str[nbytes - 1] = '\0'; 872 } else { 873 (void) strcpy(str, s); 874 } 875 876 return (len); 877 } 878 879 int 880 dtrace_addr2str(dtrace_hdl_t *dtp, uint64_t addr, char *str, int nbytes) 881 { 882 dtrace_syminfo_t dts; 883 GElf_Sym sym; 884 885 size_t n = 20; /* for 0x%llx\0 */ 886 char *s; 887 int err; 888 889 if ((err = dtrace_lookup_by_addr(dtp, addr, &sym, &dts)) == 0) 890 n += strlen(dts.dts_object) + strlen(dts.dts_name) + 2; /* +` */ 891 892 s = alloca(n); 893 894 if (err == 0 && addr != sym.st_value) { 895 (void) snprintf(s, n, "%s`%s+0x%llx", dts.dts_object, 896 dts.dts_name, (u_longlong_t)addr - sym.st_value); 897 } else if (err == 0) { 898 (void) snprintf(s, n, "%s`%s", 899 dts.dts_object, dts.dts_name); 900 } else { 901 /* 902 * We'll repeat the lookup, but this time we'll specify a NULL 903 * GElf_Sym -- indicating that we're only interested in the 904 * containing module. 905 */ 906 if (dtrace_lookup_by_addr(dtp, addr, NULL, &dts) == 0) { 907 (void) snprintf(s, n, "%s`0x%llx", dts.dts_object, 908 (u_longlong_t)addr); 909 } else { 910 (void) snprintf(s, n, "0x%llx", (u_longlong_t)addr); 911 } 912 } 913 914 return (dt_string2str(s, str, nbytes)); 915 } 916 917 int 918 dtrace_uaddr2str(dtrace_hdl_t *dtp, pid_t pid, 919 uint64_t addr, char *str, int nbytes) 920 { 921 #if 0 /* XXX TBD needs libproc */ 922 char name[PATH_MAX], objname[PATH_MAX], c[PATH_MAX * 2]; 923 struct ps_prochandle *P = NULL; 924 GElf_Sym sym; 925 char *obj; 926 927 if (pid != 0) 928 P = dt_proc_grab(dtp, pid, PGRAB_RDONLY | PGRAB_FORCE, 0); 929 930 if (P == NULL) { 931 (void) snprintf(c, sizeof (c), "0x%llx", addr); 932 return (dt_string2str(c, str, nbytes)); 933 } 934 935 dt_proc_lock(dtp, P); 936 937 #if defined(sun) 938 if (Plookup_by_addr(P, addr, name, sizeof (name), &sym) == 0) { 939 (void) Pobjname(P, addr, objname, sizeof (objname)); 940 #else 941 if (proc_addr2sym(P, addr, name, sizeof (name), &sym) == 0) { 942 (void) proc_objname(P, addr, objname, sizeof (objname)); 943 #endif 944 945 obj = dt_basename(objname); 946 947 if (addr > sym.st_value) { 948 (void) snprintf(c, sizeof (c), "%s`%s+0x%llx", obj, 949 name, (u_longlong_t)(addr - sym.st_value)); 950 } else { 951 (void) snprintf(c, sizeof (c), "%s`%s", obj, name); 952 } 953 #if defined(sun) 954 } else if (Pobjname(P, addr, objname, sizeof (objname)) != 0) { 955 #else 956 } else if (proc_objname(P, addr, objname, sizeof (objname)) != 0) { 957 #endif 958 (void) snprintf(c, sizeof (c), "%s`0x%llx", 959 dt_basename(objname), addr); 960 } else { 961 (void) snprintf(c, sizeof (c), "0x%llx", addr); 962 } 963 964 dt_proc_unlock(dtp, P); 965 dt_proc_release(dtp, P); 966 967 return (dt_string2str(c, str, nbytes)); 968 #else 969 printf("XXX %s not implemented\n", __func__); 970 return 0; 971 #endif 972 } 973