17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate * CDDL HEADER START
37c478bd9Sstevel@tonic-gate *
47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the
586be1f3cSahl * Common Development and Distribution License (the "License").
686be1f3cSahl * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate *
87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate * and limitations under the License.
127c478bd9Sstevel@tonic-gate *
137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate *
197c478bd9Sstevel@tonic-gate * CDDL HEADER END
207c478bd9Sstevel@tonic-gate */
21900524f3Sahl
227c478bd9Sstevel@tonic-gate /*
2353f3aea0SRoger A. Faulkner * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
247c478bd9Sstevel@tonic-gate * Use is subject to license terms.
257c478bd9Sstevel@tonic-gate */
26*a386cc11SRobert Mustacchi /*
27*a386cc11SRobert Mustacchi * Copyright (c) 2013, Joyent, Inc. All rights reserved.
28*a386cc11SRobert Mustacchi */
297c478bd9Sstevel@tonic-gate
307c478bd9Sstevel@tonic-gate #include <assert.h>
317c478bd9Sstevel@tonic-gate #include <strings.h>
327c478bd9Sstevel@tonic-gate #include <stdlib.h>
337c478bd9Sstevel@tonic-gate #include <stdio.h>
347c478bd9Sstevel@tonic-gate #include <errno.h>
357c478bd9Sstevel@tonic-gate #include <ctype.h>
367c478bd9Sstevel@tonic-gate #include <alloca.h>
377c478bd9Sstevel@tonic-gate #include <libgen.h>
387c478bd9Sstevel@tonic-gate #include <stddef.h>
39*a386cc11SRobert Mustacchi #include <sys/sysmacros.h>
407c478bd9Sstevel@tonic-gate
417c478bd9Sstevel@tonic-gate #include <dt_impl.h>
421a7c1b72Smws #include <dt_program.h>
437c478bd9Sstevel@tonic-gate #include <dt_pid.h>
447c478bd9Sstevel@tonic-gate #include <dt_string.h>
45*a386cc11SRobert Mustacchi #include <dt_module.h>
467c478bd9Sstevel@tonic-gate
477c478bd9Sstevel@tonic-gate typedef struct dt_pid_probe {
487c478bd9Sstevel@tonic-gate dtrace_hdl_t *dpp_dtp;
49900524f3Sahl dt_pcb_t *dpp_pcb;
50900524f3Sahl dt_proc_t *dpp_dpr;
517c478bd9Sstevel@tonic-gate struct ps_prochandle *dpp_pr;
527c478bd9Sstevel@tonic-gate const char *dpp_mod;
537c478bd9Sstevel@tonic-gate char *dpp_func;
547c478bd9Sstevel@tonic-gate const char *dpp_name;
557c478bd9Sstevel@tonic-gate const char *dpp_obj;
567c478bd9Sstevel@tonic-gate uintptr_t dpp_pc;
577c478bd9Sstevel@tonic-gate size_t dpp_size;
587c478bd9Sstevel@tonic-gate Lmid_t dpp_lmid;
597c478bd9Sstevel@tonic-gate uint_t dpp_nmatches;
607c478bd9Sstevel@tonic-gate uint64_t dpp_stret[4];
617c478bd9Sstevel@tonic-gate GElf_Sym dpp_last;
627c478bd9Sstevel@tonic-gate uint_t dpp_last_taken;
637c478bd9Sstevel@tonic-gate } dt_pid_probe_t;
647c478bd9Sstevel@tonic-gate
6535b7f6ccSahl /*
6635b7f6ccSahl * Compose the lmid and object name into the canonical representation. We
6735b7f6ccSahl * omit the lmid for the default link map for convenience.
6835b7f6ccSahl */
6935b7f6ccSahl static void
dt_pid_objname(char * buf,size_t len,Lmid_t lmid,const char * obj)7035b7f6ccSahl dt_pid_objname(char *buf, size_t len, Lmid_t lmid, const char *obj)
7135b7f6ccSahl {
7235b7f6ccSahl if (lmid == LM_ID_BASE)
7335b7f6ccSahl (void) strncpy(buf, obj, len);
7435b7f6ccSahl else
7535b7f6ccSahl (void) snprintf(buf, len, "LM%lx`%s", lmid, obj);
7635b7f6ccSahl }
7735b7f6ccSahl
78900524f3Sahl static int
dt_pid_error(dtrace_hdl_t * dtp,dt_pcb_t * pcb,dt_proc_t * dpr,fasttrap_probe_spec_t * ftp,dt_errtag_t tag,const char * fmt,...)79900524f3Sahl dt_pid_error(dtrace_hdl_t *dtp, dt_pcb_t *pcb, dt_proc_t *dpr,
80900524f3Sahl fasttrap_probe_spec_t *ftp, dt_errtag_t tag, const char *fmt, ...)
8135b7f6ccSahl {
8235b7f6ccSahl va_list ap;
83900524f3Sahl int len;
84900524f3Sahl
85900524f3Sahl if (ftp != NULL)
86900524f3Sahl dt_free(dtp, ftp);
8735b7f6ccSahl
8835b7f6ccSahl va_start(ap, fmt);
89900524f3Sahl if (pcb == NULL) {
90900524f3Sahl assert(dpr != NULL);
91900524f3Sahl len = vsnprintf(dpr->dpr_errmsg, sizeof (dpr->dpr_errmsg),
92900524f3Sahl fmt, ap);
93900524f3Sahl assert(len >= 2);
94900524f3Sahl if (dpr->dpr_errmsg[len - 2] == '\n')
95900524f3Sahl dpr->dpr_errmsg[len - 2] = '\0';
96900524f3Sahl } else {
97900524f3Sahl dt_set_errmsg(dtp, dt_errtag(tag), pcb->pcb_region,
98900524f3Sahl pcb->pcb_filetag, pcb->pcb_fileptr ? yylineno : 0, fmt, ap);
99900524f3Sahl }
10035b7f6ccSahl va_end(ap);
101900524f3Sahl
102900524f3Sahl return (1);
10335b7f6ccSahl }
10435b7f6ccSahl
105900524f3Sahl static int
dt_pid_per_sym(dt_pid_probe_t * pp,const GElf_Sym * symp,const char * func)1067c478bd9Sstevel@tonic-gate dt_pid_per_sym(dt_pid_probe_t *pp, const GElf_Sym *symp, const char *func)
1077c478bd9Sstevel@tonic-gate {
108900524f3Sahl dtrace_hdl_t *dtp = pp->dpp_dtp;
109900524f3Sahl dt_pcb_t *pcb = pp->dpp_pcb;
110900524f3Sahl dt_proc_t *dpr = pp->dpp_dpr;
1117c478bd9Sstevel@tonic-gate fasttrap_probe_spec_t *ftp;
1127c478bd9Sstevel@tonic-gate uint64_t off;
1137c478bd9Sstevel@tonic-gate char *end;
1147c478bd9Sstevel@tonic-gate uint_t nmatches = 0;
1157c478bd9Sstevel@tonic-gate ulong_t sz;
1167c478bd9Sstevel@tonic-gate int glob, err;
1177c478bd9Sstevel@tonic-gate int isdash = strcmp("-", func) == 0;
1187c478bd9Sstevel@tonic-gate pid_t pid;
1197c478bd9Sstevel@tonic-gate
1207c478bd9Sstevel@tonic-gate pid = Pstatus(pp->dpp_pr)->pr_pid;
1217c478bd9Sstevel@tonic-gate
1227c478bd9Sstevel@tonic-gate dt_dprintf("creating probe pid%d:%s:%s:%s\n", (int)pid, pp->dpp_obj,
1237c478bd9Sstevel@tonic-gate func, pp->dpp_name);
1247c478bd9Sstevel@tonic-gate
1257c478bd9Sstevel@tonic-gate sz = sizeof (fasttrap_probe_spec_t) + (isdash ? 4 :
1267c478bd9Sstevel@tonic-gate (symp->st_size - 1) * sizeof (ftp->ftps_offs[0]));
1277c478bd9Sstevel@tonic-gate
128900524f3Sahl if ((ftp = dt_alloc(dtp, sz)) == NULL) {
129900524f3Sahl dt_dprintf("proc_per_sym: dt_alloc(%lu) failed\n", sz);
130900524f3Sahl return (1); /* errno is set for us */
1317c478bd9Sstevel@tonic-gate }
1327c478bd9Sstevel@tonic-gate
1337c478bd9Sstevel@tonic-gate ftp->ftps_pid = pid;
1347c478bd9Sstevel@tonic-gate (void) strncpy(ftp->ftps_func, func, sizeof (ftp->ftps_func));
1357c478bd9Sstevel@tonic-gate
13635b7f6ccSahl dt_pid_objname(ftp->ftps_mod, sizeof (ftp->ftps_mod), pp->dpp_lmid,
13735b7f6ccSahl pp->dpp_obj);
1387c478bd9Sstevel@tonic-gate
1397c478bd9Sstevel@tonic-gate if (!isdash && gmatch("return", pp->dpp_name)) {
140900524f3Sahl if (dt_pid_create_return_probe(pp->dpp_pr, dtp, ftp, symp,
141900524f3Sahl pp->dpp_stret) < 0) {
142900524f3Sahl return (dt_pid_error(dtp, pcb, dpr, ftp,
143900524f3Sahl D_PROC_CREATEFAIL, "failed to create return probe "
144900524f3Sahl "for '%s': %s", func,
145900524f3Sahl dtrace_errmsg(dtp, dtrace_errno(dtp))));
146900524f3Sahl }
1477c478bd9Sstevel@tonic-gate
1487c478bd9Sstevel@tonic-gate nmatches++;
1497c478bd9Sstevel@tonic-gate }
1507c478bd9Sstevel@tonic-gate
1517c478bd9Sstevel@tonic-gate if (!isdash && gmatch("entry", pp->dpp_name)) {
152900524f3Sahl if (dt_pid_create_entry_probe(pp->dpp_pr, dtp, ftp, symp) < 0) {
153900524f3Sahl return (dt_pid_error(dtp, pcb, dpr, ftp,
154900524f3Sahl D_PROC_CREATEFAIL, "failed to create entry probe "
155900524f3Sahl "for '%s': %s", func,
156900524f3Sahl dtrace_errmsg(dtp, dtrace_errno(dtp))));
157900524f3Sahl }
1587c478bd9Sstevel@tonic-gate
1597c478bd9Sstevel@tonic-gate nmatches++;
1607c478bd9Sstevel@tonic-gate }
1617c478bd9Sstevel@tonic-gate
1627c478bd9Sstevel@tonic-gate glob = strisglob(pp->dpp_name);
1637c478bd9Sstevel@tonic-gate if (!glob && nmatches == 0) {
1647c478bd9Sstevel@tonic-gate off = strtoull(pp->dpp_name, &end, 16);
1657c478bd9Sstevel@tonic-gate if (*end != '\0') {
166900524f3Sahl return (dt_pid_error(dtp, pcb, dpr, ftp, D_PROC_NAME,
167900524f3Sahl "'%s' is an invalid probe name", pp->dpp_name));
1687c478bd9Sstevel@tonic-gate }
1697c478bd9Sstevel@tonic-gate
1707c478bd9Sstevel@tonic-gate if (off >= symp->st_size) {
171900524f3Sahl return (dt_pid_error(dtp, pcb, dpr, ftp, D_PROC_OFF,
172900524f3Sahl "offset 0x%llx outside of function '%s'",
173900524f3Sahl (u_longlong_t)off, func));
1747c478bd9Sstevel@tonic-gate }
1757c478bd9Sstevel@tonic-gate
1767c478bd9Sstevel@tonic-gate err = dt_pid_create_offset_probe(pp->dpp_pr, pp->dpp_dtp, ftp,
1777c478bd9Sstevel@tonic-gate symp, off);
1787c478bd9Sstevel@tonic-gate
179900524f3Sahl if (err == DT_PROC_ERR) {
180900524f3Sahl return (dt_pid_error(dtp, pcb, dpr, ftp,
181900524f3Sahl D_PROC_CREATEFAIL, "failed to create probe at "
182900524f3Sahl "'%s+0x%llx': %s", func, (u_longlong_t)off,
183900524f3Sahl dtrace_errmsg(dtp, dtrace_errno(dtp))));
184900524f3Sahl }
185900524f3Sahl
1867c478bd9Sstevel@tonic-gate if (err == DT_PROC_ALIGN) {
187900524f3Sahl return (dt_pid_error(dtp, pcb, dpr, ftp, D_PROC_ALIGN,
188900524f3Sahl "offset 0x%llx is not aligned on an instruction",
189900524f3Sahl (u_longlong_t)off));
1907c478bd9Sstevel@tonic-gate }
1917c478bd9Sstevel@tonic-gate
1927c478bd9Sstevel@tonic-gate nmatches++;
1937c478bd9Sstevel@tonic-gate
1947c478bd9Sstevel@tonic-gate } else if (glob && !isdash) {
1957c478bd9Sstevel@tonic-gate if (dt_pid_create_glob_offset_probes(pp->dpp_pr,
196900524f3Sahl pp->dpp_dtp, ftp, symp, pp->dpp_name) < 0) {
197900524f3Sahl return (dt_pid_error(dtp, pcb, dpr, ftp,
198900524f3Sahl D_PROC_CREATEFAIL,
199900524f3Sahl "failed to create offset probes in '%s': %s", func,
200900524f3Sahl dtrace_errmsg(dtp, dtrace_errno(dtp))));
201900524f3Sahl }
2027c478bd9Sstevel@tonic-gate
2037c478bd9Sstevel@tonic-gate nmatches++;
2047c478bd9Sstevel@tonic-gate }
2057c478bd9Sstevel@tonic-gate
2067c478bd9Sstevel@tonic-gate pp->dpp_nmatches += nmatches;
2077c478bd9Sstevel@tonic-gate
208900524f3Sahl dt_free(dtp, ftp);
2097c478bd9Sstevel@tonic-gate
210900524f3Sahl return (0);
2117c478bd9Sstevel@tonic-gate }
2127c478bd9Sstevel@tonic-gate
2137c478bd9Sstevel@tonic-gate static int
dt_pid_sym_filt(void * arg,const GElf_Sym * symp,const char * func)2147c478bd9Sstevel@tonic-gate dt_pid_sym_filt(void *arg, const GElf_Sym *symp, const char *func)
2157c478bd9Sstevel@tonic-gate {
2167c478bd9Sstevel@tonic-gate dt_pid_probe_t *pp = arg;
2177c478bd9Sstevel@tonic-gate
2187c478bd9Sstevel@tonic-gate if (symp->st_shndx == SHN_UNDEF)
2197c478bd9Sstevel@tonic-gate return (0);
2207c478bd9Sstevel@tonic-gate
2217c478bd9Sstevel@tonic-gate if (symp->st_size == 0) {
2227c478bd9Sstevel@tonic-gate dt_dprintf("st_size of %s is zero\n", func);
2237c478bd9Sstevel@tonic-gate return (0);
2247c478bd9Sstevel@tonic-gate }
2257c478bd9Sstevel@tonic-gate
226900524f3Sahl if (pp->dpp_last_taken == 0 ||
227900524f3Sahl symp->st_value != pp->dpp_last.st_value ||
2287c478bd9Sstevel@tonic-gate symp->st_size != pp->dpp_last.st_size) {
2297c478bd9Sstevel@tonic-gate /*
2307c478bd9Sstevel@tonic-gate * Due to 4524008, _init and _fini may have a bloated st_size.
2317c478bd9Sstevel@tonic-gate * While this bug has been fixed for a while, old binaries
2327c478bd9Sstevel@tonic-gate * may exist that still exhibit this problem. As a result, we
2337c478bd9Sstevel@tonic-gate * don't match _init and _fini though we allow users to
2347c478bd9Sstevel@tonic-gate * specify them explicitly.
2357c478bd9Sstevel@tonic-gate */
2367c478bd9Sstevel@tonic-gate if (strcmp(func, "_init") == 0 || strcmp(func, "_fini") == 0)
2377c478bd9Sstevel@tonic-gate return (0);
2387c478bd9Sstevel@tonic-gate
239900524f3Sahl if ((pp->dpp_last_taken = gmatch(func, pp->dpp_func)) != 0) {
2407c478bd9Sstevel@tonic-gate pp->dpp_last = *symp;
241900524f3Sahl return (dt_pid_per_sym(pp, symp, func));
242900524f3Sahl }
2437c478bd9Sstevel@tonic-gate }
2447c478bd9Sstevel@tonic-gate
2457c478bd9Sstevel@tonic-gate return (0);
2467c478bd9Sstevel@tonic-gate }
2477c478bd9Sstevel@tonic-gate
248900524f3Sahl static int
dt_pid_per_mod(void * arg,const prmap_t * pmp,const char * obj)2497c478bd9Sstevel@tonic-gate dt_pid_per_mod(void *arg, const prmap_t *pmp, const char *obj)
2507c478bd9Sstevel@tonic-gate {
2517c478bd9Sstevel@tonic-gate dt_pid_probe_t *pp = arg;
252900524f3Sahl dtrace_hdl_t *dtp = pp->dpp_dtp;
253900524f3Sahl dt_pcb_t *pcb = pp->dpp_pcb;
254900524f3Sahl dt_proc_t *dpr = pp->dpp_dpr;
2557c478bd9Sstevel@tonic-gate GElf_Sym sym;
2567c478bd9Sstevel@tonic-gate
2577c478bd9Sstevel@tonic-gate if (obj == NULL)
258900524f3Sahl return (0);
2597c478bd9Sstevel@tonic-gate
2607c478bd9Sstevel@tonic-gate (void) Plmid(pp->dpp_pr, pmp->pr_vaddr, &pp->dpp_lmid);
2617c478bd9Sstevel@tonic-gate
2627c478bd9Sstevel@tonic-gate if ((pp->dpp_obj = strrchr(obj, '/')) == NULL)
2637c478bd9Sstevel@tonic-gate pp->dpp_obj = obj;
2647c478bd9Sstevel@tonic-gate else
2657c478bd9Sstevel@tonic-gate pp->dpp_obj++;
2667c478bd9Sstevel@tonic-gate
2677c478bd9Sstevel@tonic-gate if (Pxlookup_by_name(pp->dpp_pr, pp->dpp_lmid, obj, ".stret1", &sym,
2687c478bd9Sstevel@tonic-gate NULL) == 0)
2697c478bd9Sstevel@tonic-gate pp->dpp_stret[0] = sym.st_value;
2707c478bd9Sstevel@tonic-gate else
2717c478bd9Sstevel@tonic-gate pp->dpp_stret[0] = 0;
2727c478bd9Sstevel@tonic-gate
2737c478bd9Sstevel@tonic-gate if (Pxlookup_by_name(pp->dpp_pr, pp->dpp_lmid, obj, ".stret2", &sym,
2747c478bd9Sstevel@tonic-gate NULL) == 0)
2757c478bd9Sstevel@tonic-gate pp->dpp_stret[1] = sym.st_value;
2767c478bd9Sstevel@tonic-gate else
2777c478bd9Sstevel@tonic-gate pp->dpp_stret[1] = 0;
2787c478bd9Sstevel@tonic-gate
2797c478bd9Sstevel@tonic-gate if (Pxlookup_by_name(pp->dpp_pr, pp->dpp_lmid, obj, ".stret4", &sym,
2807c478bd9Sstevel@tonic-gate NULL) == 0)
2817c478bd9Sstevel@tonic-gate pp->dpp_stret[2] = sym.st_value;
2827c478bd9Sstevel@tonic-gate else
2837c478bd9Sstevel@tonic-gate pp->dpp_stret[2] = 0;
2847c478bd9Sstevel@tonic-gate
2857c478bd9Sstevel@tonic-gate if (Pxlookup_by_name(pp->dpp_pr, pp->dpp_lmid, obj, ".stret8", &sym,
2867c478bd9Sstevel@tonic-gate NULL) == 0)
2877c478bd9Sstevel@tonic-gate pp->dpp_stret[3] = sym.st_value;
2887c478bd9Sstevel@tonic-gate else
2897c478bd9Sstevel@tonic-gate pp->dpp_stret[3] = 0;
2907c478bd9Sstevel@tonic-gate
2917c478bd9Sstevel@tonic-gate dt_dprintf("%s stret %llx %llx %llx %llx\n", obj,
2927c478bd9Sstevel@tonic-gate (u_longlong_t)pp->dpp_stret[0], (u_longlong_t)pp->dpp_stret[1],
2937c478bd9Sstevel@tonic-gate (u_longlong_t)pp->dpp_stret[2], (u_longlong_t)pp->dpp_stret[3]);
2947c478bd9Sstevel@tonic-gate
2957c478bd9Sstevel@tonic-gate /*
2967c478bd9Sstevel@tonic-gate * If pp->dpp_func contains any globbing meta-characters, we need
2977c478bd9Sstevel@tonic-gate * to iterate over the symbol table and compare each function name
2987c478bd9Sstevel@tonic-gate * against the pattern.
2997c478bd9Sstevel@tonic-gate */
3007c478bd9Sstevel@tonic-gate if (!strisglob(pp->dpp_func)) {
3017c478bd9Sstevel@tonic-gate /*
3027c478bd9Sstevel@tonic-gate * If we fail to lookup the symbol, try interpreting the
3037c478bd9Sstevel@tonic-gate * function as the special "-" function that indicates that the
3047c478bd9Sstevel@tonic-gate * probe name should be interpreted as a absolute virtual
3057c478bd9Sstevel@tonic-gate * address. If that fails and we were matching a specific
3067c478bd9Sstevel@tonic-gate * function in a specific module, report the error, otherwise
3077c478bd9Sstevel@tonic-gate * just fail silently in the hopes that some other object will
3087c478bd9Sstevel@tonic-gate * contain the desired symbol.
3097c478bd9Sstevel@tonic-gate */
3107c478bd9Sstevel@tonic-gate if (Pxlookup_by_name(pp->dpp_pr, pp->dpp_lmid, obj,
3117c478bd9Sstevel@tonic-gate pp->dpp_func, &sym, NULL) != 0) {
3127c478bd9Sstevel@tonic-gate if (strcmp("-", pp->dpp_func) == 0) {
3137c478bd9Sstevel@tonic-gate sym.st_name = 0;
3147c478bd9Sstevel@tonic-gate sym.st_info =
3157c478bd9Sstevel@tonic-gate GELF_ST_INFO(STB_LOCAL, STT_FUNC);
3167c478bd9Sstevel@tonic-gate sym.st_other = 0;
3177c478bd9Sstevel@tonic-gate sym.st_value = 0;
3187c478bd9Sstevel@tonic-gate sym.st_size = Pstatus(pp->dpp_pr)->pr_dmodel ==
3197c478bd9Sstevel@tonic-gate PR_MODEL_ILP32 ? -1U : -1ULL;
3207c478bd9Sstevel@tonic-gate
3217c478bd9Sstevel@tonic-gate } else if (!strisglob(pp->dpp_mod)) {
322900524f3Sahl return (dt_pid_error(dtp, pcb, dpr, NULL,
323900524f3Sahl D_PROC_FUNC,
324900524f3Sahl "failed to lookup '%s' in module '%s'",
325900524f3Sahl pp->dpp_func, pp->dpp_mod));
3267c478bd9Sstevel@tonic-gate } else {
327900524f3Sahl return (0);
3287c478bd9Sstevel@tonic-gate }
3297c478bd9Sstevel@tonic-gate }
3307c478bd9Sstevel@tonic-gate
3317c478bd9Sstevel@tonic-gate /*
3327c478bd9Sstevel@tonic-gate * Only match defined functions of non-zero size.
3337c478bd9Sstevel@tonic-gate */
3347c478bd9Sstevel@tonic-gate if (GELF_ST_TYPE(sym.st_info) != STT_FUNC ||
3357c478bd9Sstevel@tonic-gate sym.st_shndx == SHN_UNDEF || sym.st_size == 0)
336900524f3Sahl return (0);
3377c478bd9Sstevel@tonic-gate
3387c478bd9Sstevel@tonic-gate /*
3397c478bd9Sstevel@tonic-gate * We don't instrument PLTs -- they're dynamically rewritten,
3407c478bd9Sstevel@tonic-gate * and, so, inherently dicey to instrument.
3417c478bd9Sstevel@tonic-gate */
3427c478bd9Sstevel@tonic-gate if (Ppltdest(pp->dpp_pr, sym.st_value) != NULL)
343900524f3Sahl return (0);
3447c478bd9Sstevel@tonic-gate
3457c478bd9Sstevel@tonic-gate (void) Plookup_by_addr(pp->dpp_pr, sym.st_value, pp->dpp_func,
3467c478bd9Sstevel@tonic-gate DTRACE_FUNCNAMELEN, &sym);
3477c478bd9Sstevel@tonic-gate
348900524f3Sahl return (dt_pid_per_sym(pp, &sym, pp->dpp_func));
3497c478bd9Sstevel@tonic-gate } else {
3507c478bd9Sstevel@tonic-gate uint_t nmatches = pp->dpp_nmatches;
3517c478bd9Sstevel@tonic-gate
352900524f3Sahl if (Psymbol_iter_by_addr(pp->dpp_pr, obj, PR_SYMTAB,
353900524f3Sahl BIND_ANY | TYPE_FUNC, dt_pid_sym_filt, pp) == 1)
354900524f3Sahl return (1);
3557c478bd9Sstevel@tonic-gate
3567c478bd9Sstevel@tonic-gate if (nmatches == pp->dpp_nmatches) {
3577c478bd9Sstevel@tonic-gate /*
3587c478bd9Sstevel@tonic-gate * If we didn't match anything in the PR_SYMTAB, try
3597c478bd9Sstevel@tonic-gate * the PR_DYNSYM.
3607c478bd9Sstevel@tonic-gate */
361900524f3Sahl if (Psymbol_iter_by_addr(pp->dpp_pr, obj, PR_DYNSYM,
362900524f3Sahl BIND_ANY | TYPE_FUNC, dt_pid_sym_filt, pp) == 1)
363900524f3Sahl return (1);
3647c478bd9Sstevel@tonic-gate }
3657c478bd9Sstevel@tonic-gate }
366900524f3Sahl
367900524f3Sahl return (0);
3687c478bd9Sstevel@tonic-gate }
3697c478bd9Sstevel@tonic-gate
3707c478bd9Sstevel@tonic-gate static int
dt_pid_mod_filt(void * arg,const prmap_t * pmp,const char * obj)3717c478bd9Sstevel@tonic-gate dt_pid_mod_filt(void *arg, const prmap_t *pmp, const char *obj)
3727c478bd9Sstevel@tonic-gate {
373900524f3Sahl char name[DTRACE_MODNAMELEN];
3747c478bd9Sstevel@tonic-gate dt_pid_probe_t *pp = arg;
3757c478bd9Sstevel@tonic-gate
3767c478bd9Sstevel@tonic-gate if ((pp->dpp_obj = strrchr(obj, '/')) == NULL)
3777c478bd9Sstevel@tonic-gate pp->dpp_obj = obj;
3787c478bd9Sstevel@tonic-gate else
3797c478bd9Sstevel@tonic-gate pp->dpp_obj++;
3807c478bd9Sstevel@tonic-gate
3811959771bSJonathan Haslam if (gmatch(pp->dpp_obj, pp->dpp_mod))
3821959771bSJonathan Haslam return (dt_pid_per_mod(pp, pmp, obj));
3831959771bSJonathan Haslam
3841959771bSJonathan Haslam (void) Plmid(pp->dpp_pr, pmp->pr_vaddr, &pp->dpp_lmid);
3851959771bSJonathan Haslam
3861959771bSJonathan Haslam dt_pid_objname(name, sizeof (name), pp->dpp_lmid, pp->dpp_obj);
3877c478bd9Sstevel@tonic-gate
3887c478bd9Sstevel@tonic-gate if (gmatch(name, pp->dpp_mod))
389900524f3Sahl return (dt_pid_per_mod(pp, pmp, obj));
3907c478bd9Sstevel@tonic-gate
3917c478bd9Sstevel@tonic-gate return (0);
3927c478bd9Sstevel@tonic-gate }
3937c478bd9Sstevel@tonic-gate
3947c478bd9Sstevel@tonic-gate static const prmap_t *
dt_pid_fix_mod(dtrace_probedesc_t * pdp,struct ps_prochandle * P)3957c478bd9Sstevel@tonic-gate dt_pid_fix_mod(dtrace_probedesc_t *pdp, struct ps_prochandle *P)
3967c478bd9Sstevel@tonic-gate {
3977c478bd9Sstevel@tonic-gate char m[MAXPATHLEN];
3987c478bd9Sstevel@tonic-gate Lmid_t lmid = PR_LMID_EVERY;
3997c478bd9Sstevel@tonic-gate const char *obj;
4007c478bd9Sstevel@tonic-gate const prmap_t *pmp;
4017c478bd9Sstevel@tonic-gate
4027c478bd9Sstevel@tonic-gate /*
4037c478bd9Sstevel@tonic-gate * Pick apart the link map from the library name.
4047c478bd9Sstevel@tonic-gate */
4057c478bd9Sstevel@tonic-gate if (strchr(pdp->dtpd_mod, '`') != NULL) {
4067c478bd9Sstevel@tonic-gate char *end;
4077c478bd9Sstevel@tonic-gate
4087c478bd9Sstevel@tonic-gate if (strncmp(pdp->dtpd_mod, "LM", 2) != 0 ||
4097c478bd9Sstevel@tonic-gate !isdigit(pdp->dtpd_mod[2]))
4107c478bd9Sstevel@tonic-gate return (NULL);
4117c478bd9Sstevel@tonic-gate
4127c478bd9Sstevel@tonic-gate lmid = strtoul(&pdp->dtpd_mod[2], &end, 16);
4137c478bd9Sstevel@tonic-gate
4147c478bd9Sstevel@tonic-gate obj = end + 1;
4157c478bd9Sstevel@tonic-gate
4167c478bd9Sstevel@tonic-gate if (*end != '`' || strchr(obj, '`') != NULL)
4177c478bd9Sstevel@tonic-gate return (NULL);
4187c478bd9Sstevel@tonic-gate
4197c478bd9Sstevel@tonic-gate } else {
4207c478bd9Sstevel@tonic-gate obj = pdp->dtpd_mod;
4217c478bd9Sstevel@tonic-gate }
4227c478bd9Sstevel@tonic-gate
4237c478bd9Sstevel@tonic-gate if ((pmp = Plmid_to_map(P, lmid, obj)) == NULL)
4247c478bd9Sstevel@tonic-gate return (NULL);
4257c478bd9Sstevel@tonic-gate
4267c478bd9Sstevel@tonic-gate (void) Pobjname(P, pmp->pr_vaddr, m, sizeof (m));
4277c478bd9Sstevel@tonic-gate if ((obj = strrchr(m, '/')) == NULL)
4287c478bd9Sstevel@tonic-gate obj = &m[0];
4297c478bd9Sstevel@tonic-gate else
4307c478bd9Sstevel@tonic-gate obj++;
4317c478bd9Sstevel@tonic-gate
4327c478bd9Sstevel@tonic-gate (void) Plmid(P, pmp->pr_vaddr, &lmid);
43335b7f6ccSahl dt_pid_objname(pdp->dtpd_mod, sizeof (pdp->dtpd_mod), lmid, obj);
4347c478bd9Sstevel@tonic-gate
4357c478bd9Sstevel@tonic-gate return (pmp);
4367c478bd9Sstevel@tonic-gate }
4377c478bd9Sstevel@tonic-gate
4387c478bd9Sstevel@tonic-gate
439900524f3Sahl static int
dt_pid_create_pid_probes(dtrace_probedesc_t * pdp,dtrace_hdl_t * dtp,dt_pcb_t * pcb,dt_proc_t * dpr)440900524f3Sahl dt_pid_create_pid_probes(dtrace_probedesc_t *pdp, dtrace_hdl_t *dtp,
441900524f3Sahl dt_pcb_t *pcb, dt_proc_t *dpr)
4427c478bd9Sstevel@tonic-gate {
4437c478bd9Sstevel@tonic-gate dt_pid_probe_t pp;
444900524f3Sahl int ret = 0;
4457c478bd9Sstevel@tonic-gate
446900524f3Sahl pp.dpp_dtp = dtp;
447900524f3Sahl pp.dpp_dpr = dpr;
448900524f3Sahl pp.dpp_pr = dpr->dpr_proc;
449900524f3Sahl pp.dpp_pcb = pcb;
4507c478bd9Sstevel@tonic-gate
4517c478bd9Sstevel@tonic-gate /*
4527c478bd9Sstevel@tonic-gate * We can only trace dynamically-linked executables (since we've
4537c478bd9Sstevel@tonic-gate * hidden some magic in ld.so.1 as well as libc.so.1).
4547c478bd9Sstevel@tonic-gate */
4557c478bd9Sstevel@tonic-gate if (Pname_to_map(pp.dpp_pr, PR_OBJ_LDSO) == NULL) {
456900524f3Sahl return (dt_pid_error(dtp, pcb, dpr, NULL, D_PROC_DYN,
457900524f3Sahl "process %s is not a dynamically-linked executable",
458900524f3Sahl &pdp->dtpd_provider[3]));
4597c478bd9Sstevel@tonic-gate }
4607c478bd9Sstevel@tonic-gate
4617c478bd9Sstevel@tonic-gate pp.dpp_mod = pdp->dtpd_mod[0] != '\0' ? pdp->dtpd_mod : "*";
4627c478bd9Sstevel@tonic-gate pp.dpp_func = pdp->dtpd_func[0] != '\0' ? pdp->dtpd_func : "*";
4637c478bd9Sstevel@tonic-gate pp.dpp_name = pdp->dtpd_name[0] != '\0' ? pdp->dtpd_name : "*";
464900524f3Sahl pp.dpp_last_taken = 0;
4657c478bd9Sstevel@tonic-gate
4667c478bd9Sstevel@tonic-gate if (strcmp(pp.dpp_func, "-") == 0) {
4677c478bd9Sstevel@tonic-gate const prmap_t *aout, *pmp;
4687c478bd9Sstevel@tonic-gate
4697c478bd9Sstevel@tonic-gate if (pdp->dtpd_mod[0] == '\0') {
4707c478bd9Sstevel@tonic-gate pp.dpp_mod = pdp->dtpd_mod;
4717c478bd9Sstevel@tonic-gate (void) strcpy(pdp->dtpd_mod, "a.out");
4727c478bd9Sstevel@tonic-gate } else if (strisglob(pp.dpp_mod) ||
4737c478bd9Sstevel@tonic-gate (aout = Pname_to_map(pp.dpp_pr, "a.out")) == NULL ||
4747c478bd9Sstevel@tonic-gate (pmp = Pname_to_map(pp.dpp_pr, pp.dpp_mod)) == NULL ||
4757c478bd9Sstevel@tonic-gate aout->pr_vaddr != pmp->pr_vaddr) {
476900524f3Sahl return (dt_pid_error(dtp, pcb, dpr, NULL, D_PROC_LIB,
477900524f3Sahl "only the a.out module is valid with the "
478900524f3Sahl "'-' function"));
4797c478bd9Sstevel@tonic-gate }
4807c478bd9Sstevel@tonic-gate
4817c478bd9Sstevel@tonic-gate if (strisglob(pp.dpp_name)) {
482900524f3Sahl return (dt_pid_error(dtp, pcb, dpr, NULL, D_PROC_NAME,
483900524f3Sahl "only individual addresses may be specified "
484900524f3Sahl "with the '-' function"));
4857c478bd9Sstevel@tonic-gate }
4867c478bd9Sstevel@tonic-gate }
4877c478bd9Sstevel@tonic-gate
4887c478bd9Sstevel@tonic-gate /*
4897c478bd9Sstevel@tonic-gate * If pp.dpp_mod contains any globbing meta-characters, we need
4907c478bd9Sstevel@tonic-gate * to iterate over each module and compare its name against the
4917c478bd9Sstevel@tonic-gate * pattern. An empty module name is treated as '*'.
4927c478bd9Sstevel@tonic-gate */
4937c478bd9Sstevel@tonic-gate if (strisglob(pp.dpp_mod)) {
494900524f3Sahl ret = Pobject_iter(pp.dpp_pr, dt_pid_mod_filt, &pp);
4957c478bd9Sstevel@tonic-gate } else {
4967c478bd9Sstevel@tonic-gate const prmap_t *pmp;
4977c478bd9Sstevel@tonic-gate char *obj;
4987c478bd9Sstevel@tonic-gate
4997c478bd9Sstevel@tonic-gate /*
500900524f3Sahl * If we can't find a matching module, don't sweat it -- either
5017c478bd9Sstevel@tonic-gate * we'll fail the enabling because the probes don't exist or
5027c478bd9Sstevel@tonic-gate * we'll wait for that module to come along.
5037c478bd9Sstevel@tonic-gate */
5047c478bd9Sstevel@tonic-gate if ((pmp = dt_pid_fix_mod(pdp, pp.dpp_pr)) != NULL) {
5057c478bd9Sstevel@tonic-gate if ((obj = strchr(pdp->dtpd_mod, '`')) == NULL)
5067c478bd9Sstevel@tonic-gate obj = pdp->dtpd_mod;
5077c478bd9Sstevel@tonic-gate else
5087c478bd9Sstevel@tonic-gate obj++;
5097c478bd9Sstevel@tonic-gate
510900524f3Sahl ret = dt_pid_per_mod(&pp, pmp, obj);
5117c478bd9Sstevel@tonic-gate }
5127c478bd9Sstevel@tonic-gate }
5137c478bd9Sstevel@tonic-gate
514900524f3Sahl return (ret);
5157c478bd9Sstevel@tonic-gate }
5167c478bd9Sstevel@tonic-gate
5177c478bd9Sstevel@tonic-gate static int
dt_pid_usdt_mapping(void * data,const prmap_t * pmp,const char * oname)5187c478bd9Sstevel@tonic-gate dt_pid_usdt_mapping(void *data, const prmap_t *pmp, const char *oname)
5197c478bd9Sstevel@tonic-gate {
5207c478bd9Sstevel@tonic-gate struct ps_prochandle *P = data;
5217c478bd9Sstevel@tonic-gate GElf_Sym sym;
5227c478bd9Sstevel@tonic-gate prsyminfo_t sip;
5237c478bd9Sstevel@tonic-gate dof_helper_t dh;
5247c478bd9Sstevel@tonic-gate GElf_Half e_type;
5257c478bd9Sstevel@tonic-gate const char *mname;
5267c478bd9Sstevel@tonic-gate const char *syms[] = { "___SUNW_dof", "__SUNW_dof" };
527900524f3Sahl int i, fd = -1;
5287c478bd9Sstevel@tonic-gate
5297c478bd9Sstevel@tonic-gate /*
5307c478bd9Sstevel@tonic-gate * The symbol ___SUNW_dof is for lazy-loaded DOF sections, and
5317c478bd9Sstevel@tonic-gate * __SUNW_dof is for actively-loaded DOF sections. We try to force
5327c478bd9Sstevel@tonic-gate * in both types of DOF section since the process may not yet have
5337c478bd9Sstevel@tonic-gate * run the code to instantiate these providers.
5347c478bd9Sstevel@tonic-gate */
5357c478bd9Sstevel@tonic-gate for (i = 0; i < 2; i++) {
5367c478bd9Sstevel@tonic-gate if (Pxlookup_by_name(P, PR_LMID_EVERY, oname, syms[i], &sym,
5377c478bd9Sstevel@tonic-gate &sip) != 0) {
5387c478bd9Sstevel@tonic-gate continue;
5397c478bd9Sstevel@tonic-gate }
5407c478bd9Sstevel@tonic-gate
5417c478bd9Sstevel@tonic-gate if ((mname = strrchr(oname, '/')) == NULL)
5427c478bd9Sstevel@tonic-gate mname = oname;
5437c478bd9Sstevel@tonic-gate else
5447c478bd9Sstevel@tonic-gate mname++;
5457c478bd9Sstevel@tonic-gate
5467c478bd9Sstevel@tonic-gate dt_dprintf("lookup of %s succeeded for %s\n", syms[i], mname);
5477c478bd9Sstevel@tonic-gate
5487c478bd9Sstevel@tonic-gate if (Pread(P, &e_type, sizeof (e_type), pmp->pr_vaddr +
5497c478bd9Sstevel@tonic-gate offsetof(Elf64_Ehdr, e_type)) != sizeof (e_type)) {
5507c478bd9Sstevel@tonic-gate dt_dprintf("read of ELF header failed");
5517c478bd9Sstevel@tonic-gate continue;
5527c478bd9Sstevel@tonic-gate }
5537c478bd9Sstevel@tonic-gate
5547c478bd9Sstevel@tonic-gate dh.dofhp_dof = sym.st_value;
5557c478bd9Sstevel@tonic-gate dh.dofhp_addr = (e_type == ET_EXEC) ? 0 : pmp->pr_vaddr;
5567c478bd9Sstevel@tonic-gate
55735b7f6ccSahl dt_pid_objname(dh.dofhp_mod, sizeof (dh.dofhp_mod),
55835b7f6ccSahl sip.prs_lmid, mname);
5597c478bd9Sstevel@tonic-gate
560900524f3Sahl if (fd == -1 &&
561900524f3Sahl (fd = pr_open(P, "/dev/dtrace/helper", O_RDWR, 0)) < 0) {
5627c478bd9Sstevel@tonic-gate dt_dprintf("pr_open of helper device failed: %s\n",
5637c478bd9Sstevel@tonic-gate strerror(errno));
564900524f3Sahl return (-1); /* errno is set for us */
5657c478bd9Sstevel@tonic-gate }
5667c478bd9Sstevel@tonic-gate
567900524f3Sahl if (pr_ioctl(P, fd, DTRACEHIOC_ADDDOF, &dh, sizeof (dh)) < 0)
568900524f3Sahl dt_dprintf("DOF was rejected for %s\n", dh.dofhp_mod);
5697c478bd9Sstevel@tonic-gate }
5707c478bd9Sstevel@tonic-gate
571900524f3Sahl if (fd != -1)
572900524f3Sahl (void) pr_close(P, fd);
573900524f3Sahl
5747c478bd9Sstevel@tonic-gate return (0);
5757c478bd9Sstevel@tonic-gate }
5767c478bd9Sstevel@tonic-gate
5777c478bd9Sstevel@tonic-gate static int
dt_pid_create_usdt_probes(dtrace_probedesc_t * pdp,dtrace_hdl_t * dtp,dt_pcb_t * pcb,dt_proc_t * dpr)578900524f3Sahl dt_pid_create_usdt_probes(dtrace_probedesc_t *pdp, dtrace_hdl_t *dtp,
579900524f3Sahl dt_pcb_t *pcb, dt_proc_t *dpr)
5807c478bd9Sstevel@tonic-gate {
5817c478bd9Sstevel@tonic-gate struct ps_prochandle *P = dpr->dpr_proc;
582900524f3Sahl int ret = 0;
5837c478bd9Sstevel@tonic-gate
58453f3aea0SRoger A. Faulkner assert(MUTEX_HELD(&dpr->dpr_lock));
5857c478bd9Sstevel@tonic-gate
5867c478bd9Sstevel@tonic-gate (void) Pupdate_maps(P);
587900524f3Sahl if (Pobject_iter(P, dt_pid_usdt_mapping, P) != 0) {
588900524f3Sahl ret = -1;
589900524f3Sahl (void) dt_pid_error(dtp, pcb, dpr, NULL, D_PROC_USDT,
590900524f3Sahl "failed to instantiate probes for pid %d: %s",
591900524f3Sahl (int)Pstatus(P)->pr_pid, strerror(errno));
592900524f3Sahl }
5937c478bd9Sstevel@tonic-gate
5947c478bd9Sstevel@tonic-gate /*
5957c478bd9Sstevel@tonic-gate * Put the module name in its canonical form.
5967c478bd9Sstevel@tonic-gate */
5977c478bd9Sstevel@tonic-gate (void) dt_pid_fix_mod(pdp, P);
5987c478bd9Sstevel@tonic-gate
599900524f3Sahl return (ret);
6007c478bd9Sstevel@tonic-gate }
6017c478bd9Sstevel@tonic-gate
6027c478bd9Sstevel@tonic-gate static pid_t
dt_pid_get_pid(dtrace_probedesc_t * pdp,dtrace_hdl_t * dtp,dt_pcb_t * pcb,dt_proc_t * dpr)603900524f3Sahl dt_pid_get_pid(dtrace_probedesc_t *pdp, dtrace_hdl_t *dtp, dt_pcb_t *pcb,
604900524f3Sahl dt_proc_t *dpr)
6057c478bd9Sstevel@tonic-gate {
6067c478bd9Sstevel@tonic-gate pid_t pid;
6077c478bd9Sstevel@tonic-gate char *c, *last = NULL, *end;
6087c478bd9Sstevel@tonic-gate
6097c478bd9Sstevel@tonic-gate for (c = &pdp->dtpd_provider[0]; *c != '\0'; c++) {
6107c478bd9Sstevel@tonic-gate if (!isdigit(*c))
6117c478bd9Sstevel@tonic-gate last = c;
6127c478bd9Sstevel@tonic-gate }
6137c478bd9Sstevel@tonic-gate
6147c478bd9Sstevel@tonic-gate if (last == NULL || (*(++last) == '\0')) {
615900524f3Sahl (void) dt_pid_error(dtp, pcb, dpr, NULL, D_PROC_BADPROV,
616900524f3Sahl "'%s' is not a valid provider", pdp->dtpd_provider);
6177c478bd9Sstevel@tonic-gate return (-1);
6187c478bd9Sstevel@tonic-gate }
6197c478bd9Sstevel@tonic-gate
6207c478bd9Sstevel@tonic-gate errno = 0;
6217c478bd9Sstevel@tonic-gate pid = strtol(last, &end, 10);
6227c478bd9Sstevel@tonic-gate
6237c478bd9Sstevel@tonic-gate if (errno != 0 || end == last || end[0] != '\0' || pid <= 0) {
624900524f3Sahl (void) dt_pid_error(dtp, pcb, dpr, NULL, D_PROC_BADPID,
625900524f3Sahl "'%s' does not contain a valid pid", pdp->dtpd_provider);
6267c478bd9Sstevel@tonic-gate return (-1);
6277c478bd9Sstevel@tonic-gate }
6287c478bd9Sstevel@tonic-gate
6297c478bd9Sstevel@tonic-gate return (pid);
6307c478bd9Sstevel@tonic-gate }
6317c478bd9Sstevel@tonic-gate
632900524f3Sahl int
dt_pid_create_probes(dtrace_probedesc_t * pdp,dtrace_hdl_t * dtp,dt_pcb_t * pcb)633900524f3Sahl dt_pid_create_probes(dtrace_probedesc_t *pdp, dtrace_hdl_t *dtp, dt_pcb_t *pcb)
6347c478bd9Sstevel@tonic-gate {
6357c478bd9Sstevel@tonic-gate char provname[DTRACE_PROVNAMELEN];
6367c478bd9Sstevel@tonic-gate struct ps_prochandle *P;
6377c478bd9Sstevel@tonic-gate dt_proc_t *dpr;
638900524f3Sahl pid_t pid;
63986be1f3cSahl int err = 0;
640900524f3Sahl
641900524f3Sahl assert(pcb != NULL);
642900524f3Sahl
643900524f3Sahl if ((pid = dt_pid_get_pid(pdp, dtp, pcb, NULL)) == -1)
644900524f3Sahl return (-1);
6457c478bd9Sstevel@tonic-gate
6467c478bd9Sstevel@tonic-gate if (dtp->dt_ftfd == -1) {
6477c478bd9Sstevel@tonic-gate if (dtp->dt_fterr == ENOENT) {
648900524f3Sahl (void) dt_pid_error(dtp, pcb, NULL, NULL, D_PROC_NODEV,
649900524f3Sahl "pid provider is not installed on this system");
6507c478bd9Sstevel@tonic-gate } else {
651900524f3Sahl (void) dt_pid_error(dtp, pcb, NULL, NULL, D_PROC_NODEV,
652900524f3Sahl "pid provider is not available: %s",
653900524f3Sahl strerror(dtp->dt_fterr));
6547c478bd9Sstevel@tonic-gate }
655900524f3Sahl
656900524f3Sahl return (-1);
6577c478bd9Sstevel@tonic-gate }
6587c478bd9Sstevel@tonic-gate
6597c478bd9Sstevel@tonic-gate (void) snprintf(provname, sizeof (provname), "pid%d", (int)pid);
6607c478bd9Sstevel@tonic-gate
6616e0bee74Sjhaslam if (gmatch(provname, pdp->dtpd_provider) != 0) {
662900524f3Sahl if ((P = dt_proc_grab(dtp, pid, PGRAB_RDONLY | PGRAB_FORCE,
663900524f3Sahl 0)) == NULL) {
664900524f3Sahl (void) dt_pid_error(dtp, pcb, NULL, NULL, D_PROC_GRAB,
665900524f3Sahl "failed to grab process %d", (int)pid);
666900524f3Sahl return (-1);
667900524f3Sahl }
6687c478bd9Sstevel@tonic-gate
6697c478bd9Sstevel@tonic-gate dpr = dt_proc_lookup(dtp, P, 0);
6707c478bd9Sstevel@tonic-gate assert(dpr != NULL);
671900524f3Sahl (void) pthread_mutex_lock(&dpr->dpr_lock);
6727c478bd9Sstevel@tonic-gate
6736009dbc6Sahl if ((err = dt_pid_create_pid_probes(pdp, dtp, pcb, dpr)) == 0) {
6746009dbc6Sahl /*
6756009dbc6Sahl * Alert other retained enablings which may match
6766009dbc6Sahl * against the newly created probes.
6776009dbc6Sahl */
6786009dbc6Sahl (void) dt_ioctl(dtp, DTRACEIOC_ENABLE, NULL);
6796009dbc6Sahl }
680900524f3Sahl
681900524f3Sahl (void) pthread_mutex_unlock(&dpr->dpr_lock);
682900524f3Sahl dt_proc_release(dtp, P);
6836e0bee74Sjhaslam }
684900524f3Sahl
6856e0bee74Sjhaslam /*
6866e0bee74Sjhaslam * If it's not strictly a pid provider, we might match a USDT provider.
6876e0bee74Sjhaslam */
6886e0bee74Sjhaslam if (strcmp(provname, pdp->dtpd_provider) != 0) {
689900524f3Sahl if ((P = dt_proc_grab(dtp, pid, 0, 1)) == NULL) {
690900524f3Sahl (void) dt_pid_error(dtp, pcb, NULL, NULL, D_PROC_GRAB,
691900524f3Sahl "failed to grab process %d", (int)pid);
692900524f3Sahl return (-1);
693900524f3Sahl }
694900524f3Sahl
695900524f3Sahl dpr = dt_proc_lookup(dtp, P, 0);
696900524f3Sahl assert(dpr != NULL);
6977c478bd9Sstevel@tonic-gate (void) pthread_mutex_lock(&dpr->dpr_lock);
6987c478bd9Sstevel@tonic-gate
6997c478bd9Sstevel@tonic-gate if (!dpr->dpr_usdt) {
700900524f3Sahl err = dt_pid_create_usdt_probes(pdp, dtp, pcb, dpr);
7017c478bd9Sstevel@tonic-gate dpr->dpr_usdt = B_TRUE;
7027c478bd9Sstevel@tonic-gate }
7037c478bd9Sstevel@tonic-gate
7047c478bd9Sstevel@tonic-gate (void) pthread_mutex_unlock(&dpr->dpr_lock);
7057c478bd9Sstevel@tonic-gate dt_proc_release(dtp, P);
7067c478bd9Sstevel@tonic-gate }
7077c478bd9Sstevel@tonic-gate
708900524f3Sahl return (err ? -1 : 0);
709900524f3Sahl }
710900524f3Sahl
711900524f3Sahl int
dt_pid_create_probes_module(dtrace_hdl_t * dtp,dt_proc_t * dpr)7127c478bd9Sstevel@tonic-gate dt_pid_create_probes_module(dtrace_hdl_t *dtp, dt_proc_t *dpr)
7137c478bd9Sstevel@tonic-gate {
7147c478bd9Sstevel@tonic-gate dtrace_prog_t *pgp;
7157c478bd9Sstevel@tonic-gate dt_stmt_t *stp;
7167c478bd9Sstevel@tonic-gate dtrace_probedesc_t *pdp, pd;
7177c478bd9Sstevel@tonic-gate pid_t pid;
718900524f3Sahl int ret = 0, found = B_FALSE;
7196e0bee74Sjhaslam char provname[DTRACE_PROVNAMELEN];
7206e0bee74Sjhaslam
7216e0bee74Sjhaslam (void) snprintf(provname, sizeof (provname), "pid%d",
7226e0bee74Sjhaslam (int)dpr->dpr_pid);
7237c478bd9Sstevel@tonic-gate
7247c478bd9Sstevel@tonic-gate for (pgp = dt_list_next(&dtp->dt_programs); pgp != NULL;
7257c478bd9Sstevel@tonic-gate pgp = dt_list_next(pgp)) {
7267c478bd9Sstevel@tonic-gate
7277c478bd9Sstevel@tonic-gate for (stp = dt_list_next(&pgp->dp_stmts); stp != NULL;
7287c478bd9Sstevel@tonic-gate stp = dt_list_next(stp)) {
7297c478bd9Sstevel@tonic-gate
7307c478bd9Sstevel@tonic-gate pdp = &stp->ds_desc->dtsd_ecbdesc->dted_probe;
731900524f3Sahl pid = dt_pid_get_pid(pdp, dtp, NULL, dpr);
732900524f3Sahl if (pid != dpr->dpr_pid)
7337c478bd9Sstevel@tonic-gate continue;
7347c478bd9Sstevel@tonic-gate
7357c478bd9Sstevel@tonic-gate found = B_TRUE;
7367c478bd9Sstevel@tonic-gate
7377c478bd9Sstevel@tonic-gate pd = *pdp;
7387c478bd9Sstevel@tonic-gate
7396e0bee74Sjhaslam if (gmatch(provname, pdp->dtpd_provider) != 0 &&
7406e0bee74Sjhaslam dt_pid_create_pid_probes(&pd, dtp, NULL, dpr) != 0)
741900524f3Sahl ret = 1;
7426e0bee74Sjhaslam
7436e0bee74Sjhaslam /*
7446e0bee74Sjhaslam * If it's not strictly a pid provider, we might match
7456e0bee74Sjhaslam * a USDT provider.
7466e0bee74Sjhaslam */
7476e0bee74Sjhaslam if (strcmp(provname, pdp->dtpd_provider) != 0 &&
7486e0bee74Sjhaslam dt_pid_create_usdt_probes(&pd, dtp, NULL, dpr) != 0)
749900524f3Sahl ret = 1;
750900524f3Sahl }
7517c478bd9Sstevel@tonic-gate }
7527c478bd9Sstevel@tonic-gate
7537c478bd9Sstevel@tonic-gate if (found) {
7547c478bd9Sstevel@tonic-gate /*
7557c478bd9Sstevel@tonic-gate * Give DTrace a shot to the ribs to get it to check
7567c478bd9Sstevel@tonic-gate * out the newly created probes.
7577c478bd9Sstevel@tonic-gate */
7587c478bd9Sstevel@tonic-gate (void) dt_ioctl(dtp, DTRACEIOC_ENABLE, NULL);
7597c478bd9Sstevel@tonic-gate }
760900524f3Sahl
761900524f3Sahl return (ret);
7627c478bd9Sstevel@tonic-gate }
763*a386cc11SRobert Mustacchi
764*a386cc11SRobert Mustacchi /*
765*a386cc11SRobert Mustacchi * libdtrace has a backroom deal with us to ask us for type information on
766*a386cc11SRobert Mustacchi * behalf of pid provider probes when fasttrap doesn't return any type
767*a386cc11SRobert Mustacchi * information. Instead we'll look up the module and see if there is type
768*a386cc11SRobert Mustacchi * information available. However, if there is no type information available due
769*a386cc11SRobert Mustacchi * to a lack of CTF data, then we want to make sure that DTrace still carries on
770*a386cc11SRobert Mustacchi * in face of that. As such we don't have a meaningful exit code about failure.
771*a386cc11SRobert Mustacchi * We emit information about why we failed to the dtrace debug log so someone
772*a386cc11SRobert Mustacchi * can figure it out by asking nicely for DTRACE_DEBUG.
773*a386cc11SRobert Mustacchi */
774*a386cc11SRobert Mustacchi void
dt_pid_get_types(dtrace_hdl_t * dtp,const dtrace_probedesc_t * pdp,dtrace_argdesc_t * adp,int * nargs)775*a386cc11SRobert Mustacchi dt_pid_get_types(dtrace_hdl_t *dtp, const dtrace_probedesc_t *pdp,
776*a386cc11SRobert Mustacchi dtrace_argdesc_t *adp, int *nargs)
777*a386cc11SRobert Mustacchi {
778*a386cc11SRobert Mustacchi dt_module_t *dmp;
779*a386cc11SRobert Mustacchi ctf_file_t *fp;
780*a386cc11SRobert Mustacchi ctf_funcinfo_t f;
781*a386cc11SRobert Mustacchi ctf_id_t argv[32];
782*a386cc11SRobert Mustacchi GElf_Sym sym;
783*a386cc11SRobert Mustacchi prsyminfo_t si;
784*a386cc11SRobert Mustacchi struct ps_prochandle *p;
785*a386cc11SRobert Mustacchi int i, args;
786*a386cc11SRobert Mustacchi char buf[DTRACE_ARGTYPELEN];
787*a386cc11SRobert Mustacchi const char *mptr;
788*a386cc11SRobert Mustacchi char *eptr;
789*a386cc11SRobert Mustacchi int ret = 0;
790*a386cc11SRobert Mustacchi int argc = sizeof (argv) / sizeof (ctf_id_t);
791*a386cc11SRobert Mustacchi Lmid_t lmid;
792*a386cc11SRobert Mustacchi
793*a386cc11SRobert Mustacchi /* Set up a potential outcome */
794*a386cc11SRobert Mustacchi args = *nargs;
795*a386cc11SRobert Mustacchi *nargs = 0;
796*a386cc11SRobert Mustacchi
797*a386cc11SRobert Mustacchi /*
798*a386cc11SRobert Mustacchi * If we don't have an entry or return probe then we can just stop right
799*a386cc11SRobert Mustacchi * now as we don't have arguments for offset probes.
800*a386cc11SRobert Mustacchi */
801*a386cc11SRobert Mustacchi if (strcmp(pdp->dtpd_name, "entry") != 0 &&
802*a386cc11SRobert Mustacchi strcmp(pdp->dtpd_name, "return") != 0)
803*a386cc11SRobert Mustacchi return;
804*a386cc11SRobert Mustacchi
805*a386cc11SRobert Mustacchi dmp = dt_module_create(dtp, pdp->dtpd_provider);
806*a386cc11SRobert Mustacchi if (dmp == NULL) {
807*a386cc11SRobert Mustacchi dt_dprintf("failed to find module for %s\n",
808*a386cc11SRobert Mustacchi pdp->dtpd_provider);
809*a386cc11SRobert Mustacchi return;
810*a386cc11SRobert Mustacchi }
811*a386cc11SRobert Mustacchi if (dt_module_load(dtp, dmp) != 0) {
812*a386cc11SRobert Mustacchi dt_dprintf("failed to load module for %s\n",
813*a386cc11SRobert Mustacchi pdp->dtpd_provider);
814*a386cc11SRobert Mustacchi return;
815*a386cc11SRobert Mustacchi }
816*a386cc11SRobert Mustacchi
817*a386cc11SRobert Mustacchi /*
818*a386cc11SRobert Mustacchi * We may be working with a module that doesn't have ctf. If that's the
819*a386cc11SRobert Mustacchi * case then we just return now and move on with life.
820*a386cc11SRobert Mustacchi */
821*a386cc11SRobert Mustacchi fp = dt_module_getctflib(dtp, dmp, pdp->dtpd_mod);
822*a386cc11SRobert Mustacchi if (fp == NULL) {
823*a386cc11SRobert Mustacchi dt_dprintf("no ctf container for %s\n",
824*a386cc11SRobert Mustacchi pdp->dtpd_mod);
825*a386cc11SRobert Mustacchi return;
826*a386cc11SRobert Mustacchi }
827*a386cc11SRobert Mustacchi p = dt_proc_grab(dtp, dmp->dm_pid, 0, PGRAB_RDONLY | PGRAB_FORCE);
828*a386cc11SRobert Mustacchi if (p == NULL) {
829*a386cc11SRobert Mustacchi dt_dprintf("failed to grab pid\n");
830*a386cc11SRobert Mustacchi return;
831*a386cc11SRobert Mustacchi }
832*a386cc11SRobert Mustacchi dt_proc_lock(dtp, p);
833*a386cc11SRobert Mustacchi
834*a386cc11SRobert Mustacchi /*
835*a386cc11SRobert Mustacchi * Check to see if the D module has a link map ID and separate that out
836*a386cc11SRobert Mustacchi * for properly interrogating libproc.
837*a386cc11SRobert Mustacchi */
838*a386cc11SRobert Mustacchi if ((mptr = strchr(pdp->dtpd_mod, '`')) != NULL) {
839*a386cc11SRobert Mustacchi if (strlen(pdp->dtpd_mod) < 3) {
840*a386cc11SRobert Mustacchi dt_dprintf("found weird modname with linkmap, "
841*a386cc11SRobert Mustacchi "aborting: %s\n", pdp->dtpd_mod);
842*a386cc11SRobert Mustacchi goto out;
843*a386cc11SRobert Mustacchi }
844*a386cc11SRobert Mustacchi if (pdp->dtpd_mod[0] != 'L' || pdp->dtpd_mod[1] != 'M') {
845*a386cc11SRobert Mustacchi dt_dprintf("missing leading 'LM', "
846*a386cc11SRobert Mustacchi "aborting: %s\n", pdp->dtpd_mod);
847*a386cc11SRobert Mustacchi goto out;
848*a386cc11SRobert Mustacchi }
849*a386cc11SRobert Mustacchi errno = 0;
850*a386cc11SRobert Mustacchi lmid = strtol(pdp->dtpd_mod + 2, &eptr, 16);
851*a386cc11SRobert Mustacchi if (errno == ERANGE || eptr != mptr) {
852*a386cc11SRobert Mustacchi dt_dprintf("failed to parse out lmid, aborting: %s\n",
853*a386cc11SRobert Mustacchi pdp->dtpd_mod);
854*a386cc11SRobert Mustacchi goto out;
855*a386cc11SRobert Mustacchi }
856*a386cc11SRobert Mustacchi mptr++;
857*a386cc11SRobert Mustacchi } else {
858*a386cc11SRobert Mustacchi mptr = pdp->dtpd_mod;
859*a386cc11SRobert Mustacchi lmid = 0;
860*a386cc11SRobert Mustacchi }
861*a386cc11SRobert Mustacchi
862*a386cc11SRobert Mustacchi if (Pxlookup_by_name(p, lmid, mptr, pdp->dtpd_func,
863*a386cc11SRobert Mustacchi &sym, &si) != 0) {
864*a386cc11SRobert Mustacchi dt_dprintf("failed to find function %s in %s`%s\n",
865*a386cc11SRobert Mustacchi pdp->dtpd_func, pdp->dtpd_provider, pdp->dtpd_mod);
866*a386cc11SRobert Mustacchi goto out;
867*a386cc11SRobert Mustacchi }
868*a386cc11SRobert Mustacchi if (ctf_func_info(fp, si.prs_id, &f) == CTF_ERR) {
869*a386cc11SRobert Mustacchi dt_dprintf("failed to get ctf information for %s in %s`%s\n",
870*a386cc11SRobert Mustacchi pdp->dtpd_func, pdp->dtpd_provider, pdp->dtpd_mod);
871*a386cc11SRobert Mustacchi goto out;
872*a386cc11SRobert Mustacchi }
873*a386cc11SRobert Mustacchi
874*a386cc11SRobert Mustacchi (void) snprintf(buf, sizeof (buf), "%s`%s", pdp->dtpd_provider,
875*a386cc11SRobert Mustacchi pdp->dtpd_mod);
876*a386cc11SRobert Mustacchi
877*a386cc11SRobert Mustacchi if (strcmp(pdp->dtpd_name, "return") == 0) {
878*a386cc11SRobert Mustacchi if (args < 2)
879*a386cc11SRobert Mustacchi goto out;
880*a386cc11SRobert Mustacchi
881*a386cc11SRobert Mustacchi bzero(adp, sizeof (dtrace_argdesc_t));
882*a386cc11SRobert Mustacchi adp->dtargd_ndx = 0;
883*a386cc11SRobert Mustacchi adp->dtargd_id = pdp->dtpd_id;
884*a386cc11SRobert Mustacchi adp->dtargd_mapping = adp->dtargd_ndx;
885*a386cc11SRobert Mustacchi /*
886*a386cc11SRobert Mustacchi * We explicitly leave out the library here, we only care that
887*a386cc11SRobert Mustacchi * it is some int. We are assuming that there is no ctf
888*a386cc11SRobert Mustacchi * container in here that is lying about what an int is.
889*a386cc11SRobert Mustacchi */
890*a386cc11SRobert Mustacchi (void) snprintf(adp->dtargd_native, DTRACE_ARGTYPELEN,
891*a386cc11SRobert Mustacchi "user %s`%s", pdp->dtpd_provider, "int");
892*a386cc11SRobert Mustacchi adp++;
893*a386cc11SRobert Mustacchi bzero(adp, sizeof (dtrace_argdesc_t));
894*a386cc11SRobert Mustacchi adp->dtargd_ndx = 1;
895*a386cc11SRobert Mustacchi adp->dtargd_id = pdp->dtpd_id;
896*a386cc11SRobert Mustacchi adp->dtargd_mapping = adp->dtargd_ndx;
897*a386cc11SRobert Mustacchi ret = snprintf(adp->dtargd_native, DTRACE_ARGTYPELEN,
898*a386cc11SRobert Mustacchi "userland ");
899*a386cc11SRobert Mustacchi (void) ctf_type_qname(fp, f.ctc_return, adp->dtargd_native +
900*a386cc11SRobert Mustacchi ret, DTRACE_ARGTYPELEN - ret, buf);
901*a386cc11SRobert Mustacchi *nargs = 2;
902*a386cc11SRobert Mustacchi } else {
903*a386cc11SRobert Mustacchi if (ctf_func_args(fp, si.prs_id, argc, argv) == CTF_ERR)
904*a386cc11SRobert Mustacchi goto out;
905*a386cc11SRobert Mustacchi
906*a386cc11SRobert Mustacchi *nargs = MIN(args, f.ctc_argc);
907*a386cc11SRobert Mustacchi for (i = 0; i < *nargs; i++, adp++) {
908*a386cc11SRobert Mustacchi bzero(adp, sizeof (dtrace_argdesc_t));
909*a386cc11SRobert Mustacchi adp->dtargd_ndx = i;
910*a386cc11SRobert Mustacchi adp->dtargd_id = pdp->dtpd_id;
911*a386cc11SRobert Mustacchi adp->dtargd_mapping = adp->dtargd_ndx;
912*a386cc11SRobert Mustacchi ret = snprintf(adp->dtargd_native, DTRACE_ARGTYPELEN,
913*a386cc11SRobert Mustacchi "userland ");
914*a386cc11SRobert Mustacchi (void) ctf_type_qname(fp, argv[i], adp->dtargd_native +
915*a386cc11SRobert Mustacchi ret, DTRACE_ARGTYPELEN - ret, buf);
916*a386cc11SRobert Mustacchi }
917*a386cc11SRobert Mustacchi }
918*a386cc11SRobert Mustacchi out:
919*a386cc11SRobert Mustacchi dt_proc_unlock(dtp, p);
920*a386cc11SRobert Mustacchi dt_proc_release(dtp, p);
921*a386cc11SRobert Mustacchi }
922