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 2020 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, boolean_t quiet)
 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                         if (!quiet) {
 272                                 warnx("encountered non-reference type at layer "
 273                                     "%u while still expecting type %s for "
 274                                     "symbol %s", layer,
 275                                     tests->cd_tname, symbol);
 276                         }
 277                         return (B_FALSE);
 278                 }
 279 
 280                 tid = ctftest_lookup_type(fp, tests->cd_tname);
 281                 if (tid == CTF_ERR) {
 282                         if (!quiet) {
 283                                 warnx("failed to lookup type %s",
 284                                     tests->cd_tname);
 285                         }
 286                         return (B_FALSE);
 287                 }
 288 
 289                 if (tid != base) {
 290                         if (!quiet) {
 291                                 warnx("type mismatch at layer %u: found id %u, "
 292                                     "but expecting type id %u for type %s, "
 293                                     "symbol %s", layer, base, tid,
 294                                     tests->cd_tname, symbol);
 295                         }
 296                         return (B_FALSE);
 297                 }
 298 
 299                 kind = ctf_type_kind(fp, base);
 300                 if (kind != tests->cd_kind) {
 301                         if (!quiet) {
 302                                 warnx("type kind mismatch at layer %u: found "
 303                                     "kind %u, but expected kind %u for %s, "
 304                                     "symbol %s", layer, kind, tests->cd_kind,
 305                                     tests->cd_tname, symbol);
 306                         }
 307                         return (B_FALSE);
 308                 }
 309 
 310                 switch (kind) {
 311                 case CTF_K_ARRAY:
 312                         if (ctf_array_info(fp, base, &ari) == CTF_ERR) {
 313                                 if (!quiet) {
 314                                         warnx("failed to lookup array info at "
 315                                             "layer %u for type %s, symbol "
 316                                             "%s: %s", base, tests->cd_tname,
 317                                             symbol, ctf_errmsg(ctf_errno(fp)));
 318                                 }
 319                                 return (B_FALSE);
 320                         }
 321 
 322                         if (tests->cd_nents != ari.ctr_nelems) {
 323                                 if (!quiet) {
 324                                         warnx("array element mismatch at layer "
 325                                             "%u for type %s, symbol %s: found "
 326                                             "%u, expected %u", layer,
 327                                             tests->cd_tname, symbol,
 328                                             ari.ctr_nelems, tests->cd_nents);
 329                                 }
 330                                 return (B_FALSE);
 331                         }
 332 
 333                         tid = ctftest_lookup_type(fp, tests->cd_contents);
 334                         if (tid == CTF_ERR) {
 335                                 if (!quiet) {
 336                                         warnx("failed to look up type %s",
 337                                             tests->cd_contents);
 338                                 }
 339                                 return (B_FALSE);
 340                         }
 341 
 342                         if (ari.ctr_contents != tid) {
 343                                 if (!quiet) {
 344                                         warnx("array contents mismatch at "
 345                                             "layer %u for type %s, symbol %s: "
 346                                             "found %u, expected %s/%u", layer,
 347                                             tests->cd_tname, symbol,
 348                                             ari.ctr_contents,
 349                                             tests->cd_contents, tid);
 350                                 }
 351                                 return (B_FALSE);
 352                         }
 353                         base = ari.ctr_contents;
 354                         break;
 355                 default:
 356                         base = ctf_type_reference(fp, base);
 357                         break;
 358                 }
 359 
 360                 tests++;
 361                 layer++;
 362         }
 363 
 364         if (base != CTF_ERR) {
 365                 if (!quiet) {
 366                         warnx("found additional type %u in chain, "
 367                             "but expected no more", base);
 368                 }
 369                 return (B_FALSE);
 370         }
 371 
 372         return (B_TRUE);
 373 }
 374 
 375 int
 376 ctftest_check_enum_count(const char *name, int value, void *arg)
 377 {
 378         uint_t *u = arg;
 379         *u = *u + 1;
 380         return (0);
 381 }
 382 
 383 int
 384 ctftest_check_enum_value(const char *name, int value, void *arg)
 385 {
 386         uint_t i;
 387         const check_enum_t *enums = arg;
 388 
 389         for (i = 0; enums[i].ce_name != NULL; i++) {
 390                 if (strcmp(enums[i].ce_name, name) != 0)
 391                         continue;
 392                 if (enums[i].ce_value == (int64_t)value)
 393                         return (0);
 394                 warnx("enum %s value mismatch: found %d, expected %" PRId64,
 395                     name, value, enums[i].ce_value);
 396                 return (1);
 397         }
 398 
 399         warnx("found no matching entry for enum member %s", name);
 400         return (1);
 401 }
 402 
 403 boolean_t
 404 ctftest_check_enum(const char *type, ctf_file_t *fp, const check_enum_t *enums)
 405 {
 406         int ret;
 407         uint_t tcount, ecount;
 408         ctf_id_t base;
 409 
 410         if ((base = ctftest_lookup_type(fp, type)) == CTF_ERR) {
 411                 warnx("Failed to look up type %s", type);
 412                 return (B_FALSE);
 413         }
 414 
 415         if (ctf_type_kind(fp, base) != CTF_K_ENUM) {
 416                 warnx("%s is not an enum", type);
 417                 return (B_FALSE);
 418         }
 419 
 420         /*
 421          * First count how many entries we have.
 422          */
 423         tcount = 0;
 424         while (enums[tcount].ce_name != NULL) {
 425                 tcount++;
 426         }
 427 
 428         ecount = 0;
 429         if (ctf_enum_iter(fp, base, ctftest_check_enum_count, &ecount) != 0) {
 430                 warnx("failed to walk enum %s: %s", type,
 431                     ctf_errmsg(ctf_errno(fp)));
 432                 return (B_FALSE);
 433         }
 434 
 435         if (tcount != ecount) {
 436                 warnx("enum value mismatch: expected %u values, but found %u",
 437                     tcount, ecount);
 438                 return (B_FALSE);
 439         }
 440 
 441         if ((ret = ctf_enum_iter(fp, base, ctftest_check_enum_value,
 442             (void *)enums)) != 0) {
 443                 if (ret == -1) {
 444                         warnx("failed to walk enum %s: %s", type,
 445                             ctf_errmsg(ctf_errno(fp)));
 446                 }
 447                 return (B_FALSE);
 448         }
 449 
 450         return (B_TRUE);
 451 }
 452 
 453 int
 454 ctftest_check_member_count(const char *mname, ctf_id_t mtype, ulong_t bitoff,
 455     void *arg)
 456 {
 457         uint_t *countp = arg;
 458         *countp = *countp + 1;
 459         return (0);
 460 }
 461 
 462 int
 463 ctftest_check_members_cb(const char *mname, ctf_id_t mtype, ulong_t bitoff,
 464     void *arg)
 465 {
 466         uint_t i;
 467         const ctftest_member_cb_t *cmc = arg;
 468         const check_member_t *members = cmc->cmc_members;
 469         ctf_file_t *fp = cmc->cmc_fp;
 470 
 471         for (i = 0; members[i].cm_name != NULL; i++) {
 472                 boolean_t bad = B_FALSE;
 473                 char buf[2048];
 474 
 475                 if (strcmp(mname, members[i].cm_name) != 0)
 476                         continue;
 477 
 478                 if (bitoff != members[i].cm_offset) {
 479                         warnx("member %s of type %s has mismatched bit offset: "
 480                             "found %lu, expected %lu", mname, cmc->cmc_name,
 481                             bitoff, members[i].cm_offset);
 482                         bad = B_TRUE;
 483                 }
 484 
 485                 if (ctf_type_name(fp, mtype, buf, sizeof (buf)) == NULL) {
 486                         warnx("failed to obtain type name for member %s",
 487                             mname, ctf_errmsg(ctf_errno(fp)));
 488                         bad = B_TRUE;
 489                 } else if (strcmp(buf, members[i].cm_type) != 0) {
 490                         warnx("member %s has bad type, found %s, expected %s",
 491                             mname, buf, members[i].cm_type);
 492                         bad = B_TRUE;
 493                 }
 494 
 495                 return (bad ? 1 : 0);
 496         }
 497 
 498         warnx("found no matching entry for member %s of type %s", mname,
 499             cmc->cmc_name);
 500         return (1);
 501 }
 502 
 503 boolean_t
 504 ctftest_check_members(const char *type, ctf_file_t *fp, int kind,
 505     size_t size, const check_member_t *members)
 506 {
 507         int ret;
 508         uint_t tcount, mcount;
 509         ctf_id_t base;
 510         ctftest_member_cb_t cmc;
 511 
 512         if ((base = ctftest_lookup_type(fp, type)) == CTF_ERR) {
 513                 warnx("failed to look up type %s", type);
 514                 return (B_FALSE);
 515         }
 516 
 517         if (ctf_type_kind(fp, base) != kind) {
 518                 warnx("%s has kind %s, expected %s", type,
 519                     ctf_kind_name(fp, ctf_type_kind(fp, base)),
 520                     ctf_kind_name(fp, kind));
 521                 return (B_FALSE);
 522         }
 523 
 524         if (size != ctf_type_size(fp, base)) {
 525                 warnx("%s has bad size, expected %lu, found %lu",
 526                     type, size, ctf_type_size(fp, base));
 527                 return (B_FALSE);
 528         }
 529 
 530         /*
 531          * First count how many entries we have.
 532          */
 533         tcount = 0;
 534         while (members[tcount].cm_name != NULL) {
 535                 tcount++;
 536         }
 537 
 538         mcount = 0;
 539         if (ctf_member_iter(fp, base, ctftest_check_member_count, &mcount) !=
 540             0) {
 541                 warnx("failed to walk members of %s: %s", type,
 542                     ctf_errmsg(ctf_errno(fp)));
 543                 return (B_FALSE);
 544         }
 545 
 546         if (tcount != mcount) {
 547                 warnx("type member mismatch: expected %u values, but found %u",
 548                     tcount, mcount);
 549                 return (B_FALSE);
 550         }
 551 
 552         cmc.cmc_fp = fp;
 553         cmc.cmc_members = members;
 554         cmc.cmc_name = type;
 555         if ((ret = ctf_member_iter(fp, base, ctftest_check_members_cb,
 556             &cmc)) != 0) {
 557                 if (ret == -1) {
 558                         warnx("failed to walk type %s: %s", type,
 559                             ctf_errmsg(ctf_errno(fp)));
 560                 }
 561                 return (B_FALSE);
 562         }
 563 
 564         return (B_TRUE);
 565 }
 566 
 567 boolean_t
 568 ctftest_check_function(const char *symbol, ctf_file_t *fp, const char *rtype,
 569     uint_t nargs, uint_t flags, const char **argv)
 570 {
 571         ulong_t sym;
 572         ctf_funcinfo_t fi;
 573         uint_t i;
 574         boolean_t ret = B_TRUE;
 575         ctf_id_t *args;
 576         char buf[2048];
 577 
 578 
 579         if (!ctftest_lookup_function(fp, symbol, &sym, &fi)) {
 580                 warnx("failed to look up function %s", symbol);
 581                 return (B_FALSE);
 582         }
 583 
 584         if (ctf_type_name(fp, fi.ctc_return, buf, sizeof (buf)) == NULL) {
 585                 warnx("failed to lookup return type name for function %s",
 586                     symbol);
 587                 ret = B_FALSE;
 588         } else if (strcmp(rtype, buf) != 0) {
 589                 warnx("return type has wrong type: found %s, expected %s",
 590                     buf, rtype);
 591                 ret = B_FALSE;
 592         }
 593 
 594         if (nargs != fi.ctc_argc) {
 595                 warnx("function argument mismatch: found %u, expected %u",
 596                     fi.ctc_argc, nargs);
 597                 ret = B_FALSE;
 598         }
 599 
 600         if (flags != fi.ctc_flags) {
 601                 warnx("function flags mismatch, found 0x%x, expected 0x%x",
 602                     fi.ctc_flags, flags);
 603                 ret = B_FALSE;
 604         }
 605 
 606         if (!ret || fi.ctc_argc == 0) {
 607                 return (ret);
 608         }
 609 
 610         if ((args = calloc(fi.ctc_argc, sizeof (ctf_id_t))) == NULL) {
 611                 warnx("failed to allocate memory for function arguments");
 612                 return (B_FALSE);
 613         }
 614 
 615         if (ctf_func_args(fp, sym, fi.ctc_argc, args) != 0) {
 616                 warnx("failed to get function information: %s",
 617                     ctf_errmsg(ctf_errno(fp)));
 618                 free(args);
 619                 return (B_FALSE);
 620         }
 621 
 622         for (i = 0; i < fi.ctc_argc; i++) {
 623                 if (ctf_type_name(fp, args[i], buf, sizeof (buf)) == NULL) {
 624                         warnx("failed to obtain type name for argument %u",
 625                             i, ctf_errmsg(ctf_errno(fp)));
 626                         ret = B_FALSE;
 627                         break;
 628                 }
 629 
 630                 if (strcmp(buf, argv[i]) != 0) {
 631                         warnx("argument %u has wrong type: found %s, "
 632                             "expected %s", i, buf, argv[i]);
 633                         ret = B_FALSE;
 634                         break;
 635                 }
 636         }
 637 
 638         free(args);
 639         return (ret);
 640 }
 641 
 642 boolean_t
 643 ctftest_check_fptr(const char *type, ctf_file_t *fp, const char *rtype,
 644     uint_t nargs, uint_t flags, const char **argv)
 645 {
 646         ctf_id_t tid;
 647         ctf_funcinfo_t fi;
 648         uint_t i;
 649         boolean_t ret = B_TRUE;
 650         ctf_id_t *args;
 651         char buf[2048];
 652 
 653 
 654         if ((tid = ctf_lookup_by_name(fp, type)) == CTF_ERR) {
 655                 warnx("failed to look up type %s: %s", type,
 656                     ctf_errmsg(ctf_errno(fp)));
 657                 return (B_FALSE);
 658         }
 659 
 660         /*
 661          * Perform two CTF type resolves, one for the function pointer and one
 662          * for the typedef that gets passed in.
 663          */
 664         if ((tid = ctf_type_resolve(fp, tid)) == CTF_ERR) {
 665                 warnx("failed to convert type %s to base type: %s", type,
 666                     ctf_errmsg(ctf_errno(fp)));
 667                 return (B_FALSE);
 668         }
 669 
 670         if (ctf_type_kind(fp, tid) == CTF_K_POINTER &&
 671             (tid = ctf_type_reference(fp, tid)) == CTF_ERR) {
 672                 warnx("failed to convert type %s to base type: %s", type,
 673                     ctf_errmsg(ctf_errno(fp)));
 674                 return (B_FALSE);
 675         }
 676 
 677         if (ctf_func_info_by_id(fp, tid, &fi) != 0) {
 678                 warnx("failed to get function information for type %s: %s",
 679                     type, ctf_errmsg(ctf_errno(fp)));
 680                 return (B_FALSE);
 681         }
 682 
 683         if (ctf_type_name(fp, fi.ctc_return, buf, sizeof (buf)) == NULL) {
 684                 warnx("failed to lookup return type name for function %s",
 685                     type);
 686                 ret = B_FALSE;
 687         } else if (strcmp(rtype, buf) != 0) {
 688                 warnx("return type has wrong type: found %s, expected %s",
 689                     buf, rtype);
 690                 ret = B_FALSE;
 691         }
 692 
 693         if (nargs != fi.ctc_argc) {
 694                 warnx("function argument mismatch: found %u, expected %u",
 695                     fi.ctc_argc, nargs);
 696                 ret = B_FALSE;
 697         }
 698 
 699         if (flags != fi.ctc_flags) {
 700                 warnx("function flags mismatch, found 0x%x, expected 0x%x",
 701                     fi.ctc_flags, flags);
 702                 ret = B_FALSE;
 703         }
 704 
 705         if (!ret || fi.ctc_argc == 0) {
 706                 return (ret);
 707         }
 708 
 709         if ((args = calloc(fi.ctc_argc, sizeof (ctf_id_t))) == NULL) {
 710                 warnx("failed to allocate memory for function arguments");
 711                 return (B_FALSE);
 712         }
 713 
 714         if (ctf_func_args_by_id(fp, tid, fi.ctc_argc, args) != 0) {
 715                 warnx("failed to get function information: %s",
 716                     ctf_errmsg(ctf_errno(fp)));
 717                 free(args);
 718                 return (B_FALSE);
 719         }
 720 
 721         for (i = 0; i < fi.ctc_argc; i++) {
 722                 if (ctf_type_name(fp, args[i], buf, sizeof (buf)) == NULL) {
 723                         warnx("failed to obtain type name for argument %u",
 724                             i, ctf_errmsg(ctf_errno(fp)));
 725                         ret = B_FALSE;
 726                         break;
 727                 }
 728 
 729                 if (strcmp(buf, argv[i]) != 0) {
 730                         warnx("argument %u has wrong type: found %s, "
 731                             "expected %s", i, buf, argv[i]);
 732                         ret = B_FALSE;
 733                         break;
 734                 }
 735         }
 736 
 737         free(args);
 738         return (ret);
 739 }
 740 boolean_t
 741 ctftest_check_size(const char *type, ctf_file_t *fp, size_t size)
 742 {
 743         ctf_id_t base;
 744 
 745         if ((base = ctftest_lookup_type(fp, type)) == CTF_ERR) {
 746                 warnx("Failed to look up type %s", type);
 747                 return (B_FALSE);
 748         }
 749 
 750         if (size != ctf_type_size(fp, base)) {
 751                 warnx("%s has bad size, expected %lu, found %lu",
 752                     type, size, ctf_type_size(fp, base));
 753                 return (B_FALSE);
 754         }
 755 
 756         return (B_TRUE);
 757 }
 758 
 759 typedef struct ctftest_duplicates {
 760         ctf_file_t *ctd_fp;
 761         char **ctd_names;
 762         size_t ctd_len;
 763         size_t ctd_curent;
 764         boolean_t ctd_ret;
 765 } ctftest_duplicates_t;
 766 
 767 static int
 768 ctftest_duplicates_cb(ctf_id_t id, boolean_t root, void *arg)
 769 {
 770         char buf[2048];
 771         ctftest_duplicates_t *dup = arg;
 772         size_t i;
 773 
 774         if (ctf_type_name(dup->ctd_fp, id, buf, sizeof (buf)) == NULL) {
 775                 warnx("failed to lookup name for id %ld", id);
 776                 dup->ctd_ret = B_FALSE;
 777                 return (1);
 778         }
 779 
 780         for (i = 0; i < dup->ctd_curent; i++) {
 781                 if (strcmp(buf, dup->ctd_names[i]) == 0) {
 782                         warnx("encountered duplicate type '%s'", buf);
 783                         dup->ctd_ret = B_FALSE;
 784                         /*
 785                          * Don't break out of the loop and keep going in case we
 786                          * find another duplicate.
 787                          */
 788                         return (0);
 789                 }
 790         }
 791 
 792         if (dup->ctd_curent == dup->ctd_len) {
 793                 char **n;
 794                 size_t newlen = dup->ctd_len * 2;
 795 
 796                 n = recallocarray(dup->ctd_names, dup->ctd_len, newlen,
 797                     sizeof (char *));
 798                 if (n == NULL) {
 799                         warnx("failed to resize type name array");
 800                         dup->ctd_ret = B_FALSE;
 801                         return (1);
 802                 }
 803 
 804                 dup->ctd_names = n;
 805                 dup->ctd_len = newlen;
 806         }
 807 
 808         dup->ctd_names[dup->ctd_curent] = strdup(buf);
 809         if (dup->ctd_names[dup->ctd_curent] == NULL) {
 810                 warn("failed to duplicate type name");
 811                 dup->ctd_ret = B_FALSE;
 812                 return (1);
 813         }
 814         dup->ctd_curent++;
 815 
 816         return (0);
 817 }
 818 
 819 boolean_t
 820 ctftest_duplicates(ctf_file_t *fp)
 821 {
 822         size_t i;
 823         ctftest_duplicates_t d;
 824 
 825         bzero(&d, sizeof (d));
 826         d.ctd_fp = fp;
 827         d.ctd_len = 4;
 828         d.ctd_ret = B_TRUE;
 829         d.ctd_names = recallocarray(NULL, 0, d.ctd_len, sizeof (char *));
 830         if (d.ctd_names == NULL) {
 831                 warnx("failed to allocate duplicate name storage");
 832                 return (B_FALSE);
 833         }
 834 
 835         (void) ctf_type_iter(fp, B_TRUE, ctftest_duplicates_cb, &d);
 836 
 837         for (i = 0; i < d.ctd_curent; i++) {
 838                 free(d.ctd_names[i]);
 839         }
 840         free(d.ctd_names);
 841 
 842         return (d.ctd_ret);
 843 }