1 /* 2 * This file and its contents are supplied under the terms of the 3 * Common Development and Distribution License ("CDDL"), version 1.0. 4 * You may only use this file in accordance with the terms of version 5 * 1.0 of the CDDL. 6 * 7 * A full copy of the text of the CDDL should have accompanied this 8 * source. A copy of the CDDL is also available via the Internet at 9 * http://www.illumos.org/license/CDDL. 10 */ 11 12 /* 13 * Copyright (c) 2019, Joyent, Inc. 14 */ 15 16 /* 17 * Collection of common utilities for CTF testing. 18 */ 19 20 #include <strings.h> 21 #include <libctf.h> 22 #include "check-common.h" 23 24 typedef struct ctftests_lookup_cb { 25 ctf_file_t *clc_fp; 26 ctf_id_t clc_id; 27 const char *clc_name; 28 } ctftests_lookup_cb_t; 29 30 typedef struct ctftest_member_cb { 31 ctf_file_t *cmc_fp; 32 const check_member_t *cmc_members; 33 const char *cmc_name; 34 } ctftest_member_cb_t; 35 36 static int 37 ctftest_lookup_type_cb(ctf_id_t id, boolean_t root, void *arg) 38 { 39 char buf[2048]; 40 ctftests_lookup_cb_t *clc = arg; 41 42 if (ctf_type_name(clc->clc_fp, id, buf, sizeof (buf)) == NULL) 43 return (0); 44 45 if (strcmp(buf, clc->clc_name) != 0) 46 return (0); 47 48 clc->clc_id = id; 49 return (1); 50 } 51 52 /* 53 * This is a variant on the classic ctf_lookup_by_name(). ctf_lookup_by_name() 54 * skips qualifiers, which makes sense given what the consumers of it are trying 55 * to do. However, that's not what we want here. So instead we basically have to 56 * walk the type table. 57 */ 58 static ctf_id_t 59 ctftest_lookup_type(ctf_file_t *fp, const char *name) 60 { 61 ctftests_lookup_cb_t clc; 62 63 clc.clc_fp = fp; 64 clc.clc_id = CTF_ERR; 65 clc.clc_name = name; 66 67 (void) ctf_type_iter(fp, B_TRUE, ctftest_lookup_type_cb, &clc); 68 return (clc.clc_id); 69 } 70 71 static int 72 ctftest_lookup_object_cb(const char *obj, ctf_id_t type, ulong_t idx, void *arg) 73 { 74 ctftests_lookup_cb_t *clc = arg; 75 76 if (strcmp(obj, clc->clc_name) == 0) { 77 clc->clc_id = type; 78 return (1); 79 } 80 81 return (0); 82 } 83 84 static ctf_id_t 85 ctftest_lookup_symbol(ctf_file_t *fp, const char *name) 86 { 87 ctftests_lookup_cb_t clc; 88 89 clc.clc_fp = fp; 90 clc.clc_id = CTF_ERR; 91 clc.clc_name = name; 92 93 (void) ctf_object_iter(fp, ctftest_lookup_object_cb, &clc); 94 return (clc.clc_id); 95 } 96 97 typedef struct ctf_function_cb { 98 const char *cfc_name; 99 ulong_t *cfc_symp; 100 ctf_funcinfo_t *cfc_fip; 101 } ctf_function_cb_t; 102 103 static int 104 ctftest_lookup_function_cb(const char *name, ulong_t symidx, 105 ctf_funcinfo_t *fip, void *arg) 106 { 107 ctf_function_cb_t *cfc = arg; 108 if (strcmp(name, cfc->cfc_name) != 0) 109 return (0); 110 111 *cfc->cfc_symp = symidx; 112 *cfc->cfc_fip = *fip; 113 114 return (1); 115 } 116 117 /* 118 * Note, this function finds the first one with a matching name. This must not 119 * be used when performing searches where a given name may occur more than once. 120 */ 121 static boolean_t 122 ctftest_lookup_function(ctf_file_t *fp, const char *name, ulong_t *symp, 123 ctf_funcinfo_t *fip) 124 { 125 ctf_function_cb_t cfc; 126 127 *symp = 0; 128 cfc.cfc_name = name; 129 cfc.cfc_symp = symp; 130 cfc.cfc_fip = fip; 131 (void) ctf_function_iter(fp, ctftest_lookup_function_cb, &cfc); 132 return (*symp == 0 ? B_FALSE : B_TRUE); 133 } 134 135 boolean_t 136 ctftest_check_numbers(ctf_file_t *fp, const check_number_t *tests) 137 { 138 uint_t i; 139 boolean_t ret = B_TRUE; 140 141 for (i = 0; tests[i].cn_tname != NULL; i++) { 142 ctf_id_t id; 143 ctf_encoding_t enc; 144 145 id = ctftest_lookup_type(fp, tests[i].cn_tname); 146 if (id == CTF_ERR) { 147 warnx("failed to look up %s", tests[i].cn_tname); 148 ret = B_FALSE; 149 continue; 150 } 151 152 if (ctf_type_kind(fp, id) != tests[i].cn_kind) { 153 warnx("type kind mismatch for %s: got %u, expected %u", 154 tests[i].cn_tname, ctf_type_kind(fp, id), 155 tests[i].cn_kind); 156 ret = B_FALSE; 157 continue; 158 } 159 160 if (ctf_type_encoding(fp, id, &enc) == CTF_ERR) { 161 warnx("failed to get type encoding for %s: %s", 162 tests[i].cn_tname, ctf_errmsg(ctf_errno(fp))); 163 ret = B_FALSE; 164 continue; 165 } 166 167 if (enc.cte_format != tests[i].cn_flags) { 168 warnx("encoding flags mismatch for %s: got 0x%x, " 169 "expected 0x%x", tests[i].cn_tname, enc.cte_format, 170 tests[i].cn_flags); 171 ret = B_FALSE; 172 continue; 173 } 174 175 if (enc.cte_offset != tests[i].cn_offset) { 176 warnx("encoding offset mismatch for %s: got 0x%x, " 177 "expected 0x%x", tests[i].cn_tname, enc.cte_offset, 178 tests[i].cn_offset); 179 ret = B_FALSE; 180 continue; 181 } 182 183 if (enc.cte_bits != tests[i].cn_size) { 184 warnx("encoding size mismatch for %s: got 0x%x, " 185 "expected 0x%x", tests[i].cn_tname, enc.cte_bits, 186 tests[i].cn_size); 187 ret = B_FALSE; 188 continue; 189 } 190 } 191 192 return (ret); 193 } 194 195 typedef struct ctftests_symbol_cb { 196 ctf_file_t *csc_fp; 197 boolean_t csc_ret; 198 const check_symbol_t *csc_tests; 199 } ctftest_symbol_cb_t; 200 201 static int 202 ctftest_check_symbol_cb(const char *obj, ctf_id_t type, ulong_t idx, void *arg) 203 { 204 ctftest_symbol_cb_t *cb = arg; 205 const check_symbol_t *tests = cb->csc_tests; 206 ctf_file_t *fp = cb->csc_fp; 207 uint_t i; 208 209 for (i = 0; tests[i].cs_symbol != NULL; i++) { 210 ctf_id_t id; 211 212 if (strcmp(obj, tests[i].cs_symbol) != 0) 213 continue; 214 215 id = ctftest_lookup_type(fp, tests[i].cs_type); 216 if (id == CTF_ERR) { 217 warnx("failed to lookup type %s for symbol %s", 218 tests[i].cs_type, tests[i].cs_symbol); 219 cb->csc_ret = B_FALSE; 220 return (0); 221 } 222 223 if (id != type) { 224 warnx("type mismatch for symbol %s, has type id %u, " 225 "but specified type %s has id %u", 226 tests[i].cs_symbol, type, tests[i].cs_type, id); 227 cb->csc_ret = B_FALSE; 228 return (0); 229 } 230 } 231 232 return (0); 233 } 234 235 boolean_t 236 ctftest_check_symbols(ctf_file_t *fp, const check_symbol_t *tests) 237 { 238 ctftest_symbol_cb_t cb; 239 240 cb.csc_fp = fp; 241 cb.csc_ret = B_TRUE; 242 cb.csc_tests = tests; 243 if (ctf_object_iter(fp, ctftest_check_symbol_cb, &cb) != 0) 244 return (B_FALSE); 245 return (cb.csc_ret); 246 } 247 248 249 boolean_t 250 ctftest_check_descent(const char *symbol, ctf_file_t *fp, 251 const check_descent_t *tests) 252 { 253 ctf_id_t base; 254 uint_t layer = 0; 255 256 /* 257 * First, find the initial type of the symbol. 258 */ 259 base = ctftest_lookup_symbol(fp, symbol); 260 if (base == CTF_ERR) { 261 warnx("failed to lookup type for symbol %s", symbol); 262 return (B_FALSE); 263 } 264 265 while (tests->cd_tname != NULL) { 266 ctf_id_t tid; 267 int kind; 268 ctf_arinfo_t ari; 269 270 if (base == CTF_ERR) { 271 warnx("encountered non-reference type at layer %u " 272 "while still expecting type %s for symbol %s", 273 layer, tests->cd_tname, symbol); 274 return (B_FALSE); 275 } 276 277 tid = ctftest_lookup_type(fp, tests->cd_tname); 278 if (tid == CTF_ERR) { 279 warnx("failed to lookup type %s", tests->cd_tname); 280 return (B_FALSE); 281 } 282 283 if (tid != base) { 284 warnx("type mismatch at layer %u: found id %u, but " 285 "expecting type id %u for type %s, symbol %s", 286 layer, base, tid, tests->cd_tname, symbol); 287 return (B_FALSE); 288 } 289 290 kind = ctf_type_kind(fp, base); 291 if (kind != tests->cd_kind) { 292 warnx("type kind mismatch at layer %u: found kind %u, " 293 "but expected kind %u for %s, symbol %s", layer, 294 kind, tests->cd_kind, tests->cd_tname, symbol); 295 return (B_FALSE); 296 } 297 298 switch (kind) { 299 case CTF_K_ARRAY: 300 if (ctf_array_info(fp, base, &ari) == CTF_ERR) { 301 warnx("failed to lookup array info at layer " 302 "%u for type %s, symbol %s: %s", base, 303 tests->cd_tname, symbol, 304 ctf_errmsg(ctf_errno(fp))); 305 return (B_FALSE); 306 } 307 308 if (tests->cd_nents != ari.ctr_nelems) { 309 warnx("array element mismatch at layer %u " 310 "for type %s, symbol %s: found %u, " 311 "expected %u", layer, tests->cd_tname, 312 symbol, ari.ctr_nelems, tests->cd_nents); 313 return (B_FALSE); 314 } 315 316 tid = ctftest_lookup_type(fp, tests->cd_contents); 317 if (tid == CTF_ERR) { 318 warnx("failed to look up type %s", 319 tests->cd_contents); 320 return (B_FALSE); 321 } 322 323 if (ari.ctr_contents != tid) { 324 warnx("array contents mismatch at layer %u " 325 "for type %s, symbol %s: found %u, " 326 "expected %s/%u", layer, tests->cd_tname, 327 symbol, ari.ctr_contents, 328 tests->cd_contents, tid); 329 330 return (B_FALSE); 331 } 332 base = ari.ctr_contents; 333 break; 334 default: 335 base = ctf_type_reference(fp, base); 336 break; 337 } 338 339 tests++; 340 layer++; 341 } 342 343 if (base != CTF_ERR) { 344 warnx("found additional type %u in chain, but expected no more", 345 base); 346 return (B_FALSE); 347 } 348 349 return (B_TRUE); 350 } 351 352 int 353 ctftest_check_enum_count(const char *name, int value, void *arg) 354 { 355 uint_t *u = arg; 356 *u = *u + 1; 357 return (0); 358 } 359 360 int 361 ctftest_check_enum_value(const char *name, int value, void *arg) 362 { 363 uint_t i; 364 const check_enum_t *enums = arg; 365 366 for (i = 0; enums[i].ce_name != NULL; i++) { 367 if (strcmp(enums[i].ce_name, name) != 0) 368 continue; 369 if (enums[i].ce_value == (int64_t)value) 370 return (0); 371 warnx("enum %s value mismatch: found %d, expected %" PRId64, 372 name, value, enums[i].ce_value); 373 return (1); 374 } 375 376 warnx("found no matching entry for enum member %s", name); 377 return (1); 378 } 379 380 boolean_t 381 ctftest_check_enum(const char *type, ctf_file_t *fp, const check_enum_t *enums) 382 { 383 int ret; 384 uint_t tcount, ecount; 385 ctf_id_t base; 386 387 if ((base = ctftest_lookup_type(fp, type)) == CTF_ERR) { 388 warnx("Failed to look up type %s", type); 389 return (B_FALSE); 390 } 391 392 if (ctf_type_kind(fp, base) != CTF_K_ENUM) { 393 warnx("%s is not an enum", type); 394 return (B_FALSE); 395 } 396 397 /* 398 * First count how many entries we have. 399 */ 400 tcount = 0; 401 while (enums[tcount].ce_name != NULL) { 402 tcount++; 403 } 404 405 ecount = 0; 406 if (ctf_enum_iter(fp, base, ctftest_check_enum_count, &ecount) != 0) { 407 warnx("failed to walk enum %s: %s", type, 408 ctf_errmsg(ctf_errno(fp))); 409 return (B_FALSE); 410 } 411 412 if (tcount != ecount) { 413 warnx("enum value mismatch: expected %u values, but found %u", 414 tcount, ecount); 415 return (B_FALSE); 416 } 417 418 if ((ret = ctf_enum_iter(fp, base, ctftest_check_enum_value, 419 (void *)enums)) != 0) { 420 if (ret == -1) { 421 warnx("failed to walk enum %s: %s", type, 422 ctf_errmsg(ctf_errno(fp))); 423 } 424 return (B_FALSE); 425 } 426 427 return (B_TRUE); 428 } 429 430 int 431 ctftest_check_member_count(const char *mname, ctf_id_t mtype, ulong_t bitoff, 432 void *arg) 433 { 434 uint_t *countp = arg; 435 *countp = *countp + 1; 436 return (0); 437 } 438 439 int 440 ctftest_check_members_cb(const char *mname, ctf_id_t mtype, ulong_t bitoff, 441 void *arg) 442 { 443 uint_t i; 444 const ctftest_member_cb_t *cmc = arg; 445 const check_member_t *members = cmc->cmc_members; 446 ctf_file_t *fp = cmc->cmc_fp; 447 448 for (i = 0; members[i].cm_name != NULL; i++) { 449 boolean_t bad = B_FALSE; 450 char buf[2048]; 451 452 if (strcmp(mname, members[i].cm_name) != 0) 453 continue; 454 455 if (bitoff != members[i].cm_offset) { 456 warnx("member %s of type %s has mismatched bit offset: " 457 "found %lu, expected %lu", mname, cmc->cmc_name, 458 bitoff, members[i].cm_offset); 459 bad = B_TRUE; 460 } 461 462 if (ctf_type_name(fp, mtype, buf, sizeof (buf)) == NULL) { 463 warnx("failed to obtain type name for member %s", 464 mname, ctf_errmsg(ctf_errno(fp))); 465 bad = B_TRUE; 466 } else if (strcmp(buf, members[i].cm_type) != 0) { 467 warnx("member %s has bad type, found %s, expected %s", 468 mname, buf, members[i].cm_type); 469 bad = B_TRUE; 470 } 471 472 return (bad ? 1 : 0); 473 } 474 475 warnx("found no matching entry for member %s of type %s", mname, 476 cmc->cmc_name); 477 return (1); 478 } 479 480 boolean_t 481 ctftest_check_members(const char *type, ctf_file_t *fp, int kind, 482 size_t size, const check_member_t *members) 483 { 484 int ret; 485 uint_t tcount, mcount; 486 ctf_id_t base; 487 ctftest_member_cb_t cmc; 488 489 if ((base = ctftest_lookup_type(fp, type)) == CTF_ERR) { 490 warnx("failed to look up type %s", type); 491 return (B_FALSE); 492 } 493 494 if (ctf_type_kind(fp, base) != kind) { 495 warnx("%s has kind %s, expected %s", type, 496 ctf_kind_name(fp, ctf_type_kind(fp, base)), 497 ctf_kind_name(fp, kind)); 498 return (B_FALSE); 499 } 500 501 if (size != ctf_type_size(fp, base)) { 502 warnx("%s has bad size, expected %lu, found %lu", 503 type, size, ctf_type_size(fp, base)); 504 return (B_FALSE); 505 } 506 507 /* 508 * First count how many entries we have. 509 */ 510 tcount = 0; 511 while (members[tcount].cm_name != NULL) { 512 tcount++; 513 } 514 515 mcount = 0; 516 if (ctf_member_iter(fp, base, ctftest_check_member_count, &mcount) != 517 0) { 518 warnx("failed to walk members of %s: %s", type, 519 ctf_errmsg(ctf_errno(fp))); 520 return (B_FALSE); 521 } 522 523 if (tcount != mcount) { 524 warnx("type member mismatch: expected %u values, but found %u", 525 tcount, mcount); 526 return (B_FALSE); 527 } 528 529 cmc.cmc_fp = fp; 530 cmc.cmc_members = members; 531 cmc.cmc_name = type; 532 if ((ret = ctf_member_iter(fp, base, ctftest_check_members_cb, 533 &cmc)) != 0) { 534 if (ret == -1) { 535 warnx("failed to walk type %s: %s", type, 536 ctf_errmsg(ctf_errno(fp))); 537 } 538 return (B_FALSE); 539 } 540 541 return (B_TRUE); 542 } 543 544 boolean_t 545 ctftest_check_function(const char *symbol, ctf_file_t *fp, const char *rtype, 546 uint_t nargs, uint_t flags, const char **argv) 547 { 548 ulong_t sym; 549 ctf_funcinfo_t fi; 550 uint_t i; 551 boolean_t ret = B_TRUE; 552 ctf_id_t *args; 553 char buf[2048]; 554 555 556 if (!ctftest_lookup_function(fp, symbol, &sym, &fi)) { 557 warnx("failed to look up function %s", symbol); 558 return (B_FALSE); 559 } 560 561 if (ctf_type_name(fp, fi.ctc_return, buf, sizeof (buf)) == NULL) { 562 warnx("failed to lookup return type name for function %s", 563 symbol); 564 ret = B_FALSE; 565 } else if (strcmp(rtype, buf) != 0) { 566 warnx("return type has wrong type: found %s, expected %s", 567 buf, rtype); 568 ret = B_FALSE; 569 } 570 571 if (nargs != fi.ctc_argc) { 572 warnx("function argument mismatch: found %u, expected %u", 573 fi.ctc_argc, nargs); 574 ret = B_FALSE; 575 } 576 577 if (flags != fi.ctc_flags) { 578 warnx("function flags mismatch, found 0x%x, expected 0x%x", 579 fi.ctc_flags, flags); 580 ret = B_FALSE; 581 } 582 583 if (!ret || fi.ctc_argc == 0) { 584 return (ret); 585 } 586 587 if ((args = calloc(fi.ctc_argc, sizeof (ctf_id_t))) == NULL) { 588 warnx("failed to allocate memory for function arguments"); 589 return (B_FALSE); 590 } 591 592 if (ctf_func_args(fp, sym, fi.ctc_argc, args) != 0) { 593 warnx("failed to get function information: %s", 594 ctf_errmsg(ctf_errno(fp))); 595 free(args); 596 return (B_FALSE); 597 } 598 599 for (i = 0; i < fi.ctc_argc; i++) { 600 if (ctf_type_name(fp, args[i], buf, sizeof (buf)) == NULL) { 601 warnx("failed to obtain type name for argument %u", 602 i, ctf_errmsg(ctf_errno(fp))); 603 ret = B_FALSE; 604 break; 605 } 606 607 if (strcmp(buf, argv[i]) != 0) { 608 warnx("argument %u has wrong type: found %s, " 609 "expected %s", i, buf, argv[i]); 610 ret = B_FALSE; 611 break; 612 } 613 } 614 615 free(args); 616 return (ret); 617 } 618 619 boolean_t 620 ctftest_check_fptr(const char *type, ctf_file_t *fp, const char *rtype, 621 uint_t nargs, uint_t flags, const char **argv) 622 { 623 ctf_id_t tid; 624 ctf_funcinfo_t fi; 625 uint_t i; 626 boolean_t ret = B_TRUE; 627 ctf_id_t *args; 628 char buf[2048]; 629 630 631 if ((tid = ctf_lookup_by_name(fp, type)) == CTF_ERR) { 632 warnx("failed to look up type %s: %s", type, 633 ctf_errmsg(ctf_errno(fp))); 634 return (B_FALSE); 635 } 636 637 /* 638 * Perform two CTF type resolves, one for the function pointer and one 639 * for the typedef that gets passed in. 640 */ 641 if ((tid = ctf_type_resolve(fp, tid)) == CTF_ERR) { 642 warnx("failed to convert type %s to base type: %s", type, 643 ctf_errmsg(ctf_errno(fp))); 644 return (B_FALSE); 645 } 646 647 if (ctf_type_kind(fp, tid) == CTF_K_POINTER && 648 (tid = ctf_type_reference(fp, tid)) == CTF_ERR) { 649 warnx("failed to convert type %s to base type: %s", type, 650 ctf_errmsg(ctf_errno(fp))); 651 return (B_FALSE); 652 } 653 654 if (ctf_func_info_by_id(fp, tid, &fi) != 0) { 655 warnx("failed to get function information for type %s: %s", 656 type, ctf_errmsg(ctf_errno(fp))); 657 return (B_FALSE); 658 } 659 660 if (ctf_type_name(fp, fi.ctc_return, buf, sizeof (buf)) == NULL) { 661 warnx("failed to lookup return type name for function %s", 662 type); 663 ret = B_FALSE; 664 } else if (strcmp(rtype, buf) != 0) { 665 warnx("return type has wrong type: found %s, expected %s", 666 buf, rtype); 667 ret = B_FALSE; 668 } 669 670 if (nargs != fi.ctc_argc) { 671 warnx("function argument mismatch: found %u, expected %u", 672 fi.ctc_argc, nargs); 673 ret = B_FALSE; 674 } 675 676 if (flags != fi.ctc_flags) { 677 warnx("function flags mismatch, found 0x%x, expected 0x%x", 678 fi.ctc_flags, flags); 679 ret = B_FALSE; 680 } 681 682 if (!ret || fi.ctc_argc == 0) { 683 return (ret); 684 } 685 686 if ((args = calloc(fi.ctc_argc, sizeof (ctf_id_t))) == NULL) { 687 warnx("failed to allocate memory for function arguments"); 688 return (B_FALSE); 689 } 690 691 if (ctf_func_args_by_id(fp, tid, fi.ctc_argc, args) != 0) { 692 warnx("failed to get function information: %s", 693 ctf_errmsg(ctf_errno(fp))); 694 free(args); 695 return (B_FALSE); 696 } 697 698 for (i = 0; i < fi.ctc_argc; i++) { 699 if (ctf_type_name(fp, args[i], buf, sizeof (buf)) == NULL) { 700 warnx("failed to obtain type name for argument %u", 701 i, ctf_errmsg(ctf_errno(fp))); 702 ret = B_FALSE; 703 break; 704 } 705 706 if (strcmp(buf, argv[i]) != 0) { 707 warnx("argument %u has wrong type: found %s, " 708 "expected %s", i, buf, argv[i]); 709 ret = B_FALSE; 710 break; 711 } 712 } 713 714 free(args); 715 return (ret); 716 } 717 718 typedef struct ctftest_duplicates { 719 ctf_file_t *ctd_fp; 720 char **ctd_names; 721 size_t ctd_len; 722 size_t ctd_curent; 723 boolean_t ctd_ret; 724 } ctftest_duplicates_t; 725 726 static int 727 ctftest_duplicates_cb(ctf_id_t id, boolean_t root, void *arg) 728 { 729 char buf[2048]; 730 ctftest_duplicates_t *dup = arg; 731 size_t i; 732 733 if (ctf_type_name(dup->ctd_fp, id, buf, sizeof (buf)) == NULL) { 734 warnx("failed to lookup name for id %ld", id); 735 dup->ctd_ret = B_FALSE; 736 return (1); 737 } 738 739 for (i = 0; i < dup->ctd_curent; i++) { 740 if (strcmp(buf, dup->ctd_names[i]) == 0) { 741 warnx("encountered duplicate type '%s'", buf); 742 dup->ctd_ret = B_FALSE; 743 /* 744 * Don't break out of the loop and keep going in case we 745 * find another duplicate. 746 */ 747 return (0); 748 } 749 } 750 751 if (dup->ctd_curent == dup->ctd_len) { 752 char **n; 753 size_t newlen = dup->ctd_len * 2; 754 755 n = recallocarray(dup->ctd_names, dup->ctd_len, newlen, 756 sizeof (char *)); 757 if (n == NULL) { 758 warnx("failed to resize type name array"); 759 dup->ctd_ret = B_FALSE; 760 return (1); 761 } 762 763 dup->ctd_names = n; 764 dup->ctd_len = newlen; 765 } 766 767 dup->ctd_names[dup->ctd_curent] = strdup(buf); 768 if (dup->ctd_names[dup->ctd_curent] == NULL) { 769 warn("failed to duplicate type name"); 770 dup->ctd_ret = B_FALSE; 771 return (1); 772 } 773 dup->ctd_curent++; 774 775 return (0); 776 } 777 778 boolean_t 779 ctftest_duplicates(ctf_file_t *fp) 780 { 781 size_t i; 782 ctftest_duplicates_t d; 783 784 bzero(&d, sizeof (d)); 785 d.ctd_fp = fp; 786 d.ctd_len = 4; 787 d.ctd_ret = B_TRUE; 788 d.ctd_names = recallocarray(NULL, 0, d.ctd_len, sizeof (char *)); 789 if (d.ctd_names == NULL) { 790 warnx("failed to allocate duplicate name storage"); 791 return (B_FALSE); 792 } 793 794 (void) ctf_type_iter(fp, B_TRUE, ctftest_duplicates_cb, &d); 795 796 for (i = 0; i < d.ctd_curent; i++) { 797 free(d.ctd_names[i]); 798 } 799 free(d.ctd_names); 800 801 return (d.ctd_ret); 802 } 803