dt_module.c revision 297077
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 (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25/* 26 * Copyright (c) 2013, Joyent, Inc. All rights reserved. 27 */ 28 29#include <sys/types.h> 30#ifdef illumos 31#include <sys/modctl.h> 32#include <sys/kobj.h> 33#include <sys/kobj_impl.h> 34#include <sys/sysmacros.h> 35#include <sys/elf.h> 36#include <sys/task.h> 37#else 38#include <sys/param.h> 39#include <sys/linker.h> 40#include <sys/stat.h> 41#endif 42 43#include <unistd.h> 44#ifdef illumos 45#include <project.h> 46#endif 47#include <strings.h> 48#include <stdlib.h> 49#include <libelf.h> 50#include <limits.h> 51#include <assert.h> 52#include <errno.h> 53#include <dirent.h> 54#ifndef illumos 55#include <fcntl.h> 56#include <libproc_compat.h> 57#endif 58 59#include <dt_strtab.h> 60#include <dt_module.h> 61#include <dt_impl.h> 62 63static const char *dt_module_strtab; /* active strtab for qsort callbacks */ 64 65static void 66dt_module_symhash_insert(dt_module_t *dmp, const char *name, uint_t id) 67{ 68 dt_sym_t *dsp = &dmp->dm_symchains[dmp->dm_symfree]; 69 uint_t h; 70 71 assert(dmp->dm_symfree < dmp->dm_nsymelems + 1); 72 73 dsp->ds_symid = id; 74 h = dt_strtab_hash(name, NULL) % dmp->dm_nsymbuckets; 75 dsp->ds_next = dmp->dm_symbuckets[h]; 76 dmp->dm_symbuckets[h] = dmp->dm_symfree++; 77} 78 79static uint_t 80dt_module_syminit32(dt_module_t *dmp) 81{ 82#if STT_NUM != (STT_TLS + 1) 83#error "STT_NUM has grown. update dt_module_syminit32()" 84#endif 85 86 Elf32_Sym *sym = dmp->dm_symtab.cts_data; 87 const char *base = dmp->dm_strtab.cts_data; 88 size_t ss_size = dmp->dm_strtab.cts_size; 89 uint_t i, n = dmp->dm_nsymelems; 90 uint_t asrsv = 0; 91 92#if defined(__FreeBSD__) 93 GElf_Ehdr ehdr; 94 int is_elf_obj; 95 96 gelf_getehdr(dmp->dm_elf, &ehdr); 97 is_elf_obj = (ehdr.e_type == ET_REL); 98#endif 99 100 for (i = 0; i < n; i++, sym++) { 101 const char *name = base + sym->st_name; 102 uchar_t type = ELF32_ST_TYPE(sym->st_info); 103 104 if (type >= STT_NUM || type == STT_SECTION) 105 continue; /* skip sections and unknown types */ 106 107 if (sym->st_name == 0 || sym->st_name >= ss_size) 108 continue; /* skip null or invalid names */ 109 110 if (sym->st_value != 0 && 111 (ELF32_ST_BIND(sym->st_info) != STB_LOCAL || sym->st_size)) { 112 asrsv++; /* reserve space in the address map */ 113 114#if defined(__FreeBSD__) 115 sym->st_value += (Elf_Addr) dmp->dm_reloc_offset; 116 if (is_elf_obj && sym->st_shndx != SHN_UNDEF && 117 sym->st_shndx < ehdr.e_shnum) 118 sym->st_value += 119 dmp->dm_sec_offsets[sym->st_shndx]; 120#endif 121 } 122 123 dt_module_symhash_insert(dmp, name, i); 124 } 125 126 return (asrsv); 127} 128 129static uint_t 130dt_module_syminit64(dt_module_t *dmp) 131{ 132#if STT_NUM != (STT_TLS + 1) 133#error "STT_NUM has grown. update dt_module_syminit64()" 134#endif 135 136 Elf64_Sym *sym = dmp->dm_symtab.cts_data; 137 const char *base = dmp->dm_strtab.cts_data; 138 size_t ss_size = dmp->dm_strtab.cts_size; 139 uint_t i, n = dmp->dm_nsymelems; 140 uint_t asrsv = 0; 141 142#if defined(__FreeBSD__) 143 GElf_Ehdr ehdr; 144 int is_elf_obj; 145 146 gelf_getehdr(dmp->dm_elf, &ehdr); 147 is_elf_obj = (ehdr.e_type == ET_REL); 148#endif 149 150 for (i = 0; i < n; i++, sym++) { 151 const char *name = base + sym->st_name; 152 uchar_t type = ELF64_ST_TYPE(sym->st_info); 153 154 if (type >= STT_NUM || type == STT_SECTION) 155 continue; /* skip sections and unknown types */ 156 157 if (sym->st_name == 0 || sym->st_name >= ss_size) 158 continue; /* skip null or invalid names */ 159 160 if (sym->st_value != 0 && 161 (ELF64_ST_BIND(sym->st_info) != STB_LOCAL || sym->st_size)) { 162 asrsv++; /* reserve space in the address map */ 163#if defined(__FreeBSD__) 164 sym->st_value += (Elf_Addr) dmp->dm_reloc_offset; 165 if (is_elf_obj && sym->st_shndx != SHN_UNDEF && 166 sym->st_shndx < ehdr.e_shnum) 167 sym->st_value += 168 dmp->dm_sec_offsets[sym->st_shndx]; 169#endif 170 } 171 172 dt_module_symhash_insert(dmp, name, i); 173 } 174 175 return (asrsv); 176} 177 178/* 179 * Sort comparison function for 32-bit symbol address-to-name lookups. We sort 180 * symbols by value. If values are equal, we prefer the symbol that is 181 * non-zero sized, typed, not weak, or lexically first, in that order. 182 */ 183static int 184dt_module_symcomp32(const void *lp, const void *rp) 185{ 186 Elf32_Sym *lhs = *((Elf32_Sym **)lp); 187 Elf32_Sym *rhs = *((Elf32_Sym **)rp); 188 189 if (lhs->st_value != rhs->st_value) 190 return (lhs->st_value > rhs->st_value ? 1 : -1); 191 192 if ((lhs->st_size == 0) != (rhs->st_size == 0)) 193 return (lhs->st_size == 0 ? 1 : -1); 194 195 if ((ELF32_ST_TYPE(lhs->st_info) == STT_NOTYPE) != 196 (ELF32_ST_TYPE(rhs->st_info) == STT_NOTYPE)) 197 return (ELF32_ST_TYPE(lhs->st_info) == STT_NOTYPE ? 1 : -1); 198 199 if ((ELF32_ST_BIND(lhs->st_info) == STB_WEAK) != 200 (ELF32_ST_BIND(rhs->st_info) == STB_WEAK)) 201 return (ELF32_ST_BIND(lhs->st_info) == STB_WEAK ? 1 : -1); 202 203 return (strcmp(dt_module_strtab + lhs->st_name, 204 dt_module_strtab + rhs->st_name)); 205} 206 207/* 208 * Sort comparison function for 64-bit symbol address-to-name lookups. We sort 209 * symbols by value. If values are equal, we prefer the symbol that is 210 * non-zero sized, typed, not weak, or lexically first, in that order. 211 */ 212static int 213dt_module_symcomp64(const void *lp, const void *rp) 214{ 215 Elf64_Sym *lhs = *((Elf64_Sym **)lp); 216 Elf64_Sym *rhs = *((Elf64_Sym **)rp); 217 218 if (lhs->st_value != rhs->st_value) 219 return (lhs->st_value > rhs->st_value ? 1 : -1); 220 221 if ((lhs->st_size == 0) != (rhs->st_size == 0)) 222 return (lhs->st_size == 0 ? 1 : -1); 223 224 if ((ELF64_ST_TYPE(lhs->st_info) == STT_NOTYPE) != 225 (ELF64_ST_TYPE(rhs->st_info) == STT_NOTYPE)) 226 return (ELF64_ST_TYPE(lhs->st_info) == STT_NOTYPE ? 1 : -1); 227 228 if ((ELF64_ST_BIND(lhs->st_info) == STB_WEAK) != 229 (ELF64_ST_BIND(rhs->st_info) == STB_WEAK)) 230 return (ELF64_ST_BIND(lhs->st_info) == STB_WEAK ? 1 : -1); 231 232 return (strcmp(dt_module_strtab + lhs->st_name, 233 dt_module_strtab + rhs->st_name)); 234} 235 236static void 237dt_module_symsort32(dt_module_t *dmp) 238{ 239 Elf32_Sym *symtab = (Elf32_Sym *)dmp->dm_symtab.cts_data; 240 Elf32_Sym **sympp = (Elf32_Sym **)dmp->dm_asmap; 241 const dt_sym_t *dsp = dmp->dm_symchains + 1; 242 uint_t i, n = dmp->dm_symfree; 243 244 for (i = 1; i < n; i++, dsp++) { 245 Elf32_Sym *sym = symtab + dsp->ds_symid; 246 if (sym->st_value != 0 && 247 (ELF32_ST_BIND(sym->st_info) != STB_LOCAL || sym->st_size)) 248 *sympp++ = sym; 249 } 250 251 dmp->dm_aslen = (uint_t)(sympp - (Elf32_Sym **)dmp->dm_asmap); 252 assert(dmp->dm_aslen <= dmp->dm_asrsv); 253 254 dt_module_strtab = dmp->dm_strtab.cts_data; 255 qsort(dmp->dm_asmap, dmp->dm_aslen, 256 sizeof (Elf32_Sym *), dt_module_symcomp32); 257 dt_module_strtab = NULL; 258} 259 260static void 261dt_module_symsort64(dt_module_t *dmp) 262{ 263 Elf64_Sym *symtab = (Elf64_Sym *)dmp->dm_symtab.cts_data; 264 Elf64_Sym **sympp = (Elf64_Sym **)dmp->dm_asmap; 265 const dt_sym_t *dsp = dmp->dm_symchains + 1; 266 uint_t i, n = dmp->dm_symfree; 267 268 for (i = 1; i < n; i++, dsp++) { 269 Elf64_Sym *sym = symtab + dsp->ds_symid; 270 if (sym->st_value != 0 && 271 (ELF64_ST_BIND(sym->st_info) != STB_LOCAL || sym->st_size)) 272 *sympp++ = sym; 273 } 274 275 dmp->dm_aslen = (uint_t)(sympp - (Elf64_Sym **)dmp->dm_asmap); 276 assert(dmp->dm_aslen <= dmp->dm_asrsv); 277 278 dt_module_strtab = dmp->dm_strtab.cts_data; 279 qsort(dmp->dm_asmap, dmp->dm_aslen, 280 sizeof (Elf64_Sym *), dt_module_symcomp64); 281 dt_module_strtab = NULL; 282} 283 284static GElf_Sym * 285dt_module_symgelf32(const Elf32_Sym *src, GElf_Sym *dst) 286{ 287 if (dst != NULL) { 288 dst->st_name = src->st_name; 289 dst->st_info = src->st_info; 290 dst->st_other = src->st_other; 291 dst->st_shndx = src->st_shndx; 292 dst->st_value = src->st_value; 293 dst->st_size = src->st_size; 294 } 295 296 return (dst); 297} 298 299static GElf_Sym * 300dt_module_symgelf64(const Elf64_Sym *src, GElf_Sym *dst) 301{ 302 if (dst != NULL) 303 bcopy(src, dst, sizeof (GElf_Sym)); 304 305 return (dst); 306} 307 308static GElf_Sym * 309dt_module_symname32(dt_module_t *dmp, const char *name, 310 GElf_Sym *symp, uint_t *idp) 311{ 312 const Elf32_Sym *symtab = dmp->dm_symtab.cts_data; 313 const char *strtab = dmp->dm_strtab.cts_data; 314 315 const Elf32_Sym *sym; 316 const dt_sym_t *dsp; 317 uint_t i, h; 318 319 if (dmp->dm_nsymelems == 0) 320 return (NULL); 321 322 h = dt_strtab_hash(name, NULL) % dmp->dm_nsymbuckets; 323 324 for (i = dmp->dm_symbuckets[h]; i != 0; i = dsp->ds_next) { 325 dsp = &dmp->dm_symchains[i]; 326 sym = symtab + dsp->ds_symid; 327 328 if (strcmp(name, strtab + sym->st_name) == 0) { 329 if (idp != NULL) 330 *idp = dsp->ds_symid; 331 return (dt_module_symgelf32(sym, symp)); 332 } 333 } 334 335 return (NULL); 336} 337 338static GElf_Sym * 339dt_module_symname64(dt_module_t *dmp, const char *name, 340 GElf_Sym *symp, uint_t *idp) 341{ 342 const Elf64_Sym *symtab = dmp->dm_symtab.cts_data; 343 const char *strtab = dmp->dm_strtab.cts_data; 344 345 const Elf64_Sym *sym; 346 const dt_sym_t *dsp; 347 uint_t i, h; 348 349 if (dmp->dm_nsymelems == 0) 350 return (NULL); 351 352 h = dt_strtab_hash(name, NULL) % dmp->dm_nsymbuckets; 353 354 for (i = dmp->dm_symbuckets[h]; i != 0; i = dsp->ds_next) { 355 dsp = &dmp->dm_symchains[i]; 356 sym = symtab + dsp->ds_symid; 357 358 if (strcmp(name, strtab + sym->st_name) == 0) { 359 if (idp != NULL) 360 *idp = dsp->ds_symid; 361 return (dt_module_symgelf64(sym, symp)); 362 } 363 } 364 365 return (NULL); 366} 367 368static GElf_Sym * 369dt_module_symaddr32(dt_module_t *dmp, GElf_Addr addr, 370 GElf_Sym *symp, uint_t *idp) 371{ 372 const Elf32_Sym **asmap = (const Elf32_Sym **)dmp->dm_asmap; 373 const Elf32_Sym *symtab = dmp->dm_symtab.cts_data; 374 const Elf32_Sym *sym; 375 376 uint_t i, mid, lo = 0, hi = dmp->dm_aslen - 1; 377 Elf32_Addr v; 378 379 if (dmp->dm_aslen == 0) 380 return (NULL); 381 382 while (hi - lo > 1) { 383 mid = (lo + hi) / 2; 384 if (addr >= asmap[mid]->st_value) 385 lo = mid; 386 else 387 hi = mid; 388 } 389 390 i = addr < asmap[hi]->st_value ? lo : hi; 391 sym = asmap[i]; 392 v = sym->st_value; 393 394 /* 395 * If the previous entry has the same value, improve our choice. The 396 * order of equal-valued symbols is determined by the comparison func. 397 */ 398 while (i-- != 0 && asmap[i]->st_value == v) 399 sym = asmap[i]; 400 401 if (addr - sym->st_value < MAX(sym->st_size, 1)) { 402 if (idp != NULL) 403 *idp = (uint_t)(sym - symtab); 404 return (dt_module_symgelf32(sym, symp)); 405 } 406 407 return (NULL); 408} 409 410static GElf_Sym * 411dt_module_symaddr64(dt_module_t *dmp, GElf_Addr addr, 412 GElf_Sym *symp, uint_t *idp) 413{ 414 const Elf64_Sym **asmap = (const Elf64_Sym **)dmp->dm_asmap; 415 const Elf64_Sym *symtab = dmp->dm_symtab.cts_data; 416 const Elf64_Sym *sym; 417 418 uint_t i, mid, lo = 0, hi = dmp->dm_aslen - 1; 419 Elf64_Addr v; 420 421 if (dmp->dm_aslen == 0) 422 return (NULL); 423 424 while (hi - lo > 1) { 425 mid = (lo + hi) / 2; 426 if (addr >= asmap[mid]->st_value) 427 lo = mid; 428 else 429 hi = mid; 430 } 431 432 i = addr < asmap[hi]->st_value ? lo : hi; 433 sym = asmap[i]; 434 v = sym->st_value; 435 436 /* 437 * If the previous entry has the same value, improve our choice. The 438 * order of equal-valued symbols is determined by the comparison func. 439 */ 440 while (i-- != 0 && asmap[i]->st_value == v) 441 sym = asmap[i]; 442 443 if (addr - sym->st_value < MAX(sym->st_size, 1)) { 444 if (idp != NULL) 445 *idp = (uint_t)(sym - symtab); 446 return (dt_module_symgelf64(sym, symp)); 447 } 448 449 return (NULL); 450} 451 452static const dt_modops_t dt_modops_32 = { 453 dt_module_syminit32, 454 dt_module_symsort32, 455 dt_module_symname32, 456 dt_module_symaddr32 457}; 458 459static const dt_modops_t dt_modops_64 = { 460 dt_module_syminit64, 461 dt_module_symsort64, 462 dt_module_symname64, 463 dt_module_symaddr64 464}; 465 466dt_module_t * 467dt_module_create(dtrace_hdl_t *dtp, const char *name) 468{ 469 long pid; 470 char *eptr; 471 dt_ident_t *idp; 472 uint_t h = dt_strtab_hash(name, NULL) % dtp->dt_modbuckets; 473 dt_module_t *dmp; 474 475 for (dmp = dtp->dt_mods[h]; dmp != NULL; dmp = dmp->dm_next) { 476 if (strcmp(dmp->dm_name, name) == 0) 477 return (dmp); 478 } 479 480 if ((dmp = malloc(sizeof (dt_module_t))) == NULL) 481 return (NULL); /* caller must handle allocation failure */ 482 483 bzero(dmp, sizeof (dt_module_t)); 484 (void) strlcpy(dmp->dm_name, name, sizeof (dmp->dm_name)); 485 dt_list_append(&dtp->dt_modlist, dmp); 486 dmp->dm_next = dtp->dt_mods[h]; 487 dtp->dt_mods[h] = dmp; 488 dtp->dt_nmods++; 489 490 if (dtp->dt_conf.dtc_ctfmodel == CTF_MODEL_LP64) 491 dmp->dm_ops = &dt_modops_64; 492 else 493 dmp->dm_ops = &dt_modops_32; 494 495 /* 496 * Modules for userland processes are special. They always refer to a 497 * specific process and have a copy of their CTF data from a specific 498 * instant in time. Any dt_module_t that begins with 'pid' is a module 499 * for a specific process, much like how any probe description that 500 * begins with 'pid' is special. pid123 refers to process 123. A module 501 * that is just 'pid' refers specifically to pid$target. This is 502 * generally done as D does not currently allow for macros to be 503 * evaluated when working with types. 504 */ 505 if (strncmp(dmp->dm_name, "pid", 3) == 0) { 506 errno = 0; 507 if (dmp->dm_name[3] == '\0') { 508 idp = dt_idhash_lookup(dtp->dt_macros, "target"); 509 if (idp != NULL && idp->di_id != 0) 510 dmp->dm_pid = idp->di_id; 511 } else { 512 pid = strtol(dmp->dm_name + 3, &eptr, 10); 513 if (errno == 0 && *eptr == '\0') 514 dmp->dm_pid = (pid_t)pid; 515 else 516 dt_dprintf("encountered malformed pid " 517 "module: %s\n", dmp->dm_name); 518 } 519 } 520 521 return (dmp); 522} 523 524dt_module_t * 525dt_module_lookup_by_name(dtrace_hdl_t *dtp, const char *name) 526{ 527 uint_t h = dt_strtab_hash(name, NULL) % dtp->dt_modbuckets; 528 dt_module_t *dmp; 529 530 for (dmp = dtp->dt_mods[h]; dmp != NULL; dmp = dmp->dm_next) { 531 if (strcmp(dmp->dm_name, name) == 0) 532 return (dmp); 533 } 534 535 return (NULL); 536} 537 538/*ARGSUSED*/ 539dt_module_t * 540dt_module_lookup_by_ctf(dtrace_hdl_t *dtp, ctf_file_t *ctfp) 541{ 542 return (ctfp ? ctf_getspecific(ctfp) : NULL); 543} 544 545static int 546dt_module_load_sect(dtrace_hdl_t *dtp, dt_module_t *dmp, ctf_sect_t *ctsp) 547{ 548 const char *s; 549 size_t shstrs; 550 GElf_Shdr sh; 551 Elf_Data *dp; 552 Elf_Scn *sp; 553 554 if (elf_getshdrstrndx(dmp->dm_elf, &shstrs) == -1) 555 return (dt_set_errno(dtp, EDT_NOTLOADED)); 556 557 for (sp = NULL; (sp = elf_nextscn(dmp->dm_elf, sp)) != NULL; ) { 558 if (gelf_getshdr(sp, &sh) == NULL || sh.sh_type == SHT_NULL || 559 (s = elf_strptr(dmp->dm_elf, shstrs, sh.sh_name)) == NULL) 560 continue; /* skip any malformed sections */ 561 562 if (sh.sh_type == ctsp->cts_type && 563 sh.sh_entsize == ctsp->cts_entsize && 564 strcmp(s, ctsp->cts_name) == 0) 565 break; /* section matches specification */ 566 } 567 568 /* 569 * If the section isn't found, return success but leave cts_data set 570 * to NULL and cts_size set to zero for our caller. 571 */ 572 if (sp == NULL || (dp = elf_getdata(sp, NULL)) == NULL) 573 return (0); 574 575#ifdef illumos 576 ctsp->cts_data = dp->d_buf; 577#else 578 if ((ctsp->cts_data = malloc(dp->d_size)) == NULL) 579 return (0); 580 memcpy(ctsp->cts_data, dp->d_buf, dp->d_size); 581#endif 582 ctsp->cts_size = dp->d_size; 583 584 dt_dprintf("loaded %s [%s] (%lu bytes)\n", 585 dmp->dm_name, ctsp->cts_name, (ulong_t)ctsp->cts_size); 586 587 return (0); 588} 589 590typedef struct dt_module_cb_arg { 591 struct ps_prochandle *dpa_proc; 592 dtrace_hdl_t *dpa_dtp; 593 dt_module_t *dpa_dmp; 594 uint_t dpa_count; 595} dt_module_cb_arg_t; 596 597/* ARGSUSED */ 598static int 599dt_module_load_proc_count(void *arg, const prmap_t *prmap, const char *obj) 600{ 601 ctf_file_t *fp; 602 dt_module_cb_arg_t *dcp = arg; 603 604 /* Try to grab a ctf container if it exists */ 605 fp = Pname_to_ctf(dcp->dpa_proc, obj); 606 if (fp != NULL) 607 dcp->dpa_count++; 608 return (0); 609} 610 611/* ARGSUSED */ 612static int 613dt_module_load_proc_build(void *arg, const prmap_t *prmap, const char *obj) 614{ 615 ctf_file_t *fp; 616 char buf[MAXPATHLEN], *p; 617 dt_module_cb_arg_t *dcp = arg; 618 int count = dcp->dpa_count; 619 Lmid_t lmid; 620 621 fp = Pname_to_ctf(dcp->dpa_proc, obj); 622 if (fp == NULL) 623 return (0); 624 fp = ctf_dup(fp); 625 if (fp == NULL) 626 return (0); 627 dcp->dpa_dmp->dm_libctfp[count] = fp; 628 /* 629 * While it'd be nice to simply use objname here, because of our prior 630 * actions we'll always get a resolved object name to its on disk file. 631 * Like the pid provider, we need to tell a bit of a lie here. The type 632 * that the user thinks of is in terms of the libraries they requested, 633 * eg. libc.so.1, they don't care about the fact that it's 634 * libc_hwcap.so.1. 635 */ 636 (void) Pobjname(dcp->dpa_proc, prmap->pr_vaddr, buf, sizeof (buf)); 637 if ((p = strrchr(buf, '/')) == NULL) 638 p = buf; 639 else 640 p++; 641 642 /* 643 * If for some reason we can't find a link map id for this module, which 644 * would be really quite weird. We instead just say the link map id is 645 * zero. 646 */ 647 if (Plmid(dcp->dpa_proc, prmap->pr_vaddr, &lmid) != 0) 648 lmid = 0; 649 650 if (lmid == 0) 651 dcp->dpa_dmp->dm_libctfn[count] = strdup(p); 652 else 653 (void) asprintf(&dcp->dpa_dmp->dm_libctfn[count], 654 "LM%x`%s", lmid, p); 655 if (dcp->dpa_dmp->dm_libctfn[count] == NULL) 656 return (1); 657 ctf_setspecific(fp, dcp->dpa_dmp); 658 dcp->dpa_count++; 659 return (0); 660} 661 662/* 663 * We've been asked to load data that belongs to another process. As such we're 664 * going to pgrab it at this instant, load everything that we might ever care 665 * about, and then drive on. The reason for this is that the process that we're 666 * interested in might be changing. As long as we have grabbed it, then this 667 * can't be a problem for us. 668 * 669 * For now, we're actually going to punt on most things and just try to get CTF 670 * data, nothing else. Basically this is only useful as a source of type 671 * information, we can't go and do the stacktrace lookups, etc. 672 */ 673static int 674dt_module_load_proc(dtrace_hdl_t *dtp, dt_module_t *dmp) 675{ 676 struct ps_prochandle *p; 677 dt_module_cb_arg_t arg; 678 679 /* 680 * Note that on success we do not release this hold. We must hold this 681 * for our life time. 682 */ 683 p = dt_proc_grab(dtp, dmp->dm_pid, 0, PGRAB_RDONLY | PGRAB_FORCE); 684 if (p == NULL) { 685 dt_dprintf("failed to grab pid: %d\n", (int)dmp->dm_pid); 686 return (dt_set_errno(dtp, EDT_CANTLOAD)); 687 } 688 dt_proc_lock(dtp, p); 689 690 arg.dpa_proc = p; 691 arg.dpa_dtp = dtp; 692 arg.dpa_dmp = dmp; 693 arg.dpa_count = 0; 694 if (Pobject_iter_resolved(p, dt_module_load_proc_count, &arg) != 0) { 695 dt_dprintf("failed to iterate objects\n"); 696 dt_proc_release(dtp, p); 697 return (dt_set_errno(dtp, EDT_CANTLOAD)); 698 } 699 700 if (arg.dpa_count == 0) { 701 dt_dprintf("no ctf data present\n"); 702 dt_proc_unlock(dtp, p); 703 dt_proc_release(dtp, p); 704 return (dt_set_errno(dtp, EDT_CANTLOAD)); 705 } 706 707 dmp->dm_libctfp = malloc(sizeof (ctf_file_t *) * arg.dpa_count); 708 if (dmp->dm_libctfp == NULL) { 709 dt_proc_unlock(dtp, p); 710 dt_proc_release(dtp, p); 711 return (dt_set_errno(dtp, EDT_NOMEM)); 712 } 713 bzero(dmp->dm_libctfp, sizeof (ctf_file_t *) * arg.dpa_count); 714 715 dmp->dm_libctfn = malloc(sizeof (char *) * arg.dpa_count); 716 if (dmp->dm_libctfn == NULL) { 717 free(dmp->dm_libctfp); 718 dt_proc_unlock(dtp, p); 719 dt_proc_release(dtp, p); 720 return (dt_set_errno(dtp, EDT_NOMEM)); 721 } 722 bzero(dmp->dm_libctfn, sizeof (char *) * arg.dpa_count); 723 724 dmp->dm_nctflibs = arg.dpa_count; 725 726 arg.dpa_count = 0; 727 if (Pobject_iter_resolved(p, dt_module_load_proc_build, &arg) != 0) { 728 dt_proc_unlock(dtp, p); 729 dt_module_unload(dtp, dmp); 730 dt_proc_release(dtp, p); 731 return (dt_set_errno(dtp, EDT_CANTLOAD)); 732 } 733 assert(arg.dpa_count == dmp->dm_nctflibs); 734 dt_dprintf("loaded %d ctf modules for pid %d\n", arg.dpa_count, 735 (int)dmp->dm_pid); 736 737 dt_proc_unlock(dtp, p); 738 dt_proc_release(dtp, p); 739 dmp->dm_flags |= DT_DM_LOADED; 740 741 return (0); 742} 743 744int 745dt_module_load(dtrace_hdl_t *dtp, dt_module_t *dmp) 746{ 747 if (dmp->dm_flags & DT_DM_LOADED) 748 return (0); /* module is already loaded */ 749 750 if (dmp->dm_pid != 0) 751 return (dt_module_load_proc(dtp, dmp)); 752 753 dmp->dm_ctdata.cts_name = ".SUNW_ctf"; 754 dmp->dm_ctdata.cts_type = SHT_PROGBITS; 755 dmp->dm_ctdata.cts_flags = 0; 756 dmp->dm_ctdata.cts_data = NULL; 757 dmp->dm_ctdata.cts_size = 0; 758 dmp->dm_ctdata.cts_entsize = 0; 759 dmp->dm_ctdata.cts_offset = 0; 760 761 dmp->dm_symtab.cts_name = ".symtab"; 762 dmp->dm_symtab.cts_type = SHT_SYMTAB; 763 dmp->dm_symtab.cts_flags = 0; 764 dmp->dm_symtab.cts_data = NULL; 765 dmp->dm_symtab.cts_size = 0; 766 dmp->dm_symtab.cts_entsize = dmp->dm_ops == &dt_modops_64 ? 767 sizeof (Elf64_Sym) : sizeof (Elf32_Sym); 768 dmp->dm_symtab.cts_offset = 0; 769 770 dmp->dm_strtab.cts_name = ".strtab"; 771 dmp->dm_strtab.cts_type = SHT_STRTAB; 772 dmp->dm_strtab.cts_flags = 0; 773 dmp->dm_strtab.cts_data = NULL; 774 dmp->dm_strtab.cts_size = 0; 775 dmp->dm_strtab.cts_entsize = 0; 776 dmp->dm_strtab.cts_offset = 0; 777 778 /* 779 * Attempt to load the module's CTF section, symbol table section, and 780 * string table section. Note that modules may not contain CTF data: 781 * this will result in a successful load_sect but data of size zero. 782 * We will then fail if dt_module_getctf() is called, as shown below. 783 */ 784 if (dt_module_load_sect(dtp, dmp, &dmp->dm_ctdata) == -1 || 785 dt_module_load_sect(dtp, dmp, &dmp->dm_symtab) == -1 || 786 dt_module_load_sect(dtp, dmp, &dmp->dm_strtab) == -1) { 787 dt_module_unload(dtp, dmp); 788 return (-1); /* dt_errno is set for us */ 789 } 790 791 /* 792 * Allocate the hash chains and hash buckets for symbol name lookup. 793 * This is relatively simple since the symbol table is of fixed size 794 * and is known in advance. We allocate one extra element since we 795 * use element indices instead of pointers and zero is our sentinel. 796 */ 797 dmp->dm_nsymelems = 798 dmp->dm_symtab.cts_size / dmp->dm_symtab.cts_entsize; 799 800 dmp->dm_nsymbuckets = _dtrace_strbuckets; 801 dmp->dm_symfree = 1; /* first free element is index 1 */ 802 803 dmp->dm_symbuckets = malloc(sizeof (uint_t) * dmp->dm_nsymbuckets); 804 dmp->dm_symchains = malloc(sizeof (dt_sym_t) * dmp->dm_nsymelems + 1); 805 806 if (dmp->dm_symbuckets == NULL || dmp->dm_symchains == NULL) { 807 dt_module_unload(dtp, dmp); 808 return (dt_set_errno(dtp, EDT_NOMEM)); 809 } 810 811 bzero(dmp->dm_symbuckets, sizeof (uint_t) * dmp->dm_nsymbuckets); 812 bzero(dmp->dm_symchains, sizeof (dt_sym_t) * dmp->dm_nsymelems + 1); 813 814 /* 815 * Iterate over the symbol table data buffer and insert each symbol 816 * name into the name hash if the name and type are valid. Then 817 * allocate the address map, fill it in, and sort it. 818 */ 819 dmp->dm_asrsv = dmp->dm_ops->do_syminit(dmp); 820 821 dt_dprintf("hashed %s [%s] (%u symbols)\n", 822 dmp->dm_name, dmp->dm_symtab.cts_name, dmp->dm_symfree - 1); 823 824 if ((dmp->dm_asmap = malloc(sizeof (void *) * dmp->dm_asrsv)) == NULL) { 825 dt_module_unload(dtp, dmp); 826 return (dt_set_errno(dtp, EDT_NOMEM)); 827 } 828 829 dmp->dm_ops->do_symsort(dmp); 830 831 dt_dprintf("sorted %s [%s] (%u symbols)\n", 832 dmp->dm_name, dmp->dm_symtab.cts_name, dmp->dm_aslen); 833 834 dmp->dm_flags |= DT_DM_LOADED; 835 return (0); 836} 837 838int 839dt_module_hasctf(dtrace_hdl_t *dtp, dt_module_t *dmp) 840{ 841 if (dmp->dm_pid != 0 && dmp->dm_nctflibs > 0) 842 return (1); 843 return (dt_module_getctf(dtp, dmp) != NULL); 844} 845 846ctf_file_t * 847dt_module_getctf(dtrace_hdl_t *dtp, dt_module_t *dmp) 848{ 849 const char *parent; 850 dt_module_t *pmp; 851 ctf_file_t *pfp; 852 int model; 853 854 if (dmp->dm_ctfp != NULL || dt_module_load(dtp, dmp) != 0) 855 return (dmp->dm_ctfp); 856 857 if (dmp->dm_ops == &dt_modops_64) 858 model = CTF_MODEL_LP64; 859 else 860 model = CTF_MODEL_ILP32; 861 862 /* 863 * If the data model of the module does not match our program data 864 * model, then do not permit CTF from this module to be opened and 865 * returned to the compiler. If we support mixed data models in the 866 * future for combined kernel/user tracing, this can be removed. 867 */ 868 if (dtp->dt_conf.dtc_ctfmodel != model) { 869 (void) dt_set_errno(dtp, EDT_DATAMODEL); 870 return (NULL); 871 } 872 873 if (dmp->dm_ctdata.cts_size == 0) { 874 (void) dt_set_errno(dtp, EDT_NOCTF); 875 return (NULL); 876 } 877 878 dmp->dm_ctfp = ctf_bufopen(&dmp->dm_ctdata, 879 &dmp->dm_symtab, &dmp->dm_strtab, &dtp->dt_ctferr); 880 881 if (dmp->dm_ctfp == NULL) { 882 (void) dt_set_errno(dtp, EDT_CTF); 883 return (NULL); 884 } 885 886 (void) ctf_setmodel(dmp->dm_ctfp, model); 887 ctf_setspecific(dmp->dm_ctfp, dmp); 888 889 if ((parent = ctf_parent_name(dmp->dm_ctfp)) != NULL) { 890 if ((pmp = dt_module_create(dtp, parent)) == NULL || 891 (pfp = dt_module_getctf(dtp, pmp)) == NULL) { 892 if (pmp == NULL) 893 (void) dt_set_errno(dtp, EDT_NOMEM); 894 goto err; 895 } 896 897 if (ctf_import(dmp->dm_ctfp, pfp) == CTF_ERR) { 898 dtp->dt_ctferr = ctf_errno(dmp->dm_ctfp); 899 (void) dt_set_errno(dtp, EDT_CTF); 900 goto err; 901 } 902 } 903 904 dt_dprintf("loaded CTF container for %s (%p)\n", 905 dmp->dm_name, (void *)dmp->dm_ctfp); 906 907 return (dmp->dm_ctfp); 908 909err: 910 ctf_close(dmp->dm_ctfp); 911 dmp->dm_ctfp = NULL; 912 return (NULL); 913} 914 915/*ARGSUSED*/ 916void 917dt_module_unload(dtrace_hdl_t *dtp, dt_module_t *dmp) 918{ 919 int i; 920 921 ctf_close(dmp->dm_ctfp); 922 dmp->dm_ctfp = NULL; 923 924#ifndef illumos 925 if (dmp->dm_ctdata.cts_data != NULL) { 926 free(dmp->dm_ctdata.cts_data); 927 } 928 if (dmp->dm_symtab.cts_data != NULL) { 929 free(dmp->dm_symtab.cts_data); 930 } 931 if (dmp->dm_strtab.cts_data != NULL) { 932 free(dmp->dm_strtab.cts_data); 933 } 934#endif 935 936 if (dmp->dm_libctfp != NULL) { 937 for (i = 0; i < dmp->dm_nctflibs; i++) { 938 ctf_close(dmp->dm_libctfp[i]); 939 free(dmp->dm_libctfn[i]); 940 } 941 free(dmp->dm_libctfp); 942 free(dmp->dm_libctfn); 943 dmp->dm_libctfp = NULL; 944 dmp->dm_nctflibs = 0; 945 } 946 947 bzero(&dmp->dm_ctdata, sizeof (ctf_sect_t)); 948 bzero(&dmp->dm_symtab, sizeof (ctf_sect_t)); 949 bzero(&dmp->dm_strtab, sizeof (ctf_sect_t)); 950 951 if (dmp->dm_symbuckets != NULL) { 952 free(dmp->dm_symbuckets); 953 dmp->dm_symbuckets = NULL; 954 } 955 956 if (dmp->dm_symchains != NULL) { 957 free(dmp->dm_symchains); 958 dmp->dm_symchains = NULL; 959 } 960 961 if (dmp->dm_asmap != NULL) { 962 free(dmp->dm_asmap); 963 dmp->dm_asmap = NULL; 964 } 965#if defined(__FreeBSD__) 966 if (dmp->dm_sec_offsets != NULL) { 967 free(dmp->dm_sec_offsets); 968 dmp->dm_sec_offsets = NULL; 969 } 970#endif 971 dmp->dm_symfree = 0; 972 dmp->dm_nsymbuckets = 0; 973 dmp->dm_nsymelems = 0; 974 dmp->dm_asrsv = 0; 975 dmp->dm_aslen = 0; 976 977 dmp->dm_text_va = 0; 978 dmp->dm_text_size = 0; 979 dmp->dm_data_va = 0; 980 dmp->dm_data_size = 0; 981 dmp->dm_bss_va = 0; 982 dmp->dm_bss_size = 0; 983 984 if (dmp->dm_extern != NULL) { 985 dt_idhash_destroy(dmp->dm_extern); 986 dmp->dm_extern = NULL; 987 } 988 989 (void) elf_end(dmp->dm_elf); 990 dmp->dm_elf = NULL; 991 992 dmp->dm_pid = 0; 993 994 dmp->dm_flags &= ~DT_DM_LOADED; 995} 996 997void 998dt_module_destroy(dtrace_hdl_t *dtp, dt_module_t *dmp) 999{ 1000 uint_t h = dt_strtab_hash(dmp->dm_name, NULL) % dtp->dt_modbuckets; 1001 dt_module_t **dmpp = &dtp->dt_mods[h]; 1002 1003 dt_list_delete(&dtp->dt_modlist, dmp); 1004 assert(dtp->dt_nmods != 0); 1005 dtp->dt_nmods--; 1006 1007 /* 1008 * Now remove this module from its hash chain. We expect to always 1009 * find the module on its hash chain, so in this loop we assert that 1010 * we don't run off the end of the list. 1011 */ 1012 while (*dmpp != dmp) { 1013 dmpp = &((*dmpp)->dm_next); 1014 assert(*dmpp != NULL); 1015 } 1016 1017 *dmpp = dmp->dm_next; 1018 1019 dt_module_unload(dtp, dmp); 1020 free(dmp); 1021} 1022 1023/* 1024 * Insert a new external symbol reference into the specified module. The new 1025 * symbol will be marked as undefined and is assigned a symbol index beyond 1026 * any existing cached symbols from this module. We use the ident's di_data 1027 * field to store a pointer to a copy of the dtrace_syminfo_t for this symbol. 1028 */ 1029dt_ident_t * 1030dt_module_extern(dtrace_hdl_t *dtp, dt_module_t *dmp, 1031 const char *name, const dtrace_typeinfo_t *tip) 1032{ 1033 dtrace_syminfo_t *sip; 1034 dt_ident_t *idp; 1035 uint_t id; 1036 1037 if (dmp->dm_extern == NULL && (dmp->dm_extern = dt_idhash_create( 1038 "extern", NULL, dmp->dm_nsymelems, UINT_MAX)) == NULL) { 1039 (void) dt_set_errno(dtp, EDT_NOMEM); 1040 return (NULL); 1041 } 1042 1043 if (dt_idhash_nextid(dmp->dm_extern, &id) == -1) { 1044 (void) dt_set_errno(dtp, EDT_SYMOFLOW); 1045 return (NULL); 1046 } 1047 1048 if ((sip = malloc(sizeof (dtrace_syminfo_t))) == NULL) { 1049 (void) dt_set_errno(dtp, EDT_NOMEM); 1050 return (NULL); 1051 } 1052 1053 idp = dt_idhash_insert(dmp->dm_extern, name, DT_IDENT_SYMBOL, 0, id, 1054 _dtrace_symattr, 0, &dt_idops_thaw, NULL, dtp->dt_gen); 1055 1056 if (idp == NULL) { 1057 (void) dt_set_errno(dtp, EDT_NOMEM); 1058 free(sip); 1059 return (NULL); 1060 } 1061 1062 sip->dts_object = dmp->dm_name; 1063 sip->dts_name = idp->di_name; 1064 sip->dts_id = idp->di_id; 1065 1066 idp->di_data = sip; 1067 idp->di_ctfp = tip->dtt_ctfp; 1068 idp->di_type = tip->dtt_type; 1069 1070 return (idp); 1071} 1072 1073const char * 1074dt_module_modelname(dt_module_t *dmp) 1075{ 1076 if (dmp->dm_ops == &dt_modops_64) 1077 return ("64-bit"); 1078 else 1079 return ("32-bit"); 1080} 1081 1082/* ARGSUSED */ 1083int 1084dt_module_getlibid(dtrace_hdl_t *dtp, dt_module_t *dmp, const ctf_file_t *fp) 1085{ 1086 int i; 1087 1088 for (i = 0; i < dmp->dm_nctflibs; i++) { 1089 if (dmp->dm_libctfp[i] == fp) 1090 return (i); 1091 } 1092 1093 return (-1); 1094} 1095 1096/* ARGSUSED */ 1097ctf_file_t * 1098dt_module_getctflib(dtrace_hdl_t *dtp, dt_module_t *dmp, const char *name) 1099{ 1100 int i; 1101 1102 for (i = 0; i < dmp->dm_nctflibs; i++) { 1103 if (strcmp(dmp->dm_libctfn[i], name) == 0) 1104 return (dmp->dm_libctfp[i]); 1105 } 1106 1107 return (NULL); 1108} 1109 1110/* 1111 * Update our module cache by adding an entry for the specified module 'name'. 1112 * We create the dt_module_t and populate it using /system/object/<name>/. 1113 * 1114 * On FreeBSD, the module name is passed as the full module file name, 1115 * including the path. 1116 */ 1117static void 1118#ifdef illumos 1119dt_module_update(dtrace_hdl_t *dtp, const char *name) 1120#else 1121dt_module_update(dtrace_hdl_t *dtp, struct kld_file_stat *k_stat) 1122#endif 1123{ 1124 char fname[MAXPATHLEN]; 1125 struct stat64 st; 1126 int fd, err, bits; 1127 1128 dt_module_t *dmp; 1129 const char *s; 1130 size_t shstrs; 1131 GElf_Shdr sh; 1132 Elf_Data *dp; 1133 Elf_Scn *sp; 1134 1135#ifdef illumos 1136 (void) snprintf(fname, sizeof (fname), 1137 "%s/%s/object", OBJFS_ROOT, name); 1138#else 1139 GElf_Ehdr ehdr; 1140 GElf_Phdr ph; 1141 char name[MAXPATHLEN]; 1142 uintptr_t mapbase, alignmask; 1143 int i = 0; 1144 int is_elf_obj; 1145 1146 (void) strlcpy(name, k_stat->name, sizeof(name)); 1147 (void) strlcpy(fname, k_stat->pathname, sizeof(fname)); 1148#endif 1149 1150 if ((fd = open(fname, O_RDONLY)) == -1 || fstat64(fd, &st) == -1 || 1151 (dmp = dt_module_create(dtp, name)) == NULL) { 1152 dt_dprintf("failed to open %s: %s\n", fname, strerror(errno)); 1153 (void) close(fd); 1154 return; 1155 } 1156 1157 /* 1158 * Since the module can unload out from under us (and /system/object 1159 * will return ENOENT), tell libelf to cook the entire file now and 1160 * then close the underlying file descriptor immediately. If this 1161 * succeeds, we know that we can continue safely using dmp->dm_elf. 1162 */ 1163 dmp->dm_elf = elf_begin(fd, ELF_C_READ, NULL); 1164 err = elf_cntl(dmp->dm_elf, ELF_C_FDREAD); 1165 (void) close(fd); 1166 1167 if (dmp->dm_elf == NULL || err == -1 || 1168 elf_getshdrstrndx(dmp->dm_elf, &shstrs) == -1) { 1169 dt_dprintf("failed to load %s: %s\n", 1170 fname, elf_errmsg(elf_errno())); 1171 dt_module_destroy(dtp, dmp); 1172 return; 1173 } 1174 1175 switch (gelf_getclass(dmp->dm_elf)) { 1176 case ELFCLASS32: 1177 dmp->dm_ops = &dt_modops_32; 1178 bits = 32; 1179 break; 1180 case ELFCLASS64: 1181 dmp->dm_ops = &dt_modops_64; 1182 bits = 64; 1183 break; 1184 default: 1185 dt_dprintf("failed to load %s: unknown ELF class\n", fname); 1186 dt_module_destroy(dtp, dmp); 1187 return; 1188 } 1189#if defined(__FreeBSD__) 1190 mapbase = (uintptr_t)k_stat->address; 1191 gelf_getehdr(dmp->dm_elf, &ehdr); 1192 is_elf_obj = (ehdr.e_type == ET_REL); 1193 if (is_elf_obj) { 1194 dmp->dm_sec_offsets = 1195 malloc(ehdr.e_shnum * sizeof(*dmp->dm_sec_offsets)); 1196 if (dmp->dm_sec_offsets == NULL) { 1197 dt_dprintf("failed to allocate memory\n"); 1198 dt_module_destroy(dtp, dmp); 1199 return; 1200 } 1201 } 1202#endif 1203 /* 1204 * Iterate over the section headers locating various sections of 1205 * interest and use their attributes to flesh out the dt_module_t. 1206 */ 1207 for (sp = NULL; (sp = elf_nextscn(dmp->dm_elf, sp)) != NULL; ) { 1208 if (gelf_getshdr(sp, &sh) == NULL || sh.sh_type == SHT_NULL || 1209 (s = elf_strptr(dmp->dm_elf, shstrs, sh.sh_name)) == NULL) 1210 continue; /* skip any malformed sections */ 1211#if defined(__FreeBSD__) 1212 if (sh.sh_size == 0) 1213 continue; 1214 if (sh.sh_type == SHT_PROGBITS || sh.sh_type == SHT_NOBITS) { 1215 alignmask = sh.sh_addralign - 1; 1216 mapbase += alignmask; 1217 mapbase &= ~alignmask; 1218 sh.sh_addr = mapbase; 1219 if (is_elf_obj) 1220 dmp->dm_sec_offsets[elf_ndxscn(sp)] = sh.sh_addr; 1221 mapbase += sh.sh_size; 1222 } 1223#endif 1224 if (strcmp(s, ".text") == 0) { 1225 dmp->dm_text_size = sh.sh_size; 1226 dmp->dm_text_va = sh.sh_addr; 1227 } else if (strcmp(s, ".data") == 0) { 1228 dmp->dm_data_size = sh.sh_size; 1229 dmp->dm_data_va = sh.sh_addr; 1230 } else if (strcmp(s, ".bss") == 0) { 1231 dmp->dm_bss_size = sh.sh_size; 1232 dmp->dm_bss_va = sh.sh_addr; 1233 } else if (strcmp(s, ".info") == 0 && 1234 (dp = elf_getdata(sp, NULL)) != NULL) { 1235 bcopy(dp->d_buf, &dmp->dm_info, 1236 MIN(sh.sh_size, sizeof (dmp->dm_info))); 1237 } else if (strcmp(s, ".filename") == 0 && 1238 (dp = elf_getdata(sp, NULL)) != NULL) { 1239 (void) strlcpy(dmp->dm_file, 1240 dp->d_buf, sizeof (dmp->dm_file)); 1241 } 1242 } 1243 1244 dmp->dm_flags |= DT_DM_KERNEL; 1245#ifdef illumos 1246 dmp->dm_modid = (int)OBJFS_MODID(st.st_ino); 1247#else 1248 /* 1249 * Include .rodata and special sections into .text. 1250 * This depends on default section layout produced by GNU ld 1251 * for ELF objects and libraries: 1252 * [Text][R/O data][R/W data][Dynamic][BSS][Non loadable] 1253 */ 1254 dmp->dm_text_size = dmp->dm_data_va - dmp->dm_text_va; 1255#if defined(__i386__) 1256 /* 1257 * Find the first load section and figure out the relocation 1258 * offset for the symbols. The kernel module will not need 1259 * relocation, but the kernel linker modules will. 1260 */ 1261 for (i = 0; gelf_getphdr(dmp->dm_elf, i, &ph) != NULL; i++) { 1262 if (ph.p_type == PT_LOAD) { 1263 dmp->dm_reloc_offset = k_stat->address - ph.p_vaddr; 1264 break; 1265 } 1266 } 1267#endif 1268#endif /* illumos */ 1269 1270 if (dmp->dm_info.objfs_info_primary) 1271 dmp->dm_flags |= DT_DM_PRIMARY; 1272 1273 dt_dprintf("opened %d-bit module %s (%s) [%d]\n", 1274 bits, dmp->dm_name, dmp->dm_file, dmp->dm_modid); 1275} 1276 1277/* 1278 * Unload all the loaded modules and then refresh the module cache with the 1279 * latest list of loaded modules and their address ranges. 1280 */ 1281void 1282dtrace_update(dtrace_hdl_t *dtp) 1283{ 1284 dt_module_t *dmp; 1285 DIR *dirp; 1286#if defined(__FreeBSD__) 1287 int fileid; 1288#endif 1289 1290 for (dmp = dt_list_next(&dtp->dt_modlist); 1291 dmp != NULL; dmp = dt_list_next(dmp)) 1292 dt_module_unload(dtp, dmp); 1293 1294#ifdef illumos 1295 /* 1296 * Open /system/object and attempt to create a libdtrace module for 1297 * each kernel module that is loaded on the current system. 1298 */ 1299 if (!(dtp->dt_oflags & DTRACE_O_NOSYS) && 1300 (dirp = opendir(OBJFS_ROOT)) != NULL) { 1301 struct dirent *dp; 1302 1303 while ((dp = readdir(dirp)) != NULL) { 1304 if (dp->d_name[0] != '.') 1305 dt_module_update(dtp, dp->d_name); 1306 } 1307 1308 (void) closedir(dirp); 1309 } 1310#elif defined(__FreeBSD__) 1311 /* 1312 * Use FreeBSD's kernel loader interface to discover what kernel 1313 * modules are loaded and create a libdtrace module for each one. 1314 */ 1315 for (fileid = kldnext(0); fileid > 0; fileid = kldnext(fileid)) { 1316 struct kld_file_stat k_stat; 1317 k_stat.version = sizeof(k_stat); 1318 if (kldstat(fileid, &k_stat) == 0) 1319 dt_module_update(dtp, &k_stat); 1320 } 1321#endif 1322 1323 /* 1324 * Look up all the macro identifiers and set di_id to the latest value. 1325 * This code collaborates with dt_lex.l on the use of di_id. We will 1326 * need to implement something fancier if we need to support non-ints. 1327 */ 1328 dt_idhash_lookup(dtp->dt_macros, "egid")->di_id = getegid(); 1329 dt_idhash_lookup(dtp->dt_macros, "euid")->di_id = geteuid(); 1330 dt_idhash_lookup(dtp->dt_macros, "gid")->di_id = getgid(); 1331 dt_idhash_lookup(dtp->dt_macros, "pid")->di_id = getpid(); 1332 dt_idhash_lookup(dtp->dt_macros, "pgid")->di_id = getpgid(0); 1333 dt_idhash_lookup(dtp->dt_macros, "ppid")->di_id = getppid(); 1334#ifdef illumos 1335 dt_idhash_lookup(dtp->dt_macros, "projid")->di_id = getprojid(); 1336#endif 1337 dt_idhash_lookup(dtp->dt_macros, "sid")->di_id = getsid(0); 1338#ifdef illumos 1339 dt_idhash_lookup(dtp->dt_macros, "taskid")->di_id = gettaskid(); 1340#endif 1341 dt_idhash_lookup(dtp->dt_macros, "uid")->di_id = getuid(); 1342 1343 /* 1344 * Cache the pointers to the modules representing the base executable 1345 * and the run-time linker in the dtrace client handle. Note that on 1346 * x86 krtld is folded into unix, so if we don't find it, use unix 1347 * instead. 1348 */ 1349 dtp->dt_exec = dt_module_lookup_by_name(dtp, "genunix"); 1350 dtp->dt_rtld = dt_module_lookup_by_name(dtp, "krtld"); 1351 if (dtp->dt_rtld == NULL) 1352 dtp->dt_rtld = dt_module_lookup_by_name(dtp, "unix"); 1353 1354 /* 1355 * If this is the first time we are initializing the module list, 1356 * remove the module for genunix from the module list and then move it 1357 * to the front of the module list. We do this so that type and symbol 1358 * queries encounter genunix and thereby optimize for the common case 1359 * in dtrace_lookup_by_name() and dtrace_lookup_by_type(), below. 1360 */ 1361 if (dtp->dt_exec != NULL && 1362 dtp->dt_cdefs == NULL && dtp->dt_ddefs == NULL) { 1363 dt_list_delete(&dtp->dt_modlist, dtp->dt_exec); 1364 dt_list_prepend(&dtp->dt_modlist, dtp->dt_exec); 1365 } 1366} 1367 1368static dt_module_t * 1369dt_module_from_object(dtrace_hdl_t *dtp, const char *object) 1370{ 1371 int err = EDT_NOMOD; 1372 dt_module_t *dmp; 1373 1374 switch ((uintptr_t)object) { 1375 case (uintptr_t)DTRACE_OBJ_EXEC: 1376 dmp = dtp->dt_exec; 1377 break; 1378 case (uintptr_t)DTRACE_OBJ_RTLD: 1379 dmp = dtp->dt_rtld; 1380 break; 1381 case (uintptr_t)DTRACE_OBJ_CDEFS: 1382 dmp = dtp->dt_cdefs; 1383 break; 1384 case (uintptr_t)DTRACE_OBJ_DDEFS: 1385 dmp = dtp->dt_ddefs; 1386 break; 1387 default: 1388 dmp = dt_module_create(dtp, object); 1389 err = EDT_NOMEM; 1390 } 1391 1392 if (dmp == NULL) 1393 (void) dt_set_errno(dtp, err); 1394 1395 return (dmp); 1396} 1397 1398/* 1399 * Exported interface to look up a symbol by name. We return the GElf_Sym and 1400 * complete symbol information for the matching symbol. 1401 */ 1402int 1403dtrace_lookup_by_name(dtrace_hdl_t *dtp, const char *object, const char *name, 1404 GElf_Sym *symp, dtrace_syminfo_t *sip) 1405{ 1406 dt_module_t *dmp; 1407 dt_ident_t *idp; 1408 uint_t n, id; 1409 GElf_Sym sym; 1410 1411 uint_t mask = 0; /* mask of dt_module flags to match */ 1412 uint_t bits = 0; /* flag bits that must be present */ 1413 1414 if (object != DTRACE_OBJ_EVERY && 1415 object != DTRACE_OBJ_KMODS && 1416 object != DTRACE_OBJ_UMODS) { 1417 if ((dmp = dt_module_from_object(dtp, object)) == NULL) 1418 return (-1); /* dt_errno is set for us */ 1419 1420 if (dt_module_load(dtp, dmp) == -1) 1421 return (-1); /* dt_errno is set for us */ 1422 n = 1; 1423 1424 } else { 1425 if (object == DTRACE_OBJ_KMODS) 1426 mask = bits = DT_DM_KERNEL; 1427 else if (object == DTRACE_OBJ_UMODS) 1428 mask = DT_DM_KERNEL; 1429 1430 dmp = dt_list_next(&dtp->dt_modlist); 1431 n = dtp->dt_nmods; 1432 } 1433 1434 if (symp == NULL) 1435 symp = &sym; 1436 1437 for (; n > 0; n--, dmp = dt_list_next(dmp)) { 1438 if ((dmp->dm_flags & mask) != bits) 1439 continue; /* failed to match required attributes */ 1440 1441 if (dt_module_load(dtp, dmp) == -1) 1442 continue; /* failed to load symbol table */ 1443 1444 if (dmp->dm_ops->do_symname(dmp, name, symp, &id) != NULL) { 1445 if (sip != NULL) { 1446 sip->dts_object = dmp->dm_name; 1447 sip->dts_name = (const char *) 1448 dmp->dm_strtab.cts_data + symp->st_name; 1449 sip->dts_id = id; 1450 } 1451 return (0); 1452 } 1453 1454 if (dmp->dm_extern != NULL && 1455 (idp = dt_idhash_lookup(dmp->dm_extern, name)) != NULL) { 1456 if (symp != &sym) { 1457 symp->st_name = (uintptr_t)idp->di_name; 1458 symp->st_info = 1459 GELF_ST_INFO(STB_GLOBAL, STT_NOTYPE); 1460 symp->st_other = 0; 1461 symp->st_shndx = SHN_UNDEF; 1462 symp->st_value = 0; 1463 symp->st_size = 1464 ctf_type_size(idp->di_ctfp, idp->di_type); 1465 } 1466 1467 if (sip != NULL) { 1468 sip->dts_object = dmp->dm_name; 1469 sip->dts_name = idp->di_name; 1470 sip->dts_id = idp->di_id; 1471 } 1472 1473 return (0); 1474 } 1475 } 1476 1477 return (dt_set_errno(dtp, EDT_NOSYM)); 1478} 1479 1480/* 1481 * Exported interface to look up a symbol by address. We return the GElf_Sym 1482 * and complete symbol information for the matching symbol. 1483 */ 1484int 1485dtrace_lookup_by_addr(dtrace_hdl_t *dtp, GElf_Addr addr, 1486 GElf_Sym *symp, dtrace_syminfo_t *sip) 1487{ 1488 dt_module_t *dmp; 1489 uint_t id; 1490 const dtrace_vector_t *v = dtp->dt_vector; 1491 1492 if (v != NULL) 1493 return (v->dtv_lookup_by_addr(dtp->dt_varg, addr, symp, sip)); 1494 1495 for (dmp = dt_list_next(&dtp->dt_modlist); dmp != NULL; 1496 dmp = dt_list_next(dmp)) { 1497 if (addr - dmp->dm_text_va < dmp->dm_text_size || 1498 addr - dmp->dm_data_va < dmp->dm_data_size || 1499 addr - dmp->dm_bss_va < dmp->dm_bss_size) 1500 break; 1501 } 1502 1503 if (dmp == NULL) 1504 return (dt_set_errno(dtp, EDT_NOSYMADDR)); 1505 1506 if (dt_module_load(dtp, dmp) == -1) 1507 return (-1); /* dt_errno is set for us */ 1508 1509 if (symp != NULL) { 1510 if (dmp->dm_ops->do_symaddr(dmp, addr, symp, &id) == NULL) 1511 return (dt_set_errno(dtp, EDT_NOSYMADDR)); 1512 } 1513 1514 if (sip != NULL) { 1515 sip->dts_object = dmp->dm_name; 1516 1517 if (symp != NULL) { 1518 sip->dts_name = (const char *) 1519 dmp->dm_strtab.cts_data + symp->st_name; 1520 sip->dts_id = id; 1521 } else { 1522 sip->dts_name = NULL; 1523 sip->dts_id = 0; 1524 } 1525 } 1526 1527 return (0); 1528} 1529 1530int 1531dtrace_lookup_by_type(dtrace_hdl_t *dtp, const char *object, const char *name, 1532 dtrace_typeinfo_t *tip) 1533{ 1534 dtrace_typeinfo_t ti; 1535 dt_module_t *dmp; 1536 int found = 0; 1537 ctf_id_t id; 1538 uint_t n, i; 1539 int justone; 1540 ctf_file_t *fp; 1541 char *buf, *p, *q; 1542 1543 uint_t mask = 0; /* mask of dt_module flags to match */ 1544 uint_t bits = 0; /* flag bits that must be present */ 1545 1546 if (object != DTRACE_OBJ_EVERY && 1547 object != DTRACE_OBJ_KMODS && 1548 object != DTRACE_OBJ_UMODS) { 1549 if ((dmp = dt_module_from_object(dtp, object)) == NULL) 1550 return (-1); /* dt_errno is set for us */ 1551 1552 if (dt_module_load(dtp, dmp) == -1) 1553 return (-1); /* dt_errno is set for us */ 1554 n = 1; 1555 justone = 1; 1556 } else { 1557 if (object == DTRACE_OBJ_KMODS) 1558 mask = bits = DT_DM_KERNEL; 1559 else if (object == DTRACE_OBJ_UMODS) 1560 mask = DT_DM_KERNEL; 1561 1562 dmp = dt_list_next(&dtp->dt_modlist); 1563 n = dtp->dt_nmods; 1564 justone = 0; 1565 } 1566 1567 if (tip == NULL) 1568 tip = &ti; 1569 1570 for (; n > 0; n--, dmp = dt_list_next(dmp)) { 1571 if ((dmp->dm_flags & mask) != bits) 1572 continue; /* failed to match required attributes */ 1573 1574 /* 1575 * If we can't load the CTF container, continue on to the next 1576 * module. If our search was scoped to only one module then 1577 * return immediately leaving dt_errno unmodified. 1578 */ 1579 if (dt_module_hasctf(dtp, dmp) == 0) { 1580 if (justone) 1581 return (-1); 1582 continue; 1583 } 1584 1585 /* 1586 * Look up the type in the module's CTF container. If our 1587 * match is a forward declaration tag, save this choice in 1588 * 'tip' and keep going in the hope that we will locate the 1589 * underlying structure definition. Otherwise just return. 1590 */ 1591 if (dmp->dm_pid == 0) { 1592 id = ctf_lookup_by_name(dmp->dm_ctfp, name); 1593 fp = dmp->dm_ctfp; 1594 } else { 1595 if ((p = strchr(name, '`')) != NULL) { 1596 buf = strdup(name); 1597 if (buf == NULL) 1598 return (dt_set_errno(dtp, EDT_NOMEM)); 1599 p = strchr(buf, '`'); 1600 if ((q = strchr(p + 1, '`')) != NULL) 1601 p = q; 1602 *p = '\0'; 1603 fp = dt_module_getctflib(dtp, dmp, buf); 1604 if (fp == NULL || (id = ctf_lookup_by_name(fp, 1605 p + 1)) == CTF_ERR) 1606 id = CTF_ERR; 1607 free(buf); 1608 } else { 1609 for (i = 0; i < dmp->dm_nctflibs; i++) { 1610 fp = dmp->dm_libctfp[i]; 1611 id = ctf_lookup_by_name(fp, name); 1612 if (id != CTF_ERR) 1613 break; 1614 } 1615 } 1616 } 1617 if (id != CTF_ERR) { 1618 tip->dtt_object = dmp->dm_name; 1619 tip->dtt_ctfp = fp; 1620 tip->dtt_type = id; 1621 if (ctf_type_kind(fp, ctf_type_resolve(fp, id)) != 1622 CTF_K_FORWARD) 1623 return (0); 1624 1625 found++; 1626 } 1627 } 1628 1629 if (found == 0) 1630 return (dt_set_errno(dtp, EDT_NOTYPE)); 1631 1632 return (0); 1633} 1634 1635int 1636dtrace_symbol_type(dtrace_hdl_t *dtp, const GElf_Sym *symp, 1637 const dtrace_syminfo_t *sip, dtrace_typeinfo_t *tip) 1638{ 1639 dt_module_t *dmp; 1640 1641 tip->dtt_object = NULL; 1642 tip->dtt_ctfp = NULL; 1643 tip->dtt_type = CTF_ERR; 1644 tip->dtt_flags = 0; 1645 1646 if ((dmp = dt_module_lookup_by_name(dtp, sip->dts_object)) == NULL) 1647 return (dt_set_errno(dtp, EDT_NOMOD)); 1648 1649 if (symp->st_shndx == SHN_UNDEF && dmp->dm_extern != NULL) { 1650 dt_ident_t *idp = 1651 dt_idhash_lookup(dmp->dm_extern, sip->dts_name); 1652 1653 if (idp == NULL) 1654 return (dt_set_errno(dtp, EDT_NOSYM)); 1655 1656 tip->dtt_ctfp = idp->di_ctfp; 1657 tip->dtt_type = idp->di_type; 1658 1659 } else if (GELF_ST_TYPE(symp->st_info) != STT_FUNC) { 1660 if (dt_module_getctf(dtp, dmp) == NULL) 1661 return (-1); /* errno is set for us */ 1662 1663 tip->dtt_ctfp = dmp->dm_ctfp; 1664 tip->dtt_type = ctf_lookup_by_symbol(dmp->dm_ctfp, sip->dts_id); 1665 1666 if (tip->dtt_type == CTF_ERR) { 1667 dtp->dt_ctferr = ctf_errno(tip->dtt_ctfp); 1668 return (dt_set_errno(dtp, EDT_CTF)); 1669 } 1670 1671 } else { 1672 tip->dtt_ctfp = DT_FPTR_CTFP(dtp); 1673 tip->dtt_type = DT_FPTR_TYPE(dtp); 1674 } 1675 1676 tip->dtt_object = dmp->dm_name; 1677 return (0); 1678} 1679 1680static dtrace_objinfo_t * 1681dt_module_info(const dt_module_t *dmp, dtrace_objinfo_t *dto) 1682{ 1683 dto->dto_name = dmp->dm_name; 1684 dto->dto_file = dmp->dm_file; 1685 dto->dto_id = dmp->dm_modid; 1686 dto->dto_flags = 0; 1687 1688 if (dmp->dm_flags & DT_DM_KERNEL) 1689 dto->dto_flags |= DTRACE_OBJ_F_KERNEL; 1690 if (dmp->dm_flags & DT_DM_PRIMARY) 1691 dto->dto_flags |= DTRACE_OBJ_F_PRIMARY; 1692 1693 dto->dto_text_va = dmp->dm_text_va; 1694 dto->dto_text_size = dmp->dm_text_size; 1695 dto->dto_data_va = dmp->dm_data_va; 1696 dto->dto_data_size = dmp->dm_data_size; 1697 dto->dto_bss_va = dmp->dm_bss_va; 1698 dto->dto_bss_size = dmp->dm_bss_size; 1699 1700 return (dto); 1701} 1702 1703int 1704dtrace_object_iter(dtrace_hdl_t *dtp, dtrace_obj_f *func, void *data) 1705{ 1706 const dt_module_t *dmp = dt_list_next(&dtp->dt_modlist); 1707 dtrace_objinfo_t dto; 1708 int rv; 1709 1710 for (; dmp != NULL; dmp = dt_list_next(dmp)) { 1711 if ((rv = (*func)(dtp, dt_module_info(dmp, &dto), data)) != 0) 1712 return (rv); 1713 } 1714 1715 return (0); 1716} 1717 1718int 1719dtrace_object_info(dtrace_hdl_t *dtp, const char *object, dtrace_objinfo_t *dto) 1720{ 1721 dt_module_t *dmp; 1722 1723 if (object == DTRACE_OBJ_EVERY || object == DTRACE_OBJ_KMODS || 1724 object == DTRACE_OBJ_UMODS || dto == NULL) 1725 return (dt_set_errno(dtp, EINVAL)); 1726 1727 if ((dmp = dt_module_from_object(dtp, object)) == NULL) 1728 return (-1); /* dt_errno is set for us */ 1729 1730 if (dt_module_load(dtp, dmp) == -1) 1731 return (-1); /* dt_errno is set for us */ 1732 1733 (void) dt_module_info(dmp, dto); 1734 return (0); 1735} 1736