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