1178479Sjb/* 2178479Sjb * CDDL HEADER START 3178479Sjb * 4178479Sjb * The contents of this file are subject to the terms of the 5178479Sjb * Common Development and Distribution License (the "License"). 6178479Sjb * You may not use this file except in compliance with the License. 7178479Sjb * 8178479Sjb * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9178479Sjb * or http://www.opensolaris.org/os/licensing. 10178479Sjb * See the License for the specific language governing permissions 11178479Sjb * and limitations under the License. 12178479Sjb * 13178479Sjb * When distributing Covered Code, include this CDDL HEADER in each 14178479Sjb * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15178479Sjb * If applicable, add the following below this CDDL HEADER, with the 16178479Sjb * fields enclosed by brackets "[]" replaced with your own identifying 17178479Sjb * information: Portions Copyright [yyyy] [name of copyright owner] 18178479Sjb * 19178479Sjb * CDDL HEADER END 20178479Sjb */ 21178479Sjb 22178479Sjb/* 23210767Srpaulo * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 24178479Sjb * Use is subject to license terms. 25178479Sjb */ 26268578Srpaulo/* 27268578Srpaulo * Copyright (c) 2013, Joyent, Inc. All rights reserved. 28268578Srpaulo */ 29178479Sjb 30178479Sjb#include <assert.h> 31178479Sjb#include <strings.h> 32178479Sjb#include <stdlib.h> 33178479Sjb#include <stdio.h> 34178479Sjb#include <errno.h> 35178479Sjb#include <ctype.h> 36297077Smav#ifdef illumos 37178479Sjb#include <alloca.h> 38178568Sjb#endif 39178479Sjb#include <libgen.h> 40178479Sjb#include <stddef.h> 41268578Srpaulo#include <sys/sysmacros.h> 42178479Sjb 43178479Sjb#include <dt_impl.h> 44178479Sjb#include <dt_program.h> 45178479Sjb#include <dt_pid.h> 46178479Sjb#include <dt_string.h> 47297077Smav#ifndef illumos 48211554Srpaulo#include <libproc_compat.h> 49211554Srpaulo#endif 50268578Srpaulo#include <dt_module.h> 51178479Sjb 52178479Sjbtypedef struct dt_pid_probe { 53178479Sjb dtrace_hdl_t *dpp_dtp; 54178479Sjb dt_pcb_t *dpp_pcb; 55178479Sjb dt_proc_t *dpp_dpr; 56178479Sjb struct ps_prochandle *dpp_pr; 57178479Sjb const char *dpp_mod; 58178479Sjb char *dpp_func; 59178479Sjb const char *dpp_name; 60178479Sjb const char *dpp_obj; 61178479Sjb uintptr_t dpp_pc; 62178479Sjb size_t dpp_size; 63178479Sjb Lmid_t dpp_lmid; 64178479Sjb uint_t dpp_nmatches; 65178479Sjb uint64_t dpp_stret[4]; 66178479Sjb GElf_Sym dpp_last; 67178479Sjb uint_t dpp_last_taken; 68178479Sjb} dt_pid_probe_t; 69178479Sjb 70178479Sjb/* 71178479Sjb * Compose the lmid and object name into the canonical representation. We 72178479Sjb * omit the lmid for the default link map for convenience. 73178479Sjb */ 74178479Sjbstatic void 75178479Sjbdt_pid_objname(char *buf, size_t len, Lmid_t lmid, const char *obj) 76178479Sjb{ 77297077Smav#ifdef illumos 78178479Sjb if (lmid == LM_ID_BASE) 79178479Sjb (void) strncpy(buf, obj, len); 80178479Sjb else 81178479Sjb (void) snprintf(buf, len, "LM%lx`%s", lmid, obj); 82178568Sjb#else 83178568Sjb (void) strncpy(buf, obj, len); 84178568Sjb#endif 85178479Sjb} 86178479Sjb 87178479Sjbstatic int 88178479Sjbdt_pid_error(dtrace_hdl_t *dtp, dt_pcb_t *pcb, dt_proc_t *dpr, 89178479Sjb fasttrap_probe_spec_t *ftp, dt_errtag_t tag, const char *fmt, ...) 90178479Sjb{ 91178479Sjb va_list ap; 92178479Sjb int len; 93178479Sjb 94178479Sjb if (ftp != NULL) 95178479Sjb dt_free(dtp, ftp); 96178479Sjb 97178479Sjb va_start(ap, fmt); 98178479Sjb if (pcb == NULL) { 99178479Sjb assert(dpr != NULL); 100178479Sjb len = vsnprintf(dpr->dpr_errmsg, sizeof (dpr->dpr_errmsg), 101178479Sjb fmt, ap); 102178479Sjb assert(len >= 2); 103178479Sjb if (dpr->dpr_errmsg[len - 2] == '\n') 104178479Sjb dpr->dpr_errmsg[len - 2] = '\0'; 105178479Sjb } else { 106178479Sjb dt_set_errmsg(dtp, dt_errtag(tag), pcb->pcb_region, 107178479Sjb pcb->pcb_filetag, pcb->pcb_fileptr ? yylineno : 0, fmt, ap); 108178479Sjb } 109178479Sjb va_end(ap); 110178479Sjb 111178479Sjb return (1); 112178479Sjb} 113178479Sjb 114178479Sjbstatic int 115178479Sjbdt_pid_per_sym(dt_pid_probe_t *pp, const GElf_Sym *symp, const char *func) 116178479Sjb{ 117178479Sjb dtrace_hdl_t *dtp = pp->dpp_dtp; 118178479Sjb dt_pcb_t *pcb = pp->dpp_pcb; 119178479Sjb dt_proc_t *dpr = pp->dpp_dpr; 120178479Sjb fasttrap_probe_spec_t *ftp; 121178479Sjb uint64_t off; 122178479Sjb char *end; 123178479Sjb uint_t nmatches = 0; 124178479Sjb ulong_t sz; 125178479Sjb int glob, err; 126178479Sjb int isdash = strcmp("-", func) == 0; 127178479Sjb pid_t pid; 128178479Sjb 129297077Smav#ifdef illumos 130178479Sjb pid = Pstatus(pp->dpp_pr)->pr_pid; 131178568Sjb#else 132178568Sjb pid = proc_getpid(pp->dpp_pr); 133178568Sjb#endif 134178479Sjb 135178479Sjb dt_dprintf("creating probe pid%d:%s:%s:%s\n", (int)pid, pp->dpp_obj, 136178479Sjb func, pp->dpp_name); 137178479Sjb 138178479Sjb sz = sizeof (fasttrap_probe_spec_t) + (isdash ? 4 : 139178479Sjb (symp->st_size - 1) * sizeof (ftp->ftps_offs[0])); 140178479Sjb 141178479Sjb if ((ftp = dt_alloc(dtp, sz)) == NULL) { 142178479Sjb dt_dprintf("proc_per_sym: dt_alloc(%lu) failed\n", sz); 143178479Sjb return (1); /* errno is set for us */ 144178479Sjb } 145178479Sjb 146178479Sjb ftp->ftps_pid = pid; 147178479Sjb (void) strncpy(ftp->ftps_func, func, sizeof (ftp->ftps_func)); 148178479Sjb 149178479Sjb dt_pid_objname(ftp->ftps_mod, sizeof (ftp->ftps_mod), pp->dpp_lmid, 150178479Sjb pp->dpp_obj); 151178479Sjb 152178479Sjb if (!isdash && gmatch("return", pp->dpp_name)) { 153178479Sjb if (dt_pid_create_return_probe(pp->dpp_pr, dtp, ftp, symp, 154178479Sjb pp->dpp_stret) < 0) { 155178479Sjb return (dt_pid_error(dtp, pcb, dpr, ftp, 156178479Sjb D_PROC_CREATEFAIL, "failed to create return probe " 157178479Sjb "for '%s': %s", func, 158178479Sjb dtrace_errmsg(dtp, dtrace_errno(dtp)))); 159178479Sjb } 160178479Sjb 161178479Sjb nmatches++; 162178479Sjb } 163178479Sjb 164178479Sjb if (!isdash && gmatch("entry", pp->dpp_name)) { 165178479Sjb if (dt_pid_create_entry_probe(pp->dpp_pr, dtp, ftp, symp) < 0) { 166178479Sjb return (dt_pid_error(dtp, pcb, dpr, ftp, 167178479Sjb D_PROC_CREATEFAIL, "failed to create entry probe " 168178479Sjb "for '%s': %s", func, 169178479Sjb dtrace_errmsg(dtp, dtrace_errno(dtp)))); 170178479Sjb } 171178479Sjb 172178479Sjb nmatches++; 173178479Sjb } 174178479Sjb 175178479Sjb glob = strisglob(pp->dpp_name); 176178479Sjb if (!glob && nmatches == 0) { 177178479Sjb off = strtoull(pp->dpp_name, &end, 16); 178178479Sjb if (*end != '\0') { 179178479Sjb return (dt_pid_error(dtp, pcb, dpr, ftp, D_PROC_NAME, 180178479Sjb "'%s' is an invalid probe name", pp->dpp_name)); 181178479Sjb } 182178479Sjb 183178479Sjb if (off >= symp->st_size) { 184178479Sjb return (dt_pid_error(dtp, pcb, dpr, ftp, D_PROC_OFF, 185178479Sjb "offset 0x%llx outside of function '%s'", 186178479Sjb (u_longlong_t)off, func)); 187178479Sjb } 188178479Sjb 189178479Sjb err = dt_pid_create_offset_probe(pp->dpp_pr, pp->dpp_dtp, ftp, 190178479Sjb symp, off); 191178479Sjb 192178479Sjb if (err == DT_PROC_ERR) { 193178479Sjb return (dt_pid_error(dtp, pcb, dpr, ftp, 194178479Sjb D_PROC_CREATEFAIL, "failed to create probe at " 195178479Sjb "'%s+0x%llx': %s", func, (u_longlong_t)off, 196178479Sjb dtrace_errmsg(dtp, dtrace_errno(dtp)))); 197178479Sjb } 198178479Sjb 199178479Sjb if (err == DT_PROC_ALIGN) { 200178479Sjb return (dt_pid_error(dtp, pcb, dpr, ftp, D_PROC_ALIGN, 201178479Sjb "offset 0x%llx is not aligned on an instruction", 202178479Sjb (u_longlong_t)off)); 203178479Sjb } 204178479Sjb 205178479Sjb nmatches++; 206178479Sjb 207178479Sjb } else if (glob && !isdash) { 208178479Sjb if (dt_pid_create_glob_offset_probes(pp->dpp_pr, 209178479Sjb pp->dpp_dtp, ftp, symp, pp->dpp_name) < 0) { 210178479Sjb return (dt_pid_error(dtp, pcb, dpr, ftp, 211178479Sjb D_PROC_CREATEFAIL, 212178479Sjb "failed to create offset probes in '%s': %s", func, 213178479Sjb dtrace_errmsg(dtp, dtrace_errno(dtp)))); 214178479Sjb } 215178479Sjb 216178479Sjb nmatches++; 217178479Sjb } 218178479Sjb 219178479Sjb pp->dpp_nmatches += nmatches; 220178479Sjb 221178479Sjb dt_free(dtp, ftp); 222178479Sjb 223178479Sjb return (0); 224178479Sjb} 225178479Sjb 226178479Sjbstatic int 227178479Sjbdt_pid_sym_filt(void *arg, const GElf_Sym *symp, const char *func) 228178479Sjb{ 229178479Sjb dt_pid_probe_t *pp = arg; 230178479Sjb 231178479Sjb if (symp->st_shndx == SHN_UNDEF) 232178479Sjb return (0); 233178479Sjb 234178479Sjb if (symp->st_size == 0) { 235178479Sjb dt_dprintf("st_size of %s is zero\n", func); 236178479Sjb return (0); 237178479Sjb } 238178479Sjb 239178479Sjb if (pp->dpp_last_taken == 0 || 240178479Sjb symp->st_value != pp->dpp_last.st_value || 241178479Sjb symp->st_size != pp->dpp_last.st_size) { 242178479Sjb /* 243178479Sjb * Due to 4524008, _init and _fini may have a bloated st_size. 244178479Sjb * While this bug has been fixed for a while, old binaries 245178479Sjb * may exist that still exhibit this problem. As a result, we 246178479Sjb * don't match _init and _fini though we allow users to 247178479Sjb * specify them explicitly. 248178479Sjb */ 249178479Sjb if (strcmp(func, "_init") == 0 || strcmp(func, "_fini") == 0) 250178479Sjb return (0); 251178479Sjb 252178479Sjb if ((pp->dpp_last_taken = gmatch(func, pp->dpp_func)) != 0) { 253178479Sjb pp->dpp_last = *symp; 254178479Sjb return (dt_pid_per_sym(pp, symp, func)); 255178479Sjb } 256178479Sjb } 257178479Sjb 258178479Sjb return (0); 259178479Sjb} 260178479Sjb 261178479Sjbstatic int 262178479Sjbdt_pid_per_mod(void *arg, const prmap_t *pmp, const char *obj) 263178479Sjb{ 264178479Sjb dt_pid_probe_t *pp = arg; 265178479Sjb dtrace_hdl_t *dtp = pp->dpp_dtp; 266178479Sjb dt_pcb_t *pcb = pp->dpp_pcb; 267178479Sjb dt_proc_t *dpr = pp->dpp_dpr; 268178479Sjb GElf_Sym sym; 269178479Sjb 270178479Sjb if (obj == NULL) 271178479Sjb return (0); 272178479Sjb 273297077Smav#ifdef illumos 274178479Sjb (void) Plmid(pp->dpp_pr, pmp->pr_vaddr, &pp->dpp_lmid); 275178568Sjb#endif 276178568Sjb 277178479Sjb 278178479Sjb if ((pp->dpp_obj = strrchr(obj, '/')) == NULL) 279178479Sjb pp->dpp_obj = obj; 280178479Sjb else 281178479Sjb pp->dpp_obj++; 282297077Smav#ifdef illumos 283178479Sjb if (Pxlookup_by_name(pp->dpp_pr, pp->dpp_lmid, obj, ".stret1", &sym, 284178479Sjb NULL) == 0) 285178479Sjb pp->dpp_stret[0] = sym.st_value; 286178479Sjb else 287178479Sjb pp->dpp_stret[0] = 0; 288178479Sjb 289178479Sjb if (Pxlookup_by_name(pp->dpp_pr, pp->dpp_lmid, obj, ".stret2", &sym, 290178479Sjb NULL) == 0) 291178479Sjb pp->dpp_stret[1] = sym.st_value; 292178479Sjb else 293178479Sjb pp->dpp_stret[1] = 0; 294178479Sjb 295178479Sjb if (Pxlookup_by_name(pp->dpp_pr, pp->dpp_lmid, obj, ".stret4", &sym, 296178479Sjb NULL) == 0) 297178479Sjb pp->dpp_stret[2] = sym.st_value; 298178479Sjb else 299178479Sjb pp->dpp_stret[2] = 0; 300178479Sjb 301178479Sjb if (Pxlookup_by_name(pp->dpp_pr, pp->dpp_lmid, obj, ".stret8", &sym, 302178479Sjb NULL) == 0) 303178479Sjb pp->dpp_stret[3] = sym.st_value; 304178479Sjb else 305178479Sjb pp->dpp_stret[3] = 0; 306178568Sjb#else 307211554Srpaulo pp->dpp_stret[0] = 0; 308211554Srpaulo pp->dpp_stret[1] = 0; 309211554Srpaulo pp->dpp_stret[2] = 0; 310211554Srpaulo pp->dpp_stret[3] = 0; 311178568Sjb#endif 312178568Sjb 313178479Sjb dt_dprintf("%s stret %llx %llx %llx %llx\n", obj, 314178479Sjb (u_longlong_t)pp->dpp_stret[0], (u_longlong_t)pp->dpp_stret[1], 315178479Sjb (u_longlong_t)pp->dpp_stret[2], (u_longlong_t)pp->dpp_stret[3]); 316178479Sjb 317178479Sjb /* 318178479Sjb * If pp->dpp_func contains any globbing meta-characters, we need 319178479Sjb * to iterate over the symbol table and compare each function name 320178479Sjb * against the pattern. 321178479Sjb */ 322178479Sjb if (!strisglob(pp->dpp_func)) { 323178479Sjb /* 324178479Sjb * If we fail to lookup the symbol, try interpreting the 325178479Sjb * function as the special "-" function that indicates that the 326178479Sjb * probe name should be interpreted as a absolute virtual 327178479Sjb * address. If that fails and we were matching a specific 328178479Sjb * function in a specific module, report the error, otherwise 329178479Sjb * just fail silently in the hopes that some other object will 330178479Sjb * contain the desired symbol. 331178479Sjb */ 332178479Sjb if (Pxlookup_by_name(pp->dpp_pr, pp->dpp_lmid, obj, 333178479Sjb pp->dpp_func, &sym, NULL) != 0) { 334178479Sjb if (strcmp("-", pp->dpp_func) == 0) { 335178479Sjb sym.st_name = 0; 336178479Sjb sym.st_info = 337178479Sjb GELF_ST_INFO(STB_LOCAL, STT_FUNC); 338178479Sjb sym.st_other = 0; 339178479Sjb sym.st_value = 0; 340297077Smav#ifdef illumos 341178479Sjb sym.st_size = Pstatus(pp->dpp_pr)->pr_dmodel == 342178479Sjb PR_MODEL_ILP32 ? -1U : -1ULL; 343178568Sjb#else 344178568Sjb sym.st_size = ~((Elf64_Xword) 0); 345178568Sjb#endif 346178479Sjb 347178479Sjb } else if (!strisglob(pp->dpp_mod)) { 348178479Sjb return (dt_pid_error(dtp, pcb, dpr, NULL, 349178479Sjb D_PROC_FUNC, 350178479Sjb "failed to lookup '%s' in module '%s'", 351178479Sjb pp->dpp_func, pp->dpp_mod)); 352178479Sjb } else { 353178479Sjb return (0); 354178479Sjb } 355178479Sjb } 356178479Sjb 357178479Sjb /* 358178479Sjb * Only match defined functions of non-zero size. 359178479Sjb */ 360178479Sjb if (GELF_ST_TYPE(sym.st_info) != STT_FUNC || 361178479Sjb sym.st_shndx == SHN_UNDEF || sym.st_size == 0) 362178479Sjb return (0); 363178479Sjb 364178479Sjb /* 365178479Sjb * We don't instrument PLTs -- they're dynamically rewritten, 366178479Sjb * and, so, inherently dicey to instrument. 367178479Sjb */ 368178568Sjb#ifdef DOODAD 369178479Sjb if (Ppltdest(pp->dpp_pr, sym.st_value) != NULL) 370178479Sjb return (0); 371178568Sjb#endif 372178479Sjb 373178479Sjb (void) Plookup_by_addr(pp->dpp_pr, sym.st_value, pp->dpp_func, 374178479Sjb DTRACE_FUNCNAMELEN, &sym); 375178479Sjb 376178479Sjb return (dt_pid_per_sym(pp, &sym, pp->dpp_func)); 377178479Sjb } else { 378178479Sjb uint_t nmatches = pp->dpp_nmatches; 379178479Sjb 380178479Sjb if (Psymbol_iter_by_addr(pp->dpp_pr, obj, PR_SYMTAB, 381178479Sjb BIND_ANY | TYPE_FUNC, dt_pid_sym_filt, pp) == 1) 382178479Sjb return (1); 383178479Sjb 384178479Sjb if (nmatches == pp->dpp_nmatches) { 385178479Sjb /* 386178479Sjb * If we didn't match anything in the PR_SYMTAB, try 387178479Sjb * the PR_DYNSYM. 388178479Sjb */ 389178479Sjb if (Psymbol_iter_by_addr(pp->dpp_pr, obj, PR_DYNSYM, 390178479Sjb BIND_ANY | TYPE_FUNC, dt_pid_sym_filt, pp) == 1) 391178479Sjb return (1); 392178479Sjb } 393178479Sjb } 394178479Sjb 395178479Sjb return (0); 396178479Sjb} 397178479Sjb 398178479Sjbstatic int 399178479Sjbdt_pid_mod_filt(void *arg, const prmap_t *pmp, const char *obj) 400178479Sjb{ 401178479Sjb char name[DTRACE_MODNAMELEN]; 402178479Sjb dt_pid_probe_t *pp = arg; 403178479Sjb 404178479Sjb if (gmatch(obj, pp->dpp_mod)) 405178479Sjb return (dt_pid_per_mod(pp, pmp, obj)); 406178479Sjb 407297077Smav#ifdef illumos 408178479Sjb (void) Plmid(pp->dpp_pr, pmp->pr_vaddr, &pp->dpp_lmid); 409178568Sjb#else 410178568Sjb pp->dpp_lmid = 0; 411178568Sjb#endif 412178479Sjb 413178479Sjb if ((pp->dpp_obj = strrchr(obj, '/')) == NULL) 414178479Sjb pp->dpp_obj = obj; 415178479Sjb else 416178479Sjb pp->dpp_obj++; 417178479Sjb 418210767Srpaulo if (gmatch(pp->dpp_obj, pp->dpp_mod)) 419210767Srpaulo return (dt_pid_per_mod(pp, pmp, obj)); 420178479Sjb 421297077Smav#ifdef illumos 422210767Srpaulo (void) Plmid(pp->dpp_pr, pmp->pr_vaddr, &pp->dpp_lmid); 423210775Srpaulo#endif 424210767Srpaulo 425210767Srpaulo dt_pid_objname(name, sizeof (name), pp->dpp_lmid, pp->dpp_obj); 426210767Srpaulo 427178479Sjb if (gmatch(name, pp->dpp_mod)) 428178479Sjb return (dt_pid_per_mod(pp, pmp, obj)); 429178479Sjb 430178479Sjb return (0); 431178479Sjb} 432178479Sjb 433178479Sjbstatic const prmap_t * 434178479Sjbdt_pid_fix_mod(dtrace_probedesc_t *pdp, struct ps_prochandle *P) 435178479Sjb{ 436178479Sjb char m[MAXPATHLEN]; 437297077Smav#ifdef illumos 438178479Sjb Lmid_t lmid = PR_LMID_EVERY; 439211554Srpaulo#else 440211554Srpaulo Lmid_t lmid = 0; 441211554Srpaulo#endif 442178479Sjb const char *obj; 443178479Sjb const prmap_t *pmp; 444178479Sjb 445297077Smav#ifdef illumos 446178479Sjb /* 447178479Sjb * Pick apart the link map from the library name. 448178479Sjb */ 449178479Sjb if (strchr(pdp->dtpd_mod, '`') != NULL) { 450178479Sjb char *end; 451178479Sjb 452178479Sjb if (strncmp(pdp->dtpd_mod, "LM", 2) != 0 || 453178479Sjb !isdigit(pdp->dtpd_mod[2])) 454178479Sjb return (NULL); 455178479Sjb 456178479Sjb lmid = strtoul(&pdp->dtpd_mod[2], &end, 16); 457178479Sjb 458178479Sjb obj = end + 1; 459178479Sjb 460178479Sjb if (*end != '`' || strchr(obj, '`') != NULL) 461178479Sjb return (NULL); 462178479Sjb 463178479Sjb } else { 464178479Sjb obj = pdp->dtpd_mod; 465178479Sjb } 466211554Srpaulo#else 467211554Srpaulo obj = pdp->dtpd_mod; 468211554Srpaulo#endif 469178479Sjb 470178479Sjb if ((pmp = Plmid_to_map(P, lmid, obj)) == NULL) 471178479Sjb return (NULL); 472178479Sjb 473297077Smav#ifdef illumos 474178479Sjb (void) Pobjname(P, pmp->pr_vaddr, m, sizeof (m)); 475178479Sjb if ((obj = strrchr(m, '/')) == NULL) 476178479Sjb obj = &m[0]; 477178479Sjb else 478178479Sjb obj++; 479178479Sjb 480178479Sjb (void) Plmid(P, pmp->pr_vaddr, &lmid); 481211554Srpaulo#endif 482178568Sjb 483178479Sjb dt_pid_objname(pdp->dtpd_mod, sizeof (pdp->dtpd_mod), lmid, obj); 484178479Sjb 485178479Sjb return (pmp); 486178479Sjb} 487178479Sjb 488178479Sjb 489178479Sjbstatic int 490178479Sjbdt_pid_create_pid_probes(dtrace_probedesc_t *pdp, dtrace_hdl_t *dtp, 491178479Sjb dt_pcb_t *pcb, dt_proc_t *dpr) 492178479Sjb{ 493178479Sjb dt_pid_probe_t pp; 494178479Sjb int ret = 0; 495178479Sjb 496178479Sjb pp.dpp_dtp = dtp; 497178479Sjb pp.dpp_dpr = dpr; 498178479Sjb pp.dpp_pr = dpr->dpr_proc; 499178479Sjb pp.dpp_pcb = pcb; 500178479Sjb 501178568Sjb#ifdef DOODAD 502178479Sjb /* 503178479Sjb * We can only trace dynamically-linked executables (since we've 504178479Sjb * hidden some magic in ld.so.1 as well as libc.so.1). 505178479Sjb */ 506178479Sjb if (Pname_to_map(pp.dpp_pr, PR_OBJ_LDSO) == NULL) { 507178479Sjb return (dt_pid_error(dtp, pcb, dpr, NULL, D_PROC_DYN, 508178479Sjb "process %s is not a dynamically-linked executable", 509178479Sjb &pdp->dtpd_provider[3])); 510178479Sjb } 511178568Sjb#endif 512178479Sjb 513178479Sjb pp.dpp_mod = pdp->dtpd_mod[0] != '\0' ? pdp->dtpd_mod : "*"; 514178479Sjb pp.dpp_func = pdp->dtpd_func[0] != '\0' ? pdp->dtpd_func : "*"; 515178479Sjb pp.dpp_name = pdp->dtpd_name[0] != '\0' ? pdp->dtpd_name : "*"; 516178479Sjb pp.dpp_last_taken = 0; 517178479Sjb 518178479Sjb if (strcmp(pp.dpp_func, "-") == 0) { 519178479Sjb const prmap_t *aout, *pmp; 520178479Sjb 521178479Sjb if (pdp->dtpd_mod[0] == '\0') { 522178479Sjb pp.dpp_mod = pdp->dtpd_mod; 523178479Sjb (void) strcpy(pdp->dtpd_mod, "a.out"); 524178479Sjb } else if (strisglob(pp.dpp_mod) || 525178479Sjb (aout = Pname_to_map(pp.dpp_pr, "a.out")) == NULL || 526178479Sjb (pmp = Pname_to_map(pp.dpp_pr, pp.dpp_mod)) == NULL || 527178479Sjb aout->pr_vaddr != pmp->pr_vaddr) { 528178479Sjb return (dt_pid_error(dtp, pcb, dpr, NULL, D_PROC_LIB, 529178479Sjb "only the a.out module is valid with the " 530178479Sjb "'-' function")); 531178479Sjb } 532178479Sjb 533178479Sjb if (strisglob(pp.dpp_name)) { 534178479Sjb return (dt_pid_error(dtp, pcb, dpr, NULL, D_PROC_NAME, 535178479Sjb "only individual addresses may be specified " 536178479Sjb "with the '-' function")); 537178479Sjb } 538178479Sjb } 539178479Sjb 540178479Sjb /* 541178479Sjb * If pp.dpp_mod contains any globbing meta-characters, we need 542178479Sjb * to iterate over each module and compare its name against the 543178479Sjb * pattern. An empty module name is treated as '*'. 544178479Sjb */ 545178479Sjb if (strisglob(pp.dpp_mod)) { 546178479Sjb ret = Pobject_iter(pp.dpp_pr, dt_pid_mod_filt, &pp); 547178479Sjb } else { 548178479Sjb const prmap_t *pmp; 549178479Sjb char *obj; 550178479Sjb 551178479Sjb /* 552178479Sjb * If we can't find a matching module, don't sweat it -- either 553178479Sjb * we'll fail the enabling because the probes don't exist or 554178479Sjb * we'll wait for that module to come along. 555178479Sjb */ 556178479Sjb if ((pmp = dt_pid_fix_mod(pdp, pp.dpp_pr)) != NULL) { 557178479Sjb if ((obj = strchr(pdp->dtpd_mod, '`')) == NULL) 558178479Sjb obj = pdp->dtpd_mod; 559178479Sjb else 560178479Sjb obj++; 561178479Sjb 562178479Sjb ret = dt_pid_per_mod(&pp, pmp, obj); 563178479Sjb } 564178479Sjb } 565178479Sjb 566178479Sjb return (ret); 567178479Sjb} 568178479Sjb 569178479Sjbstatic int 570178479Sjbdt_pid_usdt_mapping(void *data, const prmap_t *pmp, const char *oname) 571178479Sjb{ 572178479Sjb struct ps_prochandle *P = data; 573178479Sjb GElf_Sym sym; 574297077Smav#ifdef illumos 575178479Sjb prsyminfo_t sip; 576178568Sjb#endif 577178479Sjb dof_helper_t dh; 578178479Sjb GElf_Half e_type; 579178479Sjb const char *mname; 580178479Sjb const char *syms[] = { "___SUNW_dof", "__SUNW_dof" }; 581178479Sjb int i, fd = -1; 582178479Sjb 583178479Sjb /* 584178479Sjb * The symbol ___SUNW_dof is for lazy-loaded DOF sections, and 585178479Sjb * __SUNW_dof is for actively-loaded DOF sections. We try to force 586178479Sjb * in both types of DOF section since the process may not yet have 587178479Sjb * run the code to instantiate these providers. 588178479Sjb */ 589178479Sjb for (i = 0; i < 2; i++) { 590178479Sjb if (Pxlookup_by_name(P, PR_LMID_EVERY, oname, syms[i], &sym, 591178479Sjb &sip) != 0) { 592178479Sjb continue; 593178479Sjb } 594178479Sjb 595178479Sjb if ((mname = strrchr(oname, '/')) == NULL) 596178479Sjb mname = oname; 597178479Sjb else 598178479Sjb mname++; 599178479Sjb 600178479Sjb dt_dprintf("lookup of %s succeeded for %s\n", syms[i], mname); 601178479Sjb 602178479Sjb if (Pread(P, &e_type, sizeof (e_type), pmp->pr_vaddr + 603178479Sjb offsetof(Elf64_Ehdr, e_type)) != sizeof (e_type)) { 604178479Sjb dt_dprintf("read of ELF header failed"); 605178479Sjb continue; 606178479Sjb } 607178479Sjb 608178479Sjb dh.dofhp_dof = sym.st_value; 609178479Sjb dh.dofhp_addr = (e_type == ET_EXEC) ? 0 : pmp->pr_vaddr; 610178479Sjb 611178479Sjb dt_pid_objname(dh.dofhp_mod, sizeof (dh.dofhp_mod), 612297077Smav#ifdef illumos 613178479Sjb sip.prs_lmid, mname); 614178568Sjb#else 615178568Sjb 0, mname); 616178568Sjb#endif 617178479Sjb 618297077Smav#ifdef illumos 619178479Sjb if (fd == -1 && 620178479Sjb (fd = pr_open(P, "/dev/dtrace/helper", O_RDWR, 0)) < 0) { 621178479Sjb dt_dprintf("pr_open of helper device failed: %s\n", 622178479Sjb strerror(errno)); 623178479Sjb return (-1); /* errno is set for us */ 624178479Sjb } 625178479Sjb 626178479Sjb if (pr_ioctl(P, fd, DTRACEHIOC_ADDDOF, &dh, sizeof (dh)) < 0) 627178479Sjb dt_dprintf("DOF was rejected for %s\n", dh.dofhp_mod); 628178568Sjb#endif 629178479Sjb } 630178479Sjb 631297077Smav#ifdef illumos 632178479Sjb if (fd != -1) 633178479Sjb (void) pr_close(P, fd); 634178568Sjb#endif 635178479Sjb 636178479Sjb return (0); 637178479Sjb} 638178479Sjb 639178479Sjbstatic int 640178479Sjbdt_pid_create_usdt_probes(dtrace_probedesc_t *pdp, dtrace_hdl_t *dtp, 641178479Sjb dt_pcb_t *pcb, dt_proc_t *dpr) 642178479Sjb{ 643178479Sjb struct ps_prochandle *P = dpr->dpr_proc; 644178479Sjb int ret = 0; 645178479Sjb 646210775Srpaulo assert(DT_MUTEX_HELD(&dpr->dpr_lock)); 647297077Smav#ifdef illumos 648178479Sjb (void) Pupdate_maps(P); 649178479Sjb if (Pobject_iter(P, dt_pid_usdt_mapping, P) != 0) { 650178479Sjb ret = -1; 651178479Sjb (void) dt_pid_error(dtp, pcb, dpr, NULL, D_PROC_USDT, 652178479Sjb "failed to instantiate probes for pid %d: %s", 653297077Smav#ifdef illumos 654178479Sjb (int)Pstatus(P)->pr_pid, strerror(errno)); 655178568Sjb#else 656178568Sjb (int)proc_getpid(P), strerror(errno)); 657178568Sjb#endif 658178479Sjb } 659212414Srpaulo#else 660212414Srpaulo ret = 0; 661212414Srpaulo#endif 662178479Sjb 663178479Sjb /* 664178479Sjb * Put the module name in its canonical form. 665178479Sjb */ 666178479Sjb (void) dt_pid_fix_mod(pdp, P); 667178479Sjb 668178479Sjb return (ret); 669178479Sjb} 670178479Sjb 671178479Sjbstatic pid_t 672178479Sjbdt_pid_get_pid(dtrace_probedesc_t *pdp, dtrace_hdl_t *dtp, dt_pcb_t *pcb, 673178479Sjb dt_proc_t *dpr) 674178479Sjb{ 675178479Sjb pid_t pid; 676178479Sjb char *c, *last = NULL, *end; 677178479Sjb 678178479Sjb for (c = &pdp->dtpd_provider[0]; *c != '\0'; c++) { 679178479Sjb if (!isdigit(*c)) 680178479Sjb last = c; 681178479Sjb } 682178479Sjb 683178479Sjb if (last == NULL || (*(++last) == '\0')) { 684178479Sjb (void) dt_pid_error(dtp, pcb, dpr, NULL, D_PROC_BADPROV, 685178479Sjb "'%s' is not a valid provider", pdp->dtpd_provider); 686178479Sjb return (-1); 687178479Sjb } 688178479Sjb 689178479Sjb errno = 0; 690178479Sjb pid = strtol(last, &end, 10); 691178479Sjb 692178479Sjb if (errno != 0 || end == last || end[0] != '\0' || pid <= 0) { 693178479Sjb (void) dt_pid_error(dtp, pcb, dpr, NULL, D_PROC_BADPID, 694178479Sjb "'%s' does not contain a valid pid", pdp->dtpd_provider); 695178479Sjb return (-1); 696178479Sjb } 697178479Sjb 698178479Sjb return (pid); 699178479Sjb} 700178479Sjb 701178479Sjbint 702178479Sjbdt_pid_create_probes(dtrace_probedesc_t *pdp, dtrace_hdl_t *dtp, dt_pcb_t *pcb) 703178479Sjb{ 704178479Sjb char provname[DTRACE_PROVNAMELEN]; 705178479Sjb struct ps_prochandle *P; 706178479Sjb dt_proc_t *dpr; 707178479Sjb pid_t pid; 708178479Sjb int err = 0; 709178479Sjb 710178479Sjb assert(pcb != NULL); 711178479Sjb 712178479Sjb if ((pid = dt_pid_get_pid(pdp, dtp, pcb, NULL)) == -1) 713178479Sjb return (-1); 714178479Sjb 715178479Sjb if (dtp->dt_ftfd == -1) { 716178479Sjb if (dtp->dt_fterr == ENOENT) { 717178479Sjb (void) dt_pid_error(dtp, pcb, NULL, NULL, D_PROC_NODEV, 718178479Sjb "pid provider is not installed on this system"); 719178479Sjb } else { 720178479Sjb (void) dt_pid_error(dtp, pcb, NULL, NULL, D_PROC_NODEV, 721178479Sjb "pid provider is not available: %s", 722178479Sjb strerror(dtp->dt_fterr)); 723178479Sjb } 724178479Sjb 725178479Sjb return (-1); 726178479Sjb } 727178479Sjb 728178479Sjb (void) snprintf(provname, sizeof (provname), "pid%d", (int)pid); 729178479Sjb 730178479Sjb if (gmatch(provname, pdp->dtpd_provider) != 0) { 731178479Sjb if ((P = dt_proc_grab(dtp, pid, PGRAB_RDONLY | PGRAB_FORCE, 732178479Sjb 0)) == NULL) { 733178479Sjb (void) dt_pid_error(dtp, pcb, NULL, NULL, D_PROC_GRAB, 734178479Sjb "failed to grab process %d", (int)pid); 735178479Sjb return (-1); 736178479Sjb } 737178479Sjb 738178479Sjb dpr = dt_proc_lookup(dtp, P, 0); 739178479Sjb assert(dpr != NULL); 740178479Sjb (void) pthread_mutex_lock(&dpr->dpr_lock); 741178479Sjb 742178568Sjb if ((err = dt_pid_create_pid_probes(pdp, dtp, pcb, dpr)) == 0) { 743178568Sjb /* 744178568Sjb * Alert other retained enablings which may match 745178568Sjb * against the newly created probes. 746178568Sjb */ 747178568Sjb (void) dt_ioctl(dtp, DTRACEIOC_ENABLE, NULL); 748178568Sjb } 749178479Sjb 750178479Sjb (void) pthread_mutex_unlock(&dpr->dpr_lock); 751178479Sjb dt_proc_release(dtp, P); 752178479Sjb } 753178479Sjb 754178479Sjb /* 755178479Sjb * If it's not strictly a pid provider, we might match a USDT provider. 756178479Sjb */ 757178479Sjb if (strcmp(provname, pdp->dtpd_provider) != 0) { 758178479Sjb if ((P = dt_proc_grab(dtp, pid, 0, 1)) == NULL) { 759178479Sjb (void) dt_pid_error(dtp, pcb, NULL, NULL, D_PROC_GRAB, 760178479Sjb "failed to grab process %d", (int)pid); 761178479Sjb return (-1); 762178479Sjb } 763178479Sjb 764178479Sjb dpr = dt_proc_lookup(dtp, P, 0); 765178479Sjb assert(dpr != NULL); 766178479Sjb (void) pthread_mutex_lock(&dpr->dpr_lock); 767178479Sjb 768178479Sjb if (!dpr->dpr_usdt) { 769178479Sjb err = dt_pid_create_usdt_probes(pdp, dtp, pcb, dpr); 770178479Sjb dpr->dpr_usdt = B_TRUE; 771178479Sjb } 772178479Sjb 773178479Sjb (void) pthread_mutex_unlock(&dpr->dpr_lock); 774178479Sjb dt_proc_release(dtp, P); 775178479Sjb } 776178479Sjb 777178479Sjb return (err ? -1 : 0); 778178479Sjb} 779178479Sjb 780178479Sjbint 781178479Sjbdt_pid_create_probes_module(dtrace_hdl_t *dtp, dt_proc_t *dpr) 782178479Sjb{ 783178568Sjb dtrace_enable_io_t args; 784178479Sjb dtrace_prog_t *pgp; 785178479Sjb dt_stmt_t *stp; 786178479Sjb dtrace_probedesc_t *pdp, pd; 787178479Sjb pid_t pid; 788178479Sjb int ret = 0, found = B_FALSE; 789178479Sjb char provname[DTRACE_PROVNAMELEN]; 790178479Sjb 791178479Sjb (void) snprintf(provname, sizeof (provname), "pid%d", 792178479Sjb (int)dpr->dpr_pid); 793178479Sjb 794178479Sjb for (pgp = dt_list_next(&dtp->dt_programs); pgp != NULL; 795178479Sjb pgp = dt_list_next(pgp)) { 796178479Sjb 797178479Sjb for (stp = dt_list_next(&pgp->dp_stmts); stp != NULL; 798178479Sjb stp = dt_list_next(stp)) { 799178479Sjb 800178479Sjb pdp = &stp->ds_desc->dtsd_ecbdesc->dted_probe; 801178479Sjb pid = dt_pid_get_pid(pdp, dtp, NULL, dpr); 802178479Sjb if (pid != dpr->dpr_pid) 803178479Sjb continue; 804178479Sjb 805178479Sjb found = B_TRUE; 806178479Sjb 807178479Sjb pd = *pdp; 808178479Sjb 809178479Sjb if (gmatch(provname, pdp->dtpd_provider) != 0 && 810178479Sjb dt_pid_create_pid_probes(&pd, dtp, NULL, dpr) != 0) 811178479Sjb ret = 1; 812178479Sjb 813178479Sjb /* 814178479Sjb * If it's not strictly a pid provider, we might match 815178479Sjb * a USDT provider. 816178479Sjb */ 817178479Sjb if (strcmp(provname, pdp->dtpd_provider) != 0 && 818178479Sjb dt_pid_create_usdt_probes(&pd, dtp, NULL, dpr) != 0) 819178479Sjb ret = 1; 820178479Sjb } 821178479Sjb } 822178479Sjb 823178479Sjb if (found) { 824178479Sjb /* 825178479Sjb * Give DTrace a shot to the ribs to get it to check 826178479Sjb * out the newly created probes. 827178479Sjb */ 828178568Sjb args.dof = NULL; 829178568Sjb args.n_matched = 0; 830178568Sjb (void) dt_ioctl(dtp, DTRACEIOC_ENABLE, &args); 831178479Sjb } 832178479Sjb 833178479Sjb return (ret); 834178479Sjb} 835268578Srpaulo 836268578Srpaulo/* 837268578Srpaulo * libdtrace has a backroom deal with us to ask us for type information on 838268578Srpaulo * behalf of pid provider probes when fasttrap doesn't return any type 839268578Srpaulo * information. Instead we'll look up the module and see if there is type 840268578Srpaulo * information available. However, if there is no type information available due 841268578Srpaulo * to a lack of CTF data, then we want to make sure that DTrace still carries on 842268578Srpaulo * in face of that. As such we don't have a meaningful exit code about failure. 843268578Srpaulo * We emit information about why we failed to the dtrace debug log so someone 844268578Srpaulo * can figure it out by asking nicely for DTRACE_DEBUG. 845268578Srpaulo */ 846268578Srpaulovoid 847268578Srpaulodt_pid_get_types(dtrace_hdl_t *dtp, const dtrace_probedesc_t *pdp, 848268578Srpaulo dtrace_argdesc_t *adp, int *nargs) 849268578Srpaulo{ 850268578Srpaulo dt_module_t *dmp; 851268578Srpaulo ctf_file_t *fp; 852268578Srpaulo ctf_funcinfo_t f; 853268578Srpaulo ctf_id_t argv[32]; 854268578Srpaulo GElf_Sym sym; 855297077Smav#ifdef illumos 856268578Srpaulo prsyminfo_t si; 857268578Srpaulo#else 858268578Srpaulo void *si; 859268578Srpaulo#endif 860268578Srpaulo struct ps_prochandle *p; 861268578Srpaulo int i, args; 862268578Srpaulo char buf[DTRACE_ARGTYPELEN]; 863268578Srpaulo const char *mptr; 864268578Srpaulo char *eptr; 865268578Srpaulo int ret = 0; 866268578Srpaulo int argc = sizeof (argv) / sizeof (ctf_id_t); 867268578Srpaulo Lmid_t lmid; 868268578Srpaulo 869268578Srpaulo /* Set up a potential outcome */ 870268578Srpaulo args = *nargs; 871268578Srpaulo *nargs = 0; 872268578Srpaulo 873268578Srpaulo /* 874268578Srpaulo * If we don't have an entry or return probe then we can just stop right 875268578Srpaulo * now as we don't have arguments for offset probes. 876268578Srpaulo */ 877268578Srpaulo if (strcmp(pdp->dtpd_name, "entry") != 0 && 878268578Srpaulo strcmp(pdp->dtpd_name, "return") != 0) 879268578Srpaulo return; 880268578Srpaulo 881268578Srpaulo dmp = dt_module_create(dtp, pdp->dtpd_provider); 882268578Srpaulo if (dmp == NULL) { 883268578Srpaulo dt_dprintf("failed to find module for %s\n", 884268578Srpaulo pdp->dtpd_provider); 885268578Srpaulo return; 886268578Srpaulo } 887268578Srpaulo if (dt_module_load(dtp, dmp) != 0) { 888268578Srpaulo dt_dprintf("failed to load module for %s\n", 889268578Srpaulo pdp->dtpd_provider); 890268578Srpaulo return; 891268578Srpaulo } 892268578Srpaulo 893268578Srpaulo /* 894268578Srpaulo * We may be working with a module that doesn't have ctf. If that's the 895268578Srpaulo * case then we just return now and move on with life. 896268578Srpaulo */ 897268578Srpaulo fp = dt_module_getctflib(dtp, dmp, pdp->dtpd_mod); 898268578Srpaulo if (fp == NULL) { 899268578Srpaulo dt_dprintf("no ctf container for %s\n", 900268578Srpaulo pdp->dtpd_mod); 901268578Srpaulo return; 902268578Srpaulo } 903268578Srpaulo p = dt_proc_grab(dtp, dmp->dm_pid, 0, PGRAB_RDONLY | PGRAB_FORCE); 904268578Srpaulo if (p == NULL) { 905268578Srpaulo dt_dprintf("failed to grab pid\n"); 906268578Srpaulo return; 907268578Srpaulo } 908268578Srpaulo dt_proc_lock(dtp, p); 909268578Srpaulo 910268578Srpaulo /* 911268578Srpaulo * Check to see if the D module has a link map ID and separate that out 912268578Srpaulo * for properly interrogating libproc. 913268578Srpaulo */ 914268578Srpaulo if ((mptr = strchr(pdp->dtpd_mod, '`')) != NULL) { 915268578Srpaulo if (strlen(pdp->dtpd_mod) < 3) { 916268578Srpaulo dt_dprintf("found weird modname with linkmap, " 917268578Srpaulo "aborting: %s\n", pdp->dtpd_mod); 918268578Srpaulo goto out; 919268578Srpaulo } 920268578Srpaulo if (pdp->dtpd_mod[0] != 'L' || pdp->dtpd_mod[1] != 'M') { 921268578Srpaulo dt_dprintf("missing leading 'LM', " 922268578Srpaulo "aborting: %s\n", pdp->dtpd_mod); 923268578Srpaulo goto out; 924268578Srpaulo } 925268578Srpaulo errno = 0; 926268578Srpaulo lmid = strtol(pdp->dtpd_mod + 2, &eptr, 16); 927268578Srpaulo if (errno == ERANGE || eptr != mptr) { 928268578Srpaulo dt_dprintf("failed to parse out lmid, aborting: %s\n", 929268578Srpaulo pdp->dtpd_mod); 930268578Srpaulo goto out; 931268578Srpaulo } 932268578Srpaulo mptr++; 933268578Srpaulo } else { 934268578Srpaulo mptr = pdp->dtpd_mod; 935268578Srpaulo lmid = 0; 936268578Srpaulo } 937268578Srpaulo 938268578Srpaulo if (Pxlookup_by_name(p, lmid, mptr, pdp->dtpd_func, 939268578Srpaulo &sym, &si) != 0) { 940268578Srpaulo dt_dprintf("failed to find function %s in %s`%s\n", 941268578Srpaulo pdp->dtpd_func, pdp->dtpd_provider, pdp->dtpd_mod); 942268578Srpaulo goto out; 943268578Srpaulo } 944297077Smav#ifdef illumos 945268578Srpaulo if (ctf_func_info(fp, si.prs_id, &f) == CTF_ERR) { 946268578Srpaulo dt_dprintf("failed to get ctf information for %s in %s`%s\n", 947268578Srpaulo pdp->dtpd_func, pdp->dtpd_provider, pdp->dtpd_mod); 948268578Srpaulo goto out; 949268578Srpaulo } 950268578Srpaulo#endif 951268578Srpaulo 952268578Srpaulo (void) snprintf(buf, sizeof (buf), "%s`%s", pdp->dtpd_provider, 953268578Srpaulo pdp->dtpd_mod); 954268578Srpaulo 955268578Srpaulo if (strcmp(pdp->dtpd_name, "return") == 0) { 956268578Srpaulo if (args < 2) 957268578Srpaulo goto out; 958268578Srpaulo 959268578Srpaulo bzero(adp, sizeof (dtrace_argdesc_t)); 960268578Srpaulo adp->dtargd_ndx = 0; 961268578Srpaulo adp->dtargd_id = pdp->dtpd_id; 962268578Srpaulo adp->dtargd_mapping = adp->dtargd_ndx; 963268578Srpaulo /* 964268578Srpaulo * We explicitly leave out the library here, we only care that 965268578Srpaulo * it is some int. We are assuming that there is no ctf 966268578Srpaulo * container in here that is lying about what an int is. 967268578Srpaulo */ 968268578Srpaulo (void) snprintf(adp->dtargd_native, DTRACE_ARGTYPELEN, 969268578Srpaulo "user %s`%s", pdp->dtpd_provider, "int"); 970268578Srpaulo adp++; 971268578Srpaulo bzero(adp, sizeof (dtrace_argdesc_t)); 972268578Srpaulo adp->dtargd_ndx = 1; 973268578Srpaulo adp->dtargd_id = pdp->dtpd_id; 974268578Srpaulo adp->dtargd_mapping = adp->dtargd_ndx; 975268578Srpaulo ret = snprintf(adp->dtargd_native, DTRACE_ARGTYPELEN, 976268578Srpaulo "userland "); 977268578Srpaulo (void) ctf_type_qname(fp, f.ctc_return, adp->dtargd_native + 978268578Srpaulo ret, DTRACE_ARGTYPELEN - ret, buf); 979268578Srpaulo *nargs = 2; 980297077Smav#ifdef illumos 981268578Srpaulo } else { 982268578Srpaulo if (ctf_func_args(fp, si.prs_id, argc, argv) == CTF_ERR) 983268578Srpaulo goto out; 984268578Srpaulo 985268578Srpaulo *nargs = MIN(args, f.ctc_argc); 986268578Srpaulo for (i = 0; i < *nargs; i++, adp++) { 987268578Srpaulo bzero(adp, sizeof (dtrace_argdesc_t)); 988268578Srpaulo adp->dtargd_ndx = i; 989268578Srpaulo adp->dtargd_id = pdp->dtpd_id; 990268578Srpaulo adp->dtargd_mapping = adp->dtargd_ndx; 991268578Srpaulo ret = snprintf(adp->dtargd_native, DTRACE_ARGTYPELEN, 992268578Srpaulo "userland "); 993268578Srpaulo (void) ctf_type_qname(fp, argv[i], adp->dtargd_native + 994268578Srpaulo ret, DTRACE_ARGTYPELEN - ret, buf); 995268578Srpaulo } 996268578Srpaulo#endif 997268578Srpaulo } 998268578Srpauloout: 999268578Srpaulo dt_proc_unlock(dtp, p); 1000268578Srpaulo dt_proc_release(dtp, p); 1001268578Srpaulo} 1002