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