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