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 (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* 27 * Create and parse buffers containing CTF data. 28 */ 29 30 #include <sys/types.h> 31 #include <stdio.h> 32 #include <stdlib.h> 33 #include <strings.h> 34 #include <ctype.h> 35 #include <zlib.h> 36 #include <elf.h> 37 38 #include "ctf_headers.h" 39 #include "ctftools.h" 40 #include "strtab.h" 41 #include "memory.h" 42 43 /* 44 * Name of the file currently being read, used to print error messages. We 45 * assume that only one file will be read at a time, and thus make no attempt 46 * to allow curfile to be used simultaneously by multiple threads. 47 * 48 * The value is only valid during a call to ctf_load. 49 */ 50 char *curfile; 51 52 #define CTF_BUF_CHUNK_SIZE (64 * 1024) 53 #define RES_BUF_CHUNK_SIZE (64 * 1024) 54 55 struct ctf_buf { 56 strtab_t ctb_strtab; /* string table */ 57 caddr_t ctb_base; /* pointer to base of buffer */ 58 caddr_t ctb_end; /* pointer to end of buffer */ 59 caddr_t ctb_ptr; /* pointer to empty buffer space */ 60 size_t ctb_size; /* size of buffer */ 61 int nptent; /* number of processed types */ 62 int ntholes; /* number of type holes */ 63 }; 64 65 /*PRINTFLIKE1*/ 66 static void 67 parseterminate(char *fmt, ...) 68 { 69 static char msgbuf[1024]; /* sigh */ 70 va_list ap; 71 72 va_start(ap, fmt); 73 vsnprintf(msgbuf, sizeof (msgbuf), fmt, ap); 74 va_end(ap); 75 76 terminate("%s: %s\n", curfile, msgbuf); 77 } 78 79 void 80 ctf_buf_grow(ctf_buf_t *b) 81 { 82 off_t ptroff = b->ctb_ptr - b->ctb_base; 83 84 b->ctb_size += CTF_BUF_CHUNK_SIZE; 85 b->ctb_base = xrealloc(b->ctb_base, b->ctb_size); 86 b->ctb_end = b->ctb_base + b->ctb_size; 87 b->ctb_ptr = b->ctb_base + ptroff; 88 } 89 90 ctf_buf_t * 91 ctf_buf_new(void) 92 { 93 ctf_buf_t *b = xcalloc(sizeof (ctf_buf_t)); 94 95 strtab_create(&b->ctb_strtab); 96 ctf_buf_grow(b); 97 98 return (b); 99 } 100 101 void 102 ctf_buf_free(ctf_buf_t *b) 103 { 104 strtab_destroy(&b->ctb_strtab); 105 free(b->ctb_base); 106 free(b); 107 } 108 109 uint_t 110 ctf_buf_cur(ctf_buf_t *b) 111 { 112 return (b->ctb_ptr - b->ctb_base); 113 } 114 115 void 116 ctf_buf_write(ctf_buf_t *b, const void *p, size_t n) 117 { 118 size_t len; 119 120 while (n != 0) { 121 if (b->ctb_ptr == b->ctb_end) 122 ctf_buf_grow(b); 123 124 len = MIN((size_t)(b->ctb_end - b->ctb_ptr), n); 125 bcopy(p, b->ctb_ptr, len); 126 b->ctb_ptr += len; 127 128 p = (char *)p + len; 129 n -= len; 130 } 131 } 132 133 static int 134 write_label(labelent_t *le, ctf_buf_t *b) 135 { 136 ctf_lblent_t ctl; 137 138 ctl.ctl_label = strtab_insert(&b->ctb_strtab, le->le_name); 139 ctl.ctl_typeidx = le->le_idx; 140 141 ctf_buf_write(b, &ctl, sizeof (ctl)); 142 143 return (1); 144 } 145 146 static void 147 write_objects(iidesc_t *idp, ctf_buf_t *b) 148 { 149 ushort_t id = (idp ? idp->ii_dtype->t_id : 0); 150 151 ctf_buf_write(b, &id, sizeof (id)); 152 153 debug(3, "Wrote object %s (%d)\n", (idp ? idp->ii_name : "(null)"), id); 154 } 155 156 static void 157 write_functions(iidesc_t *idp, ctf_buf_t *b) 158 { 159 ushort_t fdata[2]; 160 ushort_t id; 161 int nargs; 162 int i; 163 164 if (!idp) { 165 fdata[0] = 0; 166 ctf_buf_write(b, &fdata[0], sizeof (fdata[0])); 167 168 debug(3, "Wrote function (null)\n"); 169 return; 170 } 171 172 nargs = idp->ii_nargs + (idp->ii_vargs != 0); 173 174 if (nargs > CTF_MAX_VLEN) { 175 terminate("function %s has too many args: %d > %d\n", 176 idp->ii_name, nargs, CTF_MAX_VLEN); 177 } 178 179 fdata[0] = CTF_TYPE_INFO(CTF_K_FUNCTION, 1, nargs); 180 fdata[1] = idp->ii_dtype->t_id; 181 ctf_buf_write(b, fdata, sizeof (fdata)); 182 183 for (i = 0; i < idp->ii_nargs; i++) { 184 id = idp->ii_args[i]->t_id; 185 ctf_buf_write(b, &id, sizeof (id)); 186 } 187 188 if (idp->ii_vargs) { 189 id = 0; 190 ctf_buf_write(b, &id, sizeof (id)); 191 } 192 193 debug(3, "Wrote function %s (%d args)\n", idp->ii_name, nargs); 194 } 195 196 /* 197 * Depending on the size of the type being described, either a ctf_stype_t (for 198 * types with size < CTF_LSTRUCT_THRESH) or a ctf_type_t (all others) will be 199 * written. We isolate the determination here so the rest of the writer code 200 * doesn't need to care. 201 */ 202 static void 203 write_sized_type_rec(ctf_buf_t *b, ctf_type_t *ctt, size_t size) 204 { 205 if (size > CTF_MAX_SIZE) { 206 ctt->ctt_size = CTF_LSIZE_SENT; 207 ctt->ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI(size); 208 ctt->ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO(size); 209 ctf_buf_write(b, ctt, sizeof (*ctt)); 210 } else { 211 ctf_stype_t *cts = (ctf_stype_t *)ctt; 212 213 cts->ctt_size = (ushort_t)size; 214 ctf_buf_write(b, cts, sizeof (*cts)); 215 } 216 } 217 218 static void 219 write_unsized_type_rec(ctf_buf_t *b, ctf_type_t *ctt) 220 { 221 ctf_stype_t *cts = (ctf_stype_t *)ctt; 222 223 ctf_buf_write(b, cts, sizeof (*cts)); 224 } 225 226 static int 227 write_type(tdesc_t *tp, ctf_buf_t *b) 228 { 229 elist_t *ep; 230 mlist_t *mp; 231 intr_t *ip; 232 233 size_t offset; 234 uint_t encoding; 235 uint_t data; 236 int isroot = tp->t_flags & TDESC_F_ISROOT; 237 int i; 238 239 ctf_type_t ctt; 240 ctf_array_t cta; 241 ctf_member_t ctm; 242 ctf_lmember_t ctlm; 243 ctf_enum_t cte; 244 ushort_t id; 245 246 ctlm.ctlm_pad = 0; 247 248 /* 249 * There shouldn't be any holes in the type list (where a hole is 250 * defined as two consecutive tdescs without consecutive ids), but 251 * check for them just in case. If we do find holes, we need to make 252 * fake entries to fill the holes, or we won't be able to reconstruct 253 * the tree from the written data. 254 */ 255 if (++b->nptent < CTF_TYPE_TO_INDEX(tp->t_id)) { 256 debug(2, "genctf: type hole from %d < x < %d\n", 257 b->nptent - 1, CTF_TYPE_TO_INDEX(tp->t_id)); 258 259 ctt.ctt_name = CTF_TYPE_NAME(CTF_STRTAB_0, 0); 260 ctt.ctt_info = CTF_TYPE_INFO(0, 0, 0); 261 while (b->nptent < CTF_TYPE_TO_INDEX(tp->t_id)) { 262 write_sized_type_rec(b, &ctt, 0); 263 b->nptent++; 264 } 265 } 266 267 offset = strtab_insert(&b->ctb_strtab, tp->t_name); 268 ctt.ctt_name = CTF_TYPE_NAME(CTF_STRTAB_0, offset); 269 270 switch (tp->t_type) { 271 case INTRINSIC: 272 ip = tp->t_intr; 273 if (ip->intr_type == INTR_INT) 274 ctt.ctt_info = CTF_TYPE_INFO(CTF_K_INTEGER, 275 isroot, 1); 276 else 277 ctt.ctt_info = CTF_TYPE_INFO(CTF_K_FLOAT, isroot, 1); 278 write_sized_type_rec(b, &ctt, tp->t_size); 279 280 encoding = 0; 281 282 if (ip->intr_type == INTR_INT) { 283 if (ip->intr_signed) 284 encoding |= CTF_INT_SIGNED; 285 if (ip->intr_iformat == 'c') 286 encoding |= CTF_INT_CHAR; 287 else if (ip->intr_iformat == 'b') 288 encoding |= CTF_INT_BOOL; 289 else if (ip->intr_iformat == 'v') 290 encoding |= CTF_INT_VARARGS; 291 } else 292 encoding = ip->intr_fformat; 293 294 data = CTF_INT_DATA(encoding, ip->intr_offset, ip->intr_nbits); 295 ctf_buf_write(b, &data, sizeof (data)); 296 break; 297 298 case POINTER: 299 ctt.ctt_info = CTF_TYPE_INFO(CTF_K_POINTER, isroot, 0); 300 ctt.ctt_type = tp->t_tdesc->t_id; 301 write_unsized_type_rec(b, &ctt); 302 break; 303 304 case ARRAY: 305 ctt.ctt_info = CTF_TYPE_INFO(CTF_K_ARRAY, isroot, 1); 306 write_sized_type_rec(b, &ctt, tp->t_size); 307 308 cta.cta_contents = tp->t_ardef->ad_contents->t_id; 309 cta.cta_index = tp->t_ardef->ad_idxtype->t_id; 310 cta.cta_nelems = tp->t_ardef->ad_nelems; 311 ctf_buf_write(b, &cta, sizeof (cta)); 312 break; 313 314 case STRUCT: 315 case UNION: 316 for (i = 0, mp = tp->t_members; mp != NULL; mp = mp->ml_next) 317 i++; /* count up struct or union members */ 318 319 if (i > CTF_MAX_VLEN) { 320 terminate("sou %s has too many members: %d > %d\n", 321 tdesc_name(tp), i, CTF_MAX_VLEN); 322 } 323 324 if (tp->t_type == STRUCT) 325 ctt.ctt_info = CTF_TYPE_INFO(CTF_K_STRUCT, isroot, i); 326 else 327 ctt.ctt_info = CTF_TYPE_INFO(CTF_K_UNION, isroot, i); 328 329 write_sized_type_rec(b, &ctt, tp->t_size); 330 331 if (tp->t_size < CTF_LSTRUCT_THRESH) { 332 for (mp = tp->t_members; mp != NULL; mp = mp->ml_next) { 333 offset = strtab_insert(&b->ctb_strtab, 334 mp->ml_name); 335 336 ctm.ctm_name = CTF_TYPE_NAME(CTF_STRTAB_0, 337 offset); 338 ctm.ctm_type = mp->ml_type->t_id; 339 ctm.ctm_offset = mp->ml_offset; 340 ctf_buf_write(b, &ctm, sizeof (ctm)); 341 } 342 } else { 343 for (mp = tp->t_members; mp != NULL; mp = mp->ml_next) { 344 offset = strtab_insert(&b->ctb_strtab, 345 mp->ml_name); 346 347 ctlm.ctlm_name = CTF_TYPE_NAME(CTF_STRTAB_0, 348 offset); 349 ctlm.ctlm_type = mp->ml_type->t_id; 350 ctlm.ctlm_offsethi = 351 CTF_OFFSET_TO_LMEMHI(mp->ml_offset); 352 ctlm.ctlm_offsetlo = 353 CTF_OFFSET_TO_LMEMLO(mp->ml_offset); 354 ctf_buf_write(b, &ctlm, sizeof (ctlm)); 355 } 356 } 357 break; 358 359 case ENUM: 360 for (i = 0, ep = tp->t_emem; ep != NULL; ep = ep->el_next) 361 i++; /* count up enum members */ 362 363 if (i > CTF_MAX_VLEN) { 364 terminate("enum %s has too many values: %d > %d\n", 365 tdesc_name(tp), i, CTF_MAX_VLEN); 366 } 367 368 ctt.ctt_info = CTF_TYPE_INFO(CTF_K_ENUM, isroot, i); 369 write_sized_type_rec(b, &ctt, tp->t_size); 370 371 for (ep = tp->t_emem; ep != NULL; ep = ep->el_next) { 372 offset = strtab_insert(&b->ctb_strtab, ep->el_name); 373 cte.cte_name = CTF_TYPE_NAME(CTF_STRTAB_0, offset); 374 cte.cte_value = ep->el_number; 375 ctf_buf_write(b, &cte, sizeof (cte)); 376 } 377 break; 378 379 case FORWARD: 380 ctt.ctt_info = CTF_TYPE_INFO(CTF_K_FORWARD, isroot, 0); 381 ctt.ctt_type = 0; 382 write_unsized_type_rec(b, &ctt); 383 break; 384 385 case TYPEDEF: 386 ctt.ctt_info = CTF_TYPE_INFO(CTF_K_TYPEDEF, isroot, 0); 387 ctt.ctt_type = tp->t_tdesc->t_id; 388 write_unsized_type_rec(b, &ctt); 389 break; 390 391 case VOLATILE: 392 ctt.ctt_info = CTF_TYPE_INFO(CTF_K_VOLATILE, isroot, 0); 393 ctt.ctt_type = tp->t_tdesc->t_id; 394 write_unsized_type_rec(b, &ctt); 395 break; 396 397 case CONST: 398 ctt.ctt_info = CTF_TYPE_INFO(CTF_K_CONST, isroot, 0); 399 ctt.ctt_type = tp->t_tdesc->t_id; 400 write_unsized_type_rec(b, &ctt); 401 break; 402 403 case FUNCTION: 404 i = tp->t_fndef->fn_nargs + tp->t_fndef->fn_vargs; 405 406 if (i > CTF_MAX_VLEN) { 407 terminate("function %s has too many args: %d > %d\n", 408 i, CTF_MAX_VLEN); 409 } 410 411 ctt.ctt_info = CTF_TYPE_INFO(CTF_K_FUNCTION, isroot, i); 412 ctt.ctt_type = tp->t_fndef->fn_ret->t_id; 413 write_unsized_type_rec(b, &ctt); 414 415 for (i = 0; i < tp->t_fndef->fn_nargs; i++) { 416 id = tp->t_fndef->fn_args[i]->t_id; 417 ctf_buf_write(b, &id, sizeof (id)); 418 } 419 420 if (tp->t_fndef->fn_vargs) { 421 id = 0; 422 ctf_buf_write(b, &id, sizeof (id)); 423 i++; 424 } 425 426 if (i & 1) { 427 id = 0; 428 ctf_buf_write(b, &id, sizeof (id)); 429 } 430 break; 431 432 case RESTRICT: 433 ctt.ctt_info = CTF_TYPE_INFO(CTF_K_RESTRICT, isroot, 0); 434 ctt.ctt_type = tp->t_tdesc->t_id; 435 write_unsized_type_rec(b, &ctt); 436 break; 437 438 default: 439 warning("Can't write unknown type %d\n", tp->t_type); 440 } 441 442 debug(3, "Wrote type %d %s\n", tp->t_id, tdesc_name(tp)); 443 444 return (1); 445 } 446 447 typedef struct resbuf { 448 caddr_t rb_base; 449 caddr_t rb_ptr; 450 size_t rb_size; 451 z_stream rb_zstr; 452 } resbuf_t; 453 454 static void 455 rbzs_grow(resbuf_t *rb) 456 { 457 off_t ptroff = (caddr_t)rb->rb_zstr.next_out - rb->rb_base; 458 459 rb->rb_size += RES_BUF_CHUNK_SIZE; 460 rb->rb_base = xrealloc(rb->rb_base, rb->rb_size); 461 rb->rb_ptr = rb->rb_base + ptroff; 462 rb->rb_zstr.next_out = (Bytef *)(rb->rb_ptr); 463 rb->rb_zstr.avail_out += RES_BUF_CHUNK_SIZE; 464 } 465 466 static void 467 compress_start(resbuf_t *rb) 468 { 469 int rc; 470 471 rb->rb_zstr.zalloc = (alloc_func)0; 472 rb->rb_zstr.zfree = (free_func)0; 473 rb->rb_zstr.opaque = (voidpf)0; 474 475 if ((rc = deflateInit(&rb->rb_zstr, Z_BEST_COMPRESSION)) != Z_OK) 476 parseterminate("zlib start failed: %s", zError(rc)); 477 } 478 479 static ssize_t 480 compress_buffer(const void *buf, size_t n, void *data) 481 { 482 resbuf_t *rb = (resbuf_t *)data; 483 int rc; 484 485 rb->rb_zstr.next_out = (Bytef *)rb->rb_ptr; 486 rb->rb_zstr.avail_out = rb->rb_size - (rb->rb_ptr - rb->rb_base); 487 rb->rb_zstr.next_in = (Bytef *)buf; 488 rb->rb_zstr.avail_in = n; 489 490 while (rb->rb_zstr.avail_in) { 491 if (rb->rb_zstr.avail_out == 0) 492 rbzs_grow(rb); 493 494 if ((rc = deflate(&rb->rb_zstr, Z_NO_FLUSH)) != Z_OK) 495 parseterminate("zlib deflate failed: %s", zError(rc)); 496 } 497 rb->rb_ptr = (caddr_t)rb->rb_zstr.next_out; 498 499 return (n); 500 } 501 502 static void 503 compress_flush(resbuf_t *rb, int type) 504 { 505 int rc; 506 507 for (;;) { 508 if (rb->rb_zstr.avail_out == 0) 509 rbzs_grow(rb); 510 511 rc = deflate(&rb->rb_zstr, type); 512 if ((type == Z_FULL_FLUSH && rc == Z_BUF_ERROR) || 513 (type == Z_FINISH && rc == Z_STREAM_END)) 514 break; 515 else if (rc != Z_OK) 516 parseterminate("zlib finish failed: %s", zError(rc)); 517 } 518 rb->rb_ptr = (caddr_t)rb->rb_zstr.next_out; 519 } 520 521 static void 522 compress_end(resbuf_t *rb) 523 { 524 int rc; 525 526 compress_flush(rb, Z_FINISH); 527 528 if ((rc = deflateEnd(&rb->rb_zstr)) != Z_OK) 529 parseterminate("zlib end failed: %s", zError(rc)); 530 } 531 532 /* 533 * Pad the buffer to a power-of-2 boundary 534 */ 535 static void 536 pad_buffer(ctf_buf_t *buf, int align) 537 { 538 uint_t cur = ctf_buf_cur(buf); 539 ssize_t topad = (align - (cur % align)) % align; 540 static const char pad[8] = { 0 }; 541 542 while (topad > 0) { 543 ctf_buf_write(buf, pad, (topad > 8 ? 8 : topad)); 544 topad -= 8; 545 } 546 } 547 548 static ssize_t 549 bcopy_data(const void *buf, size_t n, void *data) 550 { 551 caddr_t *posp = (caddr_t *)data; 552 bcopy(buf, *posp, n); 553 *posp += n; 554 return (n); 555 } 556 557 static caddr_t 558 write_buffer(ctf_header_t *h, ctf_buf_t *buf, size_t *resszp) 559 { 560 caddr_t outbuf; 561 caddr_t bufpos; 562 563 outbuf = xmalloc(sizeof (ctf_header_t) + (buf->ctb_ptr - buf->ctb_base) 564 + buf->ctb_strtab.str_size); 565 566 bufpos = outbuf; 567 (void) bcopy_data(h, sizeof (ctf_header_t), &bufpos); 568 (void) bcopy_data(buf->ctb_base, buf->ctb_ptr - buf->ctb_base, 569 &bufpos); 570 (void) strtab_write(&buf->ctb_strtab, bcopy_data, &bufpos); 571 *resszp = bufpos - outbuf; 572 return (outbuf); 573 } 574 575 /* 576 * Create the compression buffer, and fill it with the CTF and string 577 * table data. We flush the compression state between the two so the 578 * dictionary used for the string tables won't be polluted with values 579 * that made sense for the CTF data. 580 */ 581 static caddr_t 582 write_compressed_buffer(ctf_header_t *h, ctf_buf_t *buf, size_t *resszp) 583 { 584 resbuf_t resbuf; 585 resbuf.rb_size = RES_BUF_CHUNK_SIZE; 586 resbuf.rb_base = xmalloc(resbuf.rb_size); 587 bcopy(h, resbuf.rb_base, sizeof (ctf_header_t)); 588 resbuf.rb_ptr = resbuf.rb_base + sizeof (ctf_header_t); 589 590 compress_start(&resbuf); 591 (void) compress_buffer(buf->ctb_base, buf->ctb_ptr - buf->ctb_base, 592 &resbuf); 593 compress_flush(&resbuf, Z_FULL_FLUSH); 594 (void) strtab_write(&buf->ctb_strtab, compress_buffer, &resbuf); 595 compress_end(&resbuf); 596 597 *resszp = (resbuf.rb_ptr - resbuf.rb_base); 598 return (resbuf.rb_base); 599 } 600 601 caddr_t 602 ctf_gen(iiburst_t *iiburst, size_t *resszp, int do_compress) 603 { 604 ctf_buf_t *buf = ctf_buf_new(); 605 ctf_header_t h; 606 caddr_t outbuf; 607 608 int i; 609 610 /* 611 * Prepare the header, and create the CTF output buffers. The data 612 * object section and function section are both lists of 2-byte 613 * integers; we pad these out to the next 4-byte boundary if needed. 614 */ 615 h.cth_magic = CTF_MAGIC; 616 h.cth_version = CTF_VERSION; 617 h.cth_flags = do_compress ? CTF_F_COMPRESS : 0; 618 h.cth_parlabel = strtab_insert(&buf->ctb_strtab, 619 iiburst->iib_td->td_parlabel); 620 h.cth_parname = strtab_insert(&buf->ctb_strtab, 621 iiburst->iib_td->td_parname); 622 623 h.cth_lbloff = 0; 624 (void) list_iter(iiburst->iib_td->td_labels, (int (*)())write_label, 625 buf); 626 627 pad_buffer(buf, 2); 628 h.cth_objtoff = ctf_buf_cur(buf); 629 for (i = 0; i < iiburst->iib_nobjts; i++) 630 write_objects(iiburst->iib_objts[i], buf); 631 632 pad_buffer(buf, 2); 633 h.cth_funcoff = ctf_buf_cur(buf); 634 for (i = 0; i < iiburst->iib_nfuncs; i++) 635 write_functions(iiburst->iib_funcs[i], buf); 636 637 pad_buffer(buf, 4); 638 h.cth_typeoff = ctf_buf_cur(buf); 639 (void) list_iter(iiburst->iib_types, (int (*)())write_type, buf); 640 641 debug(2, "CTF wrote %d types\n", list_count(iiburst->iib_types)); 642 643 h.cth_stroff = ctf_buf_cur(buf); 644 h.cth_strlen = strtab_size(&buf->ctb_strtab); 645 646 /* 647 * We only do compression for ctfmerge, as ctfconvert is only 648 * supposed to be used on intermediary build objects. This is 649 * significantly faster. 650 */ 651 if (do_compress) 652 outbuf = write_compressed_buffer(&h, buf, resszp); 653 else 654 outbuf = write_buffer(&h, buf, resszp); 655 656 ctf_buf_free(buf); 657 return (outbuf); 658 } 659 660 void 661 get_ctt_size(ctf_type_t *ctt, size_t *sizep, size_t *incrementp) 662 { 663 if (ctt->ctt_size == CTF_LSIZE_SENT) { 664 *sizep = (size_t)CTF_TYPE_LSIZE(ctt); 665 *incrementp = sizeof (ctf_type_t); 666 } else { 667 *sizep = ctt->ctt_size; 668 *incrementp = sizeof (ctf_stype_t); 669 } 670 } 671 672 static int 673 count_types(ctf_header_t *h, caddr_t data) 674 { 675 caddr_t dptr = data + h->cth_typeoff; 676 int count = 0; 677 678 dptr = data + h->cth_typeoff; 679 while (dptr < data + h->cth_stroff) { 680 /* LINTED - pointer alignment */ 681 ctf_type_t *ctt = (ctf_type_t *)dptr; 682 size_t vlen = CTF_INFO_VLEN(ctt->ctt_info); 683 size_t size, increment; 684 685 get_ctt_size(ctt, &size, &increment); 686 687 switch (CTF_INFO_KIND(ctt->ctt_info)) { 688 case CTF_K_INTEGER: 689 case CTF_K_FLOAT: 690 dptr += 4; 691 break; 692 case CTF_K_POINTER: 693 case CTF_K_FORWARD: 694 case CTF_K_TYPEDEF: 695 case CTF_K_VOLATILE: 696 case CTF_K_CONST: 697 case CTF_K_RESTRICT: 698 case CTF_K_FUNCTION: 699 dptr += sizeof (ushort_t) * (vlen + (vlen & 1)); 700 break; 701 case CTF_K_ARRAY: 702 dptr += sizeof (ctf_array_t); 703 break; 704 case CTF_K_STRUCT: 705 case CTF_K_UNION: 706 if (size < CTF_LSTRUCT_THRESH) 707 dptr += sizeof (ctf_member_t) * vlen; 708 else 709 dptr += sizeof (ctf_lmember_t) * vlen; 710 break; 711 case CTF_K_ENUM: 712 dptr += sizeof (ctf_enum_t) * vlen; 713 break; 714 case CTF_K_UNKNOWN: 715 break; 716 default: 717 parseterminate("Unknown CTF type %d (#%d) at %#x", 718 CTF_INFO_KIND(ctt->ctt_info), count, dptr - data); 719 } 720 721 dptr += increment; 722 count++; 723 } 724 725 debug(3, "CTF read %d types\n", count); 726 727 return (count); 728 } 729 730 /* 731 * Resurrect the labels stored in the CTF data, returning the index associated 732 * with a label provided by the caller. There are several cases, outlined 733 * below. Note that, given two labels, the one associated with the lesser type 734 * index is considered to be older than the other. 735 * 736 * 1. matchlbl == NULL - return the index of the most recent label. 737 * 2. matchlbl == "BASE" - return the index of the oldest label. 738 * 3. matchlbl != NULL, but doesn't match any labels in the section - warn 739 * the user, and proceed as if matchlbl == "BASE" (for safety). 740 * 4. matchlbl != NULL, and matches one of the labels in the section - return 741 * the type index associated with the label. 742 */ 743 static int 744 resurrect_labels(ctf_header_t *h, tdata_t *td, caddr_t ctfdata, char *matchlbl) 745 { 746 caddr_t buf = ctfdata + h->cth_lbloff; 747 caddr_t sbuf = ctfdata + h->cth_stroff; 748 size_t bufsz = h->cth_objtoff - h->cth_lbloff; 749 int lastidx = 0, baseidx = -1; 750 char *baselabel; 751 ctf_lblent_t *ctl; 752 753 /* LINTED - pointer alignment */ 754 for (ctl = (ctf_lblent_t *)buf; (caddr_t)ctl < buf + bufsz; ctl++) { 755 char *label = sbuf + ctl->ctl_label; 756 757 lastidx = ctl->ctl_typeidx; 758 759 debug(3, "Resurrected label %s type idx %d\n", label, lastidx); 760 761 tdata_label_add(td, label, lastidx); 762 763 if (baseidx == -1) { 764 baseidx = lastidx; 765 baselabel = label; 766 if (matchlbl != NULL && streq(matchlbl, "BASE")) 767 return (lastidx); 768 } 769 770 if (matchlbl != NULL && streq(label, matchlbl)) 771 return (lastidx); 772 } 773 774 if (matchlbl != NULL) { 775 /* User provided a label that didn't match */ 776 warning("%s: Cannot find label `%s' - using base (%s)\n", 777 curfile, matchlbl, (baselabel ? baselabel : "NONE")); 778 779 tdata_label_free(td); 780 tdata_label_add(td, baselabel, baseidx); 781 782 return (baseidx); 783 } 784 785 return (lastidx); 786 } 787 788 static void 789 resurrect_objects(ctf_header_t *h, tdata_t *td, tdesc_t **tdarr, int tdsize, 790 caddr_t ctfdata, symit_data_t *si) 791 { 792 caddr_t buf = ctfdata + h->cth_objtoff; 793 size_t bufsz = h->cth_funcoff - h->cth_objtoff; 794 caddr_t dptr; 795 796 symit_reset(si); 797 for (dptr = buf; dptr < buf + bufsz; dptr += 2) { 798 /* LINTED - pointer alignment */ 799 ushort_t id = *((ushort_t *)dptr); 800 iidesc_t *ii; 801 GElf_Sym *sym; 802 803 if (!(sym = symit_next(si, STT_OBJECT)) && id != 0) { 804 parseterminate( 805 "Unexpected end of object symbols at %x of %x", 806 dptr - buf, bufsz); 807 } 808 809 if (id == 0) { 810 debug(3, "Skipping null object\n"); 811 continue; 812 } else if (id >= tdsize) { 813 parseterminate("Reference to invalid type %d", id); 814 } 815 816 ii = iidesc_new(symit_name(si)); 817 ii->ii_dtype = tdarr[id]; 818 if (GELF_ST_BIND(sym->st_info) == STB_LOCAL) { 819 ii->ii_type = II_SVAR; 820 ii->ii_owner = xstrdup(symit_curfile(si)); 821 } else 822 ii->ii_type = II_GVAR; 823 hash_add(td->td_iihash, ii); 824 825 debug(3, "Resurrected %s object %s (%d) from %s\n", 826 (ii->ii_type == II_GVAR ? "global" : "static"), 827 ii->ii_name, id, (ii->ii_owner ? ii->ii_owner : "(none)")); 828 } 829 } 830 831 static void 832 resurrect_functions(ctf_header_t *h, tdata_t *td, tdesc_t **tdarr, int tdsize, 833 caddr_t ctfdata, symit_data_t *si) 834 { 835 caddr_t buf = ctfdata + h->cth_funcoff; 836 size_t bufsz = h->cth_typeoff - h->cth_funcoff; 837 caddr_t dptr = buf; 838 iidesc_t *ii; 839 ushort_t info; 840 ushort_t retid; 841 GElf_Sym *sym; 842 int i; 843 844 symit_reset(si); 845 while (dptr < buf + bufsz) { 846 /* LINTED - pointer alignment */ 847 info = *((ushort_t *)dptr); 848 dptr += 2; 849 850 if (!(sym = symit_next(si, STT_FUNC)) && info != 0) 851 parseterminate("Unexpected end of function symbols"); 852 853 if (info == 0) { 854 debug(3, "Skipping null function (%s)\n", 855 symit_name(si)); 856 continue; 857 } 858 859 /* LINTED - pointer alignment */ 860 retid = *((ushort_t *)dptr); 861 dptr += 2; 862 863 if (retid >= tdsize) 864 parseterminate("Reference to invalid type %d", retid); 865 866 ii = iidesc_new(symit_name(si)); 867 ii->ii_dtype = tdarr[retid]; 868 if (GELF_ST_BIND(sym->st_info) == STB_LOCAL) { 869 ii->ii_type = II_SFUN; 870 ii->ii_owner = xstrdup(symit_curfile(si)); 871 } else 872 ii->ii_type = II_GFUN; 873 ii->ii_nargs = CTF_INFO_VLEN(info); 874 if (ii->ii_nargs) 875 ii->ii_args = 876 xmalloc(sizeof (tdesc_t *) * ii->ii_nargs); 877 878 for (i = 0; i < ii->ii_nargs; i++, dptr += 2) { 879 /* LINTED - pointer alignment */ 880 ushort_t id = *((ushort_t *)dptr); 881 if (id >= tdsize) 882 parseterminate("Reference to invalid type %d", 883 id); 884 ii->ii_args[i] = tdarr[id]; 885 } 886 887 if (ii->ii_nargs && ii->ii_args[ii->ii_nargs - 1] == NULL) { 888 ii->ii_nargs--; 889 ii->ii_vargs = 1; 890 } 891 892 hash_add(td->td_iihash, ii); 893 894 debug(3, "Resurrected %s function %s (%d, %d args)\n", 895 (ii->ii_type == II_GFUN ? "global" : "static"), 896 ii->ii_name, retid, ii->ii_nargs); 897 } 898 } 899 900 static void 901 resurrect_types(ctf_header_t *h, tdata_t *td, tdesc_t **tdarr, int tdsize, 902 caddr_t ctfdata, int maxid) 903 { 904 caddr_t buf = ctfdata + h->cth_typeoff; 905 size_t bufsz = h->cth_stroff - h->cth_typeoff; 906 caddr_t sbuf = ctfdata + h->cth_stroff; 907 caddr_t dptr = buf; 908 tdesc_t *tdp; 909 uint_t data; 910 uint_t encoding; 911 size_t size, increment; 912 int tcnt; 913 int iicnt = 0; 914 tid_t tid, argid; 915 int kind, vlen; 916 int i; 917 918 elist_t **epp; 919 mlist_t **mpp; 920 intr_t *ip; 921 922 ctf_type_t *ctt; 923 ctf_array_t *cta; 924 ctf_enum_t *cte; 925 926 /* 927 * A maxid of zero indicates a request to resurrect all types, so reset 928 * maxid to the maximum type id. 929 */ 930 if (maxid == 0) 931 maxid = CTF_MAX_TYPE; 932 933 for (dptr = buf, tcnt = 0, tid = 1; dptr < buf + bufsz; tcnt++, tid++) { 934 if (tid > maxid) 935 break; 936 937 if (tid >= tdsize) 938 parseterminate("Reference to invalid type %d", tid); 939 940 /* LINTED - pointer alignment */ 941 ctt = (ctf_type_t *)dptr; 942 943 get_ctt_size(ctt, &size, &increment); 944 dptr += increment; 945 946 tdp = tdarr[tid]; 947 948 if (CTF_NAME_STID(ctt->ctt_name) != CTF_STRTAB_0) 949 parseterminate( 950 "Unable to cope with non-zero strtab id"); 951 if (CTF_NAME_OFFSET(ctt->ctt_name) != 0) { 952 tdp->t_name = 953 xstrdup(sbuf + CTF_NAME_OFFSET(ctt->ctt_name)); 954 } else 955 tdp->t_name = NULL; 956 957 kind = CTF_INFO_KIND(ctt->ctt_info); 958 vlen = CTF_INFO_VLEN(ctt->ctt_info); 959 960 switch (kind) { 961 case CTF_K_INTEGER: 962 tdp->t_type = INTRINSIC; 963 tdp->t_size = size; 964 965 /* LINTED - pointer alignment */ 966 data = *((uint_t *)dptr); 967 dptr += sizeof (uint_t); 968 encoding = CTF_INT_ENCODING(data); 969 970 ip = xmalloc(sizeof (intr_t)); 971 ip->intr_type = INTR_INT; 972 ip->intr_signed = (encoding & CTF_INT_SIGNED) ? 1 : 0; 973 974 if (encoding & CTF_INT_CHAR) 975 ip->intr_iformat = 'c'; 976 else if (encoding & CTF_INT_BOOL) 977 ip->intr_iformat = 'b'; 978 else if (encoding & CTF_INT_VARARGS) 979 ip->intr_iformat = 'v'; 980 else 981 ip->intr_iformat = '\0'; 982 983 ip->intr_offset = CTF_INT_OFFSET(data); 984 ip->intr_nbits = CTF_INT_BITS(data); 985 tdp->t_intr = ip; 986 break; 987 988 case CTF_K_FLOAT: 989 tdp->t_type = INTRINSIC; 990 tdp->t_size = size; 991 992 /* LINTED - pointer alignment */ 993 data = *((uint_t *)dptr); 994 dptr += sizeof (uint_t); 995 996 ip = xcalloc(sizeof (intr_t)); 997 ip->intr_type = INTR_REAL; 998 ip->intr_fformat = CTF_FP_ENCODING(data); 999 ip->intr_offset = CTF_FP_OFFSET(data); 1000 ip->intr_nbits = CTF_FP_BITS(data); 1001 tdp->t_intr = ip; 1002 break; 1003 1004 case CTF_K_POINTER: 1005 tdp->t_type = POINTER; 1006 tdp->t_tdesc = tdarr[ctt->ctt_type]; 1007 break; 1008 1009 case CTF_K_ARRAY: 1010 tdp->t_type = ARRAY; 1011 tdp->t_size = size; 1012 1013 /* LINTED - pointer alignment */ 1014 cta = (ctf_array_t *)dptr; 1015 dptr += sizeof (ctf_array_t); 1016 1017 tdp->t_ardef = xmalloc(sizeof (ardef_t)); 1018 tdp->t_ardef->ad_contents = tdarr[cta->cta_contents]; 1019 tdp->t_ardef->ad_idxtype = tdarr[cta->cta_index]; 1020 tdp->t_ardef->ad_nelems = cta->cta_nelems; 1021 break; 1022 1023 case CTF_K_STRUCT: 1024 case CTF_K_UNION: 1025 tdp->t_type = (kind == CTF_K_STRUCT ? STRUCT : UNION); 1026 tdp->t_size = size; 1027 1028 if (size < CTF_LSTRUCT_THRESH) { 1029 for (i = 0, mpp = &tdp->t_members; i < vlen; 1030 i++, mpp = &((*mpp)->ml_next)) { 1031 /* LINTED - pointer alignment */ 1032 ctf_member_t *ctm = (ctf_member_t *) 1033 dptr; 1034 dptr += sizeof (ctf_member_t); 1035 1036 *mpp = xmalloc(sizeof (mlist_t)); 1037 (*mpp)->ml_name = xstrdup(sbuf + 1038 ctm->ctm_name); 1039 (*mpp)->ml_type = tdarr[ctm->ctm_type]; 1040 (*mpp)->ml_offset = ctm->ctm_offset; 1041 (*mpp)->ml_size = 0; 1042 } 1043 } else { 1044 for (i = 0, mpp = &tdp->t_members; i < vlen; 1045 i++, mpp = &((*mpp)->ml_next)) { 1046 /* LINTED - pointer alignment */ 1047 ctf_lmember_t *ctlm = (ctf_lmember_t *) 1048 dptr; 1049 dptr += sizeof (ctf_lmember_t); 1050 1051 *mpp = xmalloc(sizeof (mlist_t)); 1052 (*mpp)->ml_name = xstrdup(sbuf + 1053 ctlm->ctlm_name); 1054 (*mpp)->ml_type = 1055 tdarr[ctlm->ctlm_type]; 1056 (*mpp)->ml_offset = 1057 (int)CTF_LMEM_OFFSET(ctlm); 1058 (*mpp)->ml_size = 0; 1059 } 1060 } 1061 1062 *mpp = NULL; 1063 break; 1064 1065 case CTF_K_ENUM: 1066 tdp->t_type = ENUM; 1067 tdp->t_size = size; 1068 1069 for (i = 0, epp = &tdp->t_emem; i < vlen; 1070 i++, epp = &((*epp)->el_next)) { 1071 /* LINTED - pointer alignment */ 1072 cte = (ctf_enum_t *)dptr; 1073 dptr += sizeof (ctf_enum_t); 1074 1075 *epp = xmalloc(sizeof (elist_t)); 1076 (*epp)->el_name = xstrdup(sbuf + cte->cte_name); 1077 (*epp)->el_number = cte->cte_value; 1078 } 1079 *epp = NULL; 1080 break; 1081 1082 case CTF_K_FORWARD: 1083 tdp->t_type = FORWARD; 1084 list_add(&td->td_fwdlist, tdp); 1085 break; 1086 1087 case CTF_K_TYPEDEF: 1088 tdp->t_type = TYPEDEF; 1089 tdp->t_tdesc = tdarr[ctt->ctt_type]; 1090 break; 1091 1092 case CTF_K_VOLATILE: 1093 tdp->t_type = VOLATILE; 1094 tdp->t_tdesc = tdarr[ctt->ctt_type]; 1095 break; 1096 1097 case CTF_K_CONST: 1098 tdp->t_type = CONST; 1099 tdp->t_tdesc = tdarr[ctt->ctt_type]; 1100 break; 1101 1102 case CTF_K_FUNCTION: 1103 tdp->t_type = FUNCTION; 1104 tdp->t_fndef = xcalloc(sizeof (fndef_t)); 1105 tdp->t_fndef->fn_ret = tdarr[ctt->ctt_type]; 1106 1107 /* LINTED - pointer alignment */ 1108 if (vlen > 0 && *(ushort_t *)(dptr + 1109 (sizeof (ushort_t) * (vlen - 1))) == 0) 1110 tdp->t_fndef->fn_vargs = 1; 1111 1112 tdp->t_fndef->fn_nargs = vlen - tdp->t_fndef->fn_vargs; 1113 tdp->t_fndef->fn_args = xcalloc(sizeof (tdesc_t) * 1114 vlen - tdp->t_fndef->fn_vargs); 1115 1116 for (i = 0; i < vlen; i++) { 1117 /* LINTED - pointer alignment */ 1118 argid = *(ushort_t *)dptr; 1119 dptr += sizeof (ushort_t); 1120 1121 if (argid != 0) 1122 tdp->t_fndef->fn_args[i] = tdarr[argid]; 1123 } 1124 1125 if (vlen & 1) 1126 dptr += sizeof (ushort_t); 1127 break; 1128 1129 case CTF_K_RESTRICT: 1130 tdp->t_type = RESTRICT; 1131 tdp->t_tdesc = tdarr[ctt->ctt_type]; 1132 break; 1133 1134 case CTF_K_UNKNOWN: 1135 break; 1136 1137 default: 1138 warning("Can't parse unknown CTF type %d\n", kind); 1139 } 1140 1141 if (CTF_INFO_ISROOT(ctt->ctt_info)) { 1142 iidesc_t *ii = iidesc_new(tdp->t_name); 1143 if (tdp->t_type == STRUCT || tdp->t_type == UNION || 1144 tdp->t_type == ENUM) 1145 ii->ii_type = II_SOU; 1146 else 1147 ii->ii_type = II_TYPE; 1148 ii->ii_dtype = tdp; 1149 hash_add(td->td_iihash, ii); 1150 1151 iicnt++; 1152 } 1153 1154 debug(3, "Resurrected %d %stype %s (%d)\n", tdp->t_type, 1155 (CTF_INFO_ISROOT(ctt->ctt_info) ? "root " : ""), 1156 tdesc_name(tdp), tdp->t_id); 1157 } 1158 1159 debug(3, "Resurrected %d types (%d were roots)\n", tcnt, iicnt); 1160 } 1161 1162 /* 1163 * For lack of other inspiration, we're going to take the boring route. We 1164 * count the number of types. This lets us malloc that many tdesc structs 1165 * before we start filling them in. This has the advantage of allowing us to 1166 * avoid a merge-esque remap step. 1167 */ 1168 static tdata_t * 1169 ctf_parse(ctf_header_t *h, caddr_t buf, symit_data_t *si, char *label) 1170 { 1171 tdata_t *td = tdata_new(); 1172 tdesc_t **tdarr; 1173 int ntypes = count_types(h, buf); 1174 int idx, i; 1175 1176 /* shudder */ 1177 tdarr = xcalloc(sizeof (tdesc_t *) * (ntypes + 1)); 1178 tdarr[0] = NULL; 1179 for (i = 1; i <= ntypes; i++) { 1180 tdarr[i] = xcalloc(sizeof (tdesc_t)); 1181 tdarr[i]->t_id = i; 1182 } 1183 1184 td->td_parlabel = xstrdup(buf + h->cth_stroff + h->cth_parlabel); 1185 1186 /* we have the technology - we can rebuild them */ 1187 idx = resurrect_labels(h, td, buf, label); 1188 1189 resurrect_objects(h, td, tdarr, ntypes + 1, buf, si); 1190 resurrect_functions(h, td, tdarr, ntypes + 1, buf, si); 1191 resurrect_types(h, td, tdarr, ntypes + 1, buf, idx); 1192 1193 free(tdarr); 1194 1195 td->td_nextid = ntypes + 1; 1196 1197 return (td); 1198 } 1199 1200 static size_t 1201 decompress_ctf(caddr_t cbuf, size_t cbufsz, caddr_t dbuf, size_t dbufsz) 1202 { 1203 z_stream zstr; 1204 int rc; 1205 1206 zstr.zalloc = (alloc_func)0; 1207 zstr.zfree = (free_func)0; 1208 zstr.opaque = (voidpf)0; 1209 1210 zstr.next_in = (Bytef *)cbuf; 1211 zstr.avail_in = cbufsz; 1212 zstr.next_out = (Bytef *)dbuf; 1213 zstr.avail_out = dbufsz; 1214 1215 if ((rc = inflateInit(&zstr)) != Z_OK || 1216 (rc = inflate(&zstr, Z_NO_FLUSH)) != Z_STREAM_END || 1217 (rc = inflateEnd(&zstr)) != Z_OK) { 1218 warning("CTF decompress zlib error %s\n", zError(rc)); 1219 return (0); 1220 } 1221 1222 debug(3, "reflated %lu bytes to %lu, pointer at %d\n", 1223 zstr.total_in, zstr.total_out, (caddr_t)zstr.next_in - cbuf); 1224 1225 return (zstr.total_out); 1226 } 1227 1228 /* 1229 * Reconstruct the type tree from a given buffer of CTF data. Only the types 1230 * up to the type associated with the provided label, inclusive, will be 1231 * reconstructed. If a NULL label is provided, all types will be reconstructed. 1232 * 1233 * This function won't work on files that have been uniquified. 1234 */ 1235 tdata_t * 1236 ctf_load(char *file, caddr_t buf, size_t bufsz, symit_data_t *si, char *label) 1237 { 1238 ctf_header_t *h; 1239 caddr_t ctfdata; 1240 size_t ctfdatasz; 1241 tdata_t *td; 1242 1243 curfile = file; 1244 1245 if (bufsz < sizeof (ctf_header_t)) 1246 parseterminate("Corrupt CTF - short header"); 1247 1248 /* LINTED - pointer alignment */ 1249 h = (ctf_header_t *)buf; 1250 buf += sizeof (ctf_header_t); 1251 bufsz -= sizeof (ctf_header_t); 1252 1253 if (h->cth_magic != CTF_MAGIC) 1254 parseterminate("Corrupt CTF - bad magic 0x%x", h->cth_magic); 1255 1256 if (h->cth_version != CTF_VERSION) 1257 parseterminate("Unknown CTF version %d", h->cth_version); 1258 1259 ctfdatasz = h->cth_stroff + h->cth_strlen; 1260 if (h->cth_flags & CTF_F_COMPRESS) { 1261 size_t actual; 1262 1263 ctfdata = xmalloc(ctfdatasz); 1264 if ((actual = decompress_ctf(buf, bufsz, ctfdata, ctfdatasz)) != 1265 ctfdatasz) { 1266 parseterminate("Corrupt CTF - short decompression " 1267 "(was %d, expecting %d)", actual, ctfdatasz); 1268 } 1269 } else { 1270 ctfdata = buf; 1271 ctfdatasz = bufsz; 1272 } 1273 1274 td = ctf_parse(h, ctfdata, si, label); 1275 1276 if (h->cth_flags & CTF_F_COMPRESS) 1277 free(ctfdata); 1278 1279 curfile = NULL; 1280 1281 return (td); 1282 } 1283