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 * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26 /*
27 * Copyright (c) 2019, Joyent, Inc.
28 */
29
30 #include <sys/types.h>
31 #include <sys/stat.h>
32 #include <sys/mman.h>
33 #include <libctf_impl.h>
34 #include <unistd.h>
35 #include <fcntl.h>
36 #include <errno.h>
37 #include <dlfcn.h>
38 #include <gelf.h>
39 #include <zlib.h>
40 #include <sys/debug.h>
41
42 #ifdef _LP64
43 static const char *_libctf_zlib = "/usr/lib/64/libz.so.1";
44 #else
45 static const char *_libctf_zlib = "/usr/lib/libz.so.1";
46 #endif
47
48 static struct {
49 int (*z_uncompress)(uchar_t *, ulong_t *, const uchar_t *, ulong_t);
50 int (*z_initcomp)(z_stream *, int, const char *, int);
51 int (*z_compress)(z_stream *, int);
52 int (*z_finicomp)(z_stream *);
53 const char *(*z_error)(int);
54 void *z_dlp;
55 } zlib;
56
57 static size_t _PAGESIZE;
58 static size_t _PAGEMASK;
59
60 static uint64_t ctf_phase = 0;
61
62 #define CTF_COMPRESS_CHUNK (64*1024)
63
64 typedef struct ctf_zdata {
65 void *czd_buf;
66 void *czd_next;
67 ctf_file_t *czd_ctfp;
68 size_t czd_allocsz;
69 z_stream czd_zstr;
70 } ctf_zdata_t;
71
72 #pragma init(_libctf_init)
73 void
74 _libctf_init(void)
75 {
76 const char *p = getenv("LIBCTF_DECOMPRESSOR");
77
78 if (p != NULL)
79 _libctf_zlib = p; /* use alternate decompression library */
80
81 _libctf_debug = getenv("LIBCTF_DEBUG") != NULL;
82
83 _PAGESIZE = getpagesize();
84 _PAGEMASK = ~(_PAGESIZE - 1);
85 }
86
87 /*
88 * Attempt to dlopen the decompression library and locate the symbols of
89 * interest that we will need to call. This information in cached so
90 * that multiple calls to ctf_bufopen() do not need to reopen the library.
91 */
92 void *
93 ctf_zopen(int *errp)
94 {
95 ctf_dprintf("decompressing CTF data using %s\n", _libctf_zlib);
96
97 if (zlib.z_dlp != NULL)
98 return (zlib.z_dlp); /* library is already loaded */
99
100 if (access(_libctf_zlib, R_OK) == -1)
101 return (ctf_set_open_errno(errp, ECTF_ZMISSING));
102
103 if ((zlib.z_dlp = dlopen(_libctf_zlib, RTLD_LAZY | RTLD_LOCAL)) == NULL)
104 return (ctf_set_open_errno(errp, ECTF_ZINIT));
105
106 zlib.z_uncompress = (int (*)()) dlsym(zlib.z_dlp, "uncompress");
107 zlib.z_initcomp = (int (*)()) dlsym(zlib.z_dlp, "deflateInit_");
108 zlib.z_compress = (int (*)()) dlsym(zlib.z_dlp, "deflate");
109 zlib.z_finicomp = (int (*)()) dlsym(zlib.z_dlp, "deflateEnd");
110 zlib.z_error = (const char *(*)()) dlsym(zlib.z_dlp, "zError");
111
112 if (zlib.z_uncompress == NULL || zlib.z_error == NULL ||
113 zlib.z_initcomp == NULL|| zlib.z_compress == NULL ||
114 zlib.z_finicomp == NULL) {
115 (void) dlclose(zlib.z_dlp);
116 bzero(&zlib, sizeof (zlib));
117 return (ctf_set_open_errno(errp, ECTF_ZINIT));
118 }
119
120 return (zlib.z_dlp);
121 }
122
123 /*
124 * The ctf_bufopen() routine calls these subroutines, defined by <sys/zmod.h>,
125 * which we then patch through to the functions in the decompression library.
126 */
127 int
128 z_uncompress(void *dst, size_t *dstlen, const void *src, size_t srclen)
129 {
130 return (zlib.z_uncompress(dst, (ulong_t *)dstlen, src, srclen));
131 }
132
133 const char *
134 z_strerror(int err)
135 {
136 return (zlib.z_error(err));
137 }
138
139 static int
140 ctf_zdata_init(ctf_zdata_t *czd, ctf_file_t *fp)
141 {
142 ctf_header_t *cthp;
143
144 bzero(czd, sizeof (ctf_zdata_t));
145
146 czd->czd_allocsz = fp->ctf_size;
147 czd->czd_buf = ctf_data_alloc(czd->czd_allocsz);
148 if (czd->czd_buf == MAP_FAILED)
149 return (ctf_set_errno(fp, ENOMEM));
150
151 bcopy(fp->ctf_base, czd->czd_buf, sizeof (ctf_header_t));
152 czd->czd_ctfp = fp;
153 cthp = czd->czd_buf;
154 cthp->cth_flags |= CTF_F_COMPRESS;
155 czd->czd_next = (void *)((uintptr_t)czd->czd_buf +
156 sizeof (ctf_header_t));
157
158 if (zlib.z_initcomp(&czd->czd_zstr, Z_BEST_COMPRESSION,
159 ZLIB_VERSION, sizeof (z_stream)) != Z_OK)
160 return (ctf_set_errno(fp, ECTF_ZLIB));
161
162 return (0);
163 }
164
165 static int
166 ctf_zdata_grow(ctf_zdata_t *czd)
167 {
168 size_t off;
169 size_t newsz;
170 void *ndata;
171
172 off = (uintptr_t)czd->czd_next - (uintptr_t)czd->czd_buf;
173 newsz = czd->czd_allocsz + CTF_COMPRESS_CHUNK;
174 ndata = ctf_data_alloc(newsz);
175 if (ndata == MAP_FAILED) {
176 return (ctf_set_errno(czd->czd_ctfp, ENOMEM));
177 }
178
179 bcopy(czd->czd_buf, ndata, off);
180 ctf_data_free(czd->czd_buf, czd->czd_allocsz);
181 czd->czd_allocsz = newsz;
182 czd->czd_buf = ndata;
183 czd->czd_next = (void *)((uintptr_t)ndata + off);
184
185 czd->czd_zstr.next_out = (Bytef *)czd->czd_next;
186 czd->czd_zstr.avail_out = CTF_COMPRESS_CHUNK;
187 return (0);
188 }
189
190 static int
191 ctf_zdata_compress_buffer(ctf_zdata_t *czd, const void *buf, size_t bufsize)
192 {
193 int err;
194
195 czd->czd_zstr.next_out = czd->czd_next;
196 czd->czd_zstr.avail_out = czd->czd_allocsz -
197 ((uintptr_t)czd->czd_next - (uintptr_t)czd->czd_buf);
198 czd->czd_zstr.next_in = (Bytef *)buf;
199 czd->czd_zstr.avail_in = bufsize;
200
201 while (czd->czd_zstr.avail_in != 0) {
202 if (czd->czd_zstr.avail_out == 0) {
203 czd->czd_next = czd->czd_zstr.next_out;
204 if ((err = ctf_zdata_grow(czd)) != 0) {
205 return (err);
206 }
207 }
208
209 if ((err = zlib.z_compress(&czd->czd_zstr, Z_NO_FLUSH)) != Z_OK)
210 return (ctf_set_errno(czd->czd_ctfp, ECTF_ZLIB));
211 }
212 czd->czd_next = czd->czd_zstr.next_out;
213
214 return (0);
215 }
216
217 static int
218 ctf_zdata_flush(ctf_zdata_t *czd, boolean_t finish)
219 {
220 int err;
221 int flag = finish == B_TRUE ? Z_FINISH : Z_FULL_FLUSH;
222 int bret = finish == B_TRUE ? Z_STREAM_END : Z_BUF_ERROR;
223
224 for (;;) {
225 if (czd->czd_zstr.avail_out == 0) {
226 czd->czd_next = czd->czd_zstr.next_out;
227 if ((err = ctf_zdata_grow(czd)) != 0) {
228 return (err);
229 }
230 }
231
232 err = zlib.z_compress(&czd->czd_zstr, flag);
233 if (err == bret) {
234 break;
235 }
236 if (err != Z_OK)
237 return (ctf_set_errno(czd->czd_ctfp, ECTF_ZLIB));
238
239 }
240
241 czd->czd_next = czd->czd_zstr.next_out;
242
243 return (0);
244 }
245
246 static int
247 ctf_zdata_end(ctf_zdata_t *czd)
248 {
249 int ret;
250
251 if ((ret = ctf_zdata_flush(czd, B_TRUE)) != 0)
252 return (ret);
253
254 if ((ret = zlib.z_finicomp(&czd->czd_zstr)) != 0)
255 return (ctf_set_errno(czd->czd_ctfp, ECTF_ZLIB));
256
257 return (0);
258 }
259
260 static void
261 ctf_zdata_cleanup(ctf_zdata_t *czd)
262 {
263 ctf_data_free(czd->czd_buf, czd->czd_allocsz);
264 (void) zlib.z_finicomp(&czd->czd_zstr);
265 }
266
267 /*
268 * Compress our CTF data and return both the size of the compressed data and the
269 * size of the allocation. These may be different due to the nature of
270 * compression.
271 *
272 * In addition, we flush the compression between our two phases such that we
273 * maintain a different dictionary between the CTF data and the string section.
274 */
275 int
276 ctf_compress(ctf_file_t *fp, void **buf, size_t *allocsz, size_t *elfsize)
277 {
278 int err;
279 ctf_zdata_t czd;
280 ctf_header_t *cthp = (ctf_header_t *)fp->ctf_base;
281
282 if ((err = ctf_zdata_init(&czd, fp)) != 0)
283 return (err);
284
285 if ((err = ctf_zdata_compress_buffer(&czd, fp->ctf_buf,
286 cthp->cth_stroff)) != 0) {
287 ctf_zdata_cleanup(&czd);
288 return (err);
289 }
290
291 if ((err = ctf_zdata_flush(&czd, B_FALSE)) != 0) {
292 ctf_zdata_cleanup(&czd);
293 return (err);
294 }
295
296 if ((err = ctf_zdata_compress_buffer(&czd,
297 fp->ctf_buf + cthp->cth_stroff, cthp->cth_strlen)) != 0) {
298 ctf_zdata_cleanup(&czd);
299 return (err);
300 }
301
302 if ((err = ctf_zdata_end(&czd)) != 0) {
303 ctf_zdata_cleanup(&czd);
304 return (err);
305 }
306
307 *buf = czd.czd_buf;
308 *allocsz = czd.czd_allocsz;
309 *elfsize = (uintptr_t)czd.czd_next - (uintptr_t)czd.czd_buf;
310
311 return (0);
312 }
313
314 int
315 z_compress(void *dst, size_t *dstlen, const void *src, size_t srclen)
316 {
317 z_stream zs;
318 int err;
319
320 bzero(&zs, sizeof (z_stream));
321 zs.next_in = (uchar_t *)src;
322 zs.avail_in = srclen;
323 zs.next_out = dst;
324 zs.avail_out = *dstlen;
325
326 if ((err = zlib.z_initcomp(&zs, Z_BEST_COMPRESSION, ZLIB_VERSION,
327 sizeof (z_stream))) != Z_OK)
328 return (err);
329
330 if ((err = zlib.z_compress(&zs, Z_FINISH)) != Z_STREAM_END) {
331 (void) zlib.z_finicomp(&zs);
332 return (err == Z_OK ? Z_BUF_ERROR : err);
333 }
334
335 *dstlen = zs.total_out;
336 return (zlib.z_finicomp(&zs));
337 }
338
339 /*
340 * Convert a 32-bit ELF file header into GElf.
341 */
342 static void
343 ehdr_to_gelf(const Elf32_Ehdr *src, GElf_Ehdr *dst)
344 {
345 bcopy(src->e_ident, dst->e_ident, EI_NIDENT);
346 dst->e_type = src->e_type;
347 dst->e_machine = src->e_machine;
348 dst->e_version = src->e_version;
349 dst->e_entry = (Elf64_Addr)src->e_entry;
350 dst->e_phoff = (Elf64_Off)src->e_phoff;
351 dst->e_shoff = (Elf64_Off)src->e_shoff;
352 dst->e_flags = src->e_flags;
353 dst->e_ehsize = src->e_ehsize;
354 dst->e_phentsize = src->e_phentsize;
355 dst->e_phnum = src->e_phnum;
356 dst->e_shentsize = src->e_shentsize;
357 dst->e_shnum = src->e_shnum;
358 dst->e_shstrndx = src->e_shstrndx;
359 }
360
361 /*
362 * Convert a 32-bit ELF section header into GElf.
363 */
364 static void
365 shdr_to_gelf(const Elf32_Shdr *src, GElf_Shdr *dst)
366 {
367 dst->sh_name = src->sh_name;
368 dst->sh_type = src->sh_type;
369 dst->sh_flags = src->sh_flags;
370 dst->sh_addr = src->sh_addr;
371 dst->sh_offset = src->sh_offset;
372 dst->sh_size = src->sh_size;
373 dst->sh_link = src->sh_link;
374 dst->sh_info = src->sh_info;
375 dst->sh_addralign = src->sh_addralign;
376 dst->sh_entsize = src->sh_entsize;
377 }
378
379 /*
380 * In order to mmap a section from the ELF file, we must round down sh_offset
381 * to the previous page boundary, and mmap the surrounding page. We store
382 * the pointer to the start of the actual section data back into sp->cts_data.
383 */
384 const void *
385 ctf_sect_mmap(ctf_sect_t *sp, int fd)
386 {
387 size_t pageoff = sp->cts_offset & ~_PAGEMASK;
388
389 caddr_t base = mmap64(NULL, sp->cts_size + pageoff, PROT_READ,
390 MAP_PRIVATE, fd, sp->cts_offset & _PAGEMASK);
391
392 if (base != MAP_FAILED)
393 sp->cts_data = base + pageoff;
394
395 return (base);
396 }
397
398 /*
399 * Since sp->cts_data has the adjusted offset, we have to again round down
400 * to get the actual mmap address and round up to get the size.
401 */
402 void
403 ctf_sect_munmap(const ctf_sect_t *sp)
404 {
405 uintptr_t addr = (uintptr_t)sp->cts_data;
406 uintptr_t pageoff = addr & ~_PAGEMASK;
407
408 (void) munmap((void *)(addr - pageoff), sp->cts_size + pageoff);
409 }
410
411 /*
412 * Open the specified file descriptor and return a pointer to a CTF container.
413 * The file can be either an ELF file or raw CTF file. The caller is
414 * responsible for closing the file descriptor when it is no longer needed.
415 */
416 ctf_file_t *
417 ctf_fdcreate_int(int fd, int *errp, ctf_sect_t *ctfp)
418 {
419 ctf_sect_t ctfsect, symsect, strsect;
420 ctf_file_t *fp = NULL;
421 size_t shstrndx, shnum;
422
423 struct stat64 st;
424 ssize_t nbytes;
425
426 union {
427 ctf_preamble_t ctf;
428 Elf32_Ehdr e32;
429 GElf_Ehdr e64;
430 } hdr;
431
432 bzero(&ctfsect, sizeof (ctf_sect_t));
433 bzero(&symsect, sizeof (ctf_sect_t));
434 bzero(&strsect, sizeof (ctf_sect_t));
435 bzero(&hdr.ctf, sizeof (hdr));
436
437 if (fstat64(fd, &st) == -1)
438 return (ctf_set_open_errno(errp, errno));
439
440 if ((nbytes = pread64(fd, &hdr.ctf, sizeof (hdr), 0)) <= 0)
441 return (ctf_set_open_errno(errp, nbytes < 0? errno : ECTF_FMT));
442
443 /*
444 * If we have read enough bytes to form a CTF header and the magic
445 * string matches, attempt to interpret the file as raw CTF.
446 */
447 if (nbytes >= sizeof (ctf_preamble_t) &&
448 hdr.ctf.ctp_magic == CTF_MAGIC) {
449 if (ctfp != NULL)
450 return (ctf_set_open_errno(errp, EINVAL));
451
452 if (hdr.ctf.ctp_version > CTF_VERSION)
453 return (ctf_set_open_errno(errp, ECTF_CTFVERS));
454
455 ctfsect.cts_data = mmap64(NULL, st.st_size, PROT_READ,
456 MAP_PRIVATE, fd, 0);
457
458 if (ctfsect.cts_data == MAP_FAILED)
459 return (ctf_set_open_errno(errp, errno));
460
461 ctfsect.cts_name = _CTF_SECTION;
462 ctfsect.cts_type = SHT_PROGBITS;
463 ctfsect.cts_flags = SHF_ALLOC;
464 ctfsect.cts_size = (size_t)st.st_size;
465 ctfsect.cts_entsize = 1;
466 ctfsect.cts_offset = 0;
467
468 if ((fp = ctf_bufopen(&ctfsect, NULL, NULL, errp)) == NULL)
469 ctf_sect_munmap(&ctfsect);
470
471 return (fp);
472 }
473
474 /*
475 * If we have read enough bytes to form an ELF header and the magic
476 * string matches, attempt to interpret the file as an ELF file. We
477 * do our own largefile ELF processing, and convert everything to
478 * GElf structures so that clients can operate on any data model.
479 */
480 if (nbytes >= sizeof (Elf32_Ehdr) &&
481 bcmp(&hdr.e32.e_ident[EI_MAG0], ELFMAG, SELFMAG) == 0) {
482 #ifdef _BIG_ENDIAN
483 uchar_t order = ELFDATA2MSB;
484 #else
485 uchar_t order = ELFDATA2LSB;
486 #endif
487 GElf_Shdr *sp;
488
489 void *strs_map;
490 size_t strs_mapsz, i;
491 const char *strs;
492
493 if (hdr.e32.e_ident[EI_DATA] != order)
494 return (ctf_set_open_errno(errp, ECTF_ENDIAN));
495 if (hdr.e32.e_version != EV_CURRENT)
496 return (ctf_set_open_errno(errp, ECTF_ELFVERS));
497
498 if (hdr.e32.e_ident[EI_CLASS] == ELFCLASS64) {
499 if (nbytes < sizeof (GElf_Ehdr))
500 return (ctf_set_open_errno(errp, ECTF_FMT));
501 } else {
502 Elf32_Ehdr e32 = hdr.e32;
503 ehdr_to_gelf(&e32, &hdr.e64);
504 }
505
506 shnum = hdr.e64.e_shnum;
507 shstrndx = hdr.e64.e_shstrndx;
508
509 /* Extended ELF sections */
510 if ((shstrndx == SHN_XINDEX) || (shnum == 0)) {
511 if (hdr.e32.e_ident[EI_CLASS] == ELFCLASS32) {
512 Elf32_Shdr x32;
513
514 if (pread64(fd, &x32, sizeof (x32),
515 hdr.e64.e_shoff) != sizeof (x32))
516 return (ctf_set_open_errno(errp,
517 errno));
518
519 shnum = x32.sh_size;
520 shstrndx = x32.sh_link;
521 } else {
522 Elf64_Shdr x64;
523
524 if (pread64(fd, &x64, sizeof (x64),
525 hdr.e64.e_shoff) != sizeof (x64))
526 return (ctf_set_open_errno(errp,
527 errno));
528
529 shnum = x64.sh_size;
530 shstrndx = x64.sh_link;
531 }
532 }
533
534 if (shstrndx >= shnum)
535 return (ctf_set_open_errno(errp, ECTF_CORRUPT));
536
537 nbytes = sizeof (GElf_Shdr) * shnum;
538
539 if ((sp = malloc(nbytes)) == NULL)
540 return (ctf_set_open_errno(errp, errno));
541
542 /*
543 * Read in and convert to GElf the array of Shdr structures
544 * from e_shoff so we can locate sections of interest.
545 */
546 if (hdr.e32.e_ident[EI_CLASS] == ELFCLASS32) {
547 Elf32_Shdr *sp32;
548
549 nbytes = sizeof (Elf32_Shdr) * shnum;
550
551 if ((sp32 = malloc(nbytes)) == NULL || pread64(fd,
552 sp32, nbytes, hdr.e64.e_shoff) != nbytes) {
553 free(sp);
554 return (ctf_set_open_errno(errp, errno));
555 }
556
557 for (i = 0; i < shnum; i++)
558 shdr_to_gelf(&sp32[i], &sp[i]);
559
560 free(sp32);
561
562 } else if (pread64(fd, sp, nbytes, hdr.e64.e_shoff) != nbytes) {
563 free(sp);
564 return (ctf_set_open_errno(errp, errno));
565 }
566
567 /*
568 * Now mmap the section header strings section so that we can
569 * perform string comparison on the section names.
570 */
571 strs_mapsz = sp[shstrndx].sh_size +
572 (sp[shstrndx].sh_offset & ~_PAGEMASK);
573
574 strs_map = mmap64(NULL, strs_mapsz, PROT_READ, MAP_PRIVATE,
575 fd, sp[shstrndx].sh_offset & _PAGEMASK);
576
577 strs = (const char *)strs_map +
578 (sp[shstrndx].sh_offset & ~_PAGEMASK);
579
580 if (strs_map == MAP_FAILED) {
581 free(sp);
582 return (ctf_set_open_errno(errp, ECTF_MMAP));
583 }
584
585 /*
586 * Iterate over the section header array looking for the CTF
587 * section and symbol table. The strtab is linked to symtab.
588 */
589 for (i = 0; i < shnum; i++) {
590 const GElf_Shdr *shp = &sp[i];
591 const GElf_Shdr *lhp = &sp[shp->sh_link];
592
593 if (shp->sh_link >= shnum)
594 continue; /* corrupt sh_link field */
595
596 if (shp->sh_name >= sp[shstrndx].sh_size ||
597 lhp->sh_name >= sp[shstrndx].sh_size)
598 continue; /* corrupt sh_name field */
599
600 if (shp->sh_type == SHT_PROGBITS &&
601 strcmp(strs + shp->sh_name, _CTF_SECTION) == 0 &&
602 ctfp == NULL) {
603 ctfsect.cts_name = strs + shp->sh_name;
604 ctfsect.cts_type = shp->sh_type;
605 ctfsect.cts_flags = shp->sh_flags;
606 ctfsect.cts_size = shp->sh_size;
607 ctfsect.cts_entsize = shp->sh_entsize;
608 ctfsect.cts_offset = (off64_t)shp->sh_offset;
609
610 } else if (shp->sh_type == SHT_SYMTAB) {
611 symsect.cts_name = strs + shp->sh_name;
612 symsect.cts_type = shp->sh_type;
613 symsect.cts_flags = shp->sh_flags;
614 symsect.cts_size = shp->sh_size;
615 symsect.cts_entsize = shp->sh_entsize;
616 symsect.cts_offset = (off64_t)shp->sh_offset;
617
618 strsect.cts_name = strs + lhp->sh_name;
619 strsect.cts_type = lhp->sh_type;
620 strsect.cts_flags = lhp->sh_flags;
621 strsect.cts_size = lhp->sh_size;
622 strsect.cts_entsize = lhp->sh_entsize;
623 strsect.cts_offset = (off64_t)lhp->sh_offset;
624 }
625 }
626
627 free(sp); /* free section header array */
628
629 if (ctfp == NULL) {
630 if (ctfsect.cts_type == SHT_NULL && ctfp == NULL) {
631 (void) munmap(strs_map, strs_mapsz);
632 return (ctf_set_open_errno(errp,
633 ECTF_NOCTFDATA));
634 }
635
636 /*
637 * Now mmap the CTF data, symtab, and strtab sections
638 * and call ctf_bufopen() to do the rest of the work.
639 */
640 if (ctf_sect_mmap(&ctfsect, fd) == MAP_FAILED) {
641 (void) munmap(strs_map, strs_mapsz);
642 return (ctf_set_open_errno(errp, ECTF_MMAP));
643 }
644 ctfp = &ctfsect;
645 }
646
647 if (symsect.cts_type != SHT_NULL &&
648 strsect.cts_type != SHT_NULL) {
649 if (ctf_sect_mmap(&symsect, fd) == MAP_FAILED ||
650 ctf_sect_mmap(&strsect, fd) == MAP_FAILED) {
651 (void) ctf_set_open_errno(errp, ECTF_MMAP);
652 goto bad; /* unmap all and abort */
653 }
654 fp = ctf_bufopen(ctfp, &symsect, &strsect, errp);
655 } else
656 fp = ctf_bufopen(ctfp, NULL, NULL, errp);
657 bad:
658 if (fp == NULL) {
659 if (ctfp == NULL)
660 ctf_sect_munmap(&ctfsect);
661 ctf_sect_munmap(&symsect);
662 ctf_sect_munmap(&strsect);
663 } else
664 fp->ctf_flags |= LCTF_MMAP;
665
666 (void) munmap(strs_map, strs_mapsz);
667 return (fp);
668 }
669
670 return (ctf_set_open_errno(errp, ECTF_FMT));
671 }
672
673 ctf_file_t *
674 ctf_fdopen(int fd, int *errp)
675 {
676 return (ctf_fdcreate_int(fd, errp, NULL));
677 }
678
679 /*
680 * Open the specified file and return a pointer to a CTF container. The file
681 * can be either an ELF file or raw CTF file. This is just a convenient
682 * wrapper around ctf_fdopen() for callers.
683 */
684 ctf_file_t *
685 ctf_open(const char *filename, int *errp)
686 {
687 ctf_file_t *fp;
688 int fd;
689
690 if ((fd = open64(filename, O_RDONLY)) == -1) {
691 if (errp != NULL)
692 *errp = errno;
693 return (NULL);
694 }
695
696 fp = ctf_fdopen(fd, errp);
697 (void) close(fd);
698 return (fp);
699 }
700
701 /*
702 * Write the uncompressed CTF data stream to the specified file descriptor.
703 * This is useful for saving the results of dynamic CTF containers.
704 */
705 int
706 ctf_write(ctf_file_t *fp, int fd)
707 {
708 const uchar_t *buf = fp->ctf_base;
709 ssize_t resid = fp->ctf_size;
710 ssize_t len;
711
712 while (resid != 0) {
713 if ((len = write(fd, buf, resid)) <= 0)
714 return (ctf_set_errno(fp, errno));
715 resid -= len;
716 buf += len;
717 }
718
719 return (0);
720 }
721
722 /*
723 * Set the CTF library client version to the specified version. If version is
724 * zero, we just return the default library version number.
725 */
726 int
727 ctf_version(int version)
728 {
729 if (version < 0) {
730 errno = EINVAL;
731 return (-1);
732 }
733
734 if (version > 0) {
735 if (version > CTF_VERSION) {
736 errno = ENOTSUP;
737 return (-1);
738 }
739 ctf_dprintf("ctf_version: client using version %d\n", version);
740 _libctf_version = version;
741 }
742
743 return (_libctf_version);
744 }
745
746 /*
747 * A utility function for folks debugging CTF conversion and merging.
748 */
749 void
750 ctf_phase_dump(ctf_file_t *fp, const char *phase, const char *name)
751 {
752 int fd;
753 static char *base;
754 char path[MAXPATHLEN];
755
756 if (base == NULL && (base = getenv("LIBCTF_WRITE_PHASES")) == NULL)
757 return;
758
759 if (name == NULL)
760 name = "libctf";
761
762 (void) snprintf(path, sizeof (path), "%s/%s.%s.%d.ctf", base, name,
763 phase != NULL ? phase : "",
764 ctf_phase);
765 if ((fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0777)) < 0)
766 return;
767 (void) ctf_write(fp, fd);
768 (void) close(fd);
769 }
770
771 void
772 ctf_phase_bump(void)
773 {
774 ctf_phase++;
775 }
776
777 int
778 ctf_symtab_iter(ctf_file_t *fp, ctf_symtab_f func, void *arg)
779 {
780 ulong_t i;
781 uintptr_t symbase;
782 uintptr_t strbase;
783 const char *file = NULL;
784 boolean_t primary = B_TRUE;
785
786 if (fp->ctf_symtab.cts_data == NULL ||
787 fp->ctf_strtab.cts_data == NULL) {
788 return (ECTF_NOSYMTAB);
789 }
790
791 symbase = (uintptr_t)fp->ctf_symtab.cts_data;
792 strbase = (uintptr_t)fp->ctf_strtab.cts_data;
793
794 for (i = 0; i < fp->ctf_nsyms; i++) {
795 const char *name;
796 int ret;
797 uint_t type;
798 Elf64_Sym sym;
799
800 /*
801 * The CTF library has historically tried to handle large file
802 * offsets itself so that way clients can be unaware of such
803 * isseus. Therefore, we translate everything to a 64-bit ELF
804 * symbol, this is done to make it so that the rest of the
805 * library doesn't have to know about these differences. For
806 * more information see, lib/libctf/common/ctf_lib.c.
807 */
808 if (fp->ctf_symtab.cts_entsize == sizeof (Elf32_Sym)) {
809 const Elf32_Sym *symp = (Elf32_Sym *)symbase + i;
810 uint_t bind, itype;
811
812 sym.st_name = symp->st_name;
813 sym.st_value = symp->st_value;
814 sym.st_size = symp->st_size;
815 bind = ELF32_ST_BIND(symp->st_info);
816 itype = ELF32_ST_TYPE(symp->st_info);
817 sym.st_info = ELF64_ST_INFO(bind, itype);
818 sym.st_other = symp->st_other;
819 sym.st_shndx = symp->st_shndx;
820 } else {
821 const Elf64_Sym *symp = (Elf64_Sym *)symbase + i;
822
823 sym = *symp;
824 }
825
826 type = ELF64_ST_TYPE(sym.st_info);
827 name = (const char *)(strbase + sym.st_name);
828
829 /*
830 * Check first if we have an STT_FILE entry. This is used to
831 * distinguish between various local symbols when merging.
832 */
833 if (type == STT_FILE) {
834 if (file != NULL) {
835 primary = B_FALSE;
836 }
837 file = name;
838 continue;
839 }
840
841 /*
842 * Check if this is a symbol that we care about.
843 */
844 if (!ctf_sym_valid(strbase, type, sym.st_shndx, sym.st_value,
845 sym.st_name)) {
846 continue;
847 }
848
849 if ((ret = func(&sym, i, file, name, primary, arg)) != 0) {
850 return (ret);
851 }
852 }
853
854 return (0);
855 }