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