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, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 23 /* 24 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 25 * Use is subject to license terms. 26 */ 27 28 #pragma ident "%Z%%M% %I% %E% SMI" 29 30 #include <ctf_impl.h> 31 #include <sys/mman.h> 32 #include <sys/zmod.h> 33 34 static const ctf_dmodel_t _libctf_models[] = { 35 { "ILP32", CTF_MODEL_ILP32, 4, 1, 2, 4, 4 }, 36 { "LP64", CTF_MODEL_LP64, 8, 1, 2, 4, 8 }, 37 { NULL, 0, 0, 0, 0, 0, 0 } 38 }; 39 40 const char _CTF_SECTION[] = ".SUNW_ctf"; 41 const char _CTF_NULLSTR[] = ""; 42 43 int _libctf_version = CTF_VERSION; /* library client version */ 44 int _libctf_debug = 0; /* debugging messages enabled */ 45 46 static ushort_t 47 get_kind_v1(ushort_t info) 48 { 49 return (CTF_INFO_KIND_V1(info)); 50 } 51 52 static ushort_t 53 get_kind_v2(ushort_t info) 54 { 55 return (CTF_INFO_KIND(info)); 56 } 57 58 static ushort_t 59 get_root_v1(ushort_t info) 60 { 61 return (CTF_INFO_ISROOT_V1(info)); 62 } 63 64 static ushort_t 65 get_root_v2(ushort_t info) 66 { 67 return (CTF_INFO_ISROOT(info)); 68 } 69 70 static ushort_t 71 get_vlen_v1(ushort_t info) 72 { 73 return (CTF_INFO_VLEN_V1(info)); 74 } 75 76 static ushort_t 77 get_vlen_v2(ushort_t info) 78 { 79 return (CTF_INFO_VLEN(info)); 80 } 81 82 static const ctf_fileops_t ctf_fileops[] = { 83 { NULL, NULL }, 84 { get_kind_v1, get_root_v1, get_vlen_v1 }, 85 { get_kind_v2, get_root_v2, get_vlen_v2 }, 86 }; 87 88 /* 89 * Convert a 32-bit ELF symbol into GElf (Elf64) and return a pointer to it. 90 */ 91 static Elf64_Sym * 92 sym_to_gelf(const Elf32_Sym *src, Elf64_Sym *dst) 93 { 94 dst->st_name = src->st_name; 95 dst->st_value = src->st_value; 96 dst->st_size = src->st_size; 97 dst->st_info = src->st_info; 98 dst->st_other = src->st_other; 99 dst->st_shndx = src->st_shndx; 100 101 return (dst); 102 } 103 104 /* 105 * Initialize the symtab translation table by filling each entry with the 106 * offset of the CTF type or function data corresponding to each STT_FUNC or 107 * STT_OBJECT entry in the symbol table. 108 */ 109 static int 110 init_symtab(ctf_file_t *fp, const ctf_header_t *hp, 111 const ctf_sect_t *sp, const ctf_sect_t *strp) 112 { 113 const uchar_t *symp = sp->cts_data; 114 uint_t *xp = fp->ctf_sxlate; 115 uint_t *xend = xp + fp->ctf_nsyms; 116 117 uint_t objtoff = hp->cth_objtoff; 118 uint_t funcoff = hp->cth_funcoff; 119 120 ushort_t info, vlen; 121 Elf64_Sym sym, *gsp; 122 const char *name; 123 124 /* 125 * The CTF data object and function type sections are ordered to match 126 * the relative order of the respective symbol types in the symtab. 127 * If no type information is available for a symbol table entry, a 128 * pad is inserted in the CTF section. As a further optimization, 129 * anonymous or undefined symbols are omitted from the CTF data. 130 */ 131 for (; xp < xend; xp++, symp += sp->cts_entsize) { 132 if (sp->cts_entsize == sizeof (Elf32_Sym)) 133 gsp = sym_to_gelf((Elf32_Sym *)(uintptr_t)symp, &sym); 134 else 135 gsp = (Elf64_Sym *)(uintptr_t)symp; 136 137 if (gsp->st_name < strp->cts_size) 138 name = (const char *)strp->cts_data + gsp->st_name; 139 else 140 name = _CTF_NULLSTR; 141 142 if (gsp->st_name == 0 || gsp->st_shndx == SHN_UNDEF || 143 strcmp(name, "_START_") == 0 || 144 strcmp(name, "_END_") == 0) { 145 *xp = -1u; 146 continue; 147 } 148 149 switch (ELF64_ST_TYPE(gsp->st_info)) { 150 case STT_OBJECT: 151 if (objtoff >= hp->cth_funcoff || 152 (gsp->st_shndx == SHN_ABS && gsp->st_value == 0)) { 153 *xp = -1u; 154 break; 155 } 156 157 *xp = objtoff; 158 objtoff += sizeof (ushort_t); 159 break; 160 161 case STT_FUNC: 162 if (funcoff >= hp->cth_typeoff) { 163 *xp = -1u; 164 break; 165 } 166 167 *xp = funcoff; 168 169 info = *(ushort_t *)((uintptr_t)fp->ctf_buf + funcoff); 170 vlen = LCTF_INFO_VLEN(fp, info); 171 172 /* 173 * If we encounter a zero pad at the end, just skip it. 174 * Otherwise skip over the function and its return type 175 * (+2) and the argument list (vlen). 176 */ 177 if (LCTF_INFO_KIND(fp, info) == CTF_K_UNKNOWN && 178 vlen == 0) 179 funcoff += sizeof (ushort_t); /* skip pad */ 180 else 181 funcoff += sizeof (ushort_t) * (vlen + 2); 182 break; 183 184 default: 185 *xp = -1u; 186 break; 187 } 188 } 189 190 ctf_dprintf("loaded %lu symtab entries\n", fp->ctf_nsyms); 191 return (0); 192 } 193 194 /* 195 * Initialize the type ID translation table with the byte offset of each type, 196 * and initialize the hash tables of each named type. 197 */ 198 static int 199 init_types(ctf_file_t *fp, const ctf_header_t *cth) 200 { 201 /* LINTED - pointer alignment */ 202 const ctf_type_t *tbuf = (ctf_type_t *)(fp->ctf_buf + cth->cth_typeoff); 203 /* LINTED - pointer alignment */ 204 const ctf_type_t *tend = (ctf_type_t *)(fp->ctf_buf + cth->cth_stroff); 205 206 ulong_t pop[CTF_K_MAX + 1] = { 0 }; 207 const ctf_type_t *tp; 208 ctf_hash_t *hp; 209 ushort_t id, dst; 210 uint_t *xp; 211 212 /* 213 * We initially determine whether the container is a child or a parent 214 * based on the value of cth_parname. To support containers that pre- 215 * date cth_parname, we also scan the types themselves for references 216 * to values in the range reserved for child types in our first pass. 217 */ 218 int child = cth->cth_parname != 0; 219 int nlstructs = 0, nlunions = 0; 220 int err; 221 222 /* 223 * We make two passes through the entire type section. In this first 224 * pass, we count the number of each type and the total number of types. 225 */ 226 for (tp = tbuf; tp < tend; fp->ctf_typemax++) { 227 ushort_t kind = LCTF_INFO_KIND(fp, tp->ctt_info); 228 ulong_t vlen = LCTF_INFO_VLEN(fp, tp->ctt_info); 229 ssize_t size, increment; 230 231 size_t vbytes; 232 uint_t n; 233 234 (void) ctf_get_ctt_size(fp, tp, &size, &increment); 235 236 switch (kind) { 237 case CTF_K_INTEGER: 238 case CTF_K_FLOAT: 239 vbytes = sizeof (uint_t); 240 break; 241 case CTF_K_ARRAY: 242 vbytes = sizeof (ctf_array_t); 243 break; 244 case CTF_K_FUNCTION: 245 vbytes = sizeof (ushort_t) * (vlen + (vlen & 1)); 246 break; 247 case CTF_K_STRUCT: 248 case CTF_K_UNION: 249 if (fp->ctf_version == CTF_VERSION_1 || 250 size < CTF_LSTRUCT_THRESH) { 251 ctf_member_t *mp = (ctf_member_t *) 252 ((uintptr_t)tp + increment); 253 254 vbytes = sizeof (ctf_member_t) * vlen; 255 for (n = vlen; n != 0; n--, mp++) 256 child |= CTF_TYPE_ISCHILD(mp->ctm_type); 257 } else { 258 ctf_lmember_t *lmp = (ctf_lmember_t *) 259 ((uintptr_t)tp + increment); 260 261 vbytes = sizeof (ctf_lmember_t) * vlen; 262 for (n = vlen; n != 0; n--, lmp++) 263 child |= 264 CTF_TYPE_ISCHILD(lmp->ctlm_type); 265 } 266 break; 267 case CTF_K_ENUM: 268 vbytes = sizeof (ctf_enum_t) * vlen; 269 break; 270 case CTF_K_FORWARD: 271 /* 272 * For forward declarations, ctt_type is the CTF_K_* 273 * kind for the tag, so bump that population count too. 274 * If ctt_type is unknown, treat the tag as a struct. 275 */ 276 if (tp->ctt_type == CTF_K_UNKNOWN || 277 tp->ctt_type >= CTF_K_MAX) 278 pop[CTF_K_STRUCT]++; 279 else 280 pop[tp->ctt_type]++; 281 /*FALLTHRU*/ 282 case CTF_K_UNKNOWN: 283 vbytes = 0; 284 break; 285 case CTF_K_POINTER: 286 case CTF_K_TYPEDEF: 287 case CTF_K_VOLATILE: 288 case CTF_K_CONST: 289 case CTF_K_RESTRICT: 290 child |= CTF_TYPE_ISCHILD(tp->ctt_type); 291 vbytes = 0; 292 break; 293 default: 294 ctf_dprintf("detected invalid CTF kind -- %u\n", kind); 295 return (ECTF_CORRUPT); 296 } 297 tp = (ctf_type_t *)((uintptr_t)tp + increment + vbytes); 298 pop[kind]++; 299 } 300 301 /* 302 * If we detected a reference to a child type ID, then we know this 303 * container is a child and may have a parent's types imported later. 304 */ 305 if (child) { 306 ctf_dprintf("CTF container %p is a child\n", (void *)fp); 307 fp->ctf_flags |= LCTF_CHILD; 308 } else 309 ctf_dprintf("CTF container %p is a parent\n", (void *)fp); 310 311 /* 312 * Now that we've counted up the number of each type, we can allocate 313 * the hash tables, type translation table, and pointer table. 314 */ 315 if ((err = ctf_hash_create(&fp->ctf_structs, pop[CTF_K_STRUCT])) != 0) 316 return (err); 317 318 if ((err = ctf_hash_create(&fp->ctf_unions, pop[CTF_K_UNION])) != 0) 319 return (err); 320 321 if ((err = ctf_hash_create(&fp->ctf_enums, pop[CTF_K_ENUM])) != 0) 322 return (err); 323 324 if ((err = ctf_hash_create(&fp->ctf_names, 325 pop[CTF_K_INTEGER] + pop[CTF_K_FLOAT] + pop[CTF_K_FUNCTION] + 326 pop[CTF_K_TYPEDEF] + pop[CTF_K_POINTER] + pop[CTF_K_VOLATILE] + 327 pop[CTF_K_CONST] + pop[CTF_K_RESTRICT])) != 0) 328 return (err); 329 330 fp->ctf_txlate = ctf_alloc(sizeof (uint_t) * (fp->ctf_typemax + 1)); 331 fp->ctf_ptrtab = ctf_alloc(sizeof (ushort_t) * (fp->ctf_typemax + 1)); 332 333 if (fp->ctf_txlate == NULL || fp->ctf_ptrtab == NULL) 334 return (EAGAIN); /* memory allocation failed */ 335 336 xp = fp->ctf_txlate; 337 *xp++ = 0; /* type id 0 is used as a sentinel value */ 338 339 bzero(fp->ctf_txlate, sizeof (uint_t) * (fp->ctf_typemax + 1)); 340 bzero(fp->ctf_ptrtab, sizeof (ushort_t) * (fp->ctf_typemax + 1)); 341 342 /* 343 * In the second pass through the types, we fill in each entry of the 344 * type and pointer tables and add names to the appropriate hashes. 345 */ 346 for (id = 1, tp = tbuf; tp < tend; xp++, id++) { 347 ushort_t kind = LCTF_INFO_KIND(fp, tp->ctt_info); 348 ulong_t vlen = LCTF_INFO_VLEN(fp, tp->ctt_info); 349 ssize_t size, increment; 350 351 const char *name; 352 size_t vbytes; 353 ctf_helem_t *hep; 354 ctf_encoding_t cte; 355 356 (void) ctf_get_ctt_size(fp, tp, &size, &increment); 357 name = ctf_strptr(fp, tp->ctt_name); 358 359 switch (kind) { 360 case CTF_K_INTEGER: 361 case CTF_K_FLOAT: 362 /* 363 * Only insert a new integer base type definition if 364 * this type name has not been defined yet. We re-use 365 * the names with different encodings for bit-fields. 366 */ 367 if ((hep = ctf_hash_lookup(&fp->ctf_names, fp, 368 name, strlen(name))) == NULL) { 369 err = ctf_hash_insert(&fp->ctf_names, fp, 370 CTF_INDEX_TO_TYPE(id, child), tp->ctt_name); 371 if (err != 0 && err != ECTF_STRTAB) 372 return (err); 373 } else if (ctf_type_encoding(fp, hep->h_type, 374 &cte) == 0 && cte.cte_bits == 0) { 375 /* 376 * Work-around SOS8 stabs bug: replace existing 377 * intrinsic w/ same name if it was zero bits. 378 */ 379 hep->h_type = CTF_INDEX_TO_TYPE(id, child); 380 } 381 vbytes = sizeof (uint_t); 382 break; 383 384 case CTF_K_ARRAY: 385 vbytes = sizeof (ctf_array_t); 386 break; 387 388 case CTF_K_FUNCTION: 389 err = ctf_hash_insert(&fp->ctf_names, fp, 390 CTF_INDEX_TO_TYPE(id, child), tp->ctt_name); 391 if (err != 0 && err != ECTF_STRTAB) 392 return (err); 393 vbytes = sizeof (ushort_t) * (vlen + (vlen & 1)); 394 break; 395 396 case CTF_K_STRUCT: 397 err = ctf_hash_define(&fp->ctf_structs, fp, 398 CTF_INDEX_TO_TYPE(id, child), tp->ctt_name); 399 400 if (err != 0 && err != ECTF_STRTAB) 401 return (err); 402 403 if (fp->ctf_version == CTF_VERSION_1 || 404 size < CTF_LSTRUCT_THRESH) 405 vbytes = sizeof (ctf_member_t) * vlen; 406 else { 407 vbytes = sizeof (ctf_lmember_t) * vlen; 408 nlstructs++; 409 } 410 break; 411 412 case CTF_K_UNION: 413 err = ctf_hash_define(&fp->ctf_unions, fp, 414 CTF_INDEX_TO_TYPE(id, child), tp->ctt_name); 415 416 if (err != 0 && err != ECTF_STRTAB) 417 return (err); 418 419 if (fp->ctf_version == CTF_VERSION_1 || 420 size < CTF_LSTRUCT_THRESH) 421 vbytes = sizeof (ctf_member_t) * vlen; 422 else { 423 vbytes = sizeof (ctf_lmember_t) * vlen; 424 nlunions++; 425 } 426 break; 427 428 case CTF_K_ENUM: 429 err = ctf_hash_define(&fp->ctf_enums, fp, 430 CTF_INDEX_TO_TYPE(id, child), tp->ctt_name); 431 432 if (err != 0 && err != ECTF_STRTAB) 433 return (err); 434 435 vbytes = sizeof (ctf_enum_t) * vlen; 436 break; 437 438 case CTF_K_TYPEDEF: 439 err = ctf_hash_insert(&fp->ctf_names, fp, 440 CTF_INDEX_TO_TYPE(id, child), tp->ctt_name); 441 if (err != 0 && err != ECTF_STRTAB) 442 return (err); 443 vbytes = 0; 444 break; 445 446 case CTF_K_FORWARD: 447 /* 448 * Only insert forward tags into the given hash if the 449 * type or tag name is not already present. 450 */ 451 switch (tp->ctt_type) { 452 case CTF_K_STRUCT: 453 hp = &fp->ctf_structs; 454 break; 455 case CTF_K_UNION: 456 hp = &fp->ctf_unions; 457 break; 458 case CTF_K_ENUM: 459 hp = &fp->ctf_enums; 460 break; 461 default: 462 hp = &fp->ctf_structs; 463 } 464 465 if (ctf_hash_lookup(hp, fp, 466 name, strlen(name)) == NULL) { 467 err = ctf_hash_insert(hp, fp, 468 CTF_INDEX_TO_TYPE(id, child), tp->ctt_name); 469 if (err != 0 && err != ECTF_STRTAB) 470 return (err); 471 } 472 vbytes = 0; 473 break; 474 475 case CTF_K_POINTER: 476 /* 477 * If the type referenced by the pointer is in this CTF 478 * container, then store the index of the pointer type 479 * in fp->ctf_ptrtab[ index of referenced type ]. 480 */ 481 if (CTF_TYPE_ISCHILD(tp->ctt_type) == child && 482 CTF_TYPE_TO_INDEX(tp->ctt_type) <= fp->ctf_typemax) 483 fp->ctf_ptrtab[ 484 CTF_TYPE_TO_INDEX(tp->ctt_type)] = id; 485 /*FALLTHRU*/ 486 487 case CTF_K_VOLATILE: 488 case CTF_K_CONST: 489 case CTF_K_RESTRICT: 490 err = ctf_hash_insert(&fp->ctf_names, fp, 491 CTF_INDEX_TO_TYPE(id, child), tp->ctt_name); 492 if (err != 0 && err != ECTF_STRTAB) 493 return (err); 494 /*FALLTHRU*/ 495 496 default: 497 vbytes = 0; 498 break; 499 } 500 501 *xp = (uint_t)((uintptr_t)tp - (uintptr_t)fp->ctf_buf); 502 tp = (ctf_type_t *)((uintptr_t)tp + increment + vbytes); 503 } 504 505 ctf_dprintf("%lu total types processed\n", fp->ctf_typemax); 506 ctf_dprintf("%u enum names hashed\n", ctf_hash_size(&fp->ctf_enums)); 507 ctf_dprintf("%u struct names hashed (%d long)\n", 508 ctf_hash_size(&fp->ctf_structs), nlstructs); 509 ctf_dprintf("%u union names hashed (%d long)\n", 510 ctf_hash_size(&fp->ctf_unions), nlunions); 511 ctf_dprintf("%u base type names hashed\n", 512 ctf_hash_size(&fp->ctf_names)); 513 514 /* 515 * Make an additional pass through the pointer table to find pointers 516 * that point to anonymous typedef nodes. If we find one, modify the 517 * pointer table so that the pointer is also known to point to the 518 * node that is referenced by the anonymous typedef node. 519 */ 520 for (id = 1; id <= fp->ctf_typemax; id++) { 521 if ((dst = fp->ctf_ptrtab[id]) != 0) { 522 tp = LCTF_INDEX_TO_TYPEPTR(fp, id); 523 524 if (LCTF_INFO_KIND(fp, tp->ctt_info) == CTF_K_TYPEDEF && 525 strcmp(ctf_strptr(fp, tp->ctt_name), "") == 0 && 526 CTF_TYPE_ISCHILD(tp->ctt_type) == child && 527 CTF_TYPE_TO_INDEX(tp->ctt_type) <= fp->ctf_typemax) 528 fp->ctf_ptrtab[ 529 CTF_TYPE_TO_INDEX(tp->ctt_type)] = dst; 530 } 531 } 532 533 return (0); 534 } 535 536 /* 537 * Decode the specified CTF buffer and optional symbol table and create a new 538 * CTF container representing the symbolic debugging information. This code 539 * can be used directly by the debugger, or it can be used as the engine for 540 * ctf_fdopen() or ctf_open(), below. 541 */ 542 ctf_file_t * 543 ctf_bufopen(const ctf_sect_t *ctfsect, const ctf_sect_t *symsect, 544 const ctf_sect_t *strsect, int *errp) 545 { 546 const ctf_preamble_t *pp; 547 ctf_header_t hp; 548 ctf_file_t *fp; 549 void *buf, *base; 550 size_t size, hdrsz; 551 int err; 552 553 if (ctfsect == NULL || ((symsect == NULL) != (strsect == NULL))) 554 return (ctf_set_open_errno(errp, EINVAL)); 555 556 if (symsect != NULL && symsect->cts_entsize != sizeof (Elf32_Sym) && 557 symsect->cts_entsize != sizeof (Elf64_Sym)) 558 return (ctf_set_open_errno(errp, ECTF_SYMTAB)); 559 560 if (symsect != NULL && symsect->cts_data == NULL) 561 return (ctf_set_open_errno(errp, ECTF_SYMBAD)); 562 563 if (strsect != NULL && strsect->cts_data == NULL) 564 return (ctf_set_open_errno(errp, ECTF_STRBAD)); 565 566 if (ctfsect->cts_size < sizeof (ctf_preamble_t)) 567 return (ctf_set_open_errno(errp, ECTF_NOCTFBUF)); 568 569 pp = (const ctf_preamble_t *)ctfsect->cts_data; 570 571 ctf_dprintf("ctf_bufopen: magic=0x%x version=%u\n", 572 pp->ctp_magic, pp->ctp_version); 573 574 /* 575 * Validate each part of the CTF header (either V1 or V2). 576 * First, we validate the preamble (common to all versions). At that 577 * point, we know specific header version, and can validate the 578 * version-specific parts including section offsets and alignments. 579 */ 580 if (pp->ctp_magic != CTF_MAGIC) 581 return (ctf_set_open_errno(errp, ECTF_NOCTFBUF)); 582 583 if (pp->ctp_version == CTF_VERSION_2) { 584 if (ctfsect->cts_size < sizeof (ctf_header_t)) 585 return (ctf_set_open_errno(errp, ECTF_NOCTFBUF)); 586 587 bcopy(ctfsect->cts_data, &hp, sizeof (hp)); 588 hdrsz = sizeof (ctf_header_t); 589 590 } else if (pp->ctp_version == CTF_VERSION_1) { 591 const ctf_header_v1_t *h1p = 592 (const ctf_header_v1_t *)ctfsect->cts_data; 593 594 if (ctfsect->cts_size < sizeof (ctf_header_v1_t)) 595 return (ctf_set_open_errno(errp, ECTF_NOCTFBUF)); 596 597 bzero(&hp, sizeof (hp)); 598 hp.cth_preamble = h1p->cth_preamble; 599 hp.cth_objtoff = h1p->cth_objtoff; 600 hp.cth_funcoff = h1p->cth_funcoff; 601 hp.cth_typeoff = h1p->cth_typeoff; 602 hp.cth_stroff = h1p->cth_stroff; 603 hp.cth_strlen = h1p->cth_strlen; 604 605 hdrsz = sizeof (ctf_header_v1_t); 606 } else 607 return (ctf_set_open_errno(errp, ECTF_CTFVERS)); 608 609 size = hp.cth_stroff + hp.cth_strlen; 610 611 ctf_dprintf("ctf_bufopen: uncompressed size=%lu\n", (ulong_t)size); 612 613 if (hp.cth_lbloff > size || hp.cth_objtoff > size || 614 hp.cth_funcoff > size || hp.cth_typeoff > size || 615 hp.cth_stroff > size) 616 return (ctf_set_open_errno(errp, ECTF_CORRUPT)); 617 618 if (hp.cth_lbloff > hp.cth_objtoff || 619 hp.cth_objtoff > hp.cth_funcoff || 620 hp.cth_funcoff > hp.cth_typeoff || 621 hp.cth_typeoff > hp.cth_stroff) 622 return (ctf_set_open_errno(errp, ECTF_CORRUPT)); 623 624 if ((hp.cth_lbloff & 3) || (hp.cth_objtoff & 1) || 625 (hp.cth_funcoff & 1) || (hp.cth_typeoff & 3)) 626 return (ctf_set_open_errno(errp, ECTF_CORRUPT)); 627 628 /* 629 * Once everything is determined to be valid, attempt to decompress 630 * the CTF data buffer if it is compressed. Otherwise we just put 631 * the data section's buffer pointer into ctf_buf, below. 632 */ 633 if (hp.cth_flags & CTF_F_COMPRESS) { 634 size_t srclen, dstlen; 635 const void *src; 636 int rc = Z_OK; 637 638 if (ctf_zopen(errp) == NULL) 639 return (NULL); /* errp is set for us */ 640 641 if ((base = ctf_data_alloc(size + hdrsz)) == MAP_FAILED) 642 return (ctf_set_open_errno(errp, ECTF_ZALLOC)); 643 644 bcopy(ctfsect->cts_data, base, hdrsz); 645 ((ctf_preamble_t *)base)->ctp_flags &= ~CTF_F_COMPRESS; 646 buf = (uchar_t *)base + hdrsz; 647 648 src = (uchar_t *)ctfsect->cts_data + hdrsz; 649 srclen = ctfsect->cts_size - hdrsz; 650 dstlen = size; 651 652 if ((rc = z_uncompress(buf, &dstlen, src, srclen)) != Z_OK) { 653 ctf_dprintf("zlib inflate err: %s\n", z_strerror(rc)); 654 ctf_data_free(base, size + hdrsz); 655 return (ctf_set_open_errno(errp, ECTF_DECOMPRESS)); 656 } 657 658 if (dstlen != size) { 659 ctf_dprintf("zlib inflate short -- got %lu of %lu " 660 "bytes\n", (ulong_t)dstlen, (ulong_t)size); 661 ctf_data_free(base, size + hdrsz); 662 return (ctf_set_open_errno(errp, ECTF_CORRUPT)); 663 } 664 665 ctf_data_protect(base, size + hdrsz); 666 667 } else { 668 base = (void *)ctfsect->cts_data; 669 buf = (uchar_t *)base + hdrsz; 670 } 671 672 /* 673 * Once we have uncompressed and validated the CTF data buffer, we can 674 * proceed with allocating a ctf_file_t and initializing it. 675 */ 676 if ((fp = ctf_alloc(sizeof (ctf_file_t))) == NULL) 677 return (ctf_set_open_errno(errp, EAGAIN)); 678 679 bzero(fp, sizeof (ctf_file_t)); 680 fp->ctf_version = hp.cth_version; 681 fp->ctf_fileops = &ctf_fileops[hp.cth_version]; 682 bcopy(ctfsect, &fp->ctf_data, sizeof (ctf_sect_t)); 683 684 if (symsect != NULL) { 685 bcopy(symsect, &fp->ctf_symtab, sizeof (ctf_sect_t)); 686 bcopy(strsect, &fp->ctf_strtab, sizeof (ctf_sect_t)); 687 } 688 689 if (fp->ctf_data.cts_name != NULL) 690 fp->ctf_data.cts_name = ctf_strdup(fp->ctf_data.cts_name); 691 if (fp->ctf_symtab.cts_name != NULL) 692 fp->ctf_symtab.cts_name = ctf_strdup(fp->ctf_symtab.cts_name); 693 if (fp->ctf_strtab.cts_name != NULL) 694 fp->ctf_strtab.cts_name = ctf_strdup(fp->ctf_strtab.cts_name); 695 696 if (fp->ctf_data.cts_name == NULL) 697 fp->ctf_data.cts_name = _CTF_NULLSTR; 698 if (fp->ctf_symtab.cts_name == NULL) 699 fp->ctf_symtab.cts_name = _CTF_NULLSTR; 700 if (fp->ctf_strtab.cts_name == NULL) 701 fp->ctf_strtab.cts_name = _CTF_NULLSTR; 702 703 fp->ctf_str[CTF_STRTAB_0].cts_strs = (const char *)buf + hp.cth_stroff; 704 fp->ctf_str[CTF_STRTAB_0].cts_len = hp.cth_strlen; 705 706 if (strsect != NULL) { 707 fp->ctf_str[CTF_STRTAB_1].cts_strs = strsect->cts_data; 708 fp->ctf_str[CTF_STRTAB_1].cts_len = strsect->cts_size; 709 } 710 711 fp->ctf_base = base; 712 fp->ctf_buf = buf; 713 fp->ctf_size = size + hdrsz; 714 715 /* 716 * If we have a parent container name and label, store the relocated 717 * string pointers in the CTF container for easy access later. 718 */ 719 if (hp.cth_parlabel != 0) 720 fp->ctf_parlabel = ctf_strptr(fp, hp.cth_parlabel); 721 if (hp.cth_parname != 0) 722 fp->ctf_parname = ctf_strptr(fp, hp.cth_parname); 723 724 ctf_dprintf("ctf_bufopen: parent name %s (label %s)\n", 725 fp->ctf_parname ? fp->ctf_parname : "<NULL>", 726 fp->ctf_parlabel ? fp->ctf_parlabel : "<NULL>"); 727 728 /* 729 * If we have a symbol table section, allocate and initialize 730 * the symtab translation table, pointed to by ctf_sxlate. 731 */ 732 if (symsect != NULL) { 733 fp->ctf_nsyms = symsect->cts_size / symsect->cts_entsize; 734 fp->ctf_sxlate = ctf_alloc(fp->ctf_nsyms * sizeof (uint_t)); 735 736 if (fp->ctf_sxlate == NULL) { 737 (void) ctf_set_open_errno(errp, EAGAIN); 738 goto bad; 739 } 740 741 if ((err = init_symtab(fp, &hp, symsect, strsect)) != 0) { 742 (void) ctf_set_open_errno(errp, err); 743 goto bad; 744 } 745 } 746 747 if ((err = init_types(fp, &hp)) != 0) { 748 (void) ctf_set_open_errno(errp, err); 749 goto bad; 750 } 751 752 /* 753 * Initialize the ctf_lookup_by_name top-level dictionary. We keep an 754 * array of type name prefixes and the corresponding ctf_hash to use. 755 * NOTE: This code must be kept in sync with the code in ctf_update(). 756 */ 757 fp->ctf_lookups[0].ctl_prefix = "struct"; 758 fp->ctf_lookups[0].ctl_len = strlen(fp->ctf_lookups[0].ctl_prefix); 759 fp->ctf_lookups[0].ctl_hash = &fp->ctf_structs; 760 fp->ctf_lookups[1].ctl_prefix = "union"; 761 fp->ctf_lookups[1].ctl_len = strlen(fp->ctf_lookups[1].ctl_prefix); 762 fp->ctf_lookups[1].ctl_hash = &fp->ctf_unions; 763 fp->ctf_lookups[2].ctl_prefix = "enum"; 764 fp->ctf_lookups[2].ctl_len = strlen(fp->ctf_lookups[2].ctl_prefix); 765 fp->ctf_lookups[2].ctl_hash = &fp->ctf_enums; 766 fp->ctf_lookups[3].ctl_prefix = _CTF_NULLSTR; 767 fp->ctf_lookups[3].ctl_len = strlen(fp->ctf_lookups[3].ctl_prefix); 768 fp->ctf_lookups[3].ctl_hash = &fp->ctf_names; 769 fp->ctf_lookups[4].ctl_prefix = NULL; 770 fp->ctf_lookups[4].ctl_len = 0; 771 fp->ctf_lookups[4].ctl_hash = NULL; 772 773 if (symsect != NULL) { 774 if (symsect->cts_entsize == sizeof (Elf64_Sym)) 775 (void) ctf_setmodel(fp, CTF_MODEL_LP64); 776 else 777 (void) ctf_setmodel(fp, CTF_MODEL_ILP32); 778 } else 779 (void) ctf_setmodel(fp, CTF_MODEL_NATIVE); 780 781 fp->ctf_refcnt = 1; 782 return (fp); 783 784 bad: 785 ctf_close(fp); 786 return (NULL); 787 } 788 789 /* 790 * Close the specified CTF container and free associated data structures. Note 791 * that ctf_close() is a reference counted operation: if the specified file is 792 * the parent of other active containers, its reference count will be greater 793 * than one and it will be freed later when no active children exist. 794 */ 795 void 796 ctf_close(ctf_file_t *fp) 797 { 798 ctf_dtdef_t *dtd, *ntd; 799 800 if (fp == NULL) 801 return; /* allow ctf_close(NULL) to simplify caller code */ 802 803 ctf_dprintf("ctf_close(%p) refcnt=%u\n", (void *)fp, fp->ctf_refcnt); 804 805 if (fp->ctf_refcnt > 1) { 806 fp->ctf_refcnt--; 807 return; 808 } 809 810 if (fp->ctf_parent != NULL) 811 ctf_close(fp->ctf_parent); 812 813 for (dtd = ctf_list_next(&fp->ctf_dtdefs); dtd != NULL; dtd = ntd) { 814 ntd = ctf_list_next(dtd); 815 ctf_dtd_delete(fp, dtd); 816 } 817 818 ctf_free(fp->ctf_dthash, fp->ctf_dthashlen * sizeof (ctf_dtdef_t *)); 819 820 if (fp->ctf_flags & LCTF_MMAP) { 821 if (fp->ctf_data.cts_data != NULL) 822 ctf_sect_munmap(&fp->ctf_data); 823 if (fp->ctf_symtab.cts_data != NULL) 824 ctf_sect_munmap(&fp->ctf_symtab); 825 if (fp->ctf_strtab.cts_data != NULL) 826 ctf_sect_munmap(&fp->ctf_strtab); 827 } 828 829 if (fp->ctf_data.cts_name != _CTF_NULLSTR && 830 fp->ctf_data.cts_name != NULL) { 831 ctf_free((char *)fp->ctf_data.cts_name, 832 strlen(fp->ctf_data.cts_name) + 1); 833 } 834 835 if (fp->ctf_symtab.cts_name != _CTF_NULLSTR && 836 fp->ctf_symtab.cts_name != NULL) { 837 ctf_free((char *)fp->ctf_symtab.cts_name, 838 strlen(fp->ctf_symtab.cts_name) + 1); 839 } 840 841 if (fp->ctf_strtab.cts_name != _CTF_NULLSTR && 842 fp->ctf_strtab.cts_name != NULL) { 843 ctf_free((char *)fp->ctf_strtab.cts_name, 844 strlen(fp->ctf_strtab.cts_name) + 1); 845 } 846 847 if (fp->ctf_base != fp->ctf_data.cts_data && fp->ctf_base != NULL) 848 ctf_data_free((void *)fp->ctf_base, fp->ctf_size); 849 850 if (fp->ctf_sxlate != NULL) 851 ctf_free(fp->ctf_sxlate, sizeof (uint_t) * fp->ctf_nsyms); 852 853 if (fp->ctf_txlate != NULL) { 854 ctf_free(fp->ctf_txlate, 855 sizeof (uint_t) * (fp->ctf_typemax + 1)); 856 } 857 858 if (fp->ctf_ptrtab != NULL) { 859 ctf_free(fp->ctf_ptrtab, 860 sizeof (ushort_t) * (fp->ctf_typemax + 1)); 861 } 862 863 ctf_hash_destroy(&fp->ctf_structs); 864 ctf_hash_destroy(&fp->ctf_unions); 865 ctf_hash_destroy(&fp->ctf_enums); 866 ctf_hash_destroy(&fp->ctf_names); 867 868 ctf_free(fp, sizeof (ctf_file_t)); 869 } 870 871 /* 872 * Return the CTF handle for the parent CTF container, if one exists. 873 * Otherwise return NULL to indicate this container has no imported parent. 874 */ 875 ctf_file_t * 876 ctf_parent_file(ctf_file_t *fp) 877 { 878 return (fp->ctf_parent); 879 } 880 881 /* 882 * Return the name of the parent CTF container, if one exists. Otherwise 883 * return NULL to indicate this container is a root container. 884 */ 885 const char * 886 ctf_parent_name(ctf_file_t *fp) 887 { 888 return (fp->ctf_parname); 889 } 890 891 /* 892 * Import the types from the specified parent container by storing a pointer 893 * to it in ctf_parent and incrementing its reference count. Only one parent 894 * is allowed: if a parent already exists, it is replaced by the new parent. 895 */ 896 int 897 ctf_import(ctf_file_t *fp, ctf_file_t *pfp) 898 { 899 if (fp == NULL || fp == pfp || (pfp != NULL && pfp->ctf_refcnt == 0)) 900 return (ctf_set_errno(fp, EINVAL)); 901 902 if (pfp != NULL && pfp->ctf_dmodel != fp->ctf_dmodel) 903 return (ctf_set_errno(fp, ECTF_DMODEL)); 904 905 if (fp->ctf_parent != NULL) 906 ctf_close(fp->ctf_parent); 907 908 if (pfp != NULL) { 909 fp->ctf_flags |= LCTF_CHILD; 910 pfp->ctf_refcnt++; 911 } 912 913 fp->ctf_parent = pfp; 914 return (0); 915 } 916 917 /* 918 * Set the data model constant for the CTF container. 919 */ 920 int 921 ctf_setmodel(ctf_file_t *fp, int model) 922 { 923 const ctf_dmodel_t *dp; 924 925 for (dp = _libctf_models; dp->ctd_name != NULL; dp++) { 926 if (dp->ctd_code == model) { 927 fp->ctf_dmodel = dp; 928 return (0); 929 } 930 } 931 932 return (ctf_set_errno(fp, EINVAL)); 933 } 934 935 /* 936 * Return the data model constant for the CTF container. 937 */ 938 int 939 ctf_getmodel(ctf_file_t *fp) 940 { 941 return (fp->ctf_dmodel->ctd_code); 942 } 943 944 void 945 ctf_setspecific(ctf_file_t *fp, void *data) 946 { 947 fp->ctf_specific = data; 948 } 949 950 void * 951 ctf_getspecific(ctf_file_t *fp) 952 { 953 return (fp->ctf_specific); 954 } 955