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
get_kind_v1(ushort_t info)47 get_kind_v1(ushort_t info)
48 {
49 return (CTF_INFO_KIND_V1(info));
50 }
51
52 static ushort_t
get_kind_v2(ushort_t info)53 get_kind_v2(ushort_t info)
54 {
55 return (CTF_INFO_KIND(info));
56 }
57
58 static ushort_t
get_root_v1(ushort_t info)59 get_root_v1(ushort_t info)
60 {
61 return (CTF_INFO_ISROOT_V1(info));
62 }
63
64 static ushort_t
get_root_v2(ushort_t info)65 get_root_v2(ushort_t info)
66 {
67 return (CTF_INFO_ISROOT(info));
68 }
69
70 static ushort_t
get_vlen_v1(ushort_t info)71 get_vlen_v1(ushort_t info)
72 {
73 return (CTF_INFO_VLEN_V1(info));
74 }
75
76 static ushort_t
get_vlen_v2(ushort_t info)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 *
sym_to_gelf(const Elf32_Sym * src,Elf64_Sym * dst)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
init_symtab(ctf_file_t * fp,const ctf_header_t * hp,const ctf_sect_t * sp,const ctf_sect_t * strp)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
init_types(ctf_file_t * fp,const ctf_header_t * cth)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 *
ctf_bufopen(const ctf_sect_t * ctfsect,const ctf_sect_t * symsect,const ctf_sect_t * strsect,int * errp)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
ctf_close(ctf_file_t * fp)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 *
ctf_parent_file(ctf_file_t * fp)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 *
ctf_parent_name(ctf_file_t * fp)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
ctf_import(ctf_file_t * fp,ctf_file_t * pfp)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
ctf_setmodel(ctf_file_t * fp,int model)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
ctf_getmodel(ctf_file_t * fp)939 ctf_getmodel(ctf_file_t *fp)
940 {
941 return (fp->ctf_dmodel->ctd_code);
942 }
943
944 void
ctf_setspecific(ctf_file_t * fp,void * data)945 ctf_setspecific(ctf_file_t *fp, void *data)
946 {
947 fp->ctf_specific = data;
948 }
949
950 void *
ctf_getspecific(ctf_file_t * fp)951 ctf_getspecific(ctf_file_t *fp)
952 {
953 return (fp->ctf_specific);
954 }
955