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