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) 2015 Joyent, Inc. 14 */ 15 16 /* 17 * To perform a merge of two CTF containers, we first diff the two containers 18 * types. For every type that's in the src container, but not in the dst 19 * container, we note it and add it to dst container. If there are any objects 20 * or functions associated with src, we go through and update the types that 21 * they refer to such that they all refer to types in the dst container. 22 * 23 * The bulk of the logic for the merge, after we've run the diff, occurs in 24 * ctf_merge_common(). 25 * 26 * In terms of exported APIs, we don't really export a simple merge two 27 * containers, as the general way this is used, in something like ctfmerge(1), 28 * is to add all the containers and then let us figure out the best way to merge 29 * it. 30 */ 31 32 #include <libctf_impl.h> 33 #include <sys/debug.h> 34 #include <sys/list.h> 35 #include <stddef.h> 36 #include <fcntl.h> 37 #include <sys/types.h> 38 #include <sys/stat.h> 39 #include <mergeq.h> 40 #include <errno.h> 41 42 typedef struct ctf_merge_tinfo { 43 uint16_t cmt_map; /* Map to the type in out */ 44 boolean_t cmt_fixup; 45 boolean_t cmt_forward; 46 boolean_t cmt_missing; 47 } ctf_merge_tinfo_t; 48 49 /* 50 * State required for doing an individual merge of two containers. 51 */ 52 typedef struct ctf_merge_types { 53 ctf_file_t *cm_out; /* Output CTF file */ 54 ctf_file_t *cm_src; /* Input CTF file */ 55 ctf_merge_tinfo_t *cm_tmap; /* Type state information */ 56 boolean_t cm_dedup; /* Are we doing a dedup? */ 57 boolean_t cm_unique; /* are we doing a uniquify? */ 58 } ctf_merge_types_t; 59 60 typedef struct ctf_merge_objmap { 61 list_node_t cmo_node; 62 const char *cmo_name; /* Symbol name */ 63 ulong_t cmo_idx; /* Symbol ID */ 64 ctf_id_t cmo_tid; /* Type ID */ 65 } ctf_merge_objmap_t; 66 67 typedef struct ctf_merge_funcmap { 68 list_node_t cmf_node; 69 const char *cmf_name; /* Symbol name */ 70 ulong_t cmf_idx; /* Symbol ID */ 71 ctf_id_t cmf_rtid; /* Type ID */ 72 uint_t cmf_flags; /* ctf_funcinfo_t ctc_flags */ 73 uint_t cmf_argc; /* Number of arguments */ 74 ctf_id_t cmf_args[]; /* Types of arguments */ 75 } ctf_merge_funcmap_t; 76 77 typedef struct ctf_merge_input { 78 list_node_t cmi_node; 79 ctf_file_t *cmi_input; 80 list_t cmi_omap; 81 list_t cmi_fmap; 82 boolean_t cmi_created; 83 } ctf_merge_input_t; 84 85 struct ctf_merge_handle { 86 list_t cmh_inputs; /* Input list */ 87 uint_t cmh_ninputs; /* Number of inputs */ 88 uint_t cmh_nthreads; /* Number of threads to use */ 89 ctf_file_t *cmh_unique; /* ctf to uniquify against */ 90 boolean_t cmh_msyms; /* Should we merge symbols/funcs? */ 91 int cmh_ofd; /* FD for output file */ 92 int cmh_flags; /* Flags that control merge behavior */ 93 char *cmh_label; /* Optional label */ 94 char *cmh_pname; /* Parent name */ 95 }; 96 97 static int ctf_merge_add_type(ctf_merge_types_t *, ctf_id_t); 98 99 static ctf_id_t 100 ctf_merge_gettype(ctf_merge_types_t *cmp, ctf_id_t id) 101 { 102 if (cmp->cm_dedup == B_FALSE) { 103 VERIFY(cmp->cm_tmap[id].cmt_map != 0); 104 return (cmp->cm_tmap[id].cmt_map); 105 } 106 107 while (cmp->cm_tmap[id].cmt_missing == B_FALSE) { 108 VERIFY(cmp->cm_tmap[id].cmt_map != 0); 109 id = cmp->cm_tmap[id].cmt_map; 110 } 111 VERIFY(cmp->cm_tmap[id].cmt_map != 0); 112 return (cmp->cm_tmap[id].cmt_map); 113 } 114 115 static void 116 ctf_merge_diffcb(ctf_file_t *ifp, ctf_id_t iid, boolean_t same, ctf_file_t *ofp, 117 ctf_id_t oid, void *arg) 118 { 119 ctf_merge_types_t *cmp = arg; 120 ctf_merge_tinfo_t *cmt = cmp->cm_tmap; 121 122 if (same == B_TRUE) { 123 if (ctf_type_kind(ifp, iid) == CTF_K_FORWARD && 124 ctf_type_kind(ofp, oid) != CTF_K_FORWARD) { 125 VERIFY(cmt[oid].cmt_map == 0); 126 127 /* 128 * If we're uniquifying types, it's possible for the 129 * container that we're uniquifying against to have a 130 * forward which exists in the container being reduced. 131 * For example, genunix has the machcpu structure as a 132 * forward which is actually in unix and we uniquify 133 * unix against genunix. In such cases, we explicitly do 134 * not do any mapping of the forward information, lest 135 * we risk losing the real definition. Instead, mark 136 * that it's missing. 137 */ 138 if (cmp->cm_unique == B_TRUE) { 139 cmt[oid].cmt_missing = B_TRUE; 140 return; 141 } 142 143 cmt[oid].cmt_map = iid; 144 cmt[oid].cmt_forward = B_TRUE; 145 ctf_dprintf("merge diff forward mapped %d->%d\n", oid, 146 iid); 147 return; 148 } 149 150 /* 151 * We could have multiple things that a given type ends up 152 * matching in the world of forwards and pointers to forwards. 153 * For now just take the first one... 154 */ 155 if (cmt[oid].cmt_map != 0) 156 return; 157 cmt[oid].cmt_map = iid; 158 ctf_dprintf("merge diff mapped %d->%d\n", oid, iid); 159 } else if (ifp == cmp->cm_src) { 160 VERIFY(cmt[iid].cmt_map == 0); 161 cmt[iid].cmt_missing = B_TRUE; 162 ctf_dprintf("merge diff said %d is missing\n", iid); 163 } 164 } 165 166 static int 167 ctf_merge_add_number(ctf_merge_types_t *cmp, ctf_id_t id) 168 { 169 int ret, flags; 170 const ctf_type_t *tp; 171 const char *name; 172 ctf_encoding_t en; 173 174 if (ctf_type_encoding(cmp->cm_src, id, &en) != 0) 175 return (CTF_ERR); 176 177 tp = LCTF_INDEX_TO_TYPEPTR(cmp->cm_src, id); 178 name = ctf_strraw(cmp->cm_src, tp->ctt_name); 179 if (CTF_INFO_ISROOT(tp->ctt_info) != 0) 180 flags = CTF_ADD_ROOT; 181 else 182 flags = CTF_ADD_NONROOT; 183 184 ret = ctf_add_encoded(cmp->cm_out, flags, name, &en, 185 ctf_type_kind(cmp->cm_src, id)); 186 187 if (ret == CTF_ERR) 188 return (ret); 189 190 VERIFY(cmp->cm_tmap[id].cmt_map == 0); 191 cmp->cm_tmap[id].cmt_map = ret; 192 return (0); 193 } 194 195 static int 196 ctf_merge_add_array(ctf_merge_types_t *cmp, ctf_id_t id) 197 { 198 int ret, flags; 199 const ctf_type_t *tp; 200 ctf_arinfo_t ar; 201 202 if (ctf_array_info(cmp->cm_src, id, &ar) == CTF_ERR) 203 return (CTF_ERR); 204 205 tp = LCTF_INDEX_TO_TYPEPTR(cmp->cm_src, id); 206 if (CTF_INFO_ISROOT(tp->ctt_info) != 0) 207 flags = CTF_ADD_ROOT; 208 else 209 flags = CTF_ADD_NONROOT; 210 211 if (cmp->cm_tmap[ar.ctr_contents].cmt_map == 0) { 212 ret = ctf_merge_add_type(cmp, ar.ctr_contents); 213 if (ret != 0) 214 return (ret); 215 ASSERT(cmp->cm_tmap[ar.ctr_contents].cmt_map != 0); 216 } 217 ar.ctr_contents = ctf_merge_gettype(cmp, ar.ctr_contents); 218 219 if (cmp->cm_tmap[ar.ctr_index].cmt_map == 0) { 220 ret = ctf_merge_add_type(cmp, ar.ctr_index); 221 if (ret != 0) 222 return (ret); 223 ASSERT(cmp->cm_tmap[ar.ctr_index].cmt_map != 0); 224 } 225 ar.ctr_index = ctf_merge_gettype(cmp, ar.ctr_index); 226 227 ret = ctf_add_array(cmp->cm_out, flags, &ar); 228 if (ret == CTF_ERR) 229 return (ret); 230 231 VERIFY(cmp->cm_tmap[id].cmt_map == 0); 232 cmp->cm_tmap[id].cmt_map = ret; 233 234 return (0); 235 } 236 237 static int 238 ctf_merge_add_reftype(ctf_merge_types_t *cmp, ctf_id_t id) 239 { 240 int ret, flags; 241 const ctf_type_t *tp; 242 ctf_id_t reftype; 243 const char *name; 244 245 tp = LCTF_INDEX_TO_TYPEPTR(cmp->cm_src, id); 246 name = ctf_strraw(cmp->cm_src, tp->ctt_name); 247 if (CTF_INFO_ISROOT(tp->ctt_info) != 0) 248 flags = CTF_ADD_ROOT; 249 else 250 flags = CTF_ADD_NONROOT; 251 252 reftype = ctf_type_reference(cmp->cm_src, id); 253 if (reftype == CTF_ERR) 254 return (ctf_set_errno(cmp->cm_out, ctf_errno(cmp->cm_src))); 255 256 if (cmp->cm_tmap[reftype].cmt_map == 0) { 257 ret = ctf_merge_add_type(cmp, reftype); 258 if (ret != 0) 259 return (ret); 260 ASSERT(cmp->cm_tmap[reftype].cmt_map != 0); 261 } 262 reftype = ctf_merge_gettype(cmp, reftype); 263 264 ret = ctf_add_reftype(cmp->cm_out, flags, name, reftype, 265 ctf_type_kind(cmp->cm_src, id)); 266 if (ret == CTF_ERR) 267 return (ret); 268 269 VERIFY(cmp->cm_tmap[id].cmt_map == 0); 270 cmp->cm_tmap[id].cmt_map = ret; 271 return (0); 272 } 273 274 static int 275 ctf_merge_add_typedef(ctf_merge_types_t *cmp, ctf_id_t id) 276 { 277 int ret, flags; 278 const ctf_type_t *tp; 279 const char *name; 280 ctf_id_t reftype; 281 282 tp = LCTF_INDEX_TO_TYPEPTR(cmp->cm_src, id); 283 name = ctf_strraw(cmp->cm_src, tp->ctt_name); 284 if (CTF_INFO_ISROOT(tp->ctt_info) != 0) 285 flags = CTF_ADD_ROOT; 286 else 287 flags = CTF_ADD_NONROOT; 288 289 reftype = ctf_type_reference(cmp->cm_src, id); 290 if (reftype == CTF_ERR) 291 return (ctf_set_errno(cmp->cm_out, ctf_errno(cmp->cm_src))); 292 293 if (cmp->cm_tmap[reftype].cmt_map == 0) { 294 ret = ctf_merge_add_type(cmp, reftype); 295 if (ret != 0) 296 return (ret); 297 ASSERT(cmp->cm_tmap[reftype].cmt_map != 0); 298 } 299 reftype = ctf_merge_gettype(cmp, reftype); 300 301 ret = ctf_add_typedef(cmp->cm_out, flags, name, reftype); 302 if (ret == CTF_ERR) 303 return (ret); 304 305 VERIFY(cmp->cm_tmap[id].cmt_map == 0); 306 cmp->cm_tmap[id].cmt_map = ret; 307 return (0); 308 } 309 310 typedef struct ctf_merge_enum { 311 ctf_file_t *cme_fp; 312 ctf_id_t cme_id; 313 } ctf_merge_enum_t; 314 315 static int 316 ctf_merge_add_enumerator(const char *name, int value, void *arg) 317 { 318 ctf_merge_enum_t *cmep = arg; 319 320 return (ctf_add_enumerator(cmep->cme_fp, cmep->cme_id, name, value) == 321 CTF_ERR); 322 } 323 324 static int 325 ctf_merge_add_enum(ctf_merge_types_t *cmp, ctf_id_t id) 326 { 327 int flags; 328 const ctf_type_t *tp; 329 const char *name; 330 ctf_id_t enumid; 331 ctf_merge_enum_t cme; 332 333 tp = LCTF_INDEX_TO_TYPEPTR(cmp->cm_src, id); 334 name = ctf_strraw(cmp->cm_src, tp->ctt_name); 335 if (CTF_INFO_ISROOT(tp->ctt_info) != 0) 336 flags = CTF_ADD_ROOT; 337 else 338 flags = CTF_ADD_NONROOT; 339 340 enumid = ctf_add_enum(cmp->cm_out, flags, name); 341 if (enumid == CTF_ERR) 342 return (enumid); 343 344 cme.cme_fp = cmp->cm_out; 345 cme.cme_id = enumid; 346 if (ctf_enum_iter(cmp->cm_src, id, ctf_merge_add_enumerator, 347 &cme) != 0) 348 return (CTF_ERR); 349 350 VERIFY(cmp->cm_tmap[id].cmt_map == 0); 351 cmp->cm_tmap[id].cmt_map = enumid; 352 return (0); 353 } 354 355 static int 356 ctf_merge_add_func(ctf_merge_types_t *cmp, ctf_id_t id) 357 { 358 int ret, flags, i; 359 const ctf_type_t *tp; 360 ctf_funcinfo_t ctc; 361 ctf_id_t *argv; 362 363 tp = LCTF_INDEX_TO_TYPEPTR(cmp->cm_src, id); 364 if (CTF_INFO_ISROOT(tp->ctt_info) != 0) 365 flags = CTF_ADD_ROOT; 366 else 367 flags = CTF_ADD_NONROOT; 368 369 if (ctf_func_info_by_id(cmp->cm_src, id, &ctc) == CTF_ERR) 370 return (ctf_set_errno(cmp->cm_out, ctf_errno(cmp->cm_src))); 371 372 argv = ctf_alloc(sizeof (ctf_id_t) * ctc.ctc_argc); 373 if (argv == NULL) 374 return (ctf_set_errno(cmp->cm_out, ENOMEM)); 375 if (ctf_func_args_by_id(cmp->cm_src, id, ctc.ctc_argc, argv) == 376 CTF_ERR) { 377 ctf_free(argv, sizeof (ctf_id_t) * ctc.ctc_argc); 378 return (ctf_set_errno(cmp->cm_out, ctf_errno(cmp->cm_src))); 379 } 380 381 if (cmp->cm_tmap[ctc.ctc_return].cmt_map == 0) { 382 ret = ctf_merge_add_type(cmp, ctc.ctc_return); 383 if (ret != 0) 384 return (ret); 385 ASSERT(cmp->cm_tmap[ctc.ctc_return].cmt_map != 0); 386 } 387 ctc.ctc_return = ctf_merge_gettype(cmp, ctc.ctc_return); 388 389 for (i = 0; i < ctc.ctc_argc; i++) { 390 if (cmp->cm_tmap[argv[i]].cmt_map == 0) { 391 ret = ctf_merge_add_type(cmp, argv[i]); 392 if (ret != 0) 393 return (ret); 394 ASSERT(cmp->cm_tmap[argv[i]].cmt_map != 0); 395 } 396 argv[i] = ctf_merge_gettype(cmp, argv[i]); 397 } 398 399 ret = ctf_add_funcptr(cmp->cm_out, flags, &ctc, argv); 400 ctf_free(argv, sizeof (ctf_id_t) * ctc.ctc_argc); 401 if (ret == CTF_ERR) 402 return (ret); 403 404 VERIFY(cmp->cm_tmap[id].cmt_map == 0); 405 cmp->cm_tmap[id].cmt_map = ret; 406 return (0); 407 } 408 409 static int 410 ctf_merge_add_forward(ctf_merge_types_t *cmp, ctf_id_t id) 411 { 412 int ret, flags; 413 const ctf_type_t *tp; 414 const char *name; 415 416 tp = LCTF_INDEX_TO_TYPEPTR(cmp->cm_src, id); 417 name = ctf_strraw(cmp->cm_src, tp->ctt_name); 418 if (CTF_INFO_ISROOT(tp->ctt_info) != 0) 419 flags = CTF_ADD_ROOT; 420 else 421 flags = CTF_ADD_NONROOT; 422 423 /* 424 * ctf_add_forward tries to check to see if a given forward already 425 * exists in one of its hash tables. If we're here then we know that we 426 * have a forward in a container that isn't present in another. 427 * Therefore, we choose a token hash table to satisfy the API choice 428 * here. 429 */ 430 ret = ctf_add_forward(cmp->cm_out, flags, name, CTF_K_STRUCT); 431 if (ret == CTF_ERR) 432 return (CTF_ERR); 433 434 VERIFY(cmp->cm_tmap[id].cmt_map == 0); 435 cmp->cm_tmap[id].cmt_map = ret; 436 return (0); 437 } 438 439 typedef struct ctf_merge_su { 440 ctf_merge_types_t *cms_cm; 441 ctf_id_t cms_id; 442 } ctf_merge_su_t; 443 444 static int 445 ctf_merge_add_member(const char *name, ctf_id_t type, ulong_t offset, void *arg) 446 { 447 ctf_merge_su_t *cms = arg; 448 449 VERIFY(cms->cms_cm->cm_tmap[type].cmt_map != 0); 450 type = cms->cms_cm->cm_tmap[type].cmt_map; 451 452 ctf_dprintf("Trying to add member %s to %d\n", name, cms->cms_id); 453 return (ctf_add_member(cms->cms_cm->cm_out, cms->cms_id, name, 454 type, offset) == CTF_ERR); 455 } 456 457 /* 458 * During the first pass, we always add the generic structure and union but none 459 * of its members as they might not all have been mapped yet. Instead we just 460 * mark all structures and unions as needing to be fixed up. 461 */ 462 static int 463 ctf_merge_add_sou(ctf_merge_types_t *cmp, ctf_id_t id, boolean_t forward) 464 { 465 int flags, kind; 466 const ctf_type_t *tp; 467 const char *name; 468 ctf_id_t suid; 469 470 tp = LCTF_INDEX_TO_TYPEPTR(cmp->cm_src, id); 471 name = ctf_strraw(cmp->cm_src, tp->ctt_name); 472 if (CTF_INFO_ISROOT(tp->ctt_info) != 0) 473 flags = CTF_ADD_ROOT; 474 else 475 flags = CTF_ADD_NONROOT; 476 kind = ctf_type_kind(cmp->cm_src, id); 477 478 if (kind == CTF_K_STRUCT) 479 suid = ctf_add_struct(cmp->cm_out, flags, name); 480 else 481 suid = ctf_add_union(cmp->cm_out, flags, name); 482 483 if (suid == CTF_ERR) 484 return (suid); 485 486 /* 487 * If this is a forward reference then its mapping should already 488 * exist. 489 */ 490 if (forward == B_FALSE) { 491 VERIFY(cmp->cm_tmap[id].cmt_map == 0); 492 cmp->cm_tmap[id].cmt_map = suid; 493 ctf_dprintf("added sou \"%s\" as (%d) %d->%d\n", name, kind, id, 494 suid); 495 } else { 496 VERIFY(cmp->cm_tmap[id].cmt_map == suid); 497 } 498 cmp->cm_tmap[id].cmt_fixup = B_TRUE; 499 500 return (0); 501 } 502 503 static int 504 ctf_merge_add_type(ctf_merge_types_t *cmp, ctf_id_t id) 505 { 506 int kind, ret; 507 508 /* 509 * We may end up evaluating a type more than once as we may deal with it 510 * as we recursively evaluate some kind of reference and then we may see 511 * it normally. 512 */ 513 if (cmp->cm_tmap[id].cmt_map != 0) 514 return (0); 515 516 kind = ctf_type_kind(cmp->cm_src, id); 517 switch (kind) { 518 case CTF_K_INTEGER: 519 case CTF_K_FLOAT: 520 ret = ctf_merge_add_number(cmp, id); 521 break; 522 case CTF_K_ARRAY: 523 ret = ctf_merge_add_array(cmp, id); 524 break; 525 case CTF_K_POINTER: 526 case CTF_K_VOLATILE: 527 case CTF_K_CONST: 528 case CTF_K_RESTRICT: 529 ret = ctf_merge_add_reftype(cmp, id); 530 break; 531 case CTF_K_TYPEDEF: 532 ret = ctf_merge_add_typedef(cmp, id); 533 break; 534 case CTF_K_ENUM: 535 ret = ctf_merge_add_enum(cmp, id); 536 break; 537 case CTF_K_FUNCTION: 538 ret = ctf_merge_add_func(cmp, id); 539 break; 540 case CTF_K_FORWARD: 541 ret = ctf_merge_add_forward(cmp, id); 542 break; 543 case CTF_K_STRUCT: 544 case CTF_K_UNION: 545 ret = ctf_merge_add_sou(cmp, id, B_FALSE); 546 break; 547 case CTF_K_UNKNOWN: 548 /* 549 * We don't add unknown types, and we later assert that nothing 550 * should reference them. 551 */ 552 return (0); 553 default: 554 abort(); 555 } 556 557 return (ret); 558 } 559 560 static int 561 ctf_merge_fixup_sou(ctf_merge_types_t *cmp, ctf_id_t id) 562 { 563 ctf_dtdef_t *dtd; 564 ctf_merge_su_t cms; 565 ctf_id_t mapid; 566 ssize_t size; 567 568 mapid = cmp->cm_tmap[id].cmt_map; 569 VERIFY(mapid != 0); 570 dtd = ctf_dtd_lookup(cmp->cm_out, mapid); 571 VERIFY(dtd != NULL); 572 573 ctf_dprintf("Trying to fix up sou %d\n", id); 574 cms.cms_cm = cmp; 575 cms.cms_id = mapid; 576 if (ctf_member_iter(cmp->cm_src, id, ctf_merge_add_member, &cms) != 0) 577 return (CTF_ERR); 578 579 if ((size = ctf_type_size(cmp->cm_src, id)) == CTF_ERR) 580 return (CTF_ERR); 581 if (ctf_set_size(cmp->cm_out, mapid, size) == CTF_ERR) 582 return (CTF_ERR); 583 584 return (0); 585 } 586 587 static int 588 ctf_merge_fixup_type(ctf_merge_types_t *cmp, ctf_id_t id) 589 { 590 int kind, ret; 591 592 kind = ctf_type_kind(cmp->cm_src, id); 593 switch (kind) { 594 case CTF_K_STRUCT: 595 case CTF_K_UNION: 596 ret = ctf_merge_fixup_sou(cmp, id); 597 break; 598 default: 599 VERIFY(0); 600 ret = CTF_ERR; 601 } 602 603 return (ret); 604 } 605 606 /* 607 * Now that we've successfully merged everything, we're going to clean 608 * up the merge type table. Traditionally if we had just two different 609 * files that we were working between, the types would be fully 610 * resolved. However, because we were comparing with ourself every step 611 * of the way and not our reduced self, we need to go through and update 612 * every mapped entry to what it now points to in the deduped file. 613 */ 614 static void 615 ctf_merge_fixup_dedup_map(ctf_merge_types_t *cmp) 616 { 617 int i; 618 619 for (i = 1; i < cmp->cm_src->ctf_typemax + 1; i++) { 620 ctf_id_t tid; 621 622 /* 623 * Missing types always have their id updated to exactly what it 624 * should be. 625 */ 626 if (cmp->cm_tmap[i].cmt_missing == B_TRUE) { 627 VERIFY(cmp->cm_tmap[i].cmt_map != 0); 628 continue; 629 } 630 631 tid = i; 632 while (cmp->cm_tmap[tid].cmt_missing == B_FALSE) { 633 VERIFY(cmp->cm_tmap[tid].cmt_map != 0); 634 tid = cmp->cm_tmap[tid].cmt_map; 635 } 636 VERIFY(cmp->cm_tmap[tid].cmt_map != 0); 637 cmp->cm_tmap[i].cmt_map = cmp->cm_tmap[tid].cmt_map; 638 } 639 } 640 641 642 /* 643 * We're going to do three passes over the containers. 644 * 645 * Pass 1 checks for forward references in the output container that we know 646 * exist in the source container. 647 * 648 * Pass 2 adds all the missing types from the source container. As part of this 649 * we may be adding a type as a forward reference that doesn't exist yet. 650 * Any types that we encounter in this form, we need to add to a third pass. 651 * 652 * Pass 3 is the fixup pass. Here we go through and find all the types that were 653 * missing in the first. 654 * 655 * Importantly, we *must* call ctf_update between the second and third pass, 656 * otherwise several of the libctf functions will not properly find the data in 657 * the container. If we're doing a dedup we also fix up the type mapping. 658 */ 659 static int 660 ctf_merge_common(ctf_merge_types_t *cmp) 661 { 662 int ret, i; 663 664 ctf_phase_dump(cmp->cm_src, "merge-common-src"); 665 ctf_phase_dump(cmp->cm_out, "merge-common-dest"); 666 667 /* Pass 1 */ 668 for (i = 1; i <= cmp->cm_src->ctf_typemax; i++) { 669 if (cmp->cm_tmap[i].cmt_forward == B_TRUE) { 670 ret = ctf_merge_add_sou(cmp, i, B_TRUE); 671 if (ret != 0) { 672 return (ret); 673 } 674 } 675 } 676 677 /* Pass 2 */ 678 for (i = 1; i <= cmp->cm_src->ctf_typemax; i++) { 679 if (cmp->cm_tmap[i].cmt_missing == B_TRUE) { 680 ret = ctf_merge_add_type(cmp, i); 681 if (ret != 0) { 682 ctf_dprintf("Failed to merge type %d\n", i); 683 return (ret); 684 } 685 } 686 } 687 688 ret = ctf_update(cmp->cm_out); 689 if (ret != 0) 690 return (ret); 691 692 if (cmp->cm_dedup == B_TRUE) { 693 ctf_merge_fixup_dedup_map(cmp); 694 } 695 696 ctf_dprintf("Beginning merge pass 3\n"); 697 /* Pass 3 */ 698 for (i = 1; i <= cmp->cm_src->ctf_typemax; i++) { 699 if (cmp->cm_tmap[i].cmt_fixup == B_TRUE) { 700 ret = ctf_merge_fixup_type(cmp, i); 701 if (ret != 0) 702 return (ret); 703 } 704 } 705 706 if (cmp->cm_dedup == B_TRUE) { 707 ctf_merge_fixup_dedup_map(cmp); 708 } 709 710 return (0); 711 } 712 713 /* 714 * Uniquification is slightly different from a stock merge. For starters, we 715 * don't need to replace any forward references in the output. In this case 716 * though, the types that already exist are in a parent container to the empty 717 * output container. 718 */ 719 static int 720 ctf_merge_uniquify_types(ctf_merge_types_t *cmp) 721 { 722 int i, ret; 723 724 for (i = 1; i <= cmp->cm_src->ctf_typemax; i++) { 725 if (cmp->cm_tmap[i].cmt_missing == B_FALSE) 726 continue; 727 ret = ctf_merge_add_type(cmp, i); 728 if (ret != 0) 729 return (ret); 730 } 731 732 ret = ctf_update(cmp->cm_out); 733 if (ret != 0) 734 return (ret); 735 736 for (i = 1; i <= cmp->cm_src->ctf_typemax; i++) { 737 if (cmp->cm_tmap[i].cmt_fixup == B_FALSE) 738 continue; 739 ret = ctf_merge_fixup_type(cmp, i); 740 if (ret != 0) 741 return (ret); 742 } 743 744 return (0); 745 } 746 747 static int 748 ctf_merge_types_init(ctf_merge_types_t *cmp) 749 { 750 cmp->cm_tmap = ctf_alloc(sizeof (ctf_merge_tinfo_t) * 751 (cmp->cm_src->ctf_typemax + 1)); 752 if (cmp->cm_tmap == NULL) 753 return (ctf_set_errno(cmp->cm_out, ENOMEM)); 754 bzero(cmp->cm_tmap, sizeof (ctf_merge_tinfo_t) * 755 (cmp->cm_src->ctf_typemax + 1)); 756 return (0); 757 } 758 759 static void 760 ctf_merge_types_fini(ctf_merge_types_t *cmp) 761 { 762 ctf_free(cmp->cm_tmap, sizeof (ctf_merge_tinfo_t) * 763 (cmp->cm_src->ctf_typemax + 1)); 764 } 765 766 /* 767 * Merge the types contained inside of two input files. The second input file is 768 * always going to be the destination. We're guaranteed that it's always 769 * writeable. 770 */ 771 static int 772 ctf_merge_types(void *arg, void *arg2, void **outp, void *unsued) 773 { 774 int ret; 775 ctf_merge_types_t cm; 776 ctf_diff_t *cdp; 777 ctf_merge_objmap_t *cmo; 778 ctf_merge_funcmap_t *cmf; 779 ctf_merge_input_t *scmi = arg; 780 ctf_merge_input_t *dcmi = arg2; 781 ctf_file_t *out = dcmi->cmi_input; 782 ctf_file_t *source = scmi->cmi_input; 783 784 ctf_dprintf("merging %p->%p\n", source, out); 785 786 if (!(out->ctf_flags & LCTF_RDWR)) 787 return (ctf_set_errno(out, ECTF_RDONLY)); 788 789 if (ctf_getmodel(out) != ctf_getmodel(source)) 790 return (ctf_set_errno(out, ECTF_DMODEL)); 791 792 if ((ret = ctf_diff_init(out, source, &cdp)) != 0) 793 return (ret); 794 795 cm.cm_out = out; 796 cm.cm_src = source; 797 cm.cm_dedup = B_FALSE; 798 cm.cm_unique = B_FALSE; 799 ret = ctf_merge_types_init(&cm); 800 if (ret != 0) { 801 ctf_diff_fini(cdp); 802 return (ctf_set_errno(out, ret)); 803 } 804 805 ret = ctf_diff_types(cdp, ctf_merge_diffcb, &cm); 806 if (ret != 0) 807 goto cleanup; 808 ret = ctf_merge_common(&cm); 809 ctf_dprintf("merge common returned with %d\n", ret); 810 if (ret == 0) { 811 ret = ctf_update(out); 812 ctf_dprintf("update returned with %d\n", ret); 813 } else { 814 goto cleanup; 815 } 816 817 /* 818 * Now we need to fix up the object and function maps. 819 */ 820 for (cmo = list_head(&scmi->cmi_omap); cmo != NULL; 821 cmo = list_next(&scmi->cmi_omap, cmo)) { 822 if (cmo->cmo_tid == 0) 823 continue; 824 VERIFY(cm.cm_tmap[cmo->cmo_tid].cmt_map != 0); 825 cmo->cmo_tid = cm.cm_tmap[cmo->cmo_tid].cmt_map; 826 } 827 828 for (cmf = list_head(&scmi->cmi_fmap); cmf != NULL; 829 cmf = list_next(&scmi->cmi_fmap, cmf)) { 830 int i; 831 832 VERIFY(cm.cm_tmap[cmf->cmf_rtid].cmt_map != 0); 833 cmf->cmf_rtid = cm.cm_tmap[cmf->cmf_rtid].cmt_map; 834 for (i = 0; i < cmf->cmf_argc; i++) { 835 VERIFY(cm.cm_tmap[cmf->cmf_args[i]].cmt_map != 0); 836 cmf->cmf_args[i] = cm.cm_tmap[cmf->cmf_args[i]].cmt_map; 837 } 838 } 839 840 /* 841 * Now that we've fixed things up, we need to give our function and 842 * object maps to the destination, such that it can continue to update 843 * them going forward. 844 */ 845 list_move_tail(&dcmi->cmi_fmap, &scmi->cmi_fmap); 846 list_move_tail(&dcmi->cmi_omap, &scmi->cmi_omap); 847 848 cleanup: 849 if (ret == 0) 850 *outp = dcmi; 851 ctf_merge_types_fini(&cm); 852 ctf_diff_fini(cdp); 853 if (ret != 0) 854 return (ctf_errno(out)); 855 return (0); 856 } 857 858 /* 859 * After performing a pass, we need to go through the object and function type 860 * maps and potentially fix them up based on the new maps that we haev. 861 */ 862 static void 863 ctf_merge_fixup_nontypes(ctf_merge_types_t *cmp, ctf_merge_input_t *cmi) 864 { 865 ctf_merge_objmap_t *cmo; 866 ctf_merge_funcmap_t *cmf; 867 868 for (cmo = list_head(&cmi->cmi_omap); cmo != NULL; 869 cmo = list_next(&cmi->cmi_omap, cmo)) { 870 if (cmo->cmo_tid == 0) 871 continue; 872 VERIFY(cmp->cm_tmap[cmo->cmo_tid].cmt_map != 0); 873 cmo->cmo_tid = cmp->cm_tmap[cmo->cmo_tid].cmt_map; 874 } 875 876 for (cmf = list_head(&cmi->cmi_fmap); cmf != NULL; 877 cmf = list_next(&cmi->cmi_fmap, cmf)) { 878 int i; 879 880 VERIFY(cmp->cm_tmap[cmf->cmf_rtid].cmt_map != 0); 881 cmf->cmf_rtid = cmp->cm_tmap[cmf->cmf_rtid].cmt_map; 882 for (i = 0; i < cmf->cmf_argc; i++) { 883 VERIFY(cmp->cm_tmap[cmf->cmf_args[i]].cmt_map != 884 0); 885 cmf->cmf_args[i] = 886 cmp->cm_tmap[cmf->cmf_args[i]].cmt_map; 887 } 888 } 889 } 890 891 static int 892 ctf_uniquify_types(ctf_merge_t *cmh, ctf_file_t *src, ctf_file_t **outp) 893 { 894 int err, ret; 895 ctf_file_t *out; 896 ctf_merge_types_t cm; 897 ctf_diff_t *cdp; 898 ctf_merge_input_t *cmi; 899 ctf_file_t *parent = cmh->cmh_unique; 900 901 *outp = NULL; 902 out = ctf_fdcreate(cmh->cmh_ofd, &err); 903 if (out == NULL) 904 return (ctf_set_errno(src, err)); 905 906 out->ctf_parname = cmh->cmh_pname; 907 if (ctf_setmodel(out, ctf_getmodel(parent)) != 0) { 908 (void) ctf_set_errno(src, ctf_errno(out)); 909 ctf_close(out); 910 return (CTF_ERR); 911 } 912 913 if (ctf_import(out, parent) != 0) { 914 (void) ctf_set_errno(src, ctf_errno(out)); 915 ctf_close(out); 916 return (CTF_ERR); 917 } 918 919 if ((ret = ctf_diff_init(parent, src, &cdp)) != 0) { 920 ctf_close(out); 921 return (ctf_set_errno(src, ctf_errno(parent))); 922 } 923 924 cm.cm_out = parent; 925 cm.cm_src = src; 926 cm.cm_dedup = B_FALSE; 927 cm.cm_unique = B_TRUE; 928 ret = ctf_merge_types_init(&cm); 929 if (ret != 0) { 930 ctf_close(out); 931 ctf_diff_fini(cdp); 932 return (ctf_set_errno(src, ret)); 933 } 934 935 ret = ctf_diff_types(cdp, ctf_merge_diffcb, &cm); 936 if (ret == 0) { 937 cm.cm_out = out; 938 ret = ctf_merge_uniquify_types(&cm); 939 if (ret == 0) 940 ret = ctf_update(out); 941 } 942 943 if (ret != 0) { 944 ctf_merge_types_fini(&cm); 945 ctf_diff_fini(cdp); 946 return (ctf_set_errno(src, ctf_errno(cm.cm_out))); 947 } 948 949 for (cmi = list_head(&cmh->cmh_inputs); cmi != NULL; 950 cmi = list_next(&cmh->cmh_inputs, cmi)) { 951 ctf_merge_fixup_nontypes(&cm, cmi); 952 } 953 954 ctf_merge_types_fini(&cm); 955 ctf_diff_fini(cdp); 956 *outp = out; 957 return (0); 958 } 959 960 static void 961 ctf_merge_fini_input(ctf_merge_input_t *cmi) 962 { 963 ctf_merge_objmap_t *cmo; 964 ctf_merge_funcmap_t *cmf; 965 966 while ((cmo = list_remove_head(&cmi->cmi_omap)) != NULL) 967 ctf_free(cmo, sizeof (ctf_merge_objmap_t)); 968 969 while ((cmf = list_remove_head(&cmi->cmi_fmap)) != NULL) 970 ctf_free(cmf, sizeof (ctf_merge_funcmap_t) + 971 sizeof (ctf_id_t) * cmf->cmf_argc); 972 973 if (cmi->cmi_created == B_TRUE && cmi->cmi_input != NULL) 974 ctf_close(cmi->cmi_input); 975 976 ctf_free(cmi, sizeof (ctf_merge_input_t)); 977 } 978 979 void 980 ctf_merge_fini(ctf_merge_t *cmh) 981 { 982 size_t len; 983 ctf_merge_input_t *cmi; 984 985 if (cmh->cmh_label != NULL) { 986 len = strlen(cmh->cmh_label) + 1; 987 ctf_free(cmh->cmh_label, len); 988 } 989 990 if (cmh->cmh_pname != NULL) { 991 len = strlen(cmh->cmh_pname) + 1; 992 ctf_free(cmh->cmh_pname, len); 993 } 994 995 while ((cmi = list_remove_head(&cmh->cmh_inputs)) != NULL) 996 ctf_merge_fini_input(cmi); 997 998 ctf_free(cmh, sizeof (ctf_merge_t)); 999 } 1000 1001 ctf_merge_t * 1002 ctf_merge_init(int fd, int *errp) 1003 { 1004 int err; 1005 ctf_merge_t *out; 1006 struct stat st; 1007 1008 if (errp == NULL) 1009 errp = &err; 1010 1011 if (fd != -1 && fstat(fd, &st) != 0) { 1012 *errp = EINVAL; 1013 return (NULL); 1014 } 1015 1016 out = ctf_alloc(sizeof (ctf_merge_t)); 1017 if (out == NULL) { 1018 *errp = ENOMEM; 1019 return (NULL); 1020 } 1021 1022 if (fd == -1) { 1023 out->cmh_msyms = B_FALSE; 1024 } else { 1025 out->cmh_msyms = B_TRUE; 1026 } 1027 1028 list_create(&out->cmh_inputs, sizeof (ctf_merge_input_t), 1029 offsetof(ctf_merge_input_t, cmi_node)); 1030 out->cmh_ninputs = 0; 1031 out->cmh_nthreads = 1; 1032 out->cmh_unique = NULL; 1033 out->cmh_ofd = fd; 1034 out->cmh_flags = 0; 1035 out->cmh_label = NULL; 1036 out->cmh_pname = NULL; 1037 1038 return (out); 1039 } 1040 1041 int 1042 ctf_merge_label(ctf_merge_t *cmh, const char *label) 1043 { 1044 char *dup; 1045 1046 if (label == NULL) 1047 return (EINVAL); 1048 1049 dup = ctf_strdup(label); 1050 if (dup == NULL) 1051 return (EAGAIN); 1052 1053 if (cmh->cmh_label != NULL) { 1054 size_t len = strlen(cmh->cmh_label) + 1; 1055 ctf_free(cmh->cmh_label, len); 1056 } 1057 1058 cmh->cmh_label = dup; 1059 return (0); 1060 } 1061 1062 static int 1063 ctf_merge_add_funcs_cb(const char *name, ulong_t idx, ctf_funcinfo_t *fip, 1064 void *arg) 1065 { 1066 ctf_merge_input_t *cmi = arg; 1067 ctf_merge_funcmap_t *fmap; 1068 1069 fmap = ctf_alloc(sizeof (ctf_merge_funcmap_t) + 1070 sizeof (ctf_id_t) * fip->ctc_argc); 1071 if (fmap == NULL) 1072 return (ENOMEM); 1073 1074 fmap->cmf_idx = idx; 1075 fmap->cmf_rtid = fip->ctc_return; 1076 fmap->cmf_flags = fip->ctc_flags; 1077 fmap->cmf_argc = fip->ctc_argc; 1078 fmap->cmf_name = name; 1079 1080 if (ctf_func_args(cmi->cmi_input, idx, fmap->cmf_argc, 1081 fmap->cmf_args) != 0) { 1082 ctf_free(fmap, sizeof (ctf_merge_funcmap_t) + 1083 sizeof (ctf_id_t) * fip->ctc_argc); 1084 return (ctf_errno(cmi->cmi_input)); 1085 } 1086 1087 list_insert_tail(&cmi->cmi_fmap, fmap); 1088 return (0); 1089 } 1090 1091 static int 1092 ctf_merge_add_objs_cb(const char *name, ctf_id_t id, ulong_t idx, void *arg) 1093 { 1094 ctf_merge_input_t *cmi = arg; 1095 ctf_merge_objmap_t *cmo; 1096 1097 cmo = ctf_alloc(sizeof (ctf_merge_objmap_t)); 1098 if (cmo == NULL) 1099 return (ENOMEM); 1100 1101 cmo->cmo_name = name; 1102 cmo->cmo_idx = idx; 1103 cmo->cmo_tid = id; 1104 list_insert_tail(&cmi->cmi_omap, cmo); 1105 return (0); 1106 } 1107 1108 /* 1109 * Whenever we create an entry to merge, we then go and add a second empty 1110 * ctf_file_t which we use for the purposes of our merging. It's not the best, 1111 * but it's the best that we've got at the moment. 1112 */ 1113 int 1114 ctf_merge_add(ctf_merge_t *cmh, ctf_file_t *input) 1115 { 1116 int ret; 1117 ctf_merge_input_t *cmi; 1118 ctf_file_t *empty; 1119 1120 if (input->ctf_flags & LCTF_CHILD) 1121 return (ECTF_MCHILD); 1122 1123 cmi = ctf_alloc(sizeof (ctf_merge_input_t)); 1124 if (cmi == NULL) 1125 return (ENOMEM); 1126 1127 cmi->cmi_created = B_FALSE; 1128 cmi->cmi_input = input; 1129 list_create(&cmi->cmi_fmap, sizeof (ctf_merge_funcmap_t), 1130 offsetof(ctf_merge_funcmap_t, cmf_node)); 1131 list_create(&cmi->cmi_omap, sizeof (ctf_merge_funcmap_t), 1132 offsetof(ctf_merge_objmap_t, cmo_node)); 1133 1134 if (cmh->cmh_msyms == B_TRUE) { 1135 if ((ret = ctf_function_iter(input, ctf_merge_add_funcs_cb, 1136 cmi)) != 0) { 1137 ctf_merge_fini_input(cmi); 1138 return (ret); 1139 } 1140 1141 if ((ret = ctf_object_iter(input, ctf_merge_add_objs_cb, 1142 cmi)) != 0) { 1143 ctf_merge_fini_input(cmi); 1144 return (ret); 1145 } 1146 } 1147 1148 list_insert_tail(&cmh->cmh_inputs, cmi); 1149 cmh->cmh_ninputs++; 1150 1151 /* And now the empty one to merge into this */ 1152 cmi = ctf_alloc(sizeof (ctf_merge_input_t)); 1153 if (cmi == NULL) 1154 return (ENOMEM); 1155 list_create(&cmi->cmi_fmap, sizeof (ctf_merge_funcmap_t), 1156 offsetof(ctf_merge_funcmap_t, cmf_node)); 1157 list_create(&cmi->cmi_omap, sizeof (ctf_merge_funcmap_t), 1158 offsetof(ctf_merge_objmap_t, cmo_node)); 1159 1160 empty = ctf_fdcreate(cmh->cmh_ofd, &ret); 1161 if (empty == NULL) 1162 return (ret); 1163 cmi->cmi_input = empty; 1164 cmi->cmi_created = B_TRUE; 1165 1166 if (ctf_setmodel(empty, ctf_getmodel(input)) == CTF_ERR) { 1167 return (ctf_errno(empty)); 1168 } 1169 1170 list_insert_tail(&cmh->cmh_inputs, cmi); 1171 cmh->cmh_ninputs++; 1172 ctf_dprintf("added containers %p and %p\n", input, empty); 1173 return (0); 1174 } 1175 1176 int 1177 ctf_merge_uniquify(ctf_merge_t *cmh, ctf_file_t *u, const char *pname) 1178 { 1179 char *dup; 1180 1181 if (u->ctf_flags & LCTF_CHILD) 1182 return (ECTF_MCHILD); 1183 if (pname == NULL) 1184 return (EINVAL); 1185 dup = ctf_strdup(pname); 1186 if (dup == NULL) 1187 return (EINVAL); 1188 if (cmh->cmh_pname != NULL) { 1189 size_t len = strlen(cmh->cmh_pname) + 1; 1190 ctf_free(cmh->cmh_pname, len); 1191 } 1192 cmh->cmh_pname = dup; 1193 cmh->cmh_unique = u; 1194 return (0); 1195 } 1196 1197 static int 1198 ctf_merge_symbols(ctf_merge_t *cmh, ctf_file_t *fp) 1199 { 1200 int err; 1201 ulong_t i; 1202 1203 uintptr_t symbase = (uintptr_t)fp->ctf_symtab.cts_data; 1204 uintptr_t strbase = (uintptr_t)fp->ctf_strtab.cts_data; 1205 1206 for (i = 0; i < fp->ctf_nsyms; i++) { 1207 const char *name; 1208 ctf_merge_input_t *cmi; 1209 ctf_merge_objmap_t *cmo; 1210 1211 if (fp->ctf_symtab.cts_entsize == sizeof (Elf32_Sym)) { 1212 const Elf32_Sym *symp = (Elf32_Sym *)symbase + i; 1213 int type = ELF32_ST_TYPE(symp->st_info); 1214 if (type != STT_OBJECT) 1215 continue; 1216 if (ctf_sym_valid(strbase, type, symp->st_shndx, 1217 symp->st_value, symp->st_name) == B_FALSE) 1218 continue; 1219 name = (char *)(strbase + symp->st_name); 1220 } else { 1221 const Elf64_Sym *symp = (Elf64_Sym *)symbase + i; 1222 int type = ELF64_ST_TYPE(symp->st_info); 1223 if (type != STT_OBJECT) 1224 continue; 1225 if (ctf_sym_valid(strbase, type, symp->st_shndx, 1226 symp->st_value, symp->st_name) == B_FALSE) 1227 continue; 1228 name = (char *)(strbase + symp->st_name); 1229 } 1230 1231 cmo = NULL; 1232 for (cmi = list_head(&cmh->cmh_inputs); cmi != NULL; 1233 cmi = list_next(&cmh->cmh_inputs, cmi)) { 1234 for (cmo = list_head(&cmi->cmi_omap); cmo != NULL; 1235 cmo = list_next(&cmi->cmi_omap, cmo)) { 1236 if (strcmp(cmo->cmo_name, name) == 0) 1237 goto found; 1238 } 1239 } 1240 found: 1241 if (cmo != NULL) { 1242 if (cmo->cmo_tid == 0) 1243 continue; 1244 if ((err = ctf_add_object(fp, i, cmo->cmo_tid)) != 0) { 1245 ctf_dprintf("Failed to add symbol %s->%d: %s\n", 1246 name, cmo->cmo_tid, 1247 ctf_errmsg(ctf_errno(fp))); 1248 return (err); 1249 } 1250 } 1251 } 1252 1253 return (0); 1254 } 1255 1256 static int 1257 ctf_merge_functions(ctf_merge_t *cmh, ctf_file_t *fp) 1258 { 1259 int err; 1260 ulong_t i; 1261 ctf_funcinfo_t fi; 1262 1263 uintptr_t symbase = (uintptr_t)fp->ctf_symtab.cts_data; 1264 uintptr_t strbase = (uintptr_t)fp->ctf_strtab.cts_data; 1265 1266 for (i = 0; i < fp->ctf_nsyms; i++) { 1267 const char *name; 1268 ctf_merge_input_t *cmi; 1269 ctf_merge_funcmap_t *cmf; 1270 1271 if (fp->ctf_symtab.cts_entsize == sizeof (Elf32_Sym)) { 1272 const Elf32_Sym *symp = (Elf32_Sym *)symbase + i; 1273 int type = ELF32_ST_TYPE(symp->st_info); 1274 if (ELF32_ST_TYPE(symp->st_info) != STT_FUNC) 1275 continue; 1276 if (ctf_sym_valid(strbase, type, symp->st_shndx, 1277 symp->st_value, symp->st_name) == B_FALSE) 1278 continue; 1279 name = (char *)(strbase + symp->st_name); 1280 } else { 1281 const Elf64_Sym *symp = (Elf64_Sym *)symbase + i; 1282 int type = ELF64_ST_TYPE(symp->st_info); 1283 if (ELF64_ST_TYPE(symp->st_info) != STT_FUNC) 1284 continue; 1285 if (ctf_sym_valid(strbase, type, symp->st_shndx, 1286 symp->st_value, symp->st_name) == B_FALSE) 1287 continue; 1288 name = (char *)(strbase + symp->st_name); 1289 } 1290 1291 cmf = NULL; 1292 for (cmi = list_head(&cmh->cmh_inputs); cmi != NULL; 1293 cmi = list_next(&cmh->cmh_inputs, cmi)) { 1294 for (cmf = list_head(&cmi->cmi_fmap); cmf != NULL; 1295 cmf = list_next(&cmi->cmi_fmap, cmf)) { 1296 if (strcmp(cmf->cmf_name, name) == 0) 1297 goto found; 1298 } 1299 } 1300 found: 1301 if (cmf != NULL) { 1302 fi.ctc_return = cmf->cmf_rtid; 1303 fi.ctc_argc = cmf->cmf_argc; 1304 fi.ctc_flags = cmf->cmf_flags; 1305 if ((err = ctf_add_function(fp, i, &fi, 1306 cmf->cmf_args)) != 0) 1307 return (err); 1308 } 1309 } 1310 1311 return (0); 1312 1313 } 1314 1315 int 1316 ctf_merge_merge(ctf_merge_t *cmh, ctf_file_t **outp) 1317 { 1318 int err, merr; 1319 ctf_merge_input_t *cmi; 1320 ctf_id_t ltype; 1321 mergeq_t *mqp; 1322 ctf_merge_input_t *final; 1323 ctf_file_t *out; 1324 1325 if (cmh->cmh_label != NULL && cmh->cmh_unique != NULL) { 1326 const char *label = ctf_label_topmost(cmh->cmh_unique); 1327 if (label == NULL) 1328 return (ECTF_NOLABEL); 1329 if (strcmp(label, cmh->cmh_label) != 0) 1330 return (ECTF_LCONFLICT); 1331 } 1332 1333 if (mergeq_init(&mqp, cmh->cmh_nthreads) == -1) { 1334 return (errno); 1335 } 1336 1337 VERIFY(cmh->cmh_ninputs % 2 == 0); 1338 for (cmi = list_head(&cmh->cmh_inputs); cmi != NULL; 1339 cmi = list_next(&cmh->cmh_inputs, cmi)) { 1340 if (mergeq_add(mqp, cmi) == -1) { 1341 err = errno; 1342 mergeq_fini(mqp); 1343 } 1344 } 1345 1346 err = mergeq_merge(mqp, ctf_merge_types, NULL, (void **)&final, &merr); 1347 mergeq_fini(mqp); 1348 1349 if (err == MERGEQ_ERROR) { 1350 return (errno); 1351 } else if (err == MERGEQ_UERROR) { 1352 return (merr); 1353 } 1354 1355 /* 1356 * Disassociate the generated ctf_file_t from the original input. That 1357 * way when the input gets cleaned up, we don't accidentally kill the 1358 * final reference to the ctf_file_t. If it gets uniquified then we'll 1359 * kill it. 1360 */ 1361 VERIFY(final->cmi_input != NULL); 1362 out = final->cmi_input; 1363 final->cmi_input = NULL; 1364 1365 ctf_dprintf("preparing to uniquify against: %p\n", cmh->cmh_unique); 1366 if (cmh->cmh_unique != NULL) { 1367 ctf_file_t *u; 1368 err = ctf_uniquify_types(cmh, out, &u); 1369 if (err != 0) { 1370 err = ctf_errno(out); 1371 ctf_close(out); 1372 return (err); 1373 } 1374 ctf_close(out); 1375 out = u; 1376 } 1377 1378 ltype = out->ctf_typemax; 1379 if ((out->ctf_flags & LCTF_CHILD) && ltype != 0) 1380 ltype += CTF_CHILD_START; 1381 ctf_dprintf("trying to add the label\n"); 1382 if (cmh->cmh_label != NULL && 1383 ctf_add_label(out, cmh->cmh_label, ltype, 0) != 0) { 1384 ctf_close(out); 1385 return (ctf_errno(out)); 1386 } 1387 1388 ctf_dprintf("merging symbols and the like\n"); 1389 if (cmh->cmh_msyms == B_TRUE) { 1390 err = ctf_merge_symbols(cmh, out); 1391 if (err != 0) { 1392 ctf_close(out); 1393 return (ctf_errno(out)); 1394 } 1395 1396 err = ctf_merge_functions(cmh, out); 1397 if (err != 0) { 1398 ctf_close(out); 1399 return (ctf_errno(out)); 1400 } 1401 } 1402 1403 err = ctf_update(out); 1404 if (err != 0) { 1405 ctf_close(out); 1406 return (ctf_errno(out)); 1407 } 1408 1409 *outp = out; 1410 return (0); 1411 } 1412 1413 /* 1414 * When we get told that something is unique, eg. same is B_FALSE, then that 1415 * tells us that we need to add it to the output. If same is B_TRUE, then we'll 1416 * want to record it in the mapping table so that we know how to redirect types 1417 * to the extant ones. 1418 */ 1419 static void 1420 ctf_dedup_cb(ctf_file_t *ifp, ctf_id_t iid, boolean_t same, ctf_file_t *ofp, 1421 ctf_id_t oid, void *arg) 1422 { 1423 ctf_merge_types_t *cmp = arg; 1424 ctf_merge_tinfo_t *cmt = cmp->cm_tmap; 1425 1426 if (same == B_TRUE) { 1427 /* 1428 * The output id here may itself map to something else. 1429 * Therefore, we need to basically walk a chain and see what it 1430 * points to until it itself points to a base type, eg. -1. 1431 * Otherwise we'll dedup to something which no longer exists. 1432 */ 1433 while (cmt[oid].cmt_missing == B_FALSE) 1434 oid = cmt[oid].cmt_map; 1435 cmt[iid].cmt_map = oid; 1436 ctf_dprintf("%d->%d \n", iid, oid); 1437 } else { 1438 VERIFY(cmt[iid].cmt_map == 0); 1439 cmt[iid].cmt_missing = B_TRUE; 1440 ctf_dprintf("%d is missing\n", iid); 1441 } 1442 } 1443 1444 /* 1445 * Dedup a CTF container. 1446 * 1447 * DWARF and other encoding formats that we use to create CTF data may create 1448 * multiple copies of a given type. However, after doing a conversion, and 1449 * before doing a merge, we'd prefer, if possible, to have every input container 1450 * to be unique. 1451 * 1452 * Doing a deduplication is like a normal merge. However, when we diff the types 1453 * in the container, rather than doing a normal diff, we instead want to diff 1454 * against any already processed types. eg, for a given type i in a container, 1455 * we want to diff it from 0 to i - 1. 1456 */ 1457 int 1458 ctf_merge_dedup(ctf_merge_t *cmp, ctf_file_t **outp) 1459 { 1460 int ret; 1461 ctf_diff_t *cdp = NULL; 1462 ctf_merge_input_t *cmi, *cmc; 1463 ctf_file_t *ifp, *ofp; 1464 ctf_merge_types_t cm; 1465 1466 if (cmp == NULL || outp == NULL) 1467 return (EINVAL); 1468 1469 ctf_dprintf("encountered %d inputs\n", cmp->cmh_ninputs); 1470 if (cmp->cmh_ninputs != 2) 1471 return (EINVAL); 1472 1473 ctf_dprintf("passed argument sanity check\n"); 1474 1475 cmi = list_head(&cmp->cmh_inputs); 1476 VERIFY(cmi != NULL); 1477 cmc = list_next(&cmp->cmh_inputs, cmi); 1478 VERIFY(cmc != NULL); 1479 ifp = cmi->cmi_input; 1480 ofp = cmc->cmi_input; 1481 VERIFY(ifp != NULL); 1482 VERIFY(ofp != NULL); 1483 cm.cm_src = ifp; 1484 cm.cm_out = ofp; 1485 cm.cm_dedup = B_TRUE; 1486 cm.cm_unique = B_FALSE; 1487 1488 if ((ret = ctf_merge_types_init(&cm)) != 0) { 1489 return (ret); 1490 } 1491 1492 if ((ret = ctf_diff_init(ifp, ifp, &cdp)) != 0) 1493 goto err; 1494 1495 ctf_dprintf("Successfully initialized dedup\n"); 1496 if ((ret = ctf_diff_self(cdp, ctf_dedup_cb, &cm)) != 0) 1497 goto err; 1498 1499 ctf_dprintf("Successfully diffed types\n"); 1500 ret = ctf_merge_common(&cm); 1501 ctf_dprintf("deduping types result: %d\n", ret); 1502 if (ret == 0) 1503 ret = ctf_update(cm.cm_out); 1504 if (ret != 0) 1505 goto err; 1506 1507 ctf_dprintf("Successfully deduped types\n"); 1508 ctf_phase_dump(cm.cm_out, "dedup-pre-syms"); 1509 1510 /* 1511 * Now we need to fix up the object and function maps. 1512 */ 1513 ctf_merge_fixup_nontypes(&cm, cmi); 1514 1515 if (cmp->cmh_msyms == B_TRUE) { 1516 ret = ctf_merge_symbols(cmp, cm.cm_out); 1517 if (ret != 0) { 1518 ret = ctf_errno(cm.cm_out); 1519 ctf_dprintf("failed to dedup symbols: %s\n", 1520 ctf_errmsg(ret)); 1521 goto err; 1522 } 1523 1524 ret = ctf_merge_functions(cmp, cm.cm_out); 1525 if (ret != 0) { 1526 ret = ctf_errno(cm.cm_out); 1527 ctf_dprintf("failed to dedup functions: %s\n", 1528 ctf_errmsg(ret)); 1529 goto err; 1530 } 1531 } 1532 1533 ret = ctf_update(cm.cm_out); 1534 if (ret == 0) { 1535 cmc->cmi_input = NULL; 1536 *outp = cm.cm_out; 1537 } 1538 err: 1539 ctf_merge_types_fini(&cm); 1540 ctf_diff_fini(cdp); 1541 return (ret); 1542 } 1543 1544 int 1545 ctf_merge_set_nthreads(ctf_merge_t *cmp, const uint_t nthrs) 1546 { 1547 if (nthrs == 0) 1548 return (EINVAL); 1549 cmp->cmh_nthreads = nthrs; 1550 return (0); 1551 } 1552