xref: /titanic_51/usr/src/common/ctf/ctf_open.c (revision 15d9d0b528387242011cdcc6190c9e598cfe3a07)
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