1 /* Opening CTF files. 2 Copyright (C) 2019-2020 Free Software Foundation, Inc. 3 4 This file is part of libctf. 5 6 libctf is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 This program is distributed in the hope that it will be useful, but 12 WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 14 See the GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; see the file COPYING. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #include <ctf-impl.h> 21 #include <stddef.h> 22 #include <string.h> 23 #include <sys/types.h> 24 #include <elf.h> 25 #include <assert.h> 26 #include "swap.h" 27 #include <bfd.h> 28 #include <zlib.h> 29 30 #include "elf-bfd.h" 31 32 static const ctf_dmodel_t _libctf_models[] = { 33 {"ILP32", CTF_MODEL_ILP32, 4, 1, 2, 4, 4}, 34 {"LP64", CTF_MODEL_LP64, 8, 1, 2, 4, 8}, 35 {NULL, 0, 0, 0, 0, 0, 0} 36 }; 37 38 const char _CTF_SECTION[] = ".ctf"; 39 const char _CTF_NULLSTR[] = ""; 40 41 /* Version-sensitive accessors. */ 42 43 static uint32_t 44 get_kind_v1 (uint32_t info) 45 { 46 return (CTF_V1_INFO_KIND (info)); 47 } 48 49 static uint32_t 50 get_root_v1 (uint32_t info) 51 { 52 return (CTF_V1_INFO_ISROOT (info)); 53 } 54 55 static uint32_t 56 get_vlen_v1 (uint32_t info) 57 { 58 return (CTF_V1_INFO_VLEN (info)); 59 } 60 61 static uint32_t 62 get_kind_v2 (uint32_t info) 63 { 64 return (CTF_V2_INFO_KIND (info)); 65 } 66 67 static uint32_t 68 get_root_v2 (uint32_t info) 69 { 70 return (CTF_V2_INFO_ISROOT (info)); 71 } 72 73 static uint32_t 74 get_vlen_v2 (uint32_t info) 75 { 76 return (CTF_V2_INFO_VLEN (info)); 77 } 78 79 static inline ssize_t 80 get_ctt_size_common (const ctf_file_t *fp _libctf_unused_, 81 const ctf_type_t *tp _libctf_unused_, 82 ssize_t *sizep, ssize_t *incrementp, size_t lsize, 83 size_t csize, size_t ctf_type_size, 84 size_t ctf_stype_size, size_t ctf_lsize_sent) 85 { 86 ssize_t size, increment; 87 88 if (csize == ctf_lsize_sent) 89 { 90 size = lsize; 91 increment = ctf_type_size; 92 } 93 else 94 { 95 size = csize; 96 increment = ctf_stype_size; 97 } 98 99 if (sizep) 100 *sizep = size; 101 if (incrementp) 102 *incrementp = increment; 103 104 return size; 105 } 106 107 static ssize_t 108 get_ctt_size_v1 (const ctf_file_t *fp, const ctf_type_t *tp, 109 ssize_t *sizep, ssize_t *incrementp) 110 { 111 ctf_type_v1_t *t1p = (ctf_type_v1_t *) tp; 112 113 return (get_ctt_size_common (fp, tp, sizep, incrementp, 114 CTF_TYPE_LSIZE (t1p), t1p->ctt_size, 115 sizeof (ctf_type_v1_t), sizeof (ctf_stype_v1_t), 116 CTF_LSIZE_SENT_V1)); 117 } 118 119 /* Return the size that a v1 will be once it is converted to v2. */ 120 121 static ssize_t 122 get_ctt_size_v2_unconverted (const ctf_file_t *fp, const ctf_type_t *tp, 123 ssize_t *sizep, ssize_t *incrementp) 124 { 125 ctf_type_v1_t *t1p = (ctf_type_v1_t *) tp; 126 127 return (get_ctt_size_common (fp, tp, sizep, incrementp, 128 CTF_TYPE_LSIZE (t1p), t1p->ctt_size, 129 sizeof (ctf_type_t), sizeof (ctf_stype_t), 130 CTF_LSIZE_SENT)); 131 } 132 133 static ssize_t 134 get_ctt_size_v2 (const ctf_file_t *fp, const ctf_type_t *tp, 135 ssize_t *sizep, ssize_t *incrementp) 136 { 137 return (get_ctt_size_common (fp, tp, sizep, incrementp, 138 CTF_TYPE_LSIZE (tp), tp->ctt_size, 139 sizeof (ctf_type_t), sizeof (ctf_stype_t), 140 CTF_LSIZE_SENT)); 141 } 142 143 static ssize_t 144 get_vbytes_common (unsigned short kind, ssize_t size _libctf_unused_, 145 size_t vlen) 146 { 147 switch (kind) 148 { 149 case CTF_K_INTEGER: 150 case CTF_K_FLOAT: 151 return (sizeof (uint32_t)); 152 case CTF_K_SLICE: 153 return (sizeof (ctf_slice_t)); 154 case CTF_K_ENUM: 155 return (sizeof (ctf_enum_t) * vlen); 156 case CTF_K_FORWARD: 157 case CTF_K_UNKNOWN: 158 case CTF_K_POINTER: 159 case CTF_K_TYPEDEF: 160 case CTF_K_VOLATILE: 161 case CTF_K_CONST: 162 case CTF_K_RESTRICT: 163 return 0; 164 default: 165 ctf_dprintf ("detected invalid CTF kind -- %x\n", kind); 166 return ECTF_CORRUPT; 167 } 168 } 169 170 static ssize_t 171 get_vbytes_v1 (unsigned short kind, ssize_t size, size_t vlen) 172 { 173 switch (kind) 174 { 175 case CTF_K_ARRAY: 176 return (sizeof (ctf_array_v1_t)); 177 case CTF_K_FUNCTION: 178 return (sizeof (unsigned short) * (vlen + (vlen & 1))); 179 case CTF_K_STRUCT: 180 case CTF_K_UNION: 181 if (size < CTF_LSTRUCT_THRESH_V1) 182 return (sizeof (ctf_member_v1_t) * vlen); 183 else 184 return (sizeof (ctf_lmember_v1_t) * vlen); 185 } 186 187 return (get_vbytes_common (kind, size, vlen)); 188 } 189 190 static ssize_t 191 get_vbytes_v2 (unsigned short kind, ssize_t size, size_t vlen) 192 { 193 switch (kind) 194 { 195 case CTF_K_ARRAY: 196 return (sizeof (ctf_array_t)); 197 case CTF_K_FUNCTION: 198 return (sizeof (uint32_t) * (vlen + (vlen & 1))); 199 case CTF_K_STRUCT: 200 case CTF_K_UNION: 201 if (size < CTF_LSTRUCT_THRESH) 202 return (sizeof (ctf_member_t) * vlen); 203 else 204 return (sizeof (ctf_lmember_t) * vlen); 205 } 206 207 return (get_vbytes_common (kind, size, vlen)); 208 } 209 210 static const ctf_fileops_t ctf_fileops[] = { 211 {NULL, NULL, NULL, NULL, NULL}, 212 /* CTF_VERSION_1 */ 213 {get_kind_v1, get_root_v1, get_vlen_v1, get_ctt_size_v1, get_vbytes_v1}, 214 /* CTF_VERSION_1_UPGRADED_3 */ 215 {get_kind_v2, get_root_v2, get_vlen_v2, get_ctt_size_v2, get_vbytes_v2}, 216 /* CTF_VERSION_2 */ 217 {get_kind_v2, get_root_v2, get_vlen_v2, get_ctt_size_v2, get_vbytes_v2}, 218 /* CTF_VERSION_3, identical to 2: only new type kinds */ 219 {get_kind_v2, get_root_v2, get_vlen_v2, get_ctt_size_v2, get_vbytes_v2}, 220 }; 221 222 /* Initialize the symtab translation table by filling each entry with the 223 offset of the CTF type or function data corresponding to each STT_FUNC or 224 STT_OBJECT entry in the symbol table. */ 225 226 static int 227 init_symtab (ctf_file_t *fp, const ctf_header_t *hp, 228 const ctf_sect_t *sp, const ctf_sect_t *strp) 229 { 230 const unsigned char *symp = sp->cts_data; 231 uint32_t *xp = fp->ctf_sxlate; 232 uint32_t *xend = xp + fp->ctf_nsyms; 233 234 uint32_t objtoff = hp->cth_objtoff; 235 uint32_t funcoff = hp->cth_funcoff; 236 237 uint32_t info, vlen; 238 Elf64_Sym sym, *gsp; 239 const char *name; 240 241 /* The CTF data object and function type sections are ordered to match 242 the relative order of the respective symbol types in the symtab. 243 If no type information is available for a symbol table entry, a 244 pad is inserted in the CTF section. As a further optimization, 245 anonymous or undefined symbols are omitted from the CTF data. */ 246 247 for (; xp < xend; xp++, symp += sp->cts_entsize) 248 { 249 if (sp->cts_entsize == sizeof (Elf32_Sym)) 250 gsp = ctf_sym_to_elf64 ((Elf32_Sym *) (uintptr_t) symp, &sym); 251 else 252 gsp = (Elf64_Sym *) (uintptr_t) symp; 253 254 if (gsp->st_name < strp->cts_size) 255 name = (const char *) strp->cts_data + gsp->st_name; 256 else 257 name = _CTF_NULLSTR; 258 259 if (gsp->st_name == 0 || gsp->st_shndx == SHN_UNDEF 260 || strcmp (name, "_START_") == 0 || strcmp (name, "_END_") == 0) 261 { 262 *xp = -1u; 263 continue; 264 } 265 266 switch (ELF64_ST_TYPE (gsp->st_info)) 267 { 268 case STT_OBJECT: 269 if (objtoff >= hp->cth_funcoff 270 || (gsp->st_shndx == SHN_EXTABS && gsp->st_value == 0)) 271 { 272 *xp = -1u; 273 break; 274 } 275 276 *xp = objtoff; 277 objtoff += sizeof (uint32_t); 278 break; 279 280 case STT_FUNC: 281 if (funcoff >= hp->cth_objtidxoff) 282 { 283 *xp = -1u; 284 break; 285 } 286 287 *xp = funcoff; 288 289 info = *(uint32_t *) ((uintptr_t) fp->ctf_buf + funcoff); 290 vlen = LCTF_INFO_VLEN (fp, info); 291 292 /* If we encounter a zero pad at the end, just skip it. Otherwise 293 skip over the function and its return type (+2) and the argument 294 list (vlen). 295 */ 296 if (LCTF_INFO_KIND (fp, info) == CTF_K_UNKNOWN && vlen == 0) 297 funcoff += sizeof (uint32_t); /* Skip pad. */ 298 else 299 funcoff += sizeof (uint32_t) * (vlen + 2); 300 break; 301 302 default: 303 *xp = -1u; 304 break; 305 } 306 } 307 308 ctf_dprintf ("loaded %lu symtab entries\n", fp->ctf_nsyms); 309 return 0; 310 } 311 312 /* Reset the CTF base pointer and derive the buf pointer from it, initializing 313 everything in the ctf_file that depends on the base or buf pointers. 314 315 The original gap between the buf and base pointers, if any -- the original, 316 unconverted CTF header -- is kept, but its contents are not specified and are 317 never used. */ 318 319 static void 320 ctf_set_base (ctf_file_t *fp, const ctf_header_t *hp, unsigned char *base) 321 { 322 fp->ctf_buf = base + (fp->ctf_buf - fp->ctf_base); 323 fp->ctf_base = base; 324 fp->ctf_vars = (ctf_varent_t *) ((const char *) fp->ctf_buf + 325 hp->cth_varoff); 326 fp->ctf_nvars = (hp->cth_typeoff - hp->cth_varoff) / sizeof (ctf_varent_t); 327 328 fp->ctf_str[CTF_STRTAB_0].cts_strs = (const char *) fp->ctf_buf 329 + hp->cth_stroff; 330 fp->ctf_str[CTF_STRTAB_0].cts_len = hp->cth_strlen; 331 332 /* If we have a parent container name and label, store the relocated 333 string pointers in the CTF container for easy access later. */ 334 335 /* Note: before conversion, these will be set to values that will be 336 immediately invalidated by the conversion process, but the conversion 337 process will call ctf_set_base() again to fix things up. */ 338 339 if (hp->cth_parlabel != 0) 340 fp->ctf_parlabel = ctf_strptr (fp, hp->cth_parlabel); 341 if (hp->cth_parname != 0) 342 fp->ctf_parname = ctf_strptr (fp, hp->cth_parname); 343 if (hp->cth_cuname != 0) 344 fp->ctf_cuname = ctf_strptr (fp, hp->cth_cuname); 345 346 if (fp->ctf_cuname) 347 ctf_dprintf ("ctf_set_base: CU name %s\n", fp->ctf_cuname); 348 if (fp->ctf_parname) 349 ctf_dprintf ("ctf_set_base: parent name %s (label %s)\n", 350 fp->ctf_parname, 351 fp->ctf_parlabel ? fp->ctf_parlabel : "<NULL>"); 352 } 353 354 /* Set the version of the CTF file. */ 355 356 /* When this is reset, LCTF_* changes behaviour, but there is no guarantee that 357 the variable data list associated with each type has been upgraded: the 358 caller must ensure this has been done in advance. */ 359 360 static void 361 ctf_set_version (ctf_file_t *fp, ctf_header_t *cth, int ctf_version) 362 { 363 fp->ctf_version = ctf_version; 364 cth->cth_version = ctf_version; 365 fp->ctf_fileops = &ctf_fileops[ctf_version]; 366 } 367 368 369 /* Upgrade the header to CTF_VERSION_3. The upgrade is done in-place. */ 370 static void 371 upgrade_header (ctf_header_t *hp) 372 { 373 ctf_header_v2_t *oldhp = (ctf_header_v2_t *) hp; 374 375 hp->cth_strlen = oldhp->cth_strlen; 376 hp->cth_stroff = oldhp->cth_stroff; 377 hp->cth_typeoff = oldhp->cth_typeoff; 378 hp->cth_varoff = oldhp->cth_varoff; 379 hp->cth_funcidxoff = hp->cth_varoff; /* No index sections. */ 380 hp->cth_objtidxoff = hp->cth_funcidxoff; 381 hp->cth_funcoff = oldhp->cth_funcoff; 382 hp->cth_objtoff = oldhp->cth_objtoff; 383 hp->cth_lbloff = oldhp->cth_lbloff; 384 hp->cth_cuname = 0; /* No CU name. */ 385 } 386 387 /* Upgrade the type table to CTF_VERSION_3 (really CTF_VERSION_1_UPGRADED_3) 388 from CTF_VERSION_1. 389 390 The upgrade is not done in-place: the ctf_base is moved. ctf_strptr() must 391 not be called before reallocation is complete. 392 393 Sections not checked here due to nonexistence or nonpopulated state in older 394 formats: objtidx, funcidx. 395 396 Type kinds not checked here due to nonexistence in older formats: 397 CTF_K_SLICE. */ 398 static int 399 upgrade_types_v1 (ctf_file_t *fp, ctf_header_t *cth) 400 { 401 const ctf_type_v1_t *tbuf; 402 const ctf_type_v1_t *tend; 403 unsigned char *ctf_base, *old_ctf_base = (unsigned char *) fp->ctf_dynbase; 404 ctf_type_t *t2buf; 405 406 ssize_t increase = 0, size, increment, v2increment, vbytes, v2bytes; 407 const ctf_type_v1_t *tp; 408 ctf_type_t *t2p; 409 410 tbuf = (ctf_type_v1_t *) (fp->ctf_buf + cth->cth_typeoff); 411 tend = (ctf_type_v1_t *) (fp->ctf_buf + cth->cth_stroff); 412 413 /* Much like init_types(), this is a two-pass process. 414 415 First, figure out the new type-section size needed. (It is possible, 416 in theory, for it to be less than the old size, but this is very 417 unlikely. It cannot be so small that cth_typeoff ends up of negative 418 size. We validate this with an assertion below.) 419 420 We must cater not only for changes in vlen and types sizes but also 421 for changes in 'increment', which happen because v2 places some types 422 into ctf_stype_t where v1 would be forced to use the larger non-stype. */ 423 424 for (tp = tbuf; tp < tend; 425 tp = (ctf_type_v1_t *) ((uintptr_t) tp + increment + vbytes)) 426 { 427 unsigned short kind = CTF_V1_INFO_KIND (tp->ctt_info); 428 unsigned long vlen = CTF_V1_INFO_VLEN (tp->ctt_info); 429 430 size = get_ctt_size_v1 (fp, (const ctf_type_t *) tp, NULL, &increment); 431 vbytes = get_vbytes_v1 (kind, size, vlen); 432 433 get_ctt_size_v2_unconverted (fp, (const ctf_type_t *) tp, NULL, 434 &v2increment); 435 v2bytes = get_vbytes_v2 (kind, size, vlen); 436 437 if ((vbytes < 0) || (size < 0)) 438 return ECTF_CORRUPT; 439 440 increase += v2increment - increment; /* May be negative. */ 441 increase += v2bytes - vbytes; 442 } 443 444 /* Allocate enough room for the new buffer, then copy everything but the type 445 section into place, and reset the base accordingly. Leave the version 446 number unchanged, so that LCTF_INFO_* still works on the 447 as-yet-untranslated type info. */ 448 449 if ((ctf_base = malloc (fp->ctf_size + increase)) == NULL) 450 return ECTF_ZALLOC; 451 452 /* Start at ctf_buf, not ctf_base, to squeeze out the original header: we 453 never use it and it is unconverted. */ 454 455 memcpy (ctf_base, fp->ctf_buf, cth->cth_typeoff); 456 memcpy (ctf_base + cth->cth_stroff + increase, 457 fp->ctf_buf + cth->cth_stroff, cth->cth_strlen); 458 459 memset (ctf_base + cth->cth_typeoff, 0, cth->cth_stroff - cth->cth_typeoff 460 + increase); 461 462 cth->cth_stroff += increase; 463 fp->ctf_size += increase; 464 assert (cth->cth_stroff >= cth->cth_typeoff); 465 fp->ctf_base = ctf_base; 466 fp->ctf_buf = ctf_base; 467 fp->ctf_dynbase = ctf_base; 468 ctf_set_base (fp, cth, ctf_base); 469 470 t2buf = (ctf_type_t *) (fp->ctf_buf + cth->cth_typeoff); 471 472 /* Iterate through all the types again, upgrading them. 473 474 Everything that hasn't changed can just be outright memcpy()ed. 475 Things that have changed need field-by-field consideration. */ 476 477 for (tp = tbuf, t2p = t2buf; tp < tend; 478 tp = (ctf_type_v1_t *) ((uintptr_t) tp + increment + vbytes), 479 t2p = (ctf_type_t *) ((uintptr_t) t2p + v2increment + v2bytes)) 480 { 481 unsigned short kind = CTF_V1_INFO_KIND (tp->ctt_info); 482 int isroot = CTF_V1_INFO_ISROOT (tp->ctt_info); 483 unsigned long vlen = CTF_V1_INFO_VLEN (tp->ctt_info); 484 ssize_t v2size; 485 void *vdata, *v2data; 486 487 size = get_ctt_size_v1 (fp, (const ctf_type_t *) tp, NULL, &increment); 488 vbytes = get_vbytes_v1 (kind, size, vlen); 489 490 t2p->ctt_name = tp->ctt_name; 491 t2p->ctt_info = CTF_TYPE_INFO (kind, isroot, vlen); 492 493 switch (kind) 494 { 495 case CTF_K_FUNCTION: 496 case CTF_K_FORWARD: 497 case CTF_K_TYPEDEF: 498 case CTF_K_POINTER: 499 case CTF_K_VOLATILE: 500 case CTF_K_CONST: 501 case CTF_K_RESTRICT: 502 t2p->ctt_type = tp->ctt_type; 503 break; 504 case CTF_K_INTEGER: 505 case CTF_K_FLOAT: 506 case CTF_K_ARRAY: 507 case CTF_K_STRUCT: 508 case CTF_K_UNION: 509 case CTF_K_ENUM: 510 case CTF_K_UNKNOWN: 511 if ((size_t) size <= CTF_MAX_SIZE) 512 t2p->ctt_size = size; 513 else 514 { 515 t2p->ctt_lsizehi = CTF_SIZE_TO_LSIZE_HI (size); 516 t2p->ctt_lsizelo = CTF_SIZE_TO_LSIZE_LO (size); 517 } 518 break; 519 } 520 521 v2size = get_ctt_size_v2 (fp, t2p, NULL, &v2increment); 522 v2bytes = get_vbytes_v2 (kind, v2size, vlen); 523 524 /* Catch out-of-sync get_ctt_size_*(). The count goes wrong if 525 these are not identical (and having them different makes no 526 sense semantically). */ 527 528 assert (size == v2size); 529 530 /* Now the varlen info. */ 531 532 vdata = (void *) ((uintptr_t) tp + increment); 533 v2data = (void *) ((uintptr_t) t2p + v2increment); 534 535 switch (kind) 536 { 537 case CTF_K_ARRAY: 538 { 539 const ctf_array_v1_t *ap = (const ctf_array_v1_t *) vdata; 540 ctf_array_t *a2p = (ctf_array_t *) v2data; 541 542 a2p->cta_contents = ap->cta_contents; 543 a2p->cta_index = ap->cta_index; 544 a2p->cta_nelems = ap->cta_nelems; 545 break; 546 } 547 case CTF_K_STRUCT: 548 case CTF_K_UNION: 549 { 550 ctf_member_t tmp; 551 const ctf_member_v1_t *m1 = (const ctf_member_v1_t *) vdata; 552 const ctf_lmember_v1_t *lm1 = (const ctf_lmember_v1_t *) m1; 553 ctf_member_t *m2 = (ctf_member_t *) v2data; 554 ctf_lmember_t *lm2 = (ctf_lmember_t *) m2; 555 unsigned long i; 556 557 /* We walk all four pointers forward, but only reference the two 558 that are valid for the given size, to avoid quadruplicating all 559 the code. */ 560 561 for (i = vlen; i != 0; i--, m1++, lm1++, m2++, lm2++) 562 { 563 size_t offset; 564 if (size < CTF_LSTRUCT_THRESH_V1) 565 { 566 offset = m1->ctm_offset; 567 tmp.ctm_name = m1->ctm_name; 568 tmp.ctm_type = m1->ctm_type; 569 } 570 else 571 { 572 offset = CTF_LMEM_OFFSET (lm1); 573 tmp.ctm_name = lm1->ctlm_name; 574 tmp.ctm_type = lm1->ctlm_type; 575 } 576 if (size < CTF_LSTRUCT_THRESH) 577 { 578 m2->ctm_name = tmp.ctm_name; 579 m2->ctm_type = tmp.ctm_type; 580 m2->ctm_offset = offset; 581 } 582 else 583 { 584 lm2->ctlm_name = tmp.ctm_name; 585 lm2->ctlm_type = tmp.ctm_type; 586 lm2->ctlm_offsethi = CTF_OFFSET_TO_LMEMHI (offset); 587 lm2->ctlm_offsetlo = CTF_OFFSET_TO_LMEMLO (offset); 588 } 589 } 590 break; 591 } 592 case CTF_K_FUNCTION: 593 { 594 unsigned long i; 595 unsigned short *a1 = (unsigned short *) vdata; 596 uint32_t *a2 = (uint32_t *) v2data; 597 598 for (i = vlen; i != 0; i--, a1++, a2++) 599 *a2 = *a1; 600 } 601 /* FALLTHRU */ 602 default: 603 /* Catch out-of-sync get_vbytes_*(). */ 604 assert (vbytes == v2bytes); 605 memcpy (v2data, vdata, vbytes); 606 } 607 } 608 609 /* Verify that the entire region was converted. If not, we are either 610 converting too much, or too little (leading to a buffer overrun either here 611 or at read time, in init_types().) */ 612 613 assert ((size_t) t2p - (size_t) fp->ctf_buf == cth->cth_stroff); 614 615 ctf_set_version (fp, cth, CTF_VERSION_1_UPGRADED_3); 616 free (old_ctf_base); 617 618 return 0; 619 } 620 621 /* Upgrade from any earlier version. */ 622 static int 623 upgrade_types (ctf_file_t *fp, ctf_header_t *cth) 624 { 625 switch (cth->cth_version) 626 { 627 /* v1 requires a full pass and reformatting. */ 628 case CTF_VERSION_1: 629 upgrade_types_v1 (fp, cth); 630 /* FALLTHRU */ 631 /* Already-converted v1 is just like later versions except that its 632 parent/child boundary is unchanged (and much lower). */ 633 634 case CTF_VERSION_1_UPGRADED_3: 635 fp->ctf_parmax = CTF_MAX_PTYPE_V1; 636 637 /* v2 is just the same as v3 except for new types and sections: 638 no upgrading required. */ 639 case CTF_VERSION_2: ; 640 /* FALLTHRU */ 641 } 642 return 0; 643 } 644 645 /* Initialize the type ID translation table with the byte offset of each type, 646 and initialize the hash tables of each named type. Upgrade the type table to 647 the latest supported representation in the process, if needed, and if this 648 recension of libctf supports upgrading. */ 649 650 static int 651 init_types (ctf_file_t *fp, ctf_header_t *cth) 652 { 653 const ctf_type_t *tbuf; 654 const ctf_type_t *tend; 655 656 unsigned long pop[CTF_K_MAX + 1] = { 0 }; 657 const ctf_type_t *tp; 658 uint32_t id, dst; 659 uint32_t *xp; 660 661 /* We determine whether the container is a child or a parent based on 662 the value of cth_parname. */ 663 664 int child = cth->cth_parname != 0; 665 int nlstructs = 0, nlunions = 0; 666 int err; 667 668 assert (!(fp->ctf_flags & LCTF_RDWR)); 669 670 if (_libctf_unlikely_ (fp->ctf_version == CTF_VERSION_1)) 671 { 672 int err; 673 if ((err = upgrade_types (fp, cth)) != 0) 674 return err; /* Upgrade failed. */ 675 } 676 677 tbuf = (ctf_type_t *) (fp->ctf_buf + cth->cth_typeoff); 678 tend = (ctf_type_t *) (fp->ctf_buf + cth->cth_stroff); 679 680 /* We make two passes through the entire type section. In this first 681 pass, we count the number of each type and the total number of types. */ 682 683 for (tp = tbuf; tp < tend; fp->ctf_typemax++) 684 { 685 unsigned short kind = LCTF_INFO_KIND (fp, tp->ctt_info); 686 unsigned long vlen = LCTF_INFO_VLEN (fp, tp->ctt_info); 687 ssize_t size, increment, vbytes; 688 689 (void) ctf_get_ctt_size (fp, tp, &size, &increment); 690 vbytes = LCTF_VBYTES (fp, kind, size, vlen); 691 692 if (vbytes < 0) 693 return ECTF_CORRUPT; 694 695 if (kind == CTF_K_FORWARD) 696 { 697 /* For forward declarations, ctt_type is the CTF_K_* kind for the tag, 698 so bump that population count too. If ctt_type is unknown, treat 699 the tag as a struct. */ 700 701 if (tp->ctt_type == CTF_K_UNKNOWN || tp->ctt_type >= CTF_K_MAX) 702 pop[CTF_K_STRUCT]++; 703 else 704 pop[tp->ctt_type]++; 705 } 706 tp = (ctf_type_t *) ((uintptr_t) tp + increment + vbytes); 707 pop[kind]++; 708 } 709 710 if (child) 711 { 712 ctf_dprintf ("CTF container %p is a child\n", (void *) fp); 713 fp->ctf_flags |= LCTF_CHILD; 714 } 715 else 716 ctf_dprintf ("CTF container %p is a parent\n", (void *) fp); 717 718 /* Now that we've counted up the number of each type, we can allocate 719 the hash tables, type translation table, and pointer table. */ 720 721 if ((fp->ctf_structs.ctn_readonly 722 = ctf_hash_create (pop[CTF_K_STRUCT], ctf_hash_string, 723 ctf_hash_eq_string)) == NULL) 724 return ENOMEM; 725 726 if ((fp->ctf_unions.ctn_readonly 727 = ctf_hash_create (pop[CTF_K_UNION], ctf_hash_string, 728 ctf_hash_eq_string)) == NULL) 729 return ENOMEM; 730 731 if ((fp->ctf_enums.ctn_readonly 732 = ctf_hash_create (pop[CTF_K_ENUM], ctf_hash_string, 733 ctf_hash_eq_string)) == NULL) 734 return ENOMEM; 735 736 if ((fp->ctf_names.ctn_readonly 737 = ctf_hash_create (pop[CTF_K_INTEGER] + 738 pop[CTF_K_FLOAT] + 739 pop[CTF_K_FUNCTION] + 740 pop[CTF_K_TYPEDEF] + 741 pop[CTF_K_POINTER] + 742 pop[CTF_K_VOLATILE] + 743 pop[CTF_K_CONST] + 744 pop[CTF_K_RESTRICT], 745 ctf_hash_string, 746 ctf_hash_eq_string)) == NULL) 747 return ENOMEM; 748 749 fp->ctf_txlate = malloc (sizeof (uint32_t) * (fp->ctf_typemax + 1)); 750 fp->ctf_ptrtab_len = fp->ctf_typemax + 1; 751 fp->ctf_ptrtab = malloc (sizeof (uint32_t) * fp->ctf_ptrtab_len); 752 753 if (fp->ctf_txlate == NULL || fp->ctf_ptrtab == NULL) 754 return ENOMEM; /* Memory allocation failed. */ 755 756 xp = fp->ctf_txlate; 757 *xp++ = 0; /* Type id 0 is used as a sentinel value. */ 758 759 memset (fp->ctf_txlate, 0, sizeof (uint32_t) * (fp->ctf_typemax + 1)); 760 memset (fp->ctf_ptrtab, 0, sizeof (uint32_t) * (fp->ctf_typemax + 1)); 761 762 /* In the second pass through the types, we fill in each entry of the 763 type and pointer tables and add names to the appropriate hashes. */ 764 765 for (id = 1, tp = tbuf; tp < tend; xp++, id++) 766 { 767 unsigned short kind = LCTF_INFO_KIND (fp, tp->ctt_info); 768 unsigned short flag = LCTF_INFO_ISROOT (fp, tp->ctt_info); 769 unsigned long vlen = LCTF_INFO_VLEN (fp, tp->ctt_info); 770 ssize_t size, increment, vbytes; 771 772 const char *name; 773 774 (void) ctf_get_ctt_size (fp, tp, &size, &increment); 775 name = ctf_strptr (fp, tp->ctt_name); 776 vbytes = LCTF_VBYTES (fp, kind, size, vlen); 777 778 switch (kind) 779 { 780 case CTF_K_INTEGER: 781 case CTF_K_FLOAT: 782 /* Names are reused by bit-fields, which are differentiated by their 783 encodings, and so typically we'd record only the first instance of 784 a given intrinsic. However, we replace an existing type with a 785 root-visible version so that we can be sure to find it when 786 checking for conflicting definitions in ctf_add_type(). */ 787 788 if (((ctf_hash_lookup_type (fp->ctf_names.ctn_readonly, 789 fp, name)) == 0) 790 || (flag & CTF_ADD_ROOT)) 791 { 792 err = ctf_hash_define_type (fp->ctf_names.ctn_readonly, fp, 793 LCTF_INDEX_TO_TYPE (fp, id, child), 794 tp->ctt_name); 795 if (err != 0) 796 return err; 797 } 798 break; 799 800 /* These kinds have no name, so do not need interning into any 801 hashtables. */ 802 case CTF_K_ARRAY: 803 case CTF_K_SLICE: 804 break; 805 806 case CTF_K_FUNCTION: 807 err = ctf_hash_insert_type (fp->ctf_names.ctn_readonly, fp, 808 LCTF_INDEX_TO_TYPE (fp, id, child), 809 tp->ctt_name); 810 if (err != 0) 811 return err; 812 break; 813 814 case CTF_K_STRUCT: 815 err = ctf_hash_define_type (fp->ctf_structs.ctn_readonly, fp, 816 LCTF_INDEX_TO_TYPE (fp, id, child), 817 tp->ctt_name); 818 819 if (err != 0) 820 return err; 821 822 if (size >= CTF_LSTRUCT_THRESH) 823 nlstructs++; 824 break; 825 826 case CTF_K_UNION: 827 err = ctf_hash_define_type (fp->ctf_unions.ctn_readonly, fp, 828 LCTF_INDEX_TO_TYPE (fp, id, child), 829 tp->ctt_name); 830 831 if (err != 0) 832 return err; 833 834 if (size >= CTF_LSTRUCT_THRESH) 835 nlunions++; 836 break; 837 838 case CTF_K_ENUM: 839 err = ctf_hash_define_type (fp->ctf_enums.ctn_readonly, fp, 840 LCTF_INDEX_TO_TYPE (fp, id, child), 841 tp->ctt_name); 842 843 if (err != 0) 844 return err; 845 break; 846 847 case CTF_K_TYPEDEF: 848 err = ctf_hash_insert_type (fp->ctf_names.ctn_readonly, fp, 849 LCTF_INDEX_TO_TYPE (fp, id, child), 850 tp->ctt_name); 851 if (err != 0) 852 return err; 853 break; 854 855 case CTF_K_FORWARD: 856 { 857 ctf_names_t *np = ctf_name_table (fp, tp->ctt_type); 858 /* Only insert forward tags into the given hash if the type or tag 859 name is not already present. */ 860 if (ctf_hash_lookup_type (np->ctn_readonly, fp, name) == 0) 861 { 862 err = ctf_hash_insert_type (np->ctn_readonly, fp, 863 LCTF_INDEX_TO_TYPE (fp, id, child), 864 tp->ctt_name); 865 if (err != 0) 866 return err; 867 } 868 break; 869 } 870 871 case CTF_K_POINTER: 872 /* If the type referenced by the pointer is in this CTF container, 873 then store the index of the pointer type in 874 fp->ctf_ptrtab[ index of referenced type ]. */ 875 876 if (LCTF_TYPE_ISCHILD (fp, tp->ctt_type) == child 877 && LCTF_TYPE_TO_INDEX (fp, tp->ctt_type) <= fp->ctf_typemax) 878 fp->ctf_ptrtab[LCTF_TYPE_TO_INDEX (fp, tp->ctt_type)] = id; 879 /*FALLTHRU*/ 880 881 case CTF_K_VOLATILE: 882 case CTF_K_CONST: 883 case CTF_K_RESTRICT: 884 err = ctf_hash_insert_type (fp->ctf_names.ctn_readonly, fp, 885 LCTF_INDEX_TO_TYPE (fp, id, child), 886 tp->ctt_name); 887 if (err != 0) 888 return err; 889 break; 890 default: 891 ctf_dprintf ("unhandled CTF kind in endianness conversion -- %x\n", 892 kind); 893 return ECTF_CORRUPT; 894 } 895 896 *xp = (uint32_t) ((uintptr_t) tp - (uintptr_t) fp->ctf_buf); 897 tp = (ctf_type_t *) ((uintptr_t) tp + increment + vbytes); 898 } 899 900 ctf_dprintf ("%lu total types processed\n", fp->ctf_typemax); 901 ctf_dprintf ("%u enum names hashed\n", 902 ctf_hash_size (fp->ctf_enums.ctn_readonly)); 903 ctf_dprintf ("%u struct names hashed (%d long)\n", 904 ctf_hash_size (fp->ctf_structs.ctn_readonly), nlstructs); 905 ctf_dprintf ("%u union names hashed (%d long)\n", 906 ctf_hash_size (fp->ctf_unions.ctn_readonly), nlunions); 907 ctf_dprintf ("%u base type names hashed\n", 908 ctf_hash_size (fp->ctf_names.ctn_readonly)); 909 910 /* Make an additional pass through the pointer table to find pointers that 911 point to anonymous typedef nodes. If we find one, modify the pointer table 912 so that the pointer is also known to point to the node that is referenced 913 by the anonymous typedef node. */ 914 915 for (id = 1; id <= fp->ctf_typemax; id++) 916 { 917 if ((dst = fp->ctf_ptrtab[id]) != 0) 918 { 919 tp = LCTF_INDEX_TO_TYPEPTR (fp, id); 920 921 if (LCTF_INFO_KIND (fp, tp->ctt_info) == CTF_K_TYPEDEF 922 && strcmp (ctf_strptr (fp, tp->ctt_name), "") == 0 923 && LCTF_TYPE_ISCHILD (fp, tp->ctt_type) == child 924 && LCTF_TYPE_TO_INDEX (fp, tp->ctt_type) <= fp->ctf_typemax) 925 fp->ctf_ptrtab[LCTF_TYPE_TO_INDEX (fp, tp->ctt_type)] = dst; 926 } 927 } 928 929 return 0; 930 } 931 932 /* Endianness-flipping routines. 933 934 We flip everything, mindlessly, even 1-byte entities, so that future 935 expansions do not require changes to this code. */ 936 937 /* < C11? define away static assertions. */ 938 939 #if !defined (__STDC_VERSION__) || __STDC_VERSION__ < 201112L 940 #define _Static_assert(cond, err) 941 #endif 942 943 /* Swap the endianness of something. */ 944 945 #define swap_thing(x) \ 946 do { \ 947 _Static_assert (sizeof (x) == 1 || (sizeof (x) % 2 == 0 \ 948 && sizeof (x) <= 8), \ 949 "Invalid size, update endianness code"); \ 950 switch (sizeof (x)) { \ 951 case 2: x = bswap_16 (x); break; \ 952 case 4: x = bswap_32 (x); break; \ 953 case 8: x = bswap_64 (x); break; \ 954 case 1: /* Nothing needs doing */ \ 955 break; \ 956 } \ 957 } while (0); 958 959 /* Flip the endianness of the CTF header. */ 960 961 static void 962 flip_header (ctf_header_t *cth) 963 { 964 swap_thing (cth->cth_preamble.ctp_magic); 965 swap_thing (cth->cth_preamble.ctp_version); 966 swap_thing (cth->cth_preamble.ctp_flags); 967 swap_thing (cth->cth_parlabel); 968 swap_thing (cth->cth_parname); 969 swap_thing (cth->cth_cuname); 970 swap_thing (cth->cth_objtoff); 971 swap_thing (cth->cth_funcoff); 972 swap_thing (cth->cth_objtidxoff); 973 swap_thing (cth->cth_funcidxoff); 974 swap_thing (cth->cth_varoff); 975 swap_thing (cth->cth_typeoff); 976 swap_thing (cth->cth_stroff); 977 swap_thing (cth->cth_strlen); 978 } 979 980 /* Flip the endianness of the label section, an array of ctf_lblent_t. */ 981 982 static void 983 flip_lbls (void *start, size_t len) 984 { 985 ctf_lblent_t *lbl = start; 986 ssize_t i; 987 988 for (i = len / sizeof (struct ctf_lblent); i > 0; lbl++, i--) 989 { 990 swap_thing (lbl->ctl_label); 991 swap_thing (lbl->ctl_type); 992 } 993 } 994 995 /* Flip the endianness of the data-object or function sections or their indexes, 996 all arrays of uint32_t. (The function section has more internal structure, 997 but that structure is an array of uint32_t, so can be treated as one big 998 array for byte-swapping.) */ 999 1000 static void 1001 flip_objts (void *start, size_t len) 1002 { 1003 uint32_t *obj = start; 1004 ssize_t i; 1005 1006 for (i = len / sizeof (uint32_t); i > 0; obj++, i--) 1007 swap_thing (*obj); 1008 } 1009 1010 /* Flip the endianness of the variable section, an array of ctf_varent_t. */ 1011 1012 static void 1013 flip_vars (void *start, size_t len) 1014 { 1015 ctf_varent_t *var = start; 1016 ssize_t i; 1017 1018 for (i = len / sizeof (struct ctf_varent); i > 0; var++, i--) 1019 { 1020 swap_thing (var->ctv_name); 1021 swap_thing (var->ctv_type); 1022 } 1023 } 1024 1025 /* Flip the endianness of the type section, a tagged array of ctf_type or 1026 ctf_stype followed by variable data. */ 1027 1028 static int 1029 flip_types (void *start, size_t len) 1030 { 1031 ctf_type_t *t = start; 1032 1033 while ((uintptr_t) t < ((uintptr_t) start) + len) 1034 { 1035 swap_thing (t->ctt_name); 1036 swap_thing (t->ctt_info); 1037 swap_thing (t->ctt_size); 1038 1039 uint32_t kind = CTF_V2_INFO_KIND (t->ctt_info); 1040 size_t size = t->ctt_size; 1041 uint32_t vlen = CTF_V2_INFO_VLEN (t->ctt_info); 1042 size_t vbytes = get_vbytes_v2 (kind, size, vlen); 1043 1044 if (_libctf_unlikely_ (size == CTF_LSIZE_SENT)) 1045 { 1046 swap_thing (t->ctt_lsizehi); 1047 swap_thing (t->ctt_lsizelo); 1048 size = CTF_TYPE_LSIZE (t); 1049 t = (ctf_type_t *) ((uintptr_t) t + sizeof (ctf_type_t)); 1050 } 1051 else 1052 t = (ctf_type_t *) ((uintptr_t) t + sizeof (ctf_stype_t)); 1053 1054 switch (kind) 1055 { 1056 case CTF_K_FORWARD: 1057 case CTF_K_UNKNOWN: 1058 case CTF_K_POINTER: 1059 case CTF_K_TYPEDEF: 1060 case CTF_K_VOLATILE: 1061 case CTF_K_CONST: 1062 case CTF_K_RESTRICT: 1063 /* These types have no vlen data to swap. */ 1064 assert (vbytes == 0); 1065 break; 1066 1067 case CTF_K_INTEGER: 1068 case CTF_K_FLOAT: 1069 { 1070 /* These types have a single uint32_t. */ 1071 1072 uint32_t *item = (uint32_t *) t; 1073 1074 swap_thing (*item); 1075 break; 1076 } 1077 1078 case CTF_K_FUNCTION: 1079 { 1080 /* This type has a bunch of uint32_ts. */ 1081 1082 uint32_t *item = (uint32_t *) t; 1083 ssize_t i; 1084 1085 for (i = vlen; i > 0; item++, i--) 1086 swap_thing (*item); 1087 break; 1088 } 1089 1090 case CTF_K_ARRAY: 1091 { 1092 /* This has a single ctf_array_t. */ 1093 1094 ctf_array_t *a = (ctf_array_t *) t; 1095 1096 assert (vbytes == sizeof (ctf_array_t)); 1097 swap_thing (a->cta_contents); 1098 swap_thing (a->cta_index); 1099 swap_thing (a->cta_nelems); 1100 1101 break; 1102 } 1103 1104 case CTF_K_SLICE: 1105 { 1106 /* This has a single ctf_slice_t. */ 1107 1108 ctf_slice_t *s = (ctf_slice_t *) t; 1109 1110 assert (vbytes == sizeof (ctf_slice_t)); 1111 swap_thing (s->cts_type); 1112 swap_thing (s->cts_offset); 1113 swap_thing (s->cts_bits); 1114 1115 break; 1116 } 1117 1118 case CTF_K_STRUCT: 1119 case CTF_K_UNION: 1120 { 1121 /* This has an array of ctf_member or ctf_lmember, depending on 1122 size. We could consider it to be a simple array of uint32_t, 1123 but for safety's sake in case these structures ever acquire 1124 non-uint32_t members, do it member by member. */ 1125 1126 if (_libctf_unlikely_ (size >= CTF_LSTRUCT_THRESH)) 1127 { 1128 ctf_lmember_t *lm = (ctf_lmember_t *) t; 1129 ssize_t i; 1130 for (i = vlen; i > 0; i--, lm++) 1131 { 1132 swap_thing (lm->ctlm_name); 1133 swap_thing (lm->ctlm_offsethi); 1134 swap_thing (lm->ctlm_type); 1135 swap_thing (lm->ctlm_offsetlo); 1136 } 1137 } 1138 else 1139 { 1140 ctf_member_t *m = (ctf_member_t *) t; 1141 ssize_t i; 1142 for (i = vlen; i > 0; i--, m++) 1143 { 1144 swap_thing (m->ctm_name); 1145 swap_thing (m->ctm_offset); 1146 swap_thing (m->ctm_type); 1147 } 1148 } 1149 break; 1150 } 1151 1152 case CTF_K_ENUM: 1153 { 1154 /* This has an array of ctf_enum_t. */ 1155 1156 ctf_enum_t *item = (ctf_enum_t *) t; 1157 ssize_t i; 1158 1159 for (i = vlen; i > 0; item++, i--) 1160 { 1161 swap_thing (item->cte_name); 1162 swap_thing (item->cte_value); 1163 } 1164 break; 1165 } 1166 default: 1167 ctf_dprintf ("unhandled CTF kind in endianness conversion -- %x\n", 1168 kind); 1169 return ECTF_CORRUPT; 1170 } 1171 1172 t = (ctf_type_t *) ((uintptr_t) t + vbytes); 1173 } 1174 1175 return 0; 1176 } 1177 1178 /* Flip the endianness of BUF, given the offsets in the (already endian- 1179 converted) CTH. 1180 1181 All of this stuff happens before the header is fully initialized, so the 1182 LCTF_*() macros cannot be used yet. Since we do not try to endian-convert v1 1183 data, this is no real loss. */ 1184 1185 static int 1186 flip_ctf (ctf_header_t *cth, unsigned char *buf) 1187 { 1188 flip_lbls (buf + cth->cth_lbloff, cth->cth_objtoff - cth->cth_lbloff); 1189 flip_objts (buf + cth->cth_objtoff, cth->cth_funcoff - cth->cth_objtoff); 1190 flip_objts (buf + cth->cth_funcoff, cth->cth_objtidxoff - cth->cth_funcoff); 1191 flip_objts (buf + cth->cth_objtidxoff, cth->cth_funcidxoff - cth->cth_objtidxoff); 1192 flip_objts (buf + cth->cth_funcidxoff, cth->cth_varoff - cth->cth_funcidxoff); 1193 flip_vars (buf + cth->cth_varoff, cth->cth_typeoff - cth->cth_varoff); 1194 return flip_types (buf + cth->cth_typeoff, cth->cth_stroff - cth->cth_typeoff); 1195 } 1196 1197 /* Set up the ctl hashes in a ctf_file_t. Called by both writable and 1198 non-writable dictionary initialization. */ 1199 void ctf_set_ctl_hashes (ctf_file_t *fp) 1200 { 1201 /* Initialize the ctf_lookup_by_name top-level dictionary. We keep an 1202 array of type name prefixes and the corresponding ctf_hash to use. */ 1203 fp->ctf_lookups[0].ctl_prefix = "struct"; 1204 fp->ctf_lookups[0].ctl_len = strlen (fp->ctf_lookups[0].ctl_prefix); 1205 fp->ctf_lookups[0].ctl_hash = &fp->ctf_structs; 1206 fp->ctf_lookups[1].ctl_prefix = "union"; 1207 fp->ctf_lookups[1].ctl_len = strlen (fp->ctf_lookups[1].ctl_prefix); 1208 fp->ctf_lookups[1].ctl_hash = &fp->ctf_unions; 1209 fp->ctf_lookups[2].ctl_prefix = "enum"; 1210 fp->ctf_lookups[2].ctl_len = strlen (fp->ctf_lookups[2].ctl_prefix); 1211 fp->ctf_lookups[2].ctl_hash = &fp->ctf_enums; 1212 fp->ctf_lookups[3].ctl_prefix = _CTF_NULLSTR; 1213 fp->ctf_lookups[3].ctl_len = strlen (fp->ctf_lookups[3].ctl_prefix); 1214 fp->ctf_lookups[3].ctl_hash = &fp->ctf_names; 1215 fp->ctf_lookups[4].ctl_prefix = NULL; 1216 fp->ctf_lookups[4].ctl_len = 0; 1217 fp->ctf_lookups[4].ctl_hash = NULL; 1218 } 1219 1220 /* Open a CTF file, mocking up a suitable ctf_sect. */ 1221 1222 ctf_file_t *ctf_simple_open (const char *ctfsect, size_t ctfsect_size, 1223 const char *symsect, size_t symsect_size, 1224 size_t symsect_entsize, 1225 const char *strsect, size_t strsect_size, 1226 int *errp) 1227 { 1228 return ctf_simple_open_internal (ctfsect, ctfsect_size, symsect, symsect_size, 1229 symsect_entsize, strsect, strsect_size, NULL, 1230 0, errp); 1231 } 1232 1233 /* Open a CTF file, mocking up a suitable ctf_sect and overriding the external 1234 strtab with a synthetic one. */ 1235 1236 ctf_file_t *ctf_simple_open_internal (const char *ctfsect, size_t ctfsect_size, 1237 const char *symsect, size_t symsect_size, 1238 size_t symsect_entsize, 1239 const char *strsect, size_t strsect_size, 1240 ctf_dynhash_t *syn_strtab, int writable, 1241 int *errp) 1242 { 1243 ctf_sect_t skeleton; 1244 1245 ctf_sect_t ctf_sect, sym_sect, str_sect; 1246 ctf_sect_t *ctfsectp = NULL; 1247 ctf_sect_t *symsectp = NULL; 1248 ctf_sect_t *strsectp = NULL; 1249 1250 skeleton.cts_name = _CTF_SECTION; 1251 skeleton.cts_entsize = 1; 1252 1253 if (ctfsect) 1254 { 1255 memcpy (&ctf_sect, &skeleton, sizeof (struct ctf_sect)); 1256 ctf_sect.cts_data = ctfsect; 1257 ctf_sect.cts_size = ctfsect_size; 1258 ctfsectp = &ctf_sect; 1259 } 1260 1261 if (symsect) 1262 { 1263 memcpy (&sym_sect, &skeleton, sizeof (struct ctf_sect)); 1264 sym_sect.cts_data = symsect; 1265 sym_sect.cts_size = symsect_size; 1266 sym_sect.cts_entsize = symsect_entsize; 1267 symsectp = &sym_sect; 1268 } 1269 1270 if (strsect) 1271 { 1272 memcpy (&str_sect, &skeleton, sizeof (struct ctf_sect)); 1273 str_sect.cts_data = strsect; 1274 str_sect.cts_size = strsect_size; 1275 strsectp = &str_sect; 1276 } 1277 1278 return ctf_bufopen_internal (ctfsectp, symsectp, strsectp, syn_strtab, 1279 writable, errp); 1280 } 1281 1282 /* Decode the specified CTF buffer and optional symbol table, and create a new 1283 CTF container representing the symbolic debugging information. This code can 1284 be used directly by the debugger, or it can be used as the engine for 1285 ctf_fdopen() or ctf_open(), below. */ 1286 1287 ctf_file_t * 1288 ctf_bufopen (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect, 1289 const ctf_sect_t *strsect, int *errp) 1290 { 1291 return ctf_bufopen_internal (ctfsect, symsect, strsect, NULL, 0, errp); 1292 } 1293 1294 /* Like ctf_bufopen, but overriding the external strtab with a synthetic one. */ 1295 1296 ctf_file_t * 1297 ctf_bufopen_internal (const ctf_sect_t *ctfsect, const ctf_sect_t *symsect, 1298 const ctf_sect_t *strsect, ctf_dynhash_t *syn_strtab, 1299 int writable, int *errp) 1300 { 1301 const ctf_preamble_t *pp; 1302 size_t hdrsz = sizeof (ctf_header_t); 1303 ctf_header_t *hp; 1304 ctf_file_t *fp; 1305 int foreign_endian = 0; 1306 int err; 1307 1308 libctf_init_debug(); 1309 1310 if ((ctfsect == NULL) || ((symsect != NULL) && 1311 ((strsect == NULL) && syn_strtab == NULL))) 1312 return (ctf_set_open_errno (errp, EINVAL)); 1313 1314 if (symsect != NULL && symsect->cts_entsize != sizeof (Elf32_Sym) && 1315 symsect->cts_entsize != sizeof (Elf64_Sym)) 1316 return (ctf_set_open_errno (errp, ECTF_SYMTAB)); 1317 1318 if (symsect != NULL && symsect->cts_data == NULL) 1319 return (ctf_set_open_errno (errp, ECTF_SYMBAD)); 1320 1321 if (strsect != NULL && strsect->cts_data == NULL) 1322 return (ctf_set_open_errno (errp, ECTF_STRBAD)); 1323 1324 if (ctfsect->cts_size < sizeof (ctf_preamble_t)) 1325 return (ctf_set_open_errno (errp, ECTF_NOCTFBUF)); 1326 1327 pp = (const ctf_preamble_t *) ctfsect->cts_data; 1328 1329 ctf_dprintf ("ctf_bufopen: magic=0x%x version=%u\n", 1330 pp->ctp_magic, pp->ctp_version); 1331 1332 /* Validate each part of the CTF header. 1333 1334 First, we validate the preamble (common to all versions). At that point, 1335 we know the endianness and specific header version, and can validate the 1336 version-specific parts including section offsets and alignments. 1337 1338 We specifically do not support foreign-endian old versions. */ 1339 1340 if (_libctf_unlikely_ (pp->ctp_magic != CTF_MAGIC)) 1341 { 1342 if (pp->ctp_magic == bswap_16 (CTF_MAGIC)) 1343 { 1344 if (pp->ctp_version != CTF_VERSION_3) 1345 return (ctf_set_open_errno (errp, ECTF_CTFVERS)); 1346 foreign_endian = 1; 1347 } 1348 else 1349 return (ctf_set_open_errno (errp, ECTF_NOCTFBUF)); 1350 } 1351 1352 if (_libctf_unlikely_ ((pp->ctp_version < CTF_VERSION_1) 1353 || (pp->ctp_version > CTF_VERSION_3))) 1354 return (ctf_set_open_errno (errp, ECTF_CTFVERS)); 1355 1356 if ((symsect != NULL) && (pp->ctp_version < CTF_VERSION_2)) 1357 { 1358 /* The symtab can contain function entries which contain embedded ctf 1359 info. We do not support dynamically upgrading such entries (none 1360 should exist in any case, since dwarf2ctf does not create them). */ 1361 1362 ctf_dprintf ("ctf_bufopen: CTF version %d symsect not " 1363 "supported\n", pp->ctp_version); 1364 return (ctf_set_open_errno (errp, ECTF_NOTSUP)); 1365 } 1366 1367 if (pp->ctp_version < CTF_VERSION_3) 1368 hdrsz = sizeof (ctf_header_v2_t); 1369 1370 if (ctfsect->cts_size < hdrsz) 1371 return (ctf_set_open_errno (errp, ECTF_NOCTFBUF)); 1372 1373 if ((fp = malloc (sizeof (ctf_file_t))) == NULL) 1374 return (ctf_set_open_errno (errp, ENOMEM)); 1375 1376 memset (fp, 0, sizeof (ctf_file_t)); 1377 1378 if (writable) 1379 fp->ctf_flags |= LCTF_RDWR; 1380 1381 if ((fp->ctf_header = malloc (sizeof (struct ctf_header))) == NULL) 1382 { 1383 free (fp); 1384 return (ctf_set_open_errno (errp, ENOMEM)); 1385 } 1386 hp = fp->ctf_header; 1387 memcpy (hp, ctfsect->cts_data, hdrsz); 1388 if (pp->ctp_version < CTF_VERSION_3) 1389 upgrade_header (hp); 1390 1391 if (foreign_endian) 1392 flip_header (hp); 1393 fp->ctf_openflags = hp->cth_flags; 1394 fp->ctf_size = hp->cth_stroff + hp->cth_strlen; 1395 1396 ctf_dprintf ("ctf_bufopen: uncompressed size=%lu\n", 1397 (unsigned long) fp->ctf_size); 1398 1399 if (hp->cth_lbloff > fp->ctf_size || hp->cth_objtoff > fp->ctf_size 1400 || hp->cth_funcoff > fp->ctf_size || hp->cth_objtidxoff > fp->ctf_size 1401 || hp->cth_funcidxoff > fp->ctf_size || hp->cth_typeoff > fp->ctf_size 1402 || hp->cth_stroff > fp->ctf_size) 1403 return (ctf_set_open_errno (errp, ECTF_CORRUPT)); 1404 1405 if (hp->cth_lbloff > hp->cth_objtoff 1406 || hp->cth_objtoff > hp->cth_funcoff 1407 || hp->cth_funcoff > hp->cth_typeoff 1408 || hp->cth_funcoff > hp->cth_objtidxoff 1409 || hp->cth_objtidxoff > hp->cth_funcidxoff 1410 || hp->cth_funcidxoff > hp->cth_varoff 1411 || hp->cth_varoff > hp->cth_typeoff || hp->cth_typeoff > hp->cth_stroff) 1412 return (ctf_set_open_errno (errp, ECTF_CORRUPT)); 1413 1414 if ((hp->cth_lbloff & 3) || (hp->cth_objtoff & 2) 1415 || (hp->cth_funcoff & 2) || (hp->cth_objtidxoff & 2) 1416 || (hp->cth_funcidxoff & 2) || (hp->cth_varoff & 3) 1417 || (hp->cth_typeoff & 3)) 1418 return (ctf_set_open_errno (errp, ECTF_CORRUPT)); 1419 1420 /* Once everything is determined to be valid, attempt to decompress the CTF 1421 data buffer if it is compressed, or copy it into new storage if it is not 1422 compressed but needs endian-flipping. Otherwise we just put the data 1423 section's buffer pointer into ctf_buf, below. */ 1424 1425 /* Note: if this is a v1 buffer, it will be reallocated and expanded by 1426 init_types(). */ 1427 1428 if (hp->cth_flags & CTF_F_COMPRESS) 1429 { 1430 size_t srclen; 1431 uLongf dstlen; 1432 const void *src; 1433 int rc = Z_OK; 1434 1435 /* We are allocating this ourselves, so we can drop the ctf header 1436 copy in favour of ctf->ctf_header. */ 1437 1438 if ((fp->ctf_base = malloc (fp->ctf_size)) == NULL) 1439 { 1440 err = ECTF_ZALLOC; 1441 goto bad; 1442 } 1443 fp->ctf_dynbase = fp->ctf_base; 1444 hp->cth_flags &= ~CTF_F_COMPRESS; 1445 1446 src = (unsigned char *) ctfsect->cts_data + hdrsz; 1447 srclen = ctfsect->cts_size - hdrsz; 1448 dstlen = fp->ctf_size; 1449 fp->ctf_buf = fp->ctf_base; 1450 1451 if ((rc = uncompress (fp->ctf_base, &dstlen, src, srclen)) != Z_OK) 1452 { 1453 ctf_dprintf ("zlib inflate err: %s\n", zError (rc)); 1454 err = ECTF_DECOMPRESS; 1455 goto bad; 1456 } 1457 1458 if ((size_t) dstlen != fp->ctf_size) 1459 { 1460 ctf_dprintf ("zlib inflate short -- got %lu of %lu " 1461 "bytes\n", (unsigned long) dstlen, 1462 (unsigned long) fp->ctf_size); 1463 err = ECTF_CORRUPT; 1464 goto bad; 1465 } 1466 } 1467 else if (foreign_endian) 1468 { 1469 if ((fp->ctf_base = malloc (fp->ctf_size)) == NULL) 1470 { 1471 err = ECTF_ZALLOC; 1472 goto bad; 1473 } 1474 fp->ctf_dynbase = fp->ctf_base; 1475 memcpy (fp->ctf_base, ((unsigned char *) ctfsect->cts_data) + hdrsz, 1476 fp->ctf_size); 1477 fp->ctf_buf = fp->ctf_base; 1478 } 1479 else 1480 { 1481 /* We are just using the section passed in -- but its header may be an old 1482 version. Point ctf_buf past the old header, and never touch it 1483 again. */ 1484 fp->ctf_base = (unsigned char *) ctfsect->cts_data; 1485 fp->ctf_dynbase = NULL; 1486 fp->ctf_buf = fp->ctf_base + hdrsz; 1487 } 1488 1489 /* Once we have uncompressed and validated the CTF data buffer, we can 1490 proceed with initializing the ctf_file_t we allocated above. 1491 1492 Nothing that depends on buf or base should be set directly in this function 1493 before the init_types() call, because it may be reallocated during 1494 transparent upgrade if this recension of libctf is so configured: see 1495 ctf_set_base(). */ 1496 1497 ctf_set_version (fp, hp, hp->cth_version); 1498 ctf_str_create_atoms (fp); 1499 fp->ctf_parmax = CTF_MAX_PTYPE; 1500 memcpy (&fp->ctf_data, ctfsect, sizeof (ctf_sect_t)); 1501 1502 if (symsect != NULL) 1503 { 1504 memcpy (&fp->ctf_symtab, symsect, sizeof (ctf_sect_t)); 1505 memcpy (&fp->ctf_strtab, strsect, sizeof (ctf_sect_t)); 1506 } 1507 1508 if (fp->ctf_data.cts_name != NULL) 1509 if ((fp->ctf_data.cts_name = strdup (fp->ctf_data.cts_name)) == NULL) 1510 { 1511 err = ENOMEM; 1512 goto bad; 1513 } 1514 if (fp->ctf_symtab.cts_name != NULL) 1515 if ((fp->ctf_symtab.cts_name = strdup (fp->ctf_symtab.cts_name)) == NULL) 1516 { 1517 err = ENOMEM; 1518 goto bad; 1519 } 1520 if (fp->ctf_strtab.cts_name != NULL) 1521 if ((fp->ctf_strtab.cts_name = strdup (fp->ctf_strtab.cts_name)) == NULL) 1522 { 1523 err = ENOMEM; 1524 goto bad; 1525 } 1526 1527 if (fp->ctf_data.cts_name == NULL) 1528 fp->ctf_data.cts_name = _CTF_NULLSTR; 1529 if (fp->ctf_symtab.cts_name == NULL) 1530 fp->ctf_symtab.cts_name = _CTF_NULLSTR; 1531 if (fp->ctf_strtab.cts_name == NULL) 1532 fp->ctf_strtab.cts_name = _CTF_NULLSTR; 1533 1534 if (strsect != NULL) 1535 { 1536 fp->ctf_str[CTF_STRTAB_1].cts_strs = strsect->cts_data; 1537 fp->ctf_str[CTF_STRTAB_1].cts_len = strsect->cts_size; 1538 } 1539 fp->ctf_syn_ext_strtab = syn_strtab; 1540 1541 if (foreign_endian && 1542 (err = flip_ctf (hp, fp->ctf_buf)) != 0) 1543 { 1544 /* We can be certain that flip_ctf() will have endian-flipped everything 1545 other than the types table when we return. In particular the header 1546 is fine, so set it, to allow freeing to use the usual code path. */ 1547 1548 ctf_set_base (fp, hp, fp->ctf_base); 1549 goto bad; 1550 } 1551 1552 ctf_set_base (fp, hp, fp->ctf_base); 1553 1554 /* No need to do anything else for dynamic containers: they do not support 1555 symbol lookups, and the type table is maintained in the dthashes. */ 1556 if (fp->ctf_flags & LCTF_RDWR) 1557 { 1558 fp->ctf_refcnt = 1; 1559 return fp; 1560 } 1561 1562 if ((err = init_types (fp, hp)) != 0) 1563 goto bad; 1564 1565 /* If we have a symbol table section, allocate and initialize 1566 the symtab translation table, pointed to by ctf_sxlate. This table may be 1567 too large for the actual size of the object and function info sections: if 1568 so, ctf_nsyms will be adjusted and the excess will never be used. */ 1569 1570 if (symsect != NULL) 1571 { 1572 fp->ctf_nsyms = symsect->cts_size / symsect->cts_entsize; 1573 fp->ctf_sxlate = malloc (fp->ctf_nsyms * sizeof (uint32_t)); 1574 1575 if (fp->ctf_sxlate == NULL) 1576 { 1577 err = ENOMEM; 1578 goto bad; 1579 } 1580 1581 if ((err = init_symtab (fp, hp, symsect, strsect)) != 0) 1582 goto bad; 1583 } 1584 1585 ctf_set_ctl_hashes (fp); 1586 1587 if (symsect != NULL) 1588 { 1589 if (symsect->cts_entsize == sizeof (Elf64_Sym)) 1590 (void) ctf_setmodel (fp, CTF_MODEL_LP64); 1591 else 1592 (void) ctf_setmodel (fp, CTF_MODEL_ILP32); 1593 } 1594 else 1595 (void) ctf_setmodel (fp, CTF_MODEL_NATIVE); 1596 1597 fp->ctf_refcnt = 1; 1598 return fp; 1599 1600 bad: 1601 ctf_set_open_errno (errp, err); 1602 ctf_file_close (fp); 1603 return NULL; 1604 } 1605 1606 /* Close the specified CTF container and free associated data structures. Note 1607 that ctf_file_close() is a reference counted operation: if the specified file 1608 is the parent of other active containers, its reference count will be greater 1609 than one and it will be freed later when no active children exist. */ 1610 1611 void 1612 ctf_file_close (ctf_file_t *fp) 1613 { 1614 ctf_dtdef_t *dtd, *ntd; 1615 ctf_dvdef_t *dvd, *nvd; 1616 1617 if (fp == NULL) 1618 return; /* Allow ctf_file_close(NULL) to simplify caller code. */ 1619 1620 ctf_dprintf ("ctf_file_close(%p) refcnt=%u\n", (void *) fp, fp->ctf_refcnt); 1621 1622 if (fp->ctf_refcnt > 1) 1623 { 1624 fp->ctf_refcnt--; 1625 return; 1626 } 1627 1628 free (fp->ctf_dyncuname); 1629 free (fp->ctf_dynparname); 1630 ctf_file_close (fp->ctf_parent); 1631 1632 for (dtd = ctf_list_next (&fp->ctf_dtdefs); dtd != NULL; dtd = ntd) 1633 { 1634 ntd = ctf_list_next (dtd); 1635 ctf_dtd_delete (fp, dtd); 1636 } 1637 ctf_dynhash_destroy (fp->ctf_dthash); 1638 if (fp->ctf_flags & LCTF_RDWR) 1639 { 1640 ctf_dynhash_destroy (fp->ctf_structs.ctn_writable); 1641 ctf_dynhash_destroy (fp->ctf_unions.ctn_writable); 1642 ctf_dynhash_destroy (fp->ctf_enums.ctn_writable); 1643 ctf_dynhash_destroy (fp->ctf_names.ctn_writable); 1644 } 1645 else 1646 { 1647 ctf_hash_destroy (fp->ctf_structs.ctn_readonly); 1648 ctf_hash_destroy (fp->ctf_unions.ctn_readonly); 1649 ctf_hash_destroy (fp->ctf_enums.ctn_readonly); 1650 ctf_hash_destroy (fp->ctf_names.ctn_readonly); 1651 } 1652 1653 for (dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL; dvd = nvd) 1654 { 1655 nvd = ctf_list_next (dvd); 1656 ctf_dvd_delete (fp, dvd); 1657 } 1658 ctf_dynhash_destroy (fp->ctf_dvhash); 1659 ctf_str_free_atoms (fp); 1660 free (fp->ctf_tmp_typeslice); 1661 1662 if (fp->ctf_data.cts_name != _CTF_NULLSTR) 1663 free ((char *) fp->ctf_data.cts_name); 1664 1665 if (fp->ctf_symtab.cts_name != _CTF_NULLSTR) 1666 free ((char *) fp->ctf_symtab.cts_name); 1667 1668 if (fp->ctf_strtab.cts_name != _CTF_NULLSTR) 1669 free ((char *) fp->ctf_strtab.cts_name); 1670 else if (fp->ctf_data_mmapped) 1671 ctf_munmap (fp->ctf_data_mmapped, fp->ctf_data_mmapped_len); 1672 1673 free (fp->ctf_dynbase); 1674 1675 ctf_dynhash_destroy (fp->ctf_syn_ext_strtab); 1676 ctf_dynhash_destroy (fp->ctf_link_inputs); 1677 ctf_dynhash_destroy (fp->ctf_link_outputs); 1678 ctf_dynhash_destroy (fp->ctf_link_type_mapping); 1679 ctf_dynhash_destroy (fp->ctf_link_cu_mapping); 1680 ctf_dynhash_destroy (fp->ctf_add_processing); 1681 1682 free (fp->ctf_sxlate); 1683 free (fp->ctf_txlate); 1684 free (fp->ctf_ptrtab); 1685 1686 free (fp->ctf_header); 1687 free (fp); 1688 } 1689 1690 /* The converse of ctf_open(). ctf_open() disguises whatever it opens as an 1691 archive, so closing one is just like closing an archive. */ 1692 void 1693 ctf_close (ctf_archive_t *arc) 1694 { 1695 ctf_arc_close (arc); 1696 } 1697 1698 /* Get the CTF archive from which this ctf_file_t is derived. */ 1699 ctf_archive_t * 1700 ctf_get_arc (const ctf_file_t *fp) 1701 { 1702 return fp->ctf_archive; 1703 } 1704 1705 /* Return the ctfsect out of the core ctf_impl. Useful for freeing the 1706 ctfsect's data * after ctf_file_close(), which is why we return the actual 1707 structure, not a pointer to it, since that is likely to become a pointer to 1708 freed data before the return value is used under the expected use case of 1709 ctf_getsect()/ ctf_file_close()/free(). */ 1710 ctf_sect_t 1711 ctf_getdatasect (const ctf_file_t *fp) 1712 { 1713 return fp->ctf_data; 1714 } 1715 1716 /* Return the CTF handle for the parent CTF container, if one exists. 1717 Otherwise return NULL to indicate this container has no imported parent. */ 1718 ctf_file_t * 1719 ctf_parent_file (ctf_file_t *fp) 1720 { 1721 return fp->ctf_parent; 1722 } 1723 1724 /* Return the name of the parent CTF container, if one exists. Otherwise 1725 return NULL to indicate this container is a root container. */ 1726 const char * 1727 ctf_parent_name (ctf_file_t *fp) 1728 { 1729 return fp->ctf_parname; 1730 } 1731 1732 /* Set the parent name. It is an error to call this routine without calling 1733 ctf_import() at some point. */ 1734 int 1735 ctf_parent_name_set (ctf_file_t *fp, const char *name) 1736 { 1737 if (fp->ctf_dynparname != NULL) 1738 free (fp->ctf_dynparname); 1739 1740 if ((fp->ctf_dynparname = strdup (name)) == NULL) 1741 return (ctf_set_errno (fp, ENOMEM)); 1742 fp->ctf_parname = fp->ctf_dynparname; 1743 return 0; 1744 } 1745 1746 /* Return the name of the compilation unit this CTF file applies to. Usually 1747 non-NULL only for non-parent containers. */ 1748 const char * 1749 ctf_cuname (ctf_file_t *fp) 1750 { 1751 return fp->ctf_cuname; 1752 } 1753 1754 /* Set the compilation unit name. */ 1755 int 1756 ctf_cuname_set (ctf_file_t *fp, const char *name) 1757 { 1758 if (fp->ctf_dyncuname != NULL) 1759 free (fp->ctf_dyncuname); 1760 1761 if ((fp->ctf_dyncuname = strdup (name)) == NULL) 1762 return (ctf_set_errno (fp, ENOMEM)); 1763 fp->ctf_cuname = fp->ctf_dyncuname; 1764 return 0; 1765 } 1766 1767 /* Import the types from the specified parent container by storing a pointer 1768 to it in ctf_parent and incrementing its reference count. Only one parent 1769 is allowed: if a parent already exists, it is replaced by the new parent. */ 1770 int 1771 ctf_import (ctf_file_t *fp, ctf_file_t *pfp) 1772 { 1773 if (fp == NULL || fp == pfp || (pfp != NULL && pfp->ctf_refcnt == 0)) 1774 return (ctf_set_errno (fp, EINVAL)); 1775 1776 if (pfp != NULL && pfp->ctf_dmodel != fp->ctf_dmodel) 1777 return (ctf_set_errno (fp, ECTF_DMODEL)); 1778 1779 if (fp->ctf_parent != NULL) 1780 { 1781 fp->ctf_parent->ctf_refcnt--; 1782 ctf_file_close (fp->ctf_parent); 1783 fp->ctf_parent = NULL; 1784 } 1785 1786 if (pfp != NULL) 1787 { 1788 int err; 1789 1790 if (fp->ctf_parname == NULL) 1791 if ((err = ctf_parent_name_set (fp, "PARENT")) < 0) 1792 return err; 1793 1794 fp->ctf_flags |= LCTF_CHILD; 1795 pfp->ctf_refcnt++; 1796 } 1797 1798 fp->ctf_parent = pfp; 1799 return 0; 1800 } 1801 1802 /* Set the data model constant for the CTF container. */ 1803 int 1804 ctf_setmodel (ctf_file_t *fp, int model) 1805 { 1806 const ctf_dmodel_t *dp; 1807 1808 for (dp = _libctf_models; dp->ctd_name != NULL; dp++) 1809 { 1810 if (dp->ctd_code == model) 1811 { 1812 fp->ctf_dmodel = dp; 1813 return 0; 1814 } 1815 } 1816 1817 return (ctf_set_errno (fp, EINVAL)); 1818 } 1819 1820 /* Return the data model constant for the CTF container. */ 1821 int 1822 ctf_getmodel (ctf_file_t *fp) 1823 { 1824 return fp->ctf_dmodel->ctd_code; 1825 } 1826 1827 /* The caller can hang an arbitrary pointer off each ctf_file_t using this 1828 function. */ 1829 void 1830 ctf_setspecific (ctf_file_t *fp, void *data) 1831 { 1832 fp->ctf_specific = data; 1833 } 1834 1835 /* Retrieve the arbitrary pointer again. */ 1836 void * 1837 ctf_getspecific (ctf_file_t *fp) 1838 { 1839 return fp->ctf_specific; 1840 } 1841