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 #ifdef illumos 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 #ifdef illumos 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_rname); 524 dt_free(dtp, pip->pi_fname); 525 dt_free(dtp, pip->pi_offs); 526 dt_free(dtp, pip->pi_enoffs); 527 dt_free(dtp, pip); 528 } 529 530 dt_free(dtp, prp->pr_mapping); 531 dt_free(dtp, prp->pr_argv); 532 dt_free(dtp, prp); 533 } 534 535 int 536 dt_probe_define(dt_provider_t *pvp, dt_probe_t *prp, 537 const char *fname, const char *rname, uint32_t offset, int isenabled) 538 { 539 dtrace_hdl_t *dtp = pvp->pv_hdl; 540 dt_probe_instance_t *pip; 541 uint32_t **offs; 542 uint_t *noffs, *maxoffs; 543 544 assert(fname != NULL); 545 546 for (pip = prp->pr_inst; pip != NULL; pip = pip->pi_next) { 547 if (strcmp(pip->pi_fname, fname) == 0 && 548 strcmp(pip->pi_rname, rname) == 0) 549 break; 550 } 551 552 if (pip == NULL) { 553 if ((pip = dt_zalloc(dtp, sizeof (*pip))) == NULL) 554 return (-1); 555 556 if ((pip->pi_offs = dt_zalloc(dtp, sizeof (uint32_t))) == NULL) 557 goto nomem; 558 559 if ((pip->pi_enoffs = dt_zalloc(dtp, 560 sizeof (uint32_t))) == NULL) 561 goto nomem; 562 563 if ((pip->pi_fname = strdup(fname)) == NULL) 564 goto nomem; 565 566 if ((pip->pi_rname = strdup(rname)) == NULL) 567 goto nomem; 568 569 pip->pi_noffs = 0; 570 pip->pi_maxoffs = 1; 571 pip->pi_nenoffs = 0; 572 pip->pi_maxenoffs = 1; 573 574 pip->pi_next = prp->pr_inst; 575 576 prp->pr_inst = pip; 577 } 578 579 if (isenabled) { 580 offs = &pip->pi_enoffs; 581 noffs = &pip->pi_nenoffs; 582 maxoffs = &pip->pi_maxenoffs; 583 } else { 584 offs = &pip->pi_offs; 585 noffs = &pip->pi_noffs; 586 maxoffs = &pip->pi_maxoffs; 587 } 588 589 if (*noffs == *maxoffs) { 590 uint_t new_max = *maxoffs * 2; 591 uint32_t *new_offs = dt_alloc(dtp, sizeof (uint32_t) * new_max); 592 593 if (new_offs == NULL) 594 return (-1); 595 596 bcopy(*offs, new_offs, sizeof (uint32_t) * *maxoffs); 597 598 dt_free(dtp, *offs); 599 *maxoffs = new_max; 600 *offs = new_offs; 601 } 602 603 dt_dprintf("defined probe %s %s:%s %s() +0x%x (%s)\n", 604 isenabled ? "(is-enabled)" : "", 605 pvp->pv_desc.dtvd_name, prp->pr_ident->di_name, fname, offset, 606 rname); 607 608 assert(*noffs < *maxoffs); 609 (*offs)[(*noffs)++] = offset; 610 611 return (0); 612 613 nomem: 614 dt_free(dtp, pip->pi_fname); 615 dt_free(dtp, pip->pi_enoffs); 616 dt_free(dtp, pip->pi_offs); 617 dt_free(dtp, pip); 618 return (dt_set_errno(dtp, EDT_NOMEM)); 619 } 620 621 /* 622 * Lookup the dynamic translator type tag for the specified probe argument and 623 * assign the type to the specified node. If the type is not yet defined, add 624 * it to the "D" module's type container as a typedef for an unknown type. 625 */ 626 dt_node_t * 627 dt_probe_tag(dt_probe_t *prp, uint_t argn, dt_node_t *dnp) 628 { 629 dtrace_hdl_t *dtp = prp->pr_pvp->pv_hdl; 630 dtrace_typeinfo_t dtt; 631 size_t len; 632 char *tag; 633 634 len = snprintf(NULL, 0, "__dtrace_%s___%s_arg%u", 635 prp->pr_pvp->pv_desc.dtvd_name, prp->pr_name, argn); 636 637 tag = alloca(len + 1); 638 639 (void) snprintf(tag, len + 1, "__dtrace_%s___%s_arg%u", 640 prp->pr_pvp->pv_desc.dtvd_name, prp->pr_name, argn); 641 642 if (dtrace_lookup_by_type(dtp, DTRACE_OBJ_DDEFS, tag, &dtt) != 0) { 643 dtt.dtt_object = DTRACE_OBJ_DDEFS; 644 dtt.dtt_ctfp = DT_DYN_CTFP(dtp); 645 dtt.dtt_type = ctf_add_typedef(DT_DYN_CTFP(dtp), 646 CTF_ADD_ROOT, tag, DT_DYN_TYPE(dtp)); 647 648 if (dtt.dtt_type == CTF_ERR || 649 ctf_update(dtt.dtt_ctfp) == CTF_ERR) { 650 xyerror(D_UNKNOWN, "cannot define type %s: %s\n", 651 tag, ctf_errmsg(ctf_errno(dtt.dtt_ctfp))); 652 } 653 } 654 655 bzero(dnp, sizeof (dt_node_t)); 656 dnp->dn_kind = DT_NODE_TYPE; 657 658 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type, B_FALSE); 659 dt_node_attr_assign(dnp, _dtrace_defattr); 660 661 return (dnp); 662 } 663 664 /*ARGSUSED*/ 665 static int 666 dt_probe_desc(dtrace_hdl_t *dtp, const dtrace_probedesc_t *pdp, void *arg) 667 { 668 if (((dtrace_probedesc_t *)arg)->dtpd_id == DTRACE_IDNONE) { 669 bcopy(pdp, arg, sizeof (dtrace_probedesc_t)); 670 return (0); 671 } 672 673 return (1); 674 } 675 676 dt_probe_t * 677 dt_probe_info(dtrace_hdl_t *dtp, 678 const dtrace_probedesc_t *pdp, dtrace_probeinfo_t *pip) 679 { 680 int m_is_glob = pdp->dtpd_mod[0] == '\0' || strisglob(pdp->dtpd_mod); 681 int f_is_glob = pdp->dtpd_func[0] == '\0' || strisglob(pdp->dtpd_func); 682 int n_is_glob = pdp->dtpd_name[0] == '\0' || strisglob(pdp->dtpd_name); 683 684 dt_probe_t *prp = NULL; 685 const dtrace_pattr_t *pap; 686 dt_provider_t *pvp; 687 dt_ident_t *idp; 688 689 /* 690 * Attempt to lookup the probe in our existing cache for this provider. 691 * If none is found and an explicit probe ID was specified, discover 692 * that specific probe and cache its description and arguments. 693 */ 694 if ((pvp = dt_provider_lookup(dtp, pdp->dtpd_provider)) != NULL) { 695 size_t keylen = dt_probe_keylen(pdp); 696 char *key = dt_probe_key(pdp, alloca(keylen)); 697 698 if ((idp = dt_idhash_lookup(pvp->pv_probes, key)) != NULL) 699 prp = idp->di_data; 700 else if (pdp->dtpd_id != DTRACE_IDNONE) 701 prp = dt_probe_discover(pvp, pdp); 702 } 703 704 /* 705 * If no probe was found in our cache, convert the caller's partial 706 * probe description into a fully-formed matching probe description by 707 * iterating over up to at most two probes that match 'pdp'. We then 708 * call dt_probe_discover() on the resulting probe identifier. 709 */ 710 if (prp == NULL) { 711 dtrace_probedesc_t pd; 712 int m; 713 714 bzero(&pd, sizeof (pd)); 715 pd.dtpd_id = DTRACE_IDNONE; 716 717 /* 718 * Call dtrace_probe_iter() to find matching probes. Our 719 * dt_probe_desc() callback will produce the following results: 720 * 721 * m < 0 dtrace_probe_iter() found zero matches (or failed). 722 * m > 0 dtrace_probe_iter() found more than one match. 723 * m = 0 dtrace_probe_iter() found exactly one match. 724 */ 725 if ((m = dtrace_probe_iter(dtp, pdp, dt_probe_desc, &pd)) < 0) 726 return (NULL); /* dt_errno is set for us */ 727 728 if ((pvp = dt_provider_lookup(dtp, pd.dtpd_provider)) == NULL) 729 return (NULL); /* dt_errno is set for us */ 730 731 /* 732 * If more than one probe was matched, then do not report probe 733 * information if either of the following conditions is true: 734 * 735 * (a) The Arguments Data stability of the matched provider is 736 * less than Evolving. 737 * 738 * (b) Any description component that is at least Evolving is 739 * empty or is specified using a globbing expression. 740 * 741 * These conditions imply that providers that provide Evolving 742 * or better Arguments Data stability must guarantee that all 743 * probes with identical field names in a field of Evolving or 744 * better Name stability have identical argument signatures. 745 */ 746 if (m > 0) { 747 if (pvp->pv_desc.dtvd_attr.dtpa_args.dtat_data < 748 DTRACE_STABILITY_EVOLVING) { 749 (void) dt_set_errno(dtp, EDT_UNSTABLE); 750 return (NULL); 751 } 752 753 754 if (pvp->pv_desc.dtvd_attr.dtpa_mod.dtat_name >= 755 DTRACE_STABILITY_EVOLVING && m_is_glob) { 756 (void) dt_set_errno(dtp, EDT_UNSTABLE); 757 return (NULL); 758 } 759 760 if (pvp->pv_desc.dtvd_attr.dtpa_func.dtat_name >= 761 DTRACE_STABILITY_EVOLVING && f_is_glob) { 762 (void) dt_set_errno(dtp, EDT_UNSTABLE); 763 return (NULL); 764 } 765 766 if (pvp->pv_desc.dtvd_attr.dtpa_name.dtat_name >= 767 DTRACE_STABILITY_EVOLVING && n_is_glob) { 768 (void) dt_set_errno(dtp, EDT_UNSTABLE); 769 return (NULL); 770 } 771 } 772 773 /* 774 * If we matched a probe exported by dtrace(7D), then discover 775 * the real attributes. Otherwise grab the static declaration. 776 */ 777 if (pd.dtpd_id != DTRACE_IDNONE) 778 prp = dt_probe_discover(pvp, &pd); 779 else 780 prp = dt_probe_lookup(pvp, pd.dtpd_name); 781 782 if (prp == NULL) 783 return (NULL); /* dt_errno is set for us */ 784 } 785 786 assert(pvp != NULL && prp != NULL); 787 788 /* 789 * Compute the probe description attributes by taking the minimum of 790 * the attributes of the specified fields. If no provider is specified 791 * or a glob pattern is used for the provider, use Unstable attributes. 792 */ 793 if (pdp->dtpd_provider[0] == '\0' || strisglob(pdp->dtpd_provider)) 794 pap = &_dtrace_prvdesc; 795 else 796 pap = &pvp->pv_desc.dtvd_attr; 797 798 pip->dtp_attr = pap->dtpa_provider; 799 800 if (!m_is_glob) 801 pip->dtp_attr = dt_attr_min(pip->dtp_attr, pap->dtpa_mod); 802 if (!f_is_glob) 803 pip->dtp_attr = dt_attr_min(pip->dtp_attr, pap->dtpa_func); 804 if (!n_is_glob) 805 pip->dtp_attr = dt_attr_min(pip->dtp_attr, pap->dtpa_name); 806 807 pip->dtp_arga = pap->dtpa_args; 808 pip->dtp_argv = prp->pr_argv; 809 pip->dtp_argc = prp->pr_argc; 810 811 return (prp); 812 } 813 814 int 815 dtrace_probe_info(dtrace_hdl_t *dtp, 816 const dtrace_probedesc_t *pdp, dtrace_probeinfo_t *pip) 817 { 818 return (dt_probe_info(dtp, pdp, pip) != NULL ? 0 : -1); 819 } 820 821 /*ARGSUSED*/ 822 static int 823 dt_probe_iter(dt_idhash_t *ihp, dt_ident_t *idp, dt_probe_iter_t *pit) 824 { 825 const dt_probe_t *prp = idp->di_data; 826 827 if (!dt_gmatch(prp->pr_name, pit->pit_pat)) 828 return (0); /* continue on and examine next probe in hash */ 829 830 (void) strlcpy(pit->pit_desc.dtpd_name, prp->pr_name, DTRACE_NAMELEN); 831 pit->pit_desc.dtpd_id = idp->di_id; 832 pit->pit_matches++; 833 834 return (pit->pit_func(pit->pit_hdl, &pit->pit_desc, pit->pit_arg)); 835 } 836 837 int 838 dtrace_probe_iter(dtrace_hdl_t *dtp, 839 const dtrace_probedesc_t *pdp, dtrace_probe_f *func, void *arg) 840 { 841 const char *provider = pdp ? pdp->dtpd_provider : NULL; 842 dtrace_id_t id = DTRACE_IDNONE; 843 844 dtrace_probedesc_t pd; 845 dt_probe_iter_t pit; 846 int cmd, rv; 847 848 bzero(&pit, sizeof (pit)); 849 pit.pit_hdl = dtp; 850 pit.pit_func = func; 851 pit.pit_arg = arg; 852 pit.pit_pat = pdp ? pdp->dtpd_name : NULL; 853 854 for (pit.pit_pvp = dt_list_next(&dtp->dt_provlist); 855 pit.pit_pvp != NULL; pit.pit_pvp = dt_list_next(pit.pit_pvp)) { 856 857 if (pit.pit_pvp->pv_flags & DT_PROVIDER_IMPL) 858 continue; /* we'll get these later using dt_ioctl() */ 859 860 if (!dt_gmatch(pit.pit_pvp->pv_desc.dtvd_name, provider)) 861 continue; 862 863 (void) strlcpy(pit.pit_desc.dtpd_provider, 864 pit.pit_pvp->pv_desc.dtvd_name, DTRACE_PROVNAMELEN); 865 866 if ((rv = dt_idhash_iter(pit.pit_pvp->pv_probes, 867 (dt_idhash_f *)dt_probe_iter, &pit)) != 0) 868 return (rv); 869 } 870 871 if (pdp != NULL) 872 cmd = DTRACEIOC_PROBEMATCH; 873 else 874 cmd = DTRACEIOC_PROBES; 875 876 for (;;) { 877 if (pdp != NULL) 878 bcopy(pdp, &pd, sizeof (pd)); 879 880 pd.dtpd_id = id; 881 882 if (dt_ioctl(dtp, cmd, &pd) != 0) 883 break; 884 else if ((rv = func(dtp, &pd, arg)) != 0) 885 return (rv); 886 887 pit.pit_matches++; 888 id = pd.dtpd_id + 1; 889 } 890 891 switch (errno) { 892 case ESRCH: 893 case EBADF: 894 return (pit.pit_matches ? 0 : dt_set_errno(dtp, EDT_NOPROBE)); 895 case EINVAL: 896 return (dt_set_errno(dtp, EDT_BADPGLOB)); 897 default: 898 return (dt_set_errno(dtp, errno)); 899 } 900 } 901
Indexes created Thu Jun 11 00:25:07 UTC 2026