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 #include <assert.h> 28 #include <strings.h> 29 #include <stdlib.h> 30 #include <stdio.h> 31 #include <errno.h> 32 #include <ctype.h> 33 #if defined(sun) 34 #include <alloca.h> 35 #endif 36 #include <libgen.h> 37 #include <stddef.h> 38 39 #include <dt_impl.h> 40 #include <dt_program.h> 41 #include <dt_pid.h> 42 #include <dt_string.h> 43 #if !defined(sun) 44 #include <libproc_compat.h> 45 #endif 46 47 typedef struct dt_pid_probe { 48 dtrace_hdl_t *dpp_dtp; 49 dt_pcb_t *dpp_pcb; 50 dt_proc_t *dpp_dpr; 51 struct ps_prochandle *dpp_pr; 52 const char *dpp_mod; 53 char *dpp_func; 54 const char *dpp_name; 55 const char *dpp_obj; 56 uintptr_t dpp_pc; 57 size_t dpp_size; 58 Lmid_t dpp_lmid; 59 uint_t dpp_nmatches; 60 uint64_t dpp_stret[4]; 61 GElf_Sym dpp_last; 62 uint_t dpp_last_taken; 63 } dt_pid_probe_t; 64 65 /* 66 * Compose the lmid and object name into the canonical representation. We 67 * omit the lmid for the default link map for convenience. 68 */ 69 static void 70 dt_pid_objname(char *buf, size_t len, Lmid_t lmid, const char *obj) 71 { 72 #if defined(sun) 73 if (lmid == LM_ID_BASE) 74 (void) strncpy(buf, obj, len); 75 else 76 (void) snprintf(buf, len, "LM%lx`%s", lmid, obj); 77 #else 78 (void) strncpy(buf, obj, len); 79 #endif 80 } 81 82 static int 83 dt_pid_error(dtrace_hdl_t *dtp, dt_pcb_t *pcb, dt_proc_t *dpr, 84 fasttrap_probe_spec_t *ftp, dt_errtag_t tag, const char *fmt, ...) 85 { 86 va_list ap; 87 int len; 88 89 if (ftp != NULL) 90 dt_free(dtp, ftp); 91 92 va_start(ap, fmt); 93 if (pcb == NULL) { 94 assert(dpr != NULL); 95 len = vsnprintf(dpr->dpr_errmsg, sizeof (dpr->dpr_errmsg), 96 fmt, ap); 97 assert(len >= 2); 98 if (dpr->dpr_errmsg[len - 2] == '\n') 99 dpr->dpr_errmsg[len - 2] = '\0'; 100 } else { 101 dt_set_errmsg(dtp, dt_errtag(tag), pcb->pcb_region, 102 pcb->pcb_filetag, pcb->pcb_fileptr ? yylineno : 0, fmt, ap); 103 } 104 va_end(ap); 105 106 return (1); 107 } 108 109 static int 110 dt_pid_per_sym(dt_pid_probe_t *pp, const GElf_Sym *symp, const char *func) 111 { 112 dtrace_hdl_t *dtp = pp->dpp_dtp; 113 dt_pcb_t *pcb = pp->dpp_pcb; 114 dt_proc_t *dpr = pp->dpp_dpr; 115 fasttrap_probe_spec_t *ftp; 116 uint64_t off; 117 char *end; 118 uint_t nmatches = 0; 119 ulong_t sz; 120 int glob, err; 121 int isdash = strcmp("-", func) == 0; 122 pid_t pid; 123 124 #if defined(sun) 125 pid = Pstatus(pp->dpp_pr)->pr_pid; 126 #else 127 pid = proc_getpid(pp->dpp_pr); 128 #endif 129 130 dt_dprintf("creating probe pid%d:%s:%s:%s\n", (int)pid, pp->dpp_obj, 131 func, pp->dpp_name); 132 133 sz = sizeof (fasttrap_probe_spec_t) + (isdash ? 4 : 134 (symp->st_size - 1) * sizeof (ftp->ftps_offs[0])); 135 136 if ((ftp = dt_alloc(dtp, sz)) == NULL) { 137 dt_dprintf("proc_per_sym: dt_alloc(%lu) failed\n", sz); 138 return (1); /* errno is set for us */ 139 } 140 141 ftp->ftps_pid = pid; 142 (void) strncpy(ftp->ftps_func, func, sizeof (ftp->ftps_func)); 143 144 dt_pid_objname(ftp->ftps_mod, sizeof (ftp->ftps_mod), pp->dpp_lmid, 145 pp->dpp_obj); 146 147 if (!isdash && gmatch("return", pp->dpp_name)) { 148 if (dt_pid_create_return_probe(pp->dpp_pr, dtp, ftp, symp, 149 pp->dpp_stret) < 0) { 150 return (dt_pid_error(dtp, pcb, dpr, ftp, 151 D_PROC_CREATEFAIL, "failed to create return probe " 152 "for '%s': %s", func, 153 dtrace_errmsg(dtp, dtrace_errno(dtp)))); 154 } 155 156 nmatches++; 157 } 158 159 if (!isdash && gmatch("entry", pp->dpp_name)) { 160 if (dt_pid_create_entry_probe(pp->dpp_pr, dtp, ftp, symp) < 0) { 161 return (dt_pid_error(dtp, pcb, dpr, ftp, 162 D_PROC_CREATEFAIL, "failed to create entry probe " 163 "for '%s': %s", func, 164 dtrace_errmsg(dtp, dtrace_errno(dtp)))); 165 } 166 167 nmatches++; 168 } 169 170 glob = strisglob(pp->dpp_name); 171 if (!glob && nmatches == 0) { 172 off = strtoull(pp->dpp_name, &end, 16); 173 if (*end != '\0') { 174 return (dt_pid_error(dtp, pcb, dpr, ftp, D_PROC_NAME, 175 "'%s' is an invalid probe name", pp->dpp_name)); 176 } 177 178 if (off >= symp->st_size) { 179 return (dt_pid_error(dtp, pcb, dpr, ftp, D_PROC_OFF, 180 "offset 0x%llx outside of function '%s'", 181 (u_longlong_t)off, func)); 182 } 183 184 err = dt_pid_create_offset_probe(pp->dpp_pr, pp->dpp_dtp, ftp, 185 symp, off); 186 187 if (err == DT_PROC_ERR) { 188 return (dt_pid_error(dtp, pcb, dpr, ftp, 189 D_PROC_CREATEFAIL, "failed to create probe at " 190 "'%s+0x%llx': %s", func, (u_longlong_t)off, 191 dtrace_errmsg(dtp, dtrace_errno(dtp)))); 192 } 193 194 if (err == DT_PROC_ALIGN) { 195 return (dt_pid_error(dtp, pcb, dpr, ftp, D_PROC_ALIGN, 196 "offset 0x%llx is not aligned on an instruction", 197 (u_longlong_t)off)); 198 } 199 200 nmatches++; 201 202 } else if (glob && !isdash) { 203 if (dt_pid_create_glob_offset_probes(pp->dpp_pr, 204 pp->dpp_dtp, ftp, symp, pp->dpp_name) < 0) { 205 return (dt_pid_error(dtp, pcb, dpr, ftp, 206 D_PROC_CREATEFAIL, 207 "failed to create offset probes in '%s': %s", func, 208 dtrace_errmsg(dtp, dtrace_errno(dtp)))); 209 } 210 211 nmatches++; 212 } 213 214 pp->dpp_nmatches += nmatches; 215 216 dt_free(dtp, ftp); 217 218 return (0); 219 } 220 221 static int 222 dt_pid_sym_filt(void *arg, const GElf_Sym *symp, const char *func) 223 { 224 dt_pid_probe_t *pp = arg; 225 226 if (symp->st_shndx == SHN_UNDEF) 227 return (0); 228 229 if (symp->st_size == 0) { 230 dt_dprintf("st_size of %s is zero\n", func); 231 return (0); 232 } 233 234 if (pp->dpp_last_taken == 0 || 235 symp->st_value != pp->dpp_last.st_value || 236 symp->st_size != pp->dpp_last.st_size) { 237 /* 238 * Due to 4524008, _init and _fini may have a bloated st_size. 239 * While this bug has been fixed for a while, old binaries 240 * may exist that still exhibit this problem. As a result, we 241 * don't match _init and _fini though we allow users to 242 * specify them explicitly. 243 */ 244 if (strcmp(func, "_init") == 0 || strcmp(func, "_fini") == 0) 245 return (0); 246 247 if ((pp->dpp_last_taken = gmatch(func, pp->dpp_func)) != 0) { 248 pp->dpp_last = *symp; 249 return (dt_pid_per_sym(pp, symp, func)); 250 } 251 } 252 253 return (0); 254 } 255 256 static int 257 dt_pid_per_mod(void *arg, const prmap_t *pmp, const char *obj) 258 { 259 dt_pid_probe_t *pp = arg; 260 dtrace_hdl_t *dtp = pp->dpp_dtp; 261 dt_pcb_t *pcb = pp->dpp_pcb; 262 dt_proc_t *dpr = pp->dpp_dpr; 263 GElf_Sym sym; 264 265 if (obj == NULL) 266 return (0); 267 268 #if defined(sun) 269 (void) Plmid(pp->dpp_pr, pmp->pr_vaddr, &pp->dpp_lmid); 270 #endif 271 272 273 if ((pp->dpp_obj = strrchr(obj, '/')) == NULL) 274 pp->dpp_obj = obj; 275 else 276 pp->dpp_obj++; 277 #if defined(sun) 278 if (Pxlookup_by_name(pp->dpp_pr, pp->dpp_lmid, obj, ".stret1", &sym, 279 NULL) == 0) 280 pp->dpp_stret[0] = sym.st_value; 281 else 282 pp->dpp_stret[0] = 0; 283 284 if (Pxlookup_by_name(pp->dpp_pr, pp->dpp_lmid, obj, ".stret2", &sym, 285 NULL) == 0) 286 pp->dpp_stret[1] = sym.st_value; 287 else 288 pp->dpp_stret[1] = 0; 289 290 if (Pxlookup_by_name(pp->dpp_pr, pp->dpp_lmid, obj, ".stret4", &sym, 291 NULL) == 0) 292 pp->dpp_stret[2] = sym.st_value; 293 else 294 pp->dpp_stret[2] = 0; 295 296 if (Pxlookup_by_name(pp->dpp_pr, pp->dpp_lmid, obj, ".stret8", &sym, 297 NULL) == 0) 298 pp->dpp_stret[3] = sym.st_value; 299 else 300 pp->dpp_stret[3] = 0; 301 #else 302 pp->dpp_stret[0] = 0; 303 pp->dpp_stret[1] = 0; 304 pp->dpp_stret[2] = 0; 305 pp->dpp_stret[3] = 0; 306 #endif 307 308 dt_dprintf("%s stret %llx %llx %llx %llx\n", obj, 309 (u_longlong_t)pp->dpp_stret[0], (u_longlong_t)pp->dpp_stret[1], 310 (u_longlong_t)pp->dpp_stret[2], (u_longlong_t)pp->dpp_stret[3]); 311 312 /* 313 * If pp->dpp_func contains any globbing meta-characters, we need 314 * to iterate over the symbol table and compare each function name 315 * against the pattern. 316 */ 317 if (!strisglob(pp->dpp_func)) { 318 /* 319 * If we fail to lookup the symbol, try interpreting the 320 * function as the special "-" function that indicates that the 321 * probe name should be interpreted as a absolute virtual 322 * address. If that fails and we were matching a specific 323 * function in a specific module, report the error, otherwise 324 * just fail silently in the hopes that some other object will 325 * contain the desired symbol. 326 */ 327 if (Pxlookup_by_name(pp->dpp_pr, pp->dpp_lmid, obj, 328 pp->dpp_func, &sym, NULL) != 0) { 329 if (strcmp("-", pp->dpp_func) == 0) { 330 sym.st_name = 0; 331 sym.st_info = 332 GELF_ST_INFO(STB_LOCAL, STT_FUNC); 333 sym.st_other = 0; 334 sym.st_value = 0; 335 #if defined(sun) 336 sym.st_size = Pstatus(pp->dpp_pr)->pr_dmodel == 337 PR_MODEL_ILP32 ? -1U : -1ULL; 338 #else 339 sym.st_size = ~((Elf64_Xword) 0); 340 #endif 341 342 } else if (!strisglob(pp->dpp_mod)) { 343 return (dt_pid_error(dtp, pcb, dpr, NULL, 344 D_PROC_FUNC, 345 "failed to lookup '%s' in module '%s'", 346 pp->dpp_func, pp->dpp_mod)); 347 } else { 348 return (0); 349 } 350 } 351 352 /* 353 * Only match defined functions of non-zero size. 354 */ 355 if (GELF_ST_TYPE(sym.st_info) != STT_FUNC || 356 sym.st_shndx == SHN_UNDEF || sym.st_size == 0) 357 return (0); 358 359 /* 360 * We don't instrument PLTs -- they're dynamically rewritten, 361 * and, so, inherently dicey to instrument. 362 */ 363 #ifdef DOODAD 364 if (Ppltdest(pp->dpp_pr, sym.st_value) != NULL) 365 return (0); 366 #endif 367 368 (void) Plookup_by_addr(pp->dpp_pr, sym.st_value, pp->dpp_func, 369 DTRACE_FUNCNAMELEN, &sym); 370 371 return (dt_pid_per_sym(pp, &sym, pp->dpp_func)); 372 } else { 373 uint_t nmatches = pp->dpp_nmatches; 374 375 if (Psymbol_iter_by_addr(pp->dpp_pr, obj, PR_SYMTAB, 376 BIND_ANY | TYPE_FUNC, dt_pid_sym_filt, pp) == 1) 377 return (1); 378 379 if (nmatches == pp->dpp_nmatches) { 380 /* 381 * If we didn't match anything in the PR_SYMTAB, try 382 * the PR_DYNSYM. 383 */ 384 if (Psymbol_iter_by_addr(pp->dpp_pr, obj, PR_DYNSYM, 385 BIND_ANY | TYPE_FUNC, dt_pid_sym_filt, pp) == 1) 386 return (1); 387 } 388 } 389 390 return (0); 391 } 392 393 static int 394 dt_pid_mod_filt(void *arg, const prmap_t *pmp, const char *obj) 395 { 396 char name[DTRACE_MODNAMELEN]; 397 dt_pid_probe_t *pp = arg; 398 399 if (gmatch(obj, pp->dpp_mod)) 400 return (dt_pid_per_mod(pp, pmp, obj)); 401 402 #if defined(sun) 403 (void) Plmid(pp->dpp_pr, pmp->pr_vaddr, &pp->dpp_lmid); 404 #else 405 pp->dpp_lmid = 0; 406 #endif 407 408 if ((pp->dpp_obj = strrchr(obj, '/')) == NULL) 409 pp->dpp_obj = obj; 410 else 411 pp->dpp_obj++; 412 413 if (gmatch(pp->dpp_obj, pp->dpp_mod)) 414 return (dt_pid_per_mod(pp, pmp, obj)); 415 416 #if defined(sun) 417 (void) Plmid(pp->dpp_pr, pmp->pr_vaddr, &pp->dpp_lmid); 418 #endif 419 420 dt_pid_objname(name, sizeof (name), pp->dpp_lmid, pp->dpp_obj); 421 422 if (gmatch(name, pp->dpp_mod)) 423 return (dt_pid_per_mod(pp, pmp, obj)); 424 425 return (0); 426 } 427 428 static const prmap_t * 429 dt_pid_fix_mod(dtrace_probedesc_t *pdp, struct ps_prochandle *P) 430 { 431 char m[MAXPATHLEN]; 432 #if defined(sun) 433 Lmid_t lmid = PR_LMID_EVERY; 434 #else 435 Lmid_t lmid = 0; 436 #endif 437 const char *obj; 438 const prmap_t *pmp; 439 440 #if defined(sun) 441 /* 442 * Pick apart the link map from the library name. 443 */ 444 if (strchr(pdp->dtpd_mod, '`') != NULL) { 445 char *end; 446 447 if (strncmp(pdp->dtpd_mod, "LM", 2) != 0 || 448 !isdigit(pdp->dtpd_mod[2])) 449 return (NULL); 450 451 lmid = strtoul(&pdp->dtpd_mod[2], &end, 16); 452 453 obj = end + 1; 454 455 if (*end != '`' || strchr(obj, '`') != NULL) 456 return (NULL); 457 458 } else { 459 obj = pdp->dtpd_mod; 460 } 461 #else 462 obj = pdp->dtpd_mod; 463 #endif 464 465 if ((pmp = Plmid_to_map(P, lmid, obj)) == NULL) 466 return (NULL); 467 468 #if defined(sun) 469 (void) Pobjname(P, pmp->pr_vaddr, m, sizeof (m)); 470 if ((obj = strrchr(m, '/')) == NULL) 471 obj = &m[0]; 472 else 473 obj++; 474 475 (void) Plmid(P, pmp->pr_vaddr, &lmid); 476 #endif 477 478 dt_pid_objname(pdp->dtpd_mod, sizeof (pdp->dtpd_mod), lmid, obj); 479 480 return (pmp); 481 } 482 483 484 static int 485 dt_pid_create_pid_probes(dtrace_probedesc_t *pdp, dtrace_hdl_t *dtp, 486 dt_pcb_t *pcb, dt_proc_t *dpr) 487 { 488 dt_pid_probe_t pp; 489 int ret = 0; 490 491 pp.dpp_dtp = dtp; 492 pp.dpp_dpr = dpr; 493 pp.dpp_pr = dpr->dpr_proc; 494 pp.dpp_pcb = pcb; 495 496 #ifdef DOODAD 497 /* 498 * We can only trace dynamically-linked executables (since we've 499 * hidden some magic in ld.so.1 as well as libc.so.1). 500 */ 501 if (Pname_to_map(pp.dpp_pr, PR_OBJ_LDSO) == NULL) { 502 return (dt_pid_error(dtp, pcb, dpr, NULL, D_PROC_DYN, 503 "process %s is not a dynamically-linked executable", 504 &pdp->dtpd_provider[3])); 505 } 506 #endif 507 508 pp.dpp_mod = pdp->dtpd_mod[0] != '\0' ? pdp->dtpd_mod : "*"; 509 pp.dpp_func = pdp->dtpd_func[0] != '\0' ? pdp->dtpd_func : "*"; 510 pp.dpp_name = pdp->dtpd_name[0] != '\0' ? pdp->dtpd_name : "*"; 511 pp.dpp_last_taken = 0; 512 513 if (strcmp(pp.dpp_func, "-") == 0) { 514 const prmap_t *aout, *pmp; 515 516 if (pdp->dtpd_mod[0] == '\0') { 517 pp.dpp_mod = pdp->dtpd_mod; 518 (void) strcpy(pdp->dtpd_mod, "a.out"); 519 } else if (strisglob(pp.dpp_mod) || 520 (aout = Pname_to_map(pp.dpp_pr, "a.out")) == NULL || 521 (pmp = Pname_to_map(pp.dpp_pr, pp.dpp_mod)) == NULL || 522 aout->pr_vaddr != pmp->pr_vaddr) { 523 return (dt_pid_error(dtp, pcb, dpr, NULL, D_PROC_LIB, 524 "only the a.out module is valid with the " 525 "'-' function")); 526 } 527 528 if (strisglob(pp.dpp_name)) { 529 return (dt_pid_error(dtp, pcb, dpr, NULL, D_PROC_NAME, 530 "only individual addresses may be specified " 531 "with the '-' function")); 532 } 533 } 534 535 /* 536 * If pp.dpp_mod contains any globbing meta-characters, we need 537 * to iterate over each module and compare its name against the 538 * pattern. An empty module name is treated as '*'. 539 */ 540 if (strisglob(pp.dpp_mod)) { 541 ret = Pobject_iter(pp.dpp_pr, dt_pid_mod_filt, &pp); 542 } else { 543 const prmap_t *pmp; 544 char *obj; 545 546 /* 547 * If we can't find a matching module, don't sweat it -- either 548 * we'll fail the enabling because the probes don't exist or 549 * we'll wait for that module to come along. 550 */ 551 if ((pmp = dt_pid_fix_mod(pdp, pp.dpp_pr)) != NULL) { 552 if ((obj = strchr(pdp->dtpd_mod, '`')) == NULL) 553 obj = pdp->dtpd_mod; 554 else 555 obj++; 556 557 ret = dt_pid_per_mod(&pp, pmp, obj); 558 } 559 } 560 561 return (ret); 562 } 563 564 static int 565 dt_pid_usdt_mapping(void *data, const prmap_t *pmp, const char *oname) 566 { 567 struct ps_prochandle *P = data; 568 GElf_Sym sym; 569 #if defined(sun) 570 prsyminfo_t sip; 571 #endif 572 dof_helper_t dh; 573 GElf_Half e_type; 574 const char *mname; 575 const char *syms[] = { "___SUNW_dof", "__SUNW_dof" }; 576 int i, fd = -1; 577 578 /* 579 * The symbol ___SUNW_dof is for lazy-loaded DOF sections, and 580 * __SUNW_dof is for actively-loaded DOF sections. We try to force 581 * in both types of DOF section since the process may not yet have 582 * run the code to instantiate these providers. 583 */ 584 for (i = 0; i < 2; i++) { 585 if (Pxlookup_by_name(P, PR_LMID_EVERY, oname, syms[i], &sym, 586 &sip) != 0) { 587 continue; 588 } 589 590 if ((mname = strrchr(oname, '/')) == NULL) 591 mname = oname; 592 else 593 mname++; 594 595 dt_dprintf("lookup of %s succeeded for %s\n", syms[i], mname); 596 597 if (Pread(P, &e_type, sizeof (e_type), pmp->pr_vaddr + 598 offsetof(Elf64_Ehdr, e_type)) != sizeof (e_type)) { 599 dt_dprintf("read of ELF header failed"); 600 continue; 601 } 602 603 dh.dofhp_dof = sym.st_value; 604 dh.dofhp_addr = (e_type == ET_EXEC) ? 0 : pmp->pr_vaddr; 605 606 dt_pid_objname(dh.dofhp_mod, sizeof (dh.dofhp_mod), 607 #if defined(sun) 608 sip.prs_lmid, mname); 609 #else 610 0, mname); 611 #endif 612 613 #if defined(sun) 614 if (fd == -1 && 615 (fd = pr_open(P, "/dev/dtrace/helper", O_RDWR, 0)) < 0) { 616 dt_dprintf("pr_open of helper device failed: %s\n", 617 strerror(errno)); 618 return (-1); /* errno is set for us */ 619 } 620 621 if (pr_ioctl(P, fd, DTRACEHIOC_ADDDOF, &dh, sizeof (dh)) < 0) 622 dt_dprintf("DOF was rejected for %s\n", dh.dofhp_mod); 623 #endif 624 } 625 626 #if defined(sun) 627 if (fd != -1) 628 (void) pr_close(P, fd); 629 #endif 630 631 return (0); 632 } 633 634 static int 635 dt_pid_create_usdt_probes(dtrace_probedesc_t *pdp, dtrace_hdl_t *dtp, 636 dt_pcb_t *pcb, dt_proc_t *dpr) 637 { 638 struct ps_prochandle *P = dpr->dpr_proc; 639 int ret = 0; 640 641 assert(DT_MUTEX_HELD(&dpr->dpr_lock)); 642 #if defined(sun) 643 (void) Pupdate_maps(P); 644 if (Pobject_iter(P, dt_pid_usdt_mapping, P) != 0) { 645 ret = -1; 646 (void) dt_pid_error(dtp, pcb, dpr, NULL, D_PROC_USDT, 647 "failed to instantiate probes for pid %d: %s", 648 #if defined(sun) 649 (int)Pstatus(P)->pr_pid, strerror(errno)); 650 #else 651 (int)proc_getpid(P), strerror(errno)); 652 #endif 653 } 654 #else 655 ret = 0; 656 #endif 657 658 /* 659 * Put the module name in its canonical form. 660 */ 661 (void) dt_pid_fix_mod(pdp, P); 662 663 return (ret); 664 } 665 666 static pid_t 667 dt_pid_get_pid(dtrace_probedesc_t *pdp, dtrace_hdl_t *dtp, dt_pcb_t *pcb, 668 dt_proc_t *dpr) 669 { 670 pid_t pid; 671 char *c, *last = NULL, *end; 672 673 for (c = &pdp->dtpd_provider[0]; *c != '\0'; c++) { 674 if (!isdigit(*c)) 675 last = c; 676 } 677 678 if (last == NULL || (*(++last) == '\0')) { 679 (void) dt_pid_error(dtp, pcb, dpr, NULL, D_PROC_BADPROV, 680 "'%s' is not a valid provider", pdp->dtpd_provider); 681 return (-1); 682 } 683 684 errno = 0; 685 pid = strtol(last, &end, 10); 686 687 if (errno != 0 || end == last || end[0] != '\0' || pid <= 0) { 688 (void) dt_pid_error(dtp, pcb, dpr, NULL, D_PROC_BADPID, 689 "'%s' does not contain a valid pid", pdp->dtpd_provider); 690 return (-1); 691 } 692 693 return (pid); 694 } 695 696 int 697 dt_pid_create_probes(dtrace_probedesc_t *pdp, dtrace_hdl_t *dtp, dt_pcb_t *pcb) 698 { 699 char provname[DTRACE_PROVNAMELEN]; 700 struct ps_prochandle *P; 701 dt_proc_t *dpr; 702 pid_t pid; 703 int err = 0; 704 705 assert(pcb != NULL); 706 707 if ((pid = dt_pid_get_pid(pdp, dtp, pcb, NULL)) == -1) 708 return (-1); 709 710 if (dtp->dt_ftfd == -1) { 711 if (dtp->dt_fterr == ENOENT) { 712 (void) dt_pid_error(dtp, pcb, NULL, NULL, D_PROC_NODEV, 713 "pid provider is not installed on this system"); 714 } else { 715 (void) dt_pid_error(dtp, pcb, NULL, NULL, D_PROC_NODEV, 716 "pid provider is not available: %s", 717 strerror(dtp->dt_fterr)); 718 } 719 720 return (-1); 721 } 722 723 (void) snprintf(provname, sizeof (provname), "pid%d", (int)pid); 724 725 if (gmatch(provname, pdp->dtpd_provider) != 0) { 726 if ((P = dt_proc_grab(dtp, pid, PGRAB_RDONLY | PGRAB_FORCE, 727 0)) == NULL) { 728 (void) dt_pid_error(dtp, pcb, NULL, NULL, D_PROC_GRAB, 729 "failed to grab process %d", (int)pid); 730 return (-1); 731 } 732 733 dpr = dt_proc_lookup(dtp, P, 0); 734 assert(dpr != NULL); 735 (void) pthread_mutex_lock(&dpr->dpr_lock); 736 737 if ((err = dt_pid_create_pid_probes(pdp, dtp, pcb, dpr)) == 0) { 738 /* 739 * Alert other retained enablings which may match 740 * against the newly created probes. 741 */ 742 (void) dt_ioctl(dtp, DTRACEIOC_ENABLE, NULL); 743 } 744 745 (void) pthread_mutex_unlock(&dpr->dpr_lock); 746 dt_proc_release(dtp, P); 747 } 748 749 /* 750 * If it's not strictly a pid provider, we might match a USDT provider. 751 */ 752 if (strcmp(provname, pdp->dtpd_provider) != 0) { 753 if ((P = dt_proc_grab(dtp, pid, 0, 1)) == NULL) { 754 (void) dt_pid_error(dtp, pcb, NULL, NULL, D_PROC_GRAB, 755 "failed to grab process %d", (int)pid); 756 return (-1); 757 } 758 759 dpr = dt_proc_lookup(dtp, P, 0); 760 assert(dpr != NULL); 761 (void) pthread_mutex_lock(&dpr->dpr_lock); 762 763 if (!dpr->dpr_usdt) { 764 err = dt_pid_create_usdt_probes(pdp, dtp, pcb, dpr); 765 dpr->dpr_usdt = B_TRUE; 766 } 767 768 (void) pthread_mutex_unlock(&dpr->dpr_lock); 769 dt_proc_release(dtp, P); 770 } 771 772 return (err ? -1 : 0); 773 } 774 775 int 776 dt_pid_create_probes_module(dtrace_hdl_t *dtp, dt_proc_t *dpr) 777 { 778 dtrace_enable_io_t args; 779 dtrace_prog_t *pgp; 780 dt_stmt_t *stp; 781 dtrace_probedesc_t *pdp, pd; 782 pid_t pid; 783 int ret = 0, found = B_FALSE; 784 char provname[DTRACE_PROVNAMELEN]; 785 786 (void) snprintf(provname, sizeof (provname), "pid%d", 787 (int)dpr->dpr_pid); 788 789 for (pgp = dt_list_next(&dtp->dt_programs); pgp != NULL; 790 pgp = dt_list_next(pgp)) { 791 792 for (stp = dt_list_next(&pgp->dp_stmts); stp != NULL; 793 stp = dt_list_next(stp)) { 794 795 pdp = &stp->ds_desc->dtsd_ecbdesc->dted_probe; 796 pid = dt_pid_get_pid(pdp, dtp, NULL, dpr); 797 if (pid != dpr->dpr_pid) 798 continue; 799 800 found = B_TRUE; 801 802 pd = *pdp; 803 804 if (gmatch(provname, pdp->dtpd_provider) != 0 && 805 dt_pid_create_pid_probes(&pd, dtp, NULL, dpr) != 0) 806 ret = 1; 807 808 /* 809 * If it's not strictly a pid provider, we might match 810 * a USDT provider. 811 */ 812 if (strcmp(provname, pdp->dtpd_provider) != 0 && 813 dt_pid_create_usdt_probes(&pd, dtp, NULL, dpr) != 0) 814 ret = 1; 815 } 816 } 817 818 if (found) { 819 /* 820 * Give DTrace a shot to the ribs to get it to check 821 * out the newly created probes. 822 */ 823 args.dof = NULL; 824 args.n_matched = 0; 825 (void) dt_ioctl(dtp, DTRACEIOC_ENABLE, &args); 826 } 827 828 return (ret); 829 } 830