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 2006 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 /* 27 * Copyright (c) 2013, Joyent, Inc. All rights reserved. 28 */ 29 30 #include <sys/types.h> 31 #if defined(sun) 32 #include <sys/sysmacros.h> 33 #endif 34 35 #include <assert.h> 36 #include <limits.h> 37 #include <strings.h> 38 #include <stdlib.h> 39 #if defined(sun) 40 #include <alloca.h> 41 #endif 42 #include <unistd.h> 43 #include <errno.h> 44 45 #include <dt_provider.h> 46 #include <dt_module.h> 47 #include <dt_string.h> 48 #include <dt_list.h> 49 #include <dt_pid.h> 50 #include <dtrace.h> 51 52 static dt_provider_t * 53 dt_provider_insert(dtrace_hdl_t *dtp, dt_provider_t *pvp, uint_t h) 54 { 55 dt_list_append(&dtp->dt_provlist, pvp); 56 57 pvp->pv_next = dtp->dt_provs[h]; 58 dtp->dt_provs[h] = pvp; 59 dtp->dt_nprovs++; 60 61 return (pvp); 62 } 63 64 dt_provider_t * 65 dt_provider_lookup(dtrace_hdl_t *dtp, const char *name) 66 { 67 uint_t h = dt_strtab_hash(name, NULL) % dtp->dt_provbuckets; 68 dtrace_providerdesc_t desc; 69 dt_provider_t *pvp; 70 71 for (pvp = dtp->dt_provs[h]; pvp != NULL; pvp = pvp->pv_next) { 72 if (strcmp(pvp->pv_desc.dtvd_name, name) == 0) 73 return (pvp); 74 } 75 76 if (strisglob(name) || name[0] == '\0') { 77 (void) dt_set_errno(dtp, EDT_NOPROV); 78 return (NULL); 79 } 80 81 bzero(&desc, sizeof (desc)); 82 (void) strlcpy(desc.dtvd_name, name, DTRACE_PROVNAMELEN); 83 84 if (dt_ioctl(dtp, DTRACEIOC_PROVIDER, &desc) == -1) { 85 (void) dt_set_errno(dtp, errno == ESRCH ? EDT_NOPROV : errno); 86 return (NULL); 87 } 88 89 if ((pvp = dt_provider_create(dtp, name)) == NULL) 90 return (NULL); /* dt_errno is set for us */ 91 92 bcopy(&desc, &pvp->pv_desc, sizeof (desc)); 93 pvp->pv_flags |= DT_PROVIDER_IMPL; 94 return (pvp); 95 } 96 97 dt_provider_t * 98 dt_provider_create(dtrace_hdl_t *dtp, const char *name) 99 { 100 dt_provider_t *pvp; 101 102 if ((pvp = dt_zalloc(dtp, sizeof (dt_provider_t))) == NULL) 103 return (NULL); 104 105 (void) strlcpy(pvp->pv_desc.dtvd_name, name, DTRACE_PROVNAMELEN); 106 pvp->pv_probes = dt_idhash_create(pvp->pv_desc.dtvd_name, NULL, 0, 0); 107 pvp->pv_gen = dtp->dt_gen; 108 pvp->pv_hdl = dtp; 109 110 if (pvp->pv_probes == NULL) { 111 dt_free(dtp, pvp); 112 (void) dt_set_errno(dtp, EDT_NOMEM); 113 return (NULL); 114 } 115 116 pvp->pv_desc.dtvd_attr.dtpa_provider = _dtrace_prvattr; 117 pvp->pv_desc.dtvd_attr.dtpa_mod = _dtrace_prvattr; 118 pvp->pv_desc.dtvd_attr.dtpa_func = _dtrace_prvattr; 119 pvp->pv_desc.dtvd_attr.dtpa_name = _dtrace_prvattr; 120 pvp->pv_desc.dtvd_attr.dtpa_args = _dtrace_prvattr; 121 122 return (dt_provider_insert(dtp, pvp, 123 dt_strtab_hash(name, NULL) % dtp->dt_provbuckets)); 124 } 125 126 void 127 dt_provider_destroy(dtrace_hdl_t *dtp, dt_provider_t *pvp) 128 { 129 dt_provider_t **pp; 130 uint_t h; 131 132 assert(pvp->pv_hdl == dtp); 133 134 h = dt_strtab_hash(pvp->pv_desc.dtvd_name, NULL) % dtp->dt_provbuckets; 135 pp = &dtp->dt_provs[h]; 136 137 while (*pp != NULL && *pp != pvp) 138 pp = &(*pp)->pv_next; 139 140 assert(*pp != NULL && *pp == pvp); 141 *pp = pvp->pv_next; 142 143 dt_list_delete(&dtp->dt_provlist, pvp); 144 dtp->dt_nprovs--; 145 146 if (pvp->pv_probes != NULL) 147 dt_idhash_destroy(pvp->pv_probes); 148 149 dt_node_link_free(&pvp->pv_nodes); 150 dt_free(dtp, pvp->pv_xrefs); 151 dt_free(dtp, pvp); 152 } 153 154 int 155 dt_provider_xref(dtrace_hdl_t *dtp, dt_provider_t *pvp, id_t id) 156 { 157 size_t oldsize = BT_SIZEOFMAP(pvp->pv_xrmax); 158 size_t newsize = BT_SIZEOFMAP(dtp->dt_xlatorid); 159 160 assert(id >= 0 && id < dtp->dt_xlatorid); 161 162 if (newsize > oldsize) { 163 ulong_t *xrefs = dt_zalloc(dtp, newsize); 164 165 if (xrefs == NULL) 166 return (-1); 167 168 bcopy(pvp->pv_xrefs, xrefs, oldsize); 169 dt_free(dtp, pvp->pv_xrefs); 170 171 pvp->pv_xrefs = xrefs; 172 pvp->pv_xrmax = dtp->dt_xlatorid; 173 } 174 175 BT_SET(pvp->pv_xrefs, id); 176 return (0); 177 } 178 179 static uint8_t 180 dt_probe_argmap(dt_node_t *xnp, dt_node_t *nnp) 181 { 182 uint8_t i; 183 184 for (i = 0; nnp != NULL; i++) { 185 if (nnp->dn_string != NULL && 186 strcmp(nnp->dn_string, xnp->dn_string) == 0) 187 break; 188 else 189 nnp = nnp->dn_list; 190 } 191 192 return (i); 193 } 194 195 static dt_node_t * 196 dt_probe_alloc_args(dt_provider_t *pvp, int argc) 197 { 198 dt_node_t *args = NULL, *pnp = NULL, *dnp; 199 int i; 200 201 for (i = 0; i < argc; i++, pnp = dnp) { 202 if ((dnp = dt_node_xalloc(pvp->pv_hdl, DT_NODE_TYPE)) == NULL) 203 return (NULL); 204 205 dnp->dn_link = pvp->pv_nodes; 206 pvp->pv_nodes = dnp; 207 208 if (args == NULL) 209 args = dnp; 210 else 211 pnp->dn_list = dnp; 212 } 213 214 return (args); 215 } 216 217 static size_t 218 dt_probe_keylen(const dtrace_probedesc_t *pdp) 219 { 220 return (strlen(pdp->dtpd_mod) + 1 + 221 strlen(pdp->dtpd_func) + 1 + strlen(pdp->dtpd_name) + 1); 222 } 223 224 static char * 225 dt_probe_key(const dtrace_probedesc_t *pdp, char *s) 226 { 227 (void) snprintf(s, INT_MAX, "%s:%s:%s", 228 pdp->dtpd_mod, pdp->dtpd_func, pdp->dtpd_name); 229 return (s); 230 } 231 232 /* 233 * If a probe was discovered from the kernel, ask dtrace(7D) for a description 234 * of each of its arguments, including native and translated types. 235 */ 236 static dt_probe_t * 237 dt_probe_discover(dt_provider_t *pvp, const dtrace_probedesc_t *pdp) 238 { 239 dtrace_hdl_t *dtp = pvp->pv_hdl; 240 char *name = dt_probe_key(pdp, alloca(dt_probe_keylen(pdp))); 241 242 dt_node_t *xargs, *nargs; 243 dt_ident_t *idp; 244 dt_probe_t *prp; 245 246 dtrace_typeinfo_t dtt; 247 int i, nc, xc; 248 249 int adc = _dtrace_argmax; 250 dtrace_argdesc_t *adv = alloca(sizeof (dtrace_argdesc_t) * adc); 251 dtrace_argdesc_t *adp = adv; 252 253 assert(strcmp(pvp->pv_desc.dtvd_name, pdp->dtpd_provider) == 0); 254 assert(pdp->dtpd_id != DTRACE_IDNONE); 255 256 dt_dprintf("discovering probe %s:%s id=%d\n", 257 pvp->pv_desc.dtvd_name, name, pdp->dtpd_id); 258 259 for (nc = -1, i = 0; i < adc; i++, adp++) { 260 bzero(adp, sizeof (dtrace_argdesc_t)); 261 adp->dtargd_ndx = i; 262 adp->dtargd_id = pdp->dtpd_id; 263 264 if (dt_ioctl(dtp, DTRACEIOC_PROBEARG, adp) != 0) { 265 (void) dt_set_errno(dtp, errno); 266 return (NULL); 267 } 268 269 if (adp->dtargd_ndx == DTRACE_ARGNONE) 270 break; /* all argument descs have been retrieved */ 271 272 nc = MAX(nc, adp->dtargd_mapping); 273 } 274 275 xc = i; 276 nc++; 277 278 /* 279 * The pid provider believes in giving the kernel a break. No reason to 280 * give the kernel all the ctf containers that we're keeping ourselves 281 * just to get it back from it. So if we're coming from a pid provider 282 * probe and the kernel gave us no argument information we'll get some 283 * here. If for some crazy reason the kernel knows about our userland 284 * types then we just ignore this. 285 */ 286 if (xc == 0 && nc == 0 && 287 strncmp(pvp->pv_desc.dtvd_name, "pid", 3) == 0) { 288 nc = adc; 289 dt_pid_get_types(dtp, pdp, adv, &nc); 290 xc = nc; 291 } 292 293 /* 294 * Now that we have discovered the number of native and translated 295 * arguments from the argument descriptions, allocate a new probe ident 296 * and corresponding dt_probe_t and hash it into the provider. 297 */ 298 xargs = dt_probe_alloc_args(pvp, xc); 299 nargs = dt_probe_alloc_args(pvp, nc); 300 301 if ((xc != 0 && xargs == NULL) || (nc != 0 && nargs == NULL)) 302 return (NULL); /* dt_errno is set for us */ 303 304 idp = dt_ident_create(name, DT_IDENT_PROBE, 305 DT_IDFLG_ORPHAN, pdp->dtpd_id, _dtrace_defattr, 0, 306 &dt_idops_probe, NULL, dtp->dt_gen); 307 308 if (idp == NULL) { 309 (void) dt_set_errno(dtp, EDT_NOMEM); 310 return (NULL); 311 } 312 313 if ((prp = dt_probe_create(dtp, idp, 2, 314 nargs, nc, xargs, xc)) == NULL) { 315 dt_ident_destroy(idp); 316 return (NULL); 317 } 318 319 dt_probe_declare(pvp, prp); 320 321 /* 322 * Once our new dt_probe_t is fully constructed, iterate over the 323 * cached argument descriptions and assign types to prp->pr_nargv[] 324 * and prp->pr_xargv[] and assign mappings to prp->pr_mapping[]. 325 */ 326 for (adp = adv, i = 0; i < xc; i++, adp++) { 327 if (dtrace_type_strcompile(dtp, 328 adp->dtargd_native, &dtt) != 0) { 329 dt_dprintf("failed to resolve input type %s " 330 "for %s:%s arg #%d: %s\n", adp->dtargd_native, 331 pvp->pv_desc.dtvd_name, name, i + 1, 332 dtrace_errmsg(dtp, dtrace_errno(dtp))); 333 334 dtt.dtt_object = NULL; 335 dtt.dtt_ctfp = NULL; 336 dtt.dtt_type = CTF_ERR; 337 } else { 338 dt_node_type_assign(prp->pr_nargv[adp->dtargd_mapping], 339 dtt.dtt_ctfp, dtt.dtt_type, 340 dtt.dtt_flags & DTT_FL_USER ? B_TRUE : B_FALSE); 341 } 342 343 if (dtt.dtt_type != CTF_ERR && (adp->dtargd_xlate[0] == '\0' || 344 strcmp(adp->dtargd_native, adp->dtargd_xlate) == 0)) { 345 dt_node_type_propagate(prp->pr_nargv[ 346 adp->dtargd_mapping], prp->pr_xargv[i]); 347 } else if (dtrace_type_strcompile(dtp, 348 adp->dtargd_xlate, &dtt) != 0) { 349 dt_dprintf("failed to resolve output type %s " 350 "for %s:%s arg #%d: %s\n", adp->dtargd_xlate, 351 pvp->pv_desc.dtvd_name, name, i + 1, 352 dtrace_errmsg(dtp, dtrace_errno(dtp))); 353 354 dtt.dtt_object = NULL; 355 dtt.dtt_ctfp = NULL; 356 dtt.dtt_type = CTF_ERR; 357 } else { 358 dt_node_type_assign(prp->pr_xargv[i], 359 dtt.dtt_ctfp, dtt.dtt_type, B_FALSE); 360 } 361 362 prp->pr_mapping[i] = adp->dtargd_mapping; 363 prp->pr_argv[i] = dtt; 364 } 365 366 return (prp); 367 } 368 369 /* 370 * Lookup a probe declaration based on a known provider and full or partially 371 * specified module, function, and name. If the probe is not known to us yet, 372 * ask dtrace(7D) to match the description and then cache any useful results. 373 */ 374 dt_probe_t * 375 dt_probe_lookup(dt_provider_t *pvp, const char *s) 376 { 377 dtrace_hdl_t *dtp = pvp->pv_hdl; 378 dtrace_probedesc_t pd; 379 dt_ident_t *idp; 380 size_t keylen; 381 char *key; 382 383 if (dtrace_str2desc(dtp, DTRACE_PROBESPEC_NAME, s, &pd) != 0) 384 return (NULL); /* dt_errno is set for us */ 385 386 keylen = dt_probe_keylen(&pd); 387 key = dt_probe_key(&pd, alloca(keylen)); 388 389 /* 390 * If the probe is already declared, then return the dt_probe_t from 391 * the existing identifier. This could come from a static declaration 392 * or it could have been cached from an earlier call to this function. 393 */ 394 if ((idp = dt_idhash_lookup(pvp->pv_probes, key)) != NULL) 395 return (idp->di_data); 396 397 /* 398 * If the probe isn't known, use the probe description computed above 399 * to ask dtrace(7D) to find the first matching probe. 400 */ 401 if (dt_ioctl(dtp, DTRACEIOC_PROBEMATCH, &pd) == 0) 402 return (dt_probe_discover(pvp, &pd)); 403 404 if (errno == ESRCH || errno == EBADF) 405 (void) dt_set_errno(dtp, EDT_NOPROBE); 406 else 407 (void) dt_set_errno(dtp, errno); 408 409 return (NULL); 410 } 411 412 dt_probe_t * 413 dt_probe_create(dtrace_hdl_t *dtp, dt_ident_t *idp, int protoc, 414 dt_node_t *nargs, uint_t nargc, dt_node_t *xargs, uint_t xargc) 415 { 416 dt_module_t *dmp; 417 dt_probe_t *prp; 418 const char *p; 419 uint_t i; 420 421 assert(idp->di_kind == DT_IDENT_PROBE); 422 assert(idp->di_data == NULL); 423 424 /* 425 * If only a single prototype is given, set xargc/s to nargc/s to 426 * simplify subsequent use. Note that we can have one or both of nargs 427 * and xargs be specified but set to NULL, indicating a void prototype. 428 */ 429 if (protoc < 2) { 430 assert(xargs == NULL); 431 assert(xargc == 0); 432 xargs = nargs; 433 xargc = nargc; 434 } 435 436 if ((prp = dt_alloc(dtp, sizeof (dt_probe_t))) == NULL) 437 return (NULL); 438 439 prp->pr_pvp = NULL; 440 prp->pr_ident = idp; 441 442 p = strrchr(idp->di_name, ':'); 443 assert(p != NULL); 444 prp->pr_name = p + 1; 445 446 prp->pr_nargs = nargs; 447 prp->pr_nargv = dt_alloc(dtp, sizeof (dt_node_t *) * nargc); 448 prp->pr_nargc = nargc; 449 prp->pr_xargs = xargs; 450 prp->pr_xargv = dt_alloc(dtp, sizeof (dt_node_t *) * xargc); 451 prp->pr_xargc = xargc; 452 prp->pr_mapping = dt_alloc(dtp, sizeof (uint8_t) * xargc); 453 prp->pr_inst = NULL; 454 prp->pr_argv = dt_alloc(dtp, sizeof (dtrace_typeinfo_t) * xargc); 455 prp->pr_argc = xargc; 456 457 if ((prp->pr_nargc != 0 && prp->pr_nargv == NULL) || 458 (prp->pr_xargc != 0 && prp->pr_xargv == NULL) || 459 (prp->pr_xargc != 0 && prp->pr_mapping == NULL) || 460 (prp->pr_argc != 0 && prp->pr_argv == NULL)) { 461 dt_probe_destroy(prp); 462 return (NULL); 463 } 464 465 for (i = 0; i < xargc; i++, xargs = xargs->dn_list) { 466 if (xargs->dn_string != NULL) 467 prp->pr_mapping[i] = dt_probe_argmap(xargs, nargs); 468 else 469 prp->pr_mapping[i] = i; 470 471 prp->pr_xargv[i] = xargs; 472 473 if ((dmp = dt_module_lookup_by_ctf(dtp, 474 xargs->dn_ctfp)) != NULL) 475 prp->pr_argv[i].dtt_object = dmp->dm_name; 476 else 477 prp->pr_argv[i].dtt_object = NULL; 478 479 prp->pr_argv[i].dtt_ctfp = xargs->dn_ctfp; 480 prp->pr_argv[i].dtt_type = xargs->dn_type; 481 } 482 483 for (i = 0; i < nargc; i++, nargs = nargs->dn_list) 484 prp->pr_nargv[i] = nargs; 485 486 idp->di_data = prp; 487 return (prp); 488 } 489 490 void 491 dt_probe_declare(dt_provider_t *pvp, dt_probe_t *prp) 492 { 493 assert(prp->pr_ident->di_kind == DT_IDENT_PROBE); 494 assert(prp->pr_ident->di_data == prp); 495 assert(prp->pr_pvp == NULL); 496 497 if (prp->pr_xargs != prp->pr_nargs) 498 pvp->pv_flags &= ~DT_PROVIDER_INTF; 499 500 prp->pr_pvp = pvp; 501 dt_idhash_xinsert(pvp->pv_probes, prp->pr_ident); 502 } 503 504 void 505 dt_probe_destroy(dt_probe_t *prp) 506 { 507 dt_probe_instance_t *pip, *pip_next; 508 dtrace_hdl_t *dtp; 509 510 if (prp->pr_pvp != NULL) 511 dtp = prp->pr_pvp->pv_hdl; 512 else 513 dtp = yypcb->pcb_hdl; 514 515 dt_node_list_free(&prp->pr_nargs); 516 dt_node_list_free(&prp->pr_xargs); 517 518 dt_free(dtp, prp->pr_nargv); 519 dt_free(dtp, prp->pr_xargv); 520 521 for (pip = prp->pr_inst; pip != NULL; pip = pip_next) { 522 pip_next = pip->pi_next; 523 dt_free(dtp, pip->pi_offs); 524 dt_free(dtp, pip->pi_enoffs); 525 dt_free(dtp, pip); 526 } 527 528 dt_free(dtp, prp->pr_mapping); 529 dt_free(dtp, prp->pr_argv); 530 dt_free(dtp, prp); 531 } 532 533 int 534 dt_probe_define(dt_provider_t *pvp, dt_probe_t *prp, 535 const char *fname, const char *rname, uint32_t offset, int isenabled) 536 { 537 dtrace_hdl_t *dtp = pvp->pv_hdl; 538 dt_probe_instance_t *pip; 539 uint32_t **offs; 540 uint_t *noffs, *maxoffs; 541 542 assert(fname != NULL); 543 544 for (pip = prp->pr_inst; pip != NULL; pip = pip->pi_next) { 545 if (strcmp(pip->pi_fname, fname) == 0 && 546 ((rname == NULL && pip->pi_rname[0] == '\0') || 547 (rname != NULL && strcmp(pip->pi_rname, rname)) == 0)) 548 break; 549 } 550 551 if (pip == NULL) { 552 if ((pip = dt_zalloc(dtp, sizeof (*pip))) == NULL) 553 return (-1); 554 555 if ((pip->pi_offs = dt_zalloc(dtp, 556 sizeof (uint32_t))) == NULL) { 557 dt_free(dtp, pip); 558 return (-1); 559 } 560 561 if ((pip->pi_enoffs = dt_zalloc(dtp, 562 sizeof (uint32_t))) == NULL) { 563 dt_free(dtp, pip->pi_offs); 564 dt_free(dtp, pip); 565 return (-1); 566 } 567 568 (void) strlcpy(pip->pi_fname, fname, sizeof (pip->pi_fname)); 569 if (rname != NULL) { 570 if (strlen(rname) + 1 > sizeof (pip->pi_rname)) { 571 dt_free(dtp, pip->pi_offs); 572 dt_free(dtp, pip); 573 return (dt_set_errno(dtp, EDT_COMPILER)); 574 } 575 (void) strcpy(pip->pi_rname, rname); 576 } 577 578 pip->pi_noffs = 0; 579 pip->pi_maxoffs = 1; 580 pip->pi_nenoffs = 0; 581 pip->pi_maxenoffs = 1; 582 583 pip->pi_next = prp->pr_inst; 584 585 prp->pr_inst = pip; 586 } 587 588 if (isenabled) { 589 offs = &pip->pi_enoffs; 590 noffs = &pip->pi_nenoffs; 591 maxoffs = &pip->pi_maxenoffs; 592 } else { 593 offs = &pip->pi_offs; 594 noffs = &pip->pi_noffs; 595 maxoffs = &pip->pi_maxoffs; 596 } 597 598 if (*noffs == *maxoffs) { 599 uint_t new_max = *maxoffs * 2; 600 uint32_t *new_offs = dt_alloc(dtp, sizeof (uint32_t) * new_max); 601 602 if (new_offs == NULL) 603 return (-1); 604 605 bcopy(*offs, new_offs, sizeof (uint32_t) * *maxoffs); 606 607 dt_free(dtp, *offs); 608 *maxoffs = new_max; 609 *offs = new_offs; 610 } 611 612 dt_dprintf("defined probe %s %s:%s %s() +0x%x (%s)\n", 613 isenabled ? "(is-enabled)" : "", 614 pvp->pv_desc.dtvd_name, prp->pr_ident->di_name, fname, offset, 615 rname != NULL ? rname : fname); 616 617 assert(*noffs < *maxoffs); 618 (*offs)[(*noffs)++] = offset; 619 620 return (0); 621 } 622 623 /* 624 * Lookup the dynamic translator type tag for the specified probe argument and 625 * assign the type to the specified node. If the type is not yet defined, add 626 * it to the "D" module's type container as a typedef for an unknown type. 627 */ 628 dt_node_t * 629 dt_probe_tag(dt_probe_t *prp, uint_t argn, dt_node_t *dnp) 630 { 631 dtrace_hdl_t *dtp = prp->pr_pvp->pv_hdl; 632 dtrace_typeinfo_t dtt; 633 size_t len; 634 char *tag; 635 636 len = snprintf(NULL, 0, "__dtrace_%s___%s_arg%u", 637 prp->pr_pvp->pv_desc.dtvd_name, prp->pr_name, argn); 638 639 tag = alloca(len + 1); 640 641 (void) snprintf(tag, len + 1, "__dtrace_%s___%s_arg%u", 642 prp->pr_pvp->pv_desc.dtvd_name, prp->pr_name, argn); 643 644 if (dtrace_lookup_by_type(dtp, DTRACE_OBJ_DDEFS, tag, &dtt) != 0) { 645 dtt.dtt_object = DTRACE_OBJ_DDEFS; 646 dtt.dtt_ctfp = DT_DYN_CTFP(dtp); 647 dtt.dtt_type = ctf_add_typedef(DT_DYN_CTFP(dtp), 648 CTF_ADD_ROOT, tag, DT_DYN_TYPE(dtp)); 649 650 if (dtt.dtt_type == CTF_ERR || 651 ctf_update(dtt.dtt_ctfp) == CTF_ERR) { 652 xyerror(D_UNKNOWN, "cannot define type %s: %s\n", 653 tag, ctf_errmsg(ctf_errno(dtt.dtt_ctfp))); 654 } 655 } 656 657 bzero(dnp, sizeof (dt_node_t)); 658 dnp->dn_kind = DT_NODE_TYPE; 659 660 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type, B_FALSE); 661 dt_node_attr_assign(dnp, _dtrace_defattr); 662 663 return (dnp); 664 } 665 666 /*ARGSUSED*/ 667 static int 668 dt_probe_desc(dtrace_hdl_t *dtp, const dtrace_probedesc_t *pdp, void *arg) 669 { 670 if (((dtrace_probedesc_t *)arg)->dtpd_id == DTRACE_IDNONE) { 671 bcopy(pdp, arg, sizeof (dtrace_probedesc_t)); 672 return (0); 673 } 674 675 return (1); 676 } 677 678 dt_probe_t * 679 dt_probe_info(dtrace_hdl_t *dtp, 680 const dtrace_probedesc_t *pdp, dtrace_probeinfo_t *pip) 681 { 682 int m_is_glob = pdp->dtpd_mod[0] == '\0' || strisglob(pdp->dtpd_mod); 683 int f_is_glob = pdp->dtpd_func[0] == '\0' || strisglob(pdp->dtpd_func); 684 int n_is_glob = pdp->dtpd_name[0] == '\0' || strisglob(pdp->dtpd_name); 685 686 dt_probe_t *prp = NULL; 687 const dtrace_pattr_t *pap; 688 dt_provider_t *pvp; 689 dt_ident_t *idp; 690 691 /* 692 * Attempt to lookup the probe in our existing cache for this provider. 693 * If none is found and an explicit probe ID was specified, discover 694 * that specific probe and cache its description and arguments. 695 */ 696 if ((pvp = dt_provider_lookup(dtp, pdp->dtpd_provider)) != NULL) { 697 size_t keylen = dt_probe_keylen(pdp); 698 char *key = dt_probe_key(pdp, alloca(keylen)); 699 700 if ((idp = dt_idhash_lookup(pvp->pv_probes, key)) != NULL) 701 prp = idp->di_data; 702 else if (pdp->dtpd_id != DTRACE_IDNONE) 703 prp = dt_probe_discover(pvp, pdp); 704 } 705 706 /* 707 * If no probe was found in our cache, convert the caller's partial 708 * probe description into a fully-formed matching probe description by 709 * iterating over up to at most two probes that match 'pdp'. We then 710 * call dt_probe_discover() on the resulting probe identifier. 711 */ 712 if (prp == NULL) { 713 dtrace_probedesc_t pd; 714 int m; 715 716 bzero(&pd, sizeof (pd)); 717 pd.dtpd_id = DTRACE_IDNONE; 718 719 /* 720 * Call dtrace_probe_iter() to find matching probes. Our 721 * dt_probe_desc() callback will produce the following results: 722 * 723 * m < 0 dtrace_probe_iter() found zero matches (or failed). 724 * m > 0 dtrace_probe_iter() found more than one match. 725 * m = 0 dtrace_probe_iter() found exactly one match. 726 */ 727 if ((m = dtrace_probe_iter(dtp, pdp, dt_probe_desc, &pd)) < 0) 728 return (NULL); /* dt_errno is set for us */ 729 730 if ((pvp = dt_provider_lookup(dtp, pd.dtpd_provider)) == NULL) 731 return (NULL); /* dt_errno is set for us */ 732 733 /* 734 * If more than one probe was matched, then do not report probe 735 * information if either of the following conditions is true: 736 * 737 * (a) The Arguments Data stability of the matched provider is 738 * less than Evolving. 739 * 740 * (b) Any description component that is at least Evolving is 741 * empty or is specified using a globbing expression. 742 * 743 * These conditions imply that providers that provide Evolving 744 * or better Arguments Data stability must guarantee that all 745 * probes with identical field names in a field of Evolving or 746 * better Name stability have identical argument signatures. 747 */ 748 if (m > 0) { 749 if (pvp->pv_desc.dtvd_attr.dtpa_args.dtat_data < 750 DTRACE_STABILITY_EVOLVING) { 751 (void) dt_set_errno(dtp, EDT_UNSTABLE); 752 return (NULL); 753 } 754 755 756 if (pvp->pv_desc.dtvd_attr.dtpa_mod.dtat_name >= 757 DTRACE_STABILITY_EVOLVING && m_is_glob) { 758 (void) dt_set_errno(dtp, EDT_UNSTABLE); 759 return (NULL); 760 } 761 762 if (pvp->pv_desc.dtvd_attr.dtpa_func.dtat_name >= 763 DTRACE_STABILITY_EVOLVING && f_is_glob) { 764 (void) dt_set_errno(dtp, EDT_UNSTABLE); 765 return (NULL); 766 } 767 768 if (pvp->pv_desc.dtvd_attr.dtpa_name.dtat_name >= 769 DTRACE_STABILITY_EVOLVING && n_is_glob) { 770 (void) dt_set_errno(dtp, EDT_UNSTABLE); 771 return (NULL); 772 } 773 } 774 775 /* 776 * If we matched a probe exported by dtrace(7D), then discover 777 * the real attributes. Otherwise grab the static declaration. 778 */ 779 if (pd.dtpd_id != DTRACE_IDNONE) 780 prp = dt_probe_discover(pvp, &pd); 781 else 782 prp = dt_probe_lookup(pvp, pd.dtpd_name); 783 784 if (prp == NULL) 785 return (NULL); /* dt_errno is set for us */ 786 } 787 788 assert(pvp != NULL && prp != NULL); 789 790 /* 791 * Compute the probe description attributes by taking the minimum of 792 * the attributes of the specified fields. If no provider is specified 793 * or a glob pattern is used for the provider, use Unstable attributes. 794 */ 795 if (pdp->dtpd_provider[0] == '\0' || strisglob(pdp->dtpd_provider)) 796 pap = &_dtrace_prvdesc; 797 else 798 pap = &pvp->pv_desc.dtvd_attr; 799 800 pip->dtp_attr = pap->dtpa_provider; 801 802 if (!m_is_glob) 803 pip->dtp_attr = dt_attr_min(pip->dtp_attr, pap->dtpa_mod); 804 if (!f_is_glob) 805 pip->dtp_attr = dt_attr_min(pip->dtp_attr, pap->dtpa_func); 806 if (!n_is_glob) 807 pip->dtp_attr = dt_attr_min(pip->dtp_attr, pap->dtpa_name); 808 809 pip->dtp_arga = pap->dtpa_args; 810 pip->dtp_argv = prp->pr_argv; 811 pip->dtp_argc = prp->pr_argc; 812 813 return (prp); 814 } 815 816 int 817 dtrace_probe_info(dtrace_hdl_t *dtp, 818 const dtrace_probedesc_t *pdp, dtrace_probeinfo_t *pip) 819 { 820 return (dt_probe_info(dtp, pdp, pip) != NULL ? 0 : -1); 821 } 822 823 /*ARGSUSED*/ 824 static int 825 dt_probe_iter(dt_idhash_t *ihp, dt_ident_t *idp, dt_probe_iter_t *pit) 826 { 827 const dt_probe_t *prp = idp->di_data; 828 829 if (!dt_gmatch(prp->pr_name, pit->pit_pat)) 830 return (0); /* continue on and examine next probe in hash */ 831 832 (void) strlcpy(pit->pit_desc.dtpd_name, prp->pr_name, DTRACE_NAMELEN); 833 pit->pit_desc.dtpd_id = idp->di_id; 834 pit->pit_matches++; 835 836 return (pit->pit_func(pit->pit_hdl, &pit->pit_desc, pit->pit_arg)); 837 } 838 839 int 840 dtrace_probe_iter(dtrace_hdl_t *dtp, 841 const dtrace_probedesc_t *pdp, dtrace_probe_f *func, void *arg) 842 { 843 const char *provider = pdp ? pdp->dtpd_provider : NULL; 844 dtrace_id_t id = DTRACE_IDNONE; 845 846 dtrace_probedesc_t pd; 847 dt_probe_iter_t pit; 848 int cmd, rv; 849 850 bzero(&pit, sizeof (pit)); 851 pit.pit_hdl = dtp; 852 pit.pit_func = func; 853 pit.pit_arg = arg; 854 pit.pit_pat = pdp ? pdp->dtpd_name : NULL; 855 856 for (pit.pit_pvp = dt_list_next(&dtp->dt_provlist); 857 pit.pit_pvp != NULL; pit.pit_pvp = dt_list_next(pit.pit_pvp)) { 858 859 if (pit.pit_pvp->pv_flags & DT_PROVIDER_IMPL) 860 continue; /* we'll get these later using dt_ioctl() */ 861 862 if (!dt_gmatch(pit.pit_pvp->pv_desc.dtvd_name, provider)) 863 continue; 864 865 (void) strlcpy(pit.pit_desc.dtpd_provider, 866 pit.pit_pvp->pv_desc.dtvd_name, DTRACE_PROVNAMELEN); 867 868 if ((rv = dt_idhash_iter(pit.pit_pvp->pv_probes, 869 (dt_idhash_f *)dt_probe_iter, &pit)) != 0) 870 return (rv); 871 } 872 873 if (pdp != NULL) 874 cmd = DTRACEIOC_PROBEMATCH; 875 else 876 cmd = DTRACEIOC_PROBES; 877 878 for (;;) { 879 if (pdp != NULL) 880 bcopy(pdp, &pd, sizeof (pd)); 881 882 pd.dtpd_id = id; 883 884 if (dt_ioctl(dtp, cmd, &pd) != 0) 885 break; 886 else if ((rv = func(dtp, &pd, arg)) != 0) 887 return (rv); 888 889 pit.pit_matches++; 890 id = pd.dtpd_id + 1; 891 } 892 893 switch (errno) { 894 case ESRCH: 895 case EBADF: 896 return (pit.pit_matches ? 0 : dt_set_errno(dtp, EDT_NOPROBE)); 897 case EINVAL: 898 return (dt_set_errno(dtp, EDT_BADPGLOB)); 899 default: 900 return (dt_set_errno(dtp, errno)); 901 } 902 } 903