cddl/contrib/opensolaris/lib/libdtrace/common/dt_module.c

   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  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #pragma ident   "%Z%%M% %I%     %E% SMI"
  27
  28 #include <sys/types.h>
  29 #if defined(sun)
  30 #include <sys/modctl.h>
  31 #include <sys/kobj.h>
  32 #include <sys/kobj_impl.h>
  33 #include <sys/sysmacros.h>
  34 #include <sys/elf.h>
  35 #include <sys/task.h>
  36 #else
  37 #include <sys/param.h>
  38 #include <sys/linker.h>
  39 #include <sys/stat.h>
  40 #endif
  41
  42 #include <unistd.h>
  43 #if defined(sun)
  44 #include <project.h>
  45 #endif
  46 #include <strings.h>
  47 #include <stdlib.h>
  48 #include <libelf.h>
  49 #include <limits.h>
  50 #include <assert.h>
  51 #include <errno.h>
  52 #include <dirent.h>
  53 #if !defined(sun)
  54 #include <fcntl.h>
  55 #endif
  56
  57 #include <dt_strtab.h>
  58 #include <dt_module.h>
  59 #include <dt_impl.h>
  60
  61 static const char *dt_module_strtab; /* active strtab for qsort callbacks */
  62
  63 static void
  64 dt_module_symhash_insert(dt_module_t *dmp, const char *name, uint_t id)
  65 {
  66         dt_sym_t *dsp = &dmp->dm_symchains[dmp->dm_symfree];
  67         uint_t h;
  68
  69         assert(dmp->dm_symfree < dmp->dm_nsymelems + 1);
  70
  71         dsp->ds_symid = id;
  72         h = dt_strtab_hash(name, NULL) % dmp->dm_nsymbuckets;
  73         dsp->ds_next = dmp->dm_symbuckets[h];
  74         dmp->dm_symbuckets[h] = dmp->dm_symfree++;
  75 }
  76
  77 static uint_t
  78 dt_module_syminit32(dt_module_t *dmp)
  79 {
  80         Elf32_Sym *sym = dmp->dm_symtab.cts_data;
  81         const char *base = dmp->dm_strtab.cts_data;
  82         size_t ss_size = dmp->dm_strtab.cts_size;
  83         uint_t i, n = dmp->dm_nsymelems;
  84         uint_t asrsv = 0;
  85
  86         for (i = 0; i < n; i++, sym++) {
  87                 const char *name = base + sym->st_name;
  88                 uchar_t type = ELF32_ST_TYPE(sym->st_info);
  89
  90                 if (type >= STT_NUM || type == STT_SECTION)
  91                         continue; /* skip sections and unknown types */
  92
  93                 if (sym->st_name == 0 || sym->st_name >= ss_size)
  94                         continue; /* skip null or invalid names */
  95
  96                 if (sym->st_value != 0 &&
  97                     (ELF32_ST_BIND(sym->st_info) != STB_LOCAL || sym->st_size)) {
  98                         asrsv++; /* reserve space in the address map */
  99
 100 #if !defined(sun)
 101                         sym->st_value += (Elf_Addr) dmp->dm_reloc_offset;
 102 #endif
 103                 }
 104
 105                 dt_module_symhash_insert(dmp, name, i);
 106         }
 107
 108         return (asrsv);
 109 }
 110
 111 static uint_t
 112 dt_module_syminit64(dt_module_t *dmp)
 113 {
 114         Elf64_Sym *sym = dmp->dm_symtab.cts_data;
 115         const char *base = dmp->dm_strtab.cts_data;
 116         size_t ss_size = dmp->dm_strtab.cts_size;
 117         uint_t i, n = dmp->dm_nsymelems;
 118         uint_t asrsv = 0;
 119
 120         for (i = 0; i < n; i++, sym++) {
 121                 const char *name = base + sym->st_name;
 122                 uchar_t type = ELF64_ST_TYPE(sym->st_info);
 123
 124                 if (type >= STT_NUM || type == STT_SECTION)
 125                         continue; /* skip sections and unknown types */
 126
 127                 if (sym->st_name == 0 || sym->st_name >= ss_size)
 128                         continue; /* skip null or invalid names */
 129
 130                 if (sym->st_value != 0 &&
 131                     (ELF64_ST_BIND(sym->st_info) != STB_LOCAL || sym->st_size)) {
 132                         asrsv++; /* reserve space in the address map */
 133
 134 #if !defined(sun)
 135                         sym->st_value += (Elf_Addr) dmp->dm_reloc_offset;
 136 #endif
 137                 }
 138
 139                 dt_module_symhash_insert(dmp, name, i);
 140         }
 141
 142         return (asrsv);
 143 }
 144
 145 /*
 146  * Sort comparison function for 32-bit symbol address-to-name lookups.  We sort
 147  * symbols by value.  If values are equal, we prefer the symbol that is
 148  * non-zero sized, typed, not weak, or lexically first, in that order.
 149  */
 150 static int
 151 dt_module_symcomp32(const void *lp, const void *rp)
 152 {
 153         Elf32_Sym *lhs = *((Elf32_Sym **)lp);
 154         Elf32_Sym *rhs = *((Elf32_Sym **)rp);
 155
 156         if (lhs->st_value != rhs->st_value)
 157                 return (lhs->st_value > rhs->st_value ? 1 : -1);
 158
 159         if ((lhs->st_size == 0) != (rhs->st_size == 0))
 160                 return (lhs->st_size == 0 ? 1 : -1);
 161
 162         if ((ELF32_ST_TYPE(lhs->st_info) == STT_NOTYPE) !=
 163             (ELF32_ST_TYPE(rhs->st_info) == STT_NOTYPE))
 164                 return (ELF32_ST_TYPE(lhs->st_info) == STT_NOTYPE ? 1 : -1);
 165
 166         if ((ELF32_ST_BIND(lhs->st_info) == STB_WEAK) !=
 167             (ELF32_ST_BIND(rhs->st_info) == STB_WEAK))
 168                 return (ELF32_ST_BIND(lhs->st_info) == STB_WEAK ? 1 : -1);
 169
 170         return (strcmp(dt_module_strtab + lhs->st_name,
 171             dt_module_strtab + rhs->st_name));
 172 }
 173
 174 /*
 175  * Sort comparison function for 64-bit symbol address-to-name lookups.  We sort
 176  * symbols by value.  If values are equal, we prefer the symbol that is
 177  * non-zero sized, typed, not weak, or lexically first, in that order.
 178  */
 179 static int
 180 dt_module_symcomp64(const void *lp, const void *rp)
 181 {
 182         Elf64_Sym *lhs = *((Elf64_Sym **)lp);
 183         Elf64_Sym *rhs = *((Elf64_Sym **)rp);
 184
 185         if (lhs->st_value != rhs->st_value)
 186                 return (lhs->st_value > rhs->st_value ? 1 : -1);
 187
 188         if ((lhs->st_size == 0) != (rhs->st_size == 0))
 189                 return (lhs->st_size == 0 ? 1 : -1);
 190
 191         if ((ELF64_ST_TYPE(lhs->st_info) == STT_NOTYPE) !=
 192             (ELF64_ST_TYPE(rhs->st_info) == STT_NOTYPE))
 193                 return (ELF64_ST_TYPE(lhs->st_info) == STT_NOTYPE ? 1 : -1);
 194
 195         if ((ELF64_ST_BIND(lhs->st_info) == STB_WEAK) !=
 196             (ELF64_ST_BIND(rhs->st_info) == STB_WEAK))
 197                 return (ELF64_ST_BIND(lhs->st_info) == STB_WEAK ? 1 : -1);
 198
 199         return (strcmp(dt_module_strtab + lhs->st_name,
 200             dt_module_strtab + rhs->st_name));
 201 }
 202
 203 static void
 204 dt_module_symsort32(dt_module_t *dmp)
 205 {
 206         Elf32_Sym *symtab = (Elf32_Sym *)dmp->dm_symtab.cts_data;
 207         Elf32_Sym **sympp = (Elf32_Sym **)dmp->dm_asmap;
 208         const dt_sym_t *dsp = dmp->dm_symchains + 1;
 209         uint_t i, n = dmp->dm_symfree;
 210
 211         for (i = 1; i < n; i++, dsp++) {
 212                 Elf32_Sym *sym = symtab + dsp->ds_symid;
 213                 if (sym->st_value != 0 &&
 214                     (ELF32_ST_BIND(sym->st_info) != STB_LOCAL || sym->st_size))
 215                         *sympp++ = sym;
 216         }
 217
 218         dmp->dm_aslen = (uint_t)(sympp - (Elf32_Sym **)dmp->dm_asmap);
 219         assert(dmp->dm_aslen <= dmp->dm_asrsv);
 220
 221         dt_module_strtab = dmp->dm_strtab.cts_data;
 222         qsort(dmp->dm_asmap, dmp->dm_aslen,
 223             sizeof (Elf32_Sym *), dt_module_symcomp32);
 224         dt_module_strtab = NULL;
 225 }
 226
 227 static void
 228 dt_module_symsort64(dt_module_t *dmp)
 229 {
 230         Elf64_Sym *symtab = (Elf64_Sym *)dmp->dm_symtab.cts_data;
 231         Elf64_Sym **sympp = (Elf64_Sym **)dmp->dm_asmap;
 232         const dt_sym_t *dsp = dmp->dm_symchains + 1;
 233         uint_t i, n = dmp->dm_symfree;
 234
 235         for (i = 1; i < n; i++, dsp++) {
 236                 Elf64_Sym *sym = symtab + dsp->ds_symid;
 237                 if (sym->st_value != 0 &&
 238                     (ELF64_ST_BIND(sym->st_info) != STB_LOCAL || sym->st_size))
 239                         *sympp++ = sym;
 240         }
 241
 242         dmp->dm_aslen = (uint_t)(sympp - (Elf64_Sym **)dmp->dm_asmap);
 243         assert(dmp->dm_aslen <= dmp->dm_asrsv);
 244
 245         dt_module_strtab = dmp->dm_strtab.cts_data;
 246         qsort(dmp->dm_asmap, dmp->dm_aslen,
 247             sizeof (Elf64_Sym *), dt_module_symcomp64);
 248         dt_module_strtab = NULL;
 249 }
 250
 251 static GElf_Sym *
 252 dt_module_symgelf32(const Elf32_Sym *src, GElf_Sym *dst)
 253 {
 254         if (dst != NULL) {
 255                 dst->st_name = src->st_name;
 256                 dst->st_info = src->st_info;
 257                 dst->st_other = src->st_other;
 258                 dst->st_shndx = src->st_shndx;
 259                 dst->st_value = src->st_value;
 260                 dst->st_size = src->st_size;
 261         }
 262
 263         return (dst);
 264 }
 265
 266 static GElf_Sym *
 267 dt_module_symgelf64(const Elf64_Sym *src, GElf_Sym *dst)
 268 {
 269         if (dst != NULL)
 270                 bcopy(src, dst, sizeof (GElf_Sym));
 271
 272         return (dst);
 273 }
 274
 275 static GElf_Sym *
 276 dt_module_symname32(dt_module_t *dmp, const char *name,
 277     GElf_Sym *symp, uint_t *idp)
 278 {
 279         const Elf32_Sym *symtab = dmp->dm_symtab.cts_data;
 280         const char *strtab = dmp->dm_strtab.cts_data;
 281
 282         const Elf32_Sym *sym;
 283         const dt_sym_t *dsp;
 284         uint_t i, h;
 285
 286         if (dmp->dm_nsymelems == 0)
 287                 return (NULL);
 288
 289         h = dt_strtab_hash(name, NULL) % dmp->dm_nsymbuckets;
 290
 291         for (i = dmp->dm_symbuckets[h]; i != 0; i = dsp->ds_next) {
 292                 dsp = &dmp->dm_symchains[i];
 293                 sym = symtab + dsp->ds_symid;
 294
 295                 if (strcmp(name, strtab + sym->st_name) == 0) {
 296                         if (idp != NULL)
 297                                 *idp = dsp->ds_symid;
 298                         return (dt_module_symgelf32(sym, symp));
 299                 }
 300         }
 301
 302         return (NULL);
 303 }
 304
 305 static GElf_Sym *
 306 dt_module_symname64(dt_module_t *dmp, const char *name,
 307     GElf_Sym *symp, uint_t *idp)
 308 {
 309         const Elf64_Sym *symtab = dmp->dm_symtab.cts_data;
 310         const char *strtab = dmp->dm_strtab.cts_data;
 311
 312         const Elf64_Sym *sym;
 313         const dt_sym_t *dsp;
 314         uint_t i, h;
 315
 316         if (dmp->dm_nsymelems == 0)
 317                 return (NULL);
 318
 319         h = dt_strtab_hash(name, NULL) % dmp->dm_nsymbuckets;
 320
 321         for (i = dmp->dm_symbuckets[h]; i != 0; i = dsp->ds_next) {
 322                 dsp = &dmp->dm_symchains[i];
 323                 sym = symtab + dsp->ds_symid;
 324
 325                 if (strcmp(name, strtab + sym->st_name) == 0) {
 326                         if (idp != NULL)
 327                                 *idp = dsp->ds_symid;
 328                         return (dt_module_symgelf64(sym, symp));
 329                 }
 330         }
 331
 332         return (NULL);
 333 }
 334
 335 static GElf_Sym *
 336 dt_module_symaddr32(dt_module_t *dmp, GElf_Addr addr,
 337     GElf_Sym *symp, uint_t *idp)
 338 {
 339         const Elf32_Sym **asmap = (const Elf32_Sym **)dmp->dm_asmap;
 340         const Elf32_Sym *symtab = dmp->dm_symtab.cts_data;
 341         const Elf32_Sym *sym;
 342
 343         uint_t i, mid, lo = 0, hi = dmp->dm_aslen - 1;
 344         Elf32_Addr v;
 345
 346         if (dmp->dm_aslen == 0)
 347                 return (NULL);
 348
 349         while (hi - lo > 1) {
 350                 mid = (lo + hi) / 2;
 351                 if (addr >= asmap[mid]->st_value)
 352                         lo = mid;
 353                 else
 354                         hi = mid;
 355         }
 356
 357         i = addr < asmap[hi]->st_value ? lo : hi;
 358         sym = asmap[i];
 359         v = sym->st_value;
 360
 361         /*
 362          * If the previous entry has the same value, improve our choice.  The
 363          * order of equal-valued symbols is determined by the comparison func.
 364          */
 365         while (i-- != 0 && asmap[i]->st_value == v)
 366                 sym = asmap[i];
 367
 368         if (addr - sym->st_value < MAX(sym->st_size, 1)) {
 369                 if (idp != NULL)
 370                         *idp = (uint_t)(sym - symtab);
 371                 return (dt_module_symgelf32(sym, symp));
 372         }
 373
 374         return (NULL);
 375 }
 376
 377 static GElf_Sym *
 378 dt_module_symaddr64(dt_module_t *dmp, GElf_Addr addr,
 379     GElf_Sym *symp, uint_t *idp)
 380 {
 381         const Elf64_Sym **asmap = (const Elf64_Sym **)dmp->dm_asmap;
 382         const Elf64_Sym *symtab = dmp->dm_symtab.cts_data;
 383         const Elf64_Sym *sym;
 384
 385         uint_t i, mid, lo = 0, hi = dmp->dm_aslen - 1;
 386         Elf64_Addr v;
 387
 388         if (dmp->dm_aslen == 0)
 389                 return (NULL);
 390
 391         while (hi - lo > 1) {
 392                 mid = (lo + hi) / 2;
 393                 if (addr >= asmap[mid]->st_value)
 394                         lo = mid;
 395                 else
 396                         hi = mid;
 397         }
 398
 399         i = addr < asmap[hi]->st_value ? lo : hi;
 400         sym = asmap[i];
 401         v = sym->st_value;
 402
 403         /*
 404          * If the previous entry has the same value, improve our choice.  The
 405          * order of equal-valued symbols is determined by the comparison func.
 406          */
 407         while (i-- != 0 && asmap[i]->st_value == v)
 408                 sym = asmap[i];
 409
 410         if (addr - sym->st_value < MAX(sym->st_size, 1)) {
 411                 if (idp != NULL)
 412                         *idp = (uint_t)(sym - symtab);
 413                 return (dt_module_symgelf64(sym, symp));
 414         }
 415
 416         return (NULL);
 417 }
 418
 419 static const dt_modops_t dt_modops_32 = {
 420         dt_module_syminit32,
 421         dt_module_symsort32,
 422         dt_module_symname32,
 423         dt_module_symaddr32
 424 };
 425
 426 static const dt_modops_t dt_modops_64 = {
 427         dt_module_syminit64,
 428         dt_module_symsort64,
 429         dt_module_symname64,
 430         dt_module_symaddr64
 431 };
 432
 433 dt_module_t *
 434 dt_module_create(dtrace_hdl_t *dtp, const char *name)
 435 {
 436         uint_t h = dt_strtab_hash(name, NULL) % dtp->dt_modbuckets;
 437         dt_module_t *dmp;
 438
 439         for (dmp = dtp->dt_mods[h]; dmp != NULL; dmp = dmp->dm_next) {
 440                 if (strcmp(dmp->dm_name, name) == 0)
 441                         return (dmp);
 442         }
 443
 444         if ((dmp = malloc(sizeof (dt_module_t))) == NULL)
 445                 return (NULL); /* caller must handle allocation failure */
 446
 447         bzero(dmp, sizeof (dt_module_t));
 448         (void) strlcpy(dmp->dm_name, name, sizeof (dmp->dm_name));
 449         dt_list_append(&dtp->dt_modlist, dmp);
 450         dmp->dm_next = dtp->dt_mods[h];
 451         dtp->dt_mods[h] = dmp;
 452         dtp->dt_nmods++;
 453
 454         if (dtp->dt_conf.dtc_ctfmodel == CTF_MODEL_LP64)
 455                 dmp->dm_ops = &dt_modops_64;
 456         else
 457                 dmp->dm_ops = &dt_modops_32;
 458
 459         return (dmp);
 460 }
 461
 462 dt_module_t *
 463 dt_module_lookup_by_name(dtrace_hdl_t *dtp, const char *name)
 464 {
 465         uint_t h = dt_strtab_hash(name, NULL) % dtp->dt_modbuckets;
 466         dt_module_t *dmp;
 467
 468         for (dmp = dtp->dt_mods[h]; dmp != NULL; dmp = dmp->dm_next) {
 469                 if (strcmp(dmp->dm_name, name) == 0)
 470                         return (dmp);
 471         }
 472
 473         return (NULL);
 474 }
 475
 476 /*ARGSUSED*/
 477 dt_module_t *
 478 dt_module_lookup_by_ctf(dtrace_hdl_t *dtp, ctf_file_t *ctfp)
 479 {
 480         return (ctfp ? ctf_getspecific(ctfp) : NULL);
 481 }
 482
 483 static int
 484 dt_module_load_sect(dtrace_hdl_t *dtp, dt_module_t *dmp, ctf_sect_t *ctsp)
 485 {
 486         const char *s;
 487         size_t shstrs;
 488         GElf_Shdr sh;
 489         Elf_Data *dp;
 490         Elf_Scn *sp;
 491
 492         if (elf_getshstrndx(dmp->dm_elf, &shstrs) == 0)
 493                 return (dt_set_errno(dtp, EDT_NOTLOADED));
 494
 495         for (sp = NULL; (sp = elf_nextscn(dmp->dm_elf, sp)) != NULL; ) {
 496                 if (gelf_getshdr(sp, &sh) == NULL || sh.sh_type == SHT_NULL ||
 497                     (s = elf_strptr(dmp->dm_elf, shstrs, sh.sh_name)) == NULL)
 498                         continue; /* skip any malformed sections */
 499
 500                 if (sh.sh_type == ctsp->cts_type &&
 501                     sh.sh_entsize == ctsp->cts_entsize &&
 502                     strcmp(s, ctsp->cts_name) == 0)
 503                         break; /* section matches specification */
 504         }
 505
 506         /*
 507          * If the section isn't found, return success but leave cts_data set
 508          * to NULL and cts_size set to zero for our caller.
 509          */
 510         if (sp == NULL || (dp = elf_getdata(sp, NULL)) == NULL)
 511                 return (0);
 512
 513 #if defined(sun)
 514         ctsp->cts_data = dp->d_buf;
 515 #else
 516         if ((ctsp->cts_data = malloc(dp->d_size)) == NULL)
 517                 return (0);
 518         memcpy(ctsp->cts_data, dp->d_buf, dp->d_size);
 519 #endif
 520         ctsp->cts_size = dp->d_size;
 521
 522         dt_dprintf("loaded %s [%s] (%lu bytes)\n",
 523             dmp->dm_name, ctsp->cts_name, (ulong_t)ctsp->cts_size);
 524
 525         return (0);
 526 }
 527
 528 int
 529 dt_module_load(dtrace_hdl_t *dtp, dt_module_t *dmp)
 530 {
 531         if (dmp->dm_flags & DT_DM_LOADED)
 532                 return (0); /* module is already loaded */
 533
 534         dmp->dm_ctdata.cts_name = ".SUNW_ctf";
 535         dmp->dm_ctdata.cts_type = SHT_PROGBITS;
 536         dmp->dm_ctdata.cts_flags = 0;
 537         dmp->dm_ctdata.cts_data = NULL;
 538         dmp->dm_ctdata.cts_size = 0;
 539         dmp->dm_ctdata.cts_entsize = 0;
 540         dmp->dm_ctdata.cts_offset = 0;
 541
 542         dmp->dm_symtab.cts_name = ".symtab";
 543         dmp->dm_symtab.cts_type = SHT_SYMTAB;
 544         dmp->dm_symtab.cts_flags = 0;
 545         dmp->dm_symtab.cts_data = NULL;
 546         dmp->dm_symtab.cts_size = 0;
 547         dmp->dm_symtab.cts_entsize = dmp->dm_ops == &dt_modops_64 ?
 548             sizeof (Elf64_Sym) : sizeof (Elf32_Sym);
 549         dmp->dm_symtab.cts_offset = 0;
 550
 551         dmp->dm_strtab.cts_name = ".strtab";
 552         dmp->dm_strtab.cts_type = SHT_STRTAB;
 553         dmp->dm_strtab.cts_flags = 0;
 554         dmp->dm_strtab.cts_data = NULL;
 555         dmp->dm_strtab.cts_size = 0;
 556         dmp->dm_strtab.cts_entsize = 0;
 557         dmp->dm_strtab.cts_offset = 0;
 558
 559         /*
 560          * Attempt to load the module's CTF section, symbol table section, and
 561          * string table section.  Note that modules may not contain CTF data:
 562          * this will result in a successful load_sect but data of size zero.
 563          * We will then fail if dt_module_getctf() is called, as shown below.
 564          */
 565         if (dt_module_load_sect(dtp, dmp, &dmp->dm_ctdata) == -1 ||
 566             dt_module_load_sect(dtp, dmp, &dmp->dm_symtab) == -1 ||
 567             dt_module_load_sect(dtp, dmp, &dmp->dm_strtab) == -1) {
 568                 dt_module_unload(dtp, dmp);
 569                 return (-1); /* dt_errno is set for us */
 570         }
 571
 572         /*
 573          * Allocate the hash chains and hash buckets for symbol name lookup.
 574          * This is relatively simple since the symbol table is of fixed size
 575          * and is known in advance.  We allocate one extra element since we
 576          * use element indices instead of pointers and zero is our sentinel.
 577          */
 578         dmp->dm_nsymelems =
 579             dmp->dm_symtab.cts_size / dmp->dm_symtab.cts_entsize;
 580
 581         dmp->dm_nsymbuckets = _dtrace_strbuckets;
 582         dmp->dm_symfree = 1;            /* first free element is index 1 */
 583
 584         dmp->dm_symbuckets = malloc(sizeof (uint_t) * dmp->dm_nsymbuckets);
 585         dmp->dm_symchains = malloc(sizeof (dt_sym_t) * dmp->dm_nsymelems + 1);
 586
 587         if (dmp->dm_symbuckets == NULL || dmp->dm_symchains == NULL) {
 588                 dt_module_unload(dtp, dmp);
 589                 return (dt_set_errno(dtp, EDT_NOMEM));
 590         }
 591
 592         bzero(dmp->dm_symbuckets, sizeof (uint_t) * dmp->dm_nsymbuckets);
 593         bzero(dmp->dm_symchains, sizeof (dt_sym_t) * dmp->dm_nsymelems + 1);
 594
 595         /*
 596          * Iterate over the symbol table data buffer and insert each symbol
 597          * name into the name hash if the name and type are valid.  Then
 598          * allocate the address map, fill it in, and sort it.
 599          */
 600         dmp->dm_asrsv = dmp->dm_ops->do_syminit(dmp);
 601
 602         dt_dprintf("hashed %s [%s] (%u symbols)\n",
 603             dmp->dm_name, dmp->dm_symtab.cts_name, dmp->dm_symfree - 1);
 604
 605         if ((dmp->dm_asmap = malloc(sizeof (void *) * dmp->dm_asrsv)) == NULL) {
 606                 dt_module_unload(dtp, dmp);
 607                 return (dt_set_errno(dtp, EDT_NOMEM));
 608         }
 609
 610         dmp->dm_ops->do_symsort(dmp);
 611
 612         dt_dprintf("sorted %s [%s] (%u symbols)\n",
 613             dmp->dm_name, dmp->dm_symtab.cts_name, dmp->dm_aslen);
 614
 615         dmp->dm_flags |= DT_DM_LOADED;
 616         return (0);
 617 }
 618
 619 ctf_file_t *
 620 dt_module_getctf(dtrace_hdl_t *dtp, dt_module_t *dmp)
 621 {
 622         const char *parent;
 623         dt_module_t *pmp;
 624         ctf_file_t *pfp;
 625         int model;
 626
 627         if (dmp->dm_ctfp != NULL || dt_module_load(dtp, dmp) != 0)
 628                 return (dmp->dm_ctfp);
 629
 630         if (dmp->dm_ops == &dt_modops_64)
 631                 model = CTF_MODEL_LP64;
 632         else
 633                 model = CTF_MODEL_ILP32;
 634
 635         /*
 636          * If the data model of the module does not match our program data
 637          * model, then do not permit CTF from this module to be opened and
 638          * returned to the compiler.  If we support mixed data models in the
 639          * future for combined kernel/user tracing, this can be removed.
 640          */
 641         if (dtp->dt_conf.dtc_ctfmodel != model) {
 642                 (void) dt_set_errno(dtp, EDT_DATAMODEL);
 643                 return (NULL);
 644         }
 645
 646         if (dmp->dm_ctdata.cts_size == 0) {
 647                 (void) dt_set_errno(dtp, EDT_NOCTF);
 648                 return (NULL);
 649         }
 650
 651         dmp->dm_ctfp = ctf_bufopen(&dmp->dm_ctdata,
 652             &dmp->dm_symtab, &dmp->dm_strtab, &dtp->dt_ctferr);
 653
 654         if (dmp->dm_ctfp == NULL) {
 655                 (void) dt_set_errno(dtp, EDT_CTF);
 656                 return (NULL);
 657         }
 658
 659         (void) ctf_setmodel(dmp->dm_ctfp, model);
 660         ctf_setspecific(dmp->dm_ctfp, dmp);
 661
 662         if ((parent = ctf_parent_name(dmp->dm_ctfp)) != NULL) {
 663                 if ((pmp = dt_module_create(dtp, parent)) == NULL ||
 664                     (pfp = dt_module_getctf(dtp, pmp)) == NULL) {
 665                         if (pmp == NULL)
 666                                 (void) dt_set_errno(dtp, EDT_NOMEM);
 667                         goto err;
 668                 }
 669
 670                 if (ctf_import(dmp->dm_ctfp, pfp) == CTF_ERR) {
 671                         dtp->dt_ctferr = ctf_errno(dmp->dm_ctfp);
 672                         (void) dt_set_errno(dtp, EDT_CTF);
 673                         goto err;
 674                 }
 675         }
 676
 677         dt_dprintf("loaded CTF container for %s (%p)\n",
 678             dmp->dm_name, (void *)dmp->dm_ctfp);
 679
 680         return (dmp->dm_ctfp);
 681
 682 err:
 683         ctf_close(dmp->dm_ctfp);
 684         dmp->dm_ctfp = NULL;
 685         return (NULL);
 686 }
 687
 688 /*ARGSUSED*/
 689 void
 690 dt_module_unload(dtrace_hdl_t *dtp, dt_module_t *dmp)
 691 {
 692         ctf_close(dmp->dm_ctfp);
 693         dmp->dm_ctfp = NULL;
 694
 695 #if !defined(sun)
 696         if (dmp->dm_ctdata.cts_data != NULL) {
 697                 free(dmp->dm_ctdata.cts_data);
 698         }
 699         if (dmp->dm_symtab.cts_data != NULL) {
 700                 free(dmp->dm_symtab.cts_data);
 701         }
 702         if (dmp->dm_strtab.cts_data != NULL) {
 703                 free(dmp->dm_strtab.cts_data);
 704         }
 705 #endif
 706
 707         bzero(&dmp->dm_ctdata, sizeof (ctf_sect_t));
 708         bzero(&dmp->dm_symtab, sizeof (ctf_sect_t));
 709         bzero(&dmp->dm_strtab, sizeof (ctf_sect_t));
 710
 711         if (dmp->dm_symbuckets != NULL) {
 712                 free(dmp->dm_symbuckets);
 713                 dmp->dm_symbuckets = NULL;
 714         }
 715
 716         if (dmp->dm_symchains != NULL) {
 717                 free(dmp->dm_symchains);
 718                 dmp->dm_symchains = NULL;
 719         }
 720
 721         if (dmp->dm_asmap != NULL) {
 722                 free(dmp->dm_asmap);
 723                 dmp->dm_asmap = NULL;
 724         }
 725
 726         dmp->dm_symfree = 0;
 727         dmp->dm_nsymbuckets = 0;
 728         dmp->dm_nsymelems = 0;
 729         dmp->dm_asrsv = 0;
 730         dmp->dm_aslen = 0;
 731
 732         dmp->dm_text_va = 0;
 733         dmp->dm_text_size = 0;
 734         dmp->dm_data_va = 0;
 735         dmp->dm_data_size = 0;
 736         dmp->dm_bss_va = 0;
 737         dmp->dm_bss_size = 0;
 738
 739         if (dmp->dm_extern != NULL) {
 740                 dt_idhash_destroy(dmp->dm_extern);
 741                 dmp->dm_extern = NULL;
 742         }
 743
 744         (void) elf_end(dmp->dm_elf);
 745         dmp->dm_elf = NULL;
 746
 747         dmp->dm_flags &= ~DT_DM_LOADED;
 748 }
 749
 750 void
 751 dt_module_destroy(dtrace_hdl_t *dtp, dt_module_t *dmp)
 752 {
 753         dt_list_delete(&dtp->dt_modlist, dmp);
 754         assert(dtp->dt_nmods != 0);
 755         dtp->dt_nmods--;
 756
 757         dt_module_unload(dtp, dmp);
 758         free(dmp);
 759 }
 760
 761 /*
 762  * Insert a new external symbol reference into the specified module.  The new
 763  * symbol will be marked as undefined and is assigned a symbol index beyond
 764  * any existing cached symbols from this module.  We use the ident's di_data
 765  * field to store a pointer to a copy of the dtrace_syminfo_t for this symbol.
 766  */
 767 dt_ident_t *
 768 dt_module_extern(dtrace_hdl_t *dtp, dt_module_t *dmp,
 769     const char *name, const dtrace_typeinfo_t *tip)
 770 {
 771         dtrace_syminfo_t *sip;
 772         dt_ident_t *idp;
 773         uint_t id;
 774
 775         if (dmp->dm_extern == NULL && (dmp->dm_extern = dt_idhash_create(
 776             "extern", NULL, dmp->dm_nsymelems, UINT_MAX)) == NULL) {
 777                 (void) dt_set_errno(dtp, EDT_NOMEM);
 778                 return (NULL);
 779         }
 780
 781         if (dt_idhash_nextid(dmp->dm_extern, &id) == -1) {
 782                 (void) dt_set_errno(dtp, EDT_SYMOFLOW);
 783                 return (NULL);
 784         }
 785
 786         if ((sip = malloc(sizeof (dtrace_syminfo_t))) == NULL) {
 787                 (void) dt_set_errno(dtp, EDT_NOMEM);
 788                 return (NULL);
 789         }
 790
 791         idp = dt_idhash_insert(dmp->dm_extern, name, DT_IDENT_SYMBOL, 0, id,
 792             _dtrace_symattr, 0, &dt_idops_thaw, NULL, dtp->dt_gen);
 793
 794         if (idp == NULL) {
 795                 (void) dt_set_errno(dtp, EDT_NOMEM);
 796                 free(sip);
 797                 return (NULL);
 798         }
 799
 800         sip->dts_object = dmp->dm_name;
 801         sip->dts_name = idp->di_name;
 802         sip->dts_id = idp->di_id;
 803
 804         idp->di_data = sip;
 805         idp->di_ctfp = tip->dtt_ctfp;
 806         idp->di_type = tip->dtt_type;
 807
 808         return (idp);
 809 }
 810
 811 const char *
 812 dt_module_modelname(dt_module_t *dmp)
 813 {
 814         if (dmp->dm_ops == &dt_modops_64)
 815                 return ("64-bit");
 816         else
 817                 return ("32-bit");
 818 }
 819
 820 /*
 821  * Update our module cache by adding an entry for the specified module 'name'.
 822  * We create the dt_module_t and populate it using /system/object/<name>/.
 823  *
 824  * On FreeBSD, the module name is passed as the full module file name,
 825  * including the path.
 826  */
 827 static void
 828 #if defined(sun)
 829 dt_module_update(dtrace_hdl_t *dtp, const char *name)
 830 #else
 831 dt_module_update(dtrace_hdl_t *dtp, struct kld_file_stat *k_stat)
 832 #endif
 833 {
 834         char fname[MAXPATHLEN];
 835         struct stat64 st;
 836         int fd, err, bits;
 837
 838         dt_module_t *dmp;
 839         const char *s;
 840         size_t shstrs;
 841         GElf_Shdr sh;
 842         Elf_Data *dp;
 843         Elf_Scn *sp;
 844
 845 #if defined(sun)
 846         (void) snprintf(fname, sizeof (fname),
 847             "%s/%s/object", OBJFS_ROOT, name);
 848 #else
 849         GElf_Phdr ph;
 850         char name[MAXPATHLEN];
 851         int i = 0;
 852
 853         (void) strlcpy(name, k_stat->name, sizeof(name));
 854         (void) strlcpy(fname, k_stat->pathname, sizeof(fname));
 855 #endif
 856
 857         if ((fd = open(fname, O_RDONLY)) == -1 || fstat64(fd, &st) == -1 ||
 858             (dmp = dt_module_create(dtp, name)) == NULL) {
 859                 dt_dprintf("failed to open %s: %s\n", fname, strerror(errno));
 860                 (void) close(fd);
 861                 return;
 862         }
 863
 864         /*
 865          * Since the module can unload out from under us (and /system/object
 866          * will return ENOENT), tell libelf to cook the entire file now and
 867          * then close the underlying file descriptor immediately.  If this
 868          * succeeds, we know that we can continue safely using dmp->dm_elf.
 869          */
 870         dmp->dm_elf = elf_begin(fd, ELF_C_READ, NULL);
 871         err = elf_cntl(dmp->dm_elf, ELF_C_FDREAD);
 872         (void) close(fd);
 873
 874         if (dmp->dm_elf == NULL || err == -1 ||
 875             elf_getshstrndx(dmp->dm_elf, &shstrs) == 0) {
 876                 dt_dprintf("failed to load %s: %s\n",
 877                     fname, elf_errmsg(elf_errno()));
 878                 dt_module_destroy(dtp, dmp);
 879                 return;
 880         }
 881
 882         switch (gelf_getclass(dmp->dm_elf)) {
 883         case ELFCLASS32:
 884                 dmp->dm_ops = &dt_modops_32;
 885                 bits = 32;
 886                 break;
 887         case ELFCLASS64:
 888                 dmp->dm_ops = &dt_modops_64;
 889                 bits = 64;
 890                 break;
 891         default:
 892                 dt_dprintf("failed to load %s: unknown ELF class\n", fname);
 893                 dt_module_destroy(dtp, dmp);
 894                 return;
 895         }
 896
 897         /*
 898          * Iterate over the section headers locating various sections of
 899          * interest and use their attributes to flesh out the dt_module_t.
 900          */
 901         for (sp = NULL; (sp = elf_nextscn(dmp->dm_elf, sp)) != NULL; ) {
 902                 if (gelf_getshdr(sp, &sh) == NULL || sh.sh_type == SHT_NULL ||
 903                     (s = elf_strptr(dmp->dm_elf, shstrs, sh.sh_name)) == NULL)
 904                         continue; /* skip any malformed sections */
 905
 906                 if (strcmp(s, ".text") == 0) {
 907                         dmp->dm_text_size = sh.sh_size;
 908                         dmp->dm_text_va = sh.sh_addr;
 909                 } else if (strcmp(s, ".data") == 0) {
 910                         dmp->dm_data_size = sh.sh_size;
 911                         dmp->dm_data_va = sh.sh_addr;
 912                 } else if (strcmp(s, ".bss") == 0) {
 913                         dmp->dm_bss_size = sh.sh_size;
 914                         dmp->dm_bss_va = sh.sh_addr;
 915                 } else if (strcmp(s, ".info") == 0 &&
 916                     (dp = elf_getdata(sp, NULL)) != NULL) {
 917                         bcopy(dp->d_buf, &dmp->dm_info,
 918                             MIN(sh.sh_size, sizeof (dmp->dm_info)));
 919                 } else if (strcmp(s, ".filename") == 0 &&
 920                     (dp = elf_getdata(sp, NULL)) != NULL) {
 921                         (void) strlcpy(dmp->dm_file,
 922                             dp->d_buf, sizeof (dmp->dm_file));
 923                 }
 924         }
 925
 926         dmp->dm_flags |= DT_DM_KERNEL;
 927 #if defined(sun)
 928         dmp->dm_modid = (int)OBJFS_MODID(st.st_ino);
 929 #else
 930 #if defined(__i386__)
 931         /*
 932          * Find the first load section and figure out the relocation
 933          * offset for the symbols. The kernel module will not need
 934          * relocation, but the kernel linker modules will.
 935          */
 936         for (i = 0; gelf_getphdr(dmp->dm_elf, i, &ph) != NULL; i++) {
 937                 if (ph.p_type == PT_LOAD) {
 938                         dmp->dm_reloc_offset = k_stat->address - ph.p_vaddr;
 939                         break;
 940                 }
 941         }
 942 #endif
 943 #endif
 944
 945         if (dmp->dm_info.objfs_info_primary)
 946                 dmp->dm_flags |= DT_DM_PRIMARY;
 947
 948         dt_dprintf("opened %d-bit module %s (%s) [%d]\n",
 949             bits, dmp->dm_name, dmp->dm_file, dmp->dm_modid);
 950 }
 951
 952 /*
 953  * Unload all the loaded modules and then refresh the module cache with the
 954  * latest list of loaded modules and their address ranges.
 955  */
 956 void
 957 dtrace_update(dtrace_hdl_t *dtp)
 958 {
 959         dt_module_t *dmp;
 960         DIR *dirp;
 961 #if defined(__FreeBSD__)
 962         int fileid;
 963 #endif
 964
 965         for (dmp = dt_list_next(&dtp->dt_modlist);
 966             dmp != NULL; dmp = dt_list_next(dmp))
 967                 dt_module_unload(dtp, dmp);
 968
 969 #if defined(sun)
 970         /*
 971          * Open /system/object and attempt to create a libdtrace module for
 972          * each kernel module that is loaded on the current system.
 973          */
 974         if (!(dtp->dt_oflags & DTRACE_O_NOSYS) &&
 975             (dirp = opendir(OBJFS_ROOT)) != NULL) {
 976                 struct dirent *dp;
 977
 978                 while ((dp = readdir(dirp)) != NULL) {
 979                         if (dp->d_name[0] != '.')
 980                                 dt_module_update(dtp, dp->d_name);
 981                 }
 982
 983                 (void) closedir(dirp);
 984         }
 985 #elif defined(__FreeBSD__)
 986         /*
 987          * Use FreeBSD's kernel loader interface to discover what kernel
 988          * modules are loaded and create a libdtrace module for each one.
 989          */
 990         for (fileid = kldnext(0); fileid > 0; fileid = kldnext(fileid)) {
 991                 struct kld_file_stat k_stat;
 992                 k_stat.version = sizeof(k_stat);
 993                 if (kldstat(fileid, &k_stat) == 0)
 994                         dt_module_update(dtp, &k_stat);
 995         }
 996 #endif
 997
 998         /*
 999          * Look up all the macro identifiers and set di_id to the latest value.
1000          * This code collaborates with dt_lex.l on the use of di_id.  We will
1001          * need to implement something fancier if we need to support non-ints.
1002          */
1003         dt_idhash_lookup(dtp->dt_macros, "egid")->di_id = getegid();
1004         dt_idhash_lookup(dtp->dt_macros, "euid")->di_id = geteuid();
1005         dt_idhash_lookup(dtp->dt_macros, "gid")->di_id = getgid();
1006         dt_idhash_lookup(dtp->dt_macros, "pid")->di_id = getpid();
1007         dt_idhash_lookup(dtp->dt_macros, "pgid")->di_id = getpgid(0);
1008         dt_idhash_lookup(dtp->dt_macros, "ppid")->di_id = getppid();
1009 #if defined(sun)
1010         dt_idhash_lookup(dtp->dt_macros, "projid")->di_id = getprojid();
1011 #endif
1012         dt_idhash_lookup(dtp->dt_macros, "sid")->di_id = getsid(0);
1013 #if defined(sun)
1014         dt_idhash_lookup(dtp->dt_macros, "taskid")->di_id = gettaskid();
1015 #endif
1016         dt_idhash_lookup(dtp->dt_macros, "uid")->di_id = getuid();
1017
1018         /*
1019          * Cache the pointers to the modules representing the base executable
1020          * and the run-time linker in the dtrace client handle. Note that on
1021          * x86 krtld is folded into unix, so if we don't find it, use unix
1022          * instead.
1023          */
1024         dtp->dt_exec = dt_module_lookup_by_name(dtp, "genunix");
1025         dtp->dt_rtld = dt_module_lookup_by_name(dtp, "krtld");
1026         if (dtp->dt_rtld == NULL)
1027                 dtp->dt_rtld = dt_module_lookup_by_name(dtp, "unix");
1028
1029         /*
1030          * If this is the first time we are initializing the module list,
1031          * remove the module for genunix from the module list and then move it
1032          * to the front of the module list.  We do this so that type and symbol
1033          * queries encounter genunix and thereby optimize for the common case
1034          * in dtrace_lookup_by_name() and dtrace_lookup_by_type(), below.
1035          */
1036         if (dtp->dt_exec != NULL &&
1037             dtp->dt_cdefs == NULL && dtp->dt_ddefs == NULL) {
1038                 dt_list_delete(&dtp->dt_modlist, dtp->dt_exec);
1039                 dt_list_prepend(&dtp->dt_modlist, dtp->dt_exec);
1040         }
1041 }
1042
1043 static dt_module_t *
1044 dt_module_from_object(dtrace_hdl_t *dtp, const char *object)
1045 {
1046         int err = EDT_NOMOD;
1047         dt_module_t *dmp;
1048
1049         switch ((uintptr_t)object) {
1050         case (uintptr_t)DTRACE_OBJ_EXEC:
1051                 dmp = dtp->dt_exec;
1052                 break;
1053         case (uintptr_t)DTRACE_OBJ_RTLD:
1054                 dmp = dtp->dt_rtld;
1055                 break;
1056         case (uintptr_t)DTRACE_OBJ_CDEFS:
1057                 dmp = dtp->dt_cdefs;
1058                 break;
1059         case (uintptr_t)DTRACE_OBJ_DDEFS:
1060                 dmp = dtp->dt_ddefs;
1061                 break;
1062         default:
1063                 dmp = dt_module_create(dtp, object);
1064                 err = EDT_NOMEM;
1065         }
1066
1067         if (dmp == NULL)
1068                 (void) dt_set_errno(dtp, err);
1069
1070         return (dmp);
1071 }
1072
1073 /*
1074  * Exported interface to look up a symbol by name.  We return the GElf_Sym and
1075  * complete symbol information for the matching symbol.
1076  */
1077 int
1078 dtrace_lookup_by_name(dtrace_hdl_t *dtp, const char *object, const char *name,
1079     GElf_Sym *symp, dtrace_syminfo_t *sip)
1080 {
1081         dt_module_t *dmp;
1082         dt_ident_t *idp;
1083         uint_t n, id;
1084         GElf_Sym sym;
1085
1086         uint_t mask = 0; /* mask of dt_module flags to match */
1087         uint_t bits = 0; /* flag bits that must be present */
1088
1089         if (object != DTRACE_OBJ_EVERY &&
1090             object != DTRACE_OBJ_KMODS &&
1091             object != DTRACE_OBJ_UMODS) {
1092                 if ((dmp = dt_module_from_object(dtp, object)) == NULL)
1093                         return (-1); /* dt_errno is set for us */
1094
1095                 if (dt_module_load(dtp, dmp) == -1)
1096                         return (-1); /* dt_errno is set for us */
1097                 n = 1;
1098
1099         } else {
1100                 if (object == DTRACE_OBJ_KMODS)
1101                         mask = bits = DT_DM_KERNEL;
1102                 else if (object == DTRACE_OBJ_UMODS)
1103                         mask = DT_DM_KERNEL;
1104
1105                 dmp = dt_list_next(&dtp->dt_modlist);
1106                 n = dtp->dt_nmods;
1107         }
1108
1109         if (symp == NULL)
1110                 symp = &sym;
1111
1112         for (; n > 0; n--, dmp = dt_list_next(dmp)) {
1113                 if ((dmp->dm_flags & mask) != bits)
1114                         continue; /* failed to match required attributes */
1115
1116                 if (dt_module_load(dtp, dmp) == -1)
1117                         continue; /* failed to load symbol table */
1118
1119                 if (dmp->dm_ops->do_symname(dmp, name, symp, &id) != NULL) {
1120                         if (sip != NULL) {
1121                                 sip->dts_object = dmp->dm_name;
1122                                 sip->dts_name = (const char *)
1123                                     dmp->dm_strtab.cts_data + symp->st_name;
1124                                 sip->dts_id = id;
1125                         }
1126                         return (0);
1127                 }
1128
1129                 if (dmp->dm_extern != NULL &&
1130                     (idp = dt_idhash_lookup(dmp->dm_extern, name)) != NULL) {
1131                         if (symp != &sym) {
1132                                 symp->st_name = (uintptr_t)idp->di_name;
1133                                 symp->st_info =
1134                                     GELF_ST_INFO(STB_GLOBAL, STT_NOTYPE);
1135                                 symp->st_other = 0;
1136                                 symp->st_shndx = SHN_UNDEF;
1137                                 symp->st_value = 0;
1138                                 symp->st_size =
1139                                     ctf_type_size(idp->di_ctfp, idp->di_type);
1140                         }
1141
1142                         if (sip != NULL) {
1143                                 sip->dts_object = dmp->dm_name;
1144                                 sip->dts_name = idp->di_name;
1145                                 sip->dts_id = idp->di_id;
1146                         }
1147
1148                         return (0);
1149                 }
1150         }
1151
1152         return (dt_set_errno(dtp, EDT_NOSYM));
1153 }
1154
1155 /*
1156  * Exported interface to look up a symbol by address.  We return the GElf_Sym
1157  * and complete symbol information for the matching symbol.
1158  */
1159 int
1160 dtrace_lookup_by_addr(dtrace_hdl_t *dtp, GElf_Addr addr,
1161     GElf_Sym *symp, dtrace_syminfo_t *sip)
1162 {
1163         dt_module_t *dmp;
1164         uint_t id;
1165         const dtrace_vector_t *v = dtp->dt_vector;
1166
1167         if (v != NULL)
1168                 return (v->dtv_lookup_by_addr(dtp->dt_varg, addr, symp, sip));
1169
1170         for (dmp = dt_list_next(&dtp->dt_modlist); dmp != NULL;
1171             dmp = dt_list_next(dmp)) {
1172                 if (addr - dmp->dm_text_va < dmp->dm_text_size ||
1173                     addr - dmp->dm_data_va < dmp->dm_data_size ||
1174                     addr - dmp->dm_bss_va < dmp->dm_bss_size)
1175                         break;
1176         }
1177
1178         if (dmp == NULL)
1179                 return (dt_set_errno(dtp, EDT_NOSYMADDR));
1180
1181         if (dt_module_load(dtp, dmp) == -1)
1182                 return (-1); /* dt_errno is set for us */
1183
1184         if (symp != NULL) {
1185                 if (dmp->dm_ops->do_symaddr(dmp, addr, symp, &id) == NULL)
1186                         return (dt_set_errno(dtp, EDT_NOSYMADDR));
1187         }
1188
1189         if (sip != NULL) {
1190                 sip->dts_object = dmp->dm_name;
1191
1192                 if (symp != NULL) {
1193                         sip->dts_name = (const char *)
1194                             dmp->dm_strtab.cts_data + symp->st_name;
1195                         sip->dts_id = id;
1196                 } else {
1197                         sip->dts_name = NULL;
1198                         sip->dts_id = 0;
1199                 }
1200         }
1201
1202         return (0);
1203 }
1204
1205 int
1206 dtrace_lookup_by_type(dtrace_hdl_t *dtp, const char *object, const char *name,
1207     dtrace_typeinfo_t *tip)
1208 {
1209         dtrace_typeinfo_t ti;
1210         dt_module_t *dmp;
1211         int found = 0;
1212         ctf_id_t id;
1213         uint_t n;
1214         int justone;
1215
1216         uint_t mask = 0; /* mask of dt_module flags to match */
1217         uint_t bits = 0; /* flag bits that must be present */
1218
1219         if (object != DTRACE_OBJ_EVERY &&
1220             object != DTRACE_OBJ_KMODS &&
1221             object != DTRACE_OBJ_UMODS) {
1222                 if ((dmp = dt_module_from_object(dtp, object)) == NULL)
1223                         return (-1); /* dt_errno is set for us */
1224
1225                 if (dt_module_load(dtp, dmp) == -1)
1226                         return (-1); /* dt_errno is set for us */
1227                 n = 1;
1228                 justone = 1;
1229
1230         } else {
1231                 if (object == DTRACE_OBJ_KMODS)
1232                         mask = bits = DT_DM_KERNEL;
1233                 else if (object == DTRACE_OBJ_UMODS)
1234                         mask = DT_DM_KERNEL;
1235
1236                 dmp = dt_list_next(&dtp->dt_modlist);
1237                 n = dtp->dt_nmods;
1238                 justone = 0;
1239         }
1240
1241         if (tip == NULL)
1242                 tip = &ti;
1243
1244         for (; n > 0; n--, dmp = dt_list_next(dmp)) {
1245                 if ((dmp->dm_flags & mask) != bits)
1246                         continue; /* failed to match required attributes */
1247
1248                 /*
1249                  * If we can't load the CTF container, continue on to the next
1250                  * module.  If our search was scoped to only one module then
1251                  * return immediately leaving dt_errno unmodified.
1252                  */
1253                 if (dt_module_getctf(dtp, dmp) == NULL) {
1254                         if (justone)
1255                                 return (-1);
1256                         continue;
1257                 }
1258
1259                 /*
1260                  * Look up the type in the module's CTF container.  If our
1261                  * match is a forward declaration tag, save this choice in
1262                  * 'tip' and keep going in the hope that we will locate the
1263                  * underlying structure definition.  Otherwise just return.
1264                  */
1265                 if ((id = ctf_lookup_by_name(dmp->dm_ctfp, name)) != CTF_ERR) {
1266                         tip->dtt_object = dmp->dm_name;
1267                         tip->dtt_ctfp = dmp->dm_ctfp;
1268                         tip->dtt_type = id;
1269
1270                         if (ctf_type_kind(dmp->dm_ctfp, ctf_type_resolve(
1271                             dmp->dm_ctfp, id)) != CTF_K_FORWARD)
1272                                 return (0);
1273
1274                         found++;
1275                 }
1276         }
1277
1278         if (found == 0)
1279                 return (dt_set_errno(dtp, EDT_NOTYPE));
1280
1281         return (0);
1282 }
1283
1284 int
1285 dtrace_symbol_type(dtrace_hdl_t *dtp, const GElf_Sym *symp,
1286     const dtrace_syminfo_t *sip, dtrace_typeinfo_t *tip)
1287 {
1288         dt_module_t *dmp;
1289
1290         tip->dtt_object = NULL;
1291         tip->dtt_ctfp = NULL;
1292         tip->dtt_type = CTF_ERR;
1293
1294         if ((dmp = dt_module_lookup_by_name(dtp, sip->dts_object)) == NULL)
1295                 return (dt_set_errno(dtp, EDT_NOMOD));
1296
1297         if (symp->st_shndx == SHN_UNDEF && dmp->dm_extern != NULL) {
1298                 dt_ident_t *idp =
1299                     dt_idhash_lookup(dmp->dm_extern, sip->dts_name);
1300
1301                 if (idp == NULL)
1302                         return (dt_set_errno(dtp, EDT_NOSYM));
1303
1304                 tip->dtt_ctfp = idp->di_ctfp;
1305                 tip->dtt_type = idp->di_type;
1306
1307         } else if (GELF_ST_TYPE(symp->st_info) != STT_FUNC) {
1308                 if (dt_module_getctf(dtp, dmp) == NULL)
1309                         return (-1); /* errno is set for us */
1310
1311                 tip->dtt_ctfp = dmp->dm_ctfp;
1312                 tip->dtt_type = ctf_lookup_by_symbol(dmp->dm_ctfp, sip->dts_id);
1313
1314                 if (tip->dtt_type == CTF_ERR) {
1315                         dtp->dt_ctferr = ctf_errno(tip->dtt_ctfp);
1316                         return (dt_set_errno(dtp, EDT_CTF));
1317                 }
1318
1319         } else {
1320                 tip->dtt_ctfp = DT_FPTR_CTFP(dtp);
1321                 tip->dtt_type = DT_FPTR_TYPE(dtp);
1322         }
1323
1324         tip->dtt_object = dmp->dm_name;
1325         return (0);
1326 }
1327
1328 static dtrace_objinfo_t *
1329 dt_module_info(const dt_module_t *dmp, dtrace_objinfo_t *dto)
1330 {
1331         dto->dto_name = dmp->dm_name;
1332         dto->dto_file = dmp->dm_file;
1333         dto->dto_id = dmp->dm_modid;
1334         dto->dto_flags = 0;
1335
1336         if (dmp->dm_flags & DT_DM_KERNEL)
1337                 dto->dto_flags |= DTRACE_OBJ_F_KERNEL;
1338         if (dmp->dm_flags & DT_DM_PRIMARY)
1339                 dto->dto_flags |= DTRACE_OBJ_F_PRIMARY;
1340
1341         dto->dto_text_va = dmp->dm_text_va;
1342         dto->dto_text_size = dmp->dm_text_size;
1343         dto->dto_data_va = dmp->dm_data_va;
1344         dto->dto_data_size = dmp->dm_data_size;
1345         dto->dto_bss_va = dmp->dm_bss_va;
1346         dto->dto_bss_size = dmp->dm_bss_size;
1347
1348         return (dto);
1349 }
1350
1351 int
1352 dtrace_object_iter(dtrace_hdl_t *dtp, dtrace_obj_f *func, void *data)
1353 {
1354         const dt_module_t *dmp = dt_list_next(&dtp->dt_modlist);
1355         dtrace_objinfo_t dto;
1356         int rv;
1357
1358         for (; dmp != NULL; dmp = dt_list_next(dmp)) {
1359                 if ((rv = (*func)(dtp, dt_module_info(dmp, &dto), data)) != 0)
1360                         return (rv);
1361         }
1362
1363         return (0);
1364 }
1365
1366 int
1367 dtrace_object_info(dtrace_hdl_t *dtp, const char *object, dtrace_objinfo_t *dto)
1368 {
1369         dt_module_t *dmp;
1370
1371         if (object == DTRACE_OBJ_EVERY || object == DTRACE_OBJ_KMODS ||
1372             object == DTRACE_OBJ_UMODS || dto == NULL)
1373                 return (dt_set_errno(dtp, EINVAL));
1374
1375         if ((dmp = dt_module_from_object(dtp, object)) == NULL)
1376                 return (-1); /* dt_errno is set for us */
1377
1378         if (dt_module_load(dtp, dmp) == -1)
1379                 return (-1); /* dt_errno is set for us */
1380
1381         (void) dt_module_info(dmp, dto);
1382         return (0);
1383 }