libkern/kxld/kxld_kext.c

   1 /*
   2  * Copyright (c) 2008 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 #include <string.h>
  29 #include <mach/machine.h>
  30 #include <mach/vm_param.h>
  31 #include <mach/vm_types.h>
  32 #include <mach/kmod.h>
  33 #include <mach-o/loader.h>
  34 #include <mach-o/nlist.h>
  35 #include <mach-o/reloc.h>
  36 #include <sys/types.h>
  37
  38 #if KERNEL
  39     #include <libkern/kernel_mach_header.h>
  40     #include <libkern/OSKextLib.h>
  41     #include <libkern/OSKextLibPrivate.h>
  42     #include <mach/vm_param.h>
  43     #include <mach-o/fat.h>
  44 #else /* !KERNEL */
  45     #include <architecture/byte_order.h>
  46     #include <mach/mach_init.h>
  47     #include <mach-o/arch.h>
  48     #include <mach-o/swap.h>
  49 #endif /* KERNEL */
  50
  51 #define DEBUG_ASSERT_COMPONENT_NAME_STRING "kxld"
  52 #include <AssertMacros.h>
  53
  54 #include "kxld_demangle.h"
  55 #include "kxld_dict.h"
  56 #include "kxld_kext.h"
  57 #include "kxld_object.h"
  58 #include "kxld_reloc.h"
  59 #include "kxld_sect.h"
  60 #include "kxld_seg.h"
  61 #include "kxld_symtab.h"
  62 #include "kxld_util.h"
  63 #include "kxld_uuid.h"
  64 #include "kxld_vtable.h"
  65
  66 struct symtab_command;
  67
  68 struct kxld_kext {
  69     KXLDObject *kext;
  70     KXLDObject *interface;
  71     KXLDArray vtables;
  72     KXLDDict vtable_index;
  73     boolean_t vtables_created;
  74     boolean_t vtable_index_created;
  75 };
  76
  77 /*******************************************************************************
  78 * Prototypes
  79 *******************************************************************************/
  80
  81 static kern_return_t export_symbols_through_interface(
  82     const KXLDObject *kext, const KXLDObject *interface,
  83     KXLDDict *defined_symbols_by_name,
  84     KXLDDict *defined_cxx_symbol_by_value,
  85     KXLDDict *obsolete_symbols_by_name);
  86 static kern_return_t export_symbols(const KXLDObject *kext,
  87     KXLDDict *defined_symbols_by_name,
  88     KXLDDict *defined_cxx_symbols_by_value);
  89
  90 static kern_return_t create_vtables(KXLDKext *kext,
  91     const KXLDDict *defined_symbols, const KXLDDict *defined_cxx_symbols);
  92 static kern_return_t get_vtable_syms_from_smcp(KXLDKext *kext,
  93     const KXLDDict *defined_symbols, KXLDSym *super_metaclass_ptr_sym,
  94     KXLDSym **vtable_sym_out, KXLDSym **meta_vtable_sym_out);
  95
  96 static kern_return_t resolve_symbols(KXLDKext *kext,
  97     const KXLDDict *defined_symbols, const KXLDDict *obsolete_symbols);
  98
  99 static kern_return_t patch_vtables(KXLDKext *kext, KXLDDict *patched_vtables,
 100     const KXLDDict *defined_symbols);
 101 static const KXLDSym *get_metaclass_symbol_from_super_meta_class_pointer_symbol(
 102     KXLDKext *kext, KXLDSym *super_metaclass_pointer_sym);
 103 static kern_return_t create_vtable_index(KXLDKext *kext);
 104
 105 static kern_return_t validate_symbols(KXLDKext *kext);
 106
 107 /*******************************************************************************
 108 *******************************************************************************/
 109 size_t
 110 kxld_kext_sizeof(void)
 111 {
 112     return sizeof(KXLDKext);
 113 }
 114
 115 /*******************************************************************************
 116 *******************************************************************************/
 117 kern_return_t
 118 kxld_kext_init(KXLDKext *kext, KXLDObject *kext_object,
 119     KXLDObject *interface_object)
 120 {
 121     kern_return_t rval = KERN_FAILURE;
 122
 123     check(kext);
 124     check(kext_object);
 125
 126     kext->kext = kext_object;
 127
 128     if (interface_object) {
 129         kext->interface = interface_object;
 130
 131         rval = kxld_object_index_symbols_by_name(kext->kext);
 132         require_noerr(rval, finish);
 133     }
 134
 135     rval = KERN_SUCCESS;
 136 finish:
 137     return rval;
 138 }
 139
 140 /*******************************************************************************
 141 *******************************************************************************/
 142 void
 143 kxld_kext_clear(KXLDKext *kext)
 144 {
 145     KXLDVTable *vtable = NULL;
 146     u_int i;
 147
 148     check(kext);
 149
 150     for (i = 0; i < kext->vtables.nitems; ++i) {
 151         vtable = kxld_array_get_item(&kext->vtables, i);
 152         kxld_vtable_clear(vtable);
 153     }
 154     kxld_array_reset(&kext->vtables);
 155     kxld_dict_clear(&kext->vtable_index);
 156
 157     kext->kext = NULL;
 158     kext->interface = NULL;
 159     kext->vtables_created = FALSE;
 160     kext->vtable_index_created = FALSE;
 161 }
 162
 163
 164 /*******************************************************************************
 165 *******************************************************************************/
 166 void
 167 kxld_kext_deinit(KXLDKext *kext)
 168 {
 169     KXLDVTable *vtable = NULL;
 170     u_int i;
 171
 172     check(kext);
 173
 174     for (i = 0; i < kext->vtables.maxitems; ++i) {
 175         vtable = kxld_array_get_slot(&kext->vtables, i);
 176         kxld_vtable_deinit(vtable);
 177     }
 178     kxld_array_deinit(&kext->vtables);
 179     kxld_dict_deinit(&kext->vtable_index);
 180
 181     bzero(kext, sizeof(*kext));
 182 }
 183
 184 /*******************************************************************************
 185 *******************************************************************************/
 186 kern_return_t
 187 kxld_kext_export_symbols(const KXLDKext *kext,
 188     struct kxld_dict *defined_symbols_by_name,
 189     struct kxld_dict *obsolete_symbols_by_name,
 190     struct kxld_dict *defined_cxx_symbols_by_value)
 191 {
 192     kern_return_t rval = KERN_FAILURE;
 193
 194     check(kext);
 195
 196     if (kext->interface) {
 197         rval = export_symbols_through_interface(kext->kext, kext->interface,
 198             defined_symbols_by_name, obsolete_symbols_by_name,
 199             defined_cxx_symbols_by_value);
 200         require_noerr(rval, finish);
 201     } else {
 202         rval = export_symbols(kext->kext, defined_symbols_by_name,
 203             defined_cxx_symbols_by_value);
 204         require_noerr(rval, finish);
 205     }
 206
 207     rval = KERN_SUCCESS;
 208 finish:
 209     return rval;
 210 }
 211
 212 /*******************************************************************************
 213 *******************************************************************************/
 214 kern_return_t
 215 export_symbols_through_interface(const KXLDObject *kext,
 216     const KXLDObject *interface, KXLDDict *defined_symbols_by_name,
 217     KXLDDict *obsolete_symbols_by_name, KXLDDict *defined_cxx_symbols_by_value)
 218 {
 219     kern_return_t rval = KERN_FAILURE;
 220     KXLDSymtabIterator iter;
 221     const KXLDSymtab *kext_symtab = NULL;
 222     const KXLDSymtab *interface_symtab = NULL;
 223     KXLDSym *kext_sym = NULL;
 224     const KXLDSym *interface_sym = NULL;
 225
 226     check(kext);
 227     check(interface);
 228
 229     kext_symtab = kxld_object_get_symtab(kext);
 230     interface_symtab = kxld_object_get_symtab(interface);
 231
 232     if (defined_symbols_by_name) {
 233         /* Add exported symbols */
 234         (void) kxld_symtab_iterator_init(&iter, interface_symtab,
 235             kxld_sym_is_undefined, FALSE);
 236         while ((interface_sym = kxld_symtab_iterator_get_next(&iter))) {
 237             kext_sym = kxld_symtab_get_locally_defined_symbol_by_name(kext_symtab,
 238                 interface_sym->name);
 239             if (!kext_sym) {
 240                 kxld_log(kKxldLogLinking, kKxldLogWarn,
 241                     "In interface %s of %s, couldn't find symbol %s\n",
 242                     kxld_object_get_name(interface), kxld_object_get_name(kext),
 243                     interface_sym->name);
 244                 continue;
 245             }
 246
 247             rval = kxld_dict_insert(defined_symbols_by_name,
 248                 kext_sym->name, kext_sym);
 249             require_noerr(rval, finish);
 250         }
 251
 252         /* Add indirect symbols */
 253         (void) kxld_symtab_iterator_init(&iter, interface_symtab,
 254             kxld_sym_is_indirect, FALSE);
 255         while ((interface_sym = kxld_symtab_iterator_get_next(&iter))) {
 256             kext_sym = kxld_symtab_get_locally_defined_symbol_by_name(kext_symtab,
 257                 interface_sym->alias);
 258             if (!kext_sym) {
 259                 kxld_log(kKxldLogLinking, kKxldLogWarn,
 260                     "In interface %s of %s, couldn't find indirect symbol %s (%s)\n",
 261                     kxld_object_get_name(interface), kxld_object_get_name(kext),
 262                     interface_sym->alias, interface_sym->name);
 263                 continue;
 264             }
 265
 266             rval = kxld_dict_insert(defined_symbols_by_name,
 267                 interface_sym->name, kext_sym);
 268             require_noerr(rval, finish);
 269         }
 270     }
 271
 272     /* Add obsolete symbols */
 273     if (obsolete_symbols_by_name) {
 274         (void) kxld_symtab_iterator_init(&iter, interface_symtab,
 275             kxld_sym_is_obsolete, FALSE);
 276         while ((kext_sym = kxld_symtab_iterator_get_next(&iter))) {
 277             rval = kxld_dict_insert(obsolete_symbols_by_name,
 278                 kext_sym->name, kext_sym);
 279             require_noerr(rval, finish);
 280         }
 281     }
 282
 283     /* Add C++ symbols */
 284     if (defined_cxx_symbols_by_value) {
 285         (void) kxld_symtab_iterator_init(&iter, kext_symtab,
 286             kxld_sym_is_cxx, FALSE);
 287         while ((kext_sym = kxld_symtab_iterator_get_next(&iter))) {
 288             rval = kxld_dict_insert(defined_cxx_symbols_by_value,
 289                 &kext_sym->link_addr, kext_sym);
 290             require_noerr(rval, finish);
 291         }
 292     }
 293
 294     rval = KERN_SUCCESS;
 295 finish:
 296     return rval;
 297 }
 298
 299 /*******************************************************************************
 300 *******************************************************************************/
 301 kern_return_t
 302 export_symbols(const KXLDObject *kext, KXLDDict *defined_symbols_by_name,
 303     KXLDDict *defined_cxx_symbols_by_value)
 304 {
 305     kern_return_t rval = KERN_FAILURE;
 306     KXLDSymtabIterator iter;
 307     KXLDSym *sym = NULL;
 308
 309     (void) kxld_symtab_iterator_init(&iter, kxld_object_get_symtab(kext),
 310         kxld_sym_is_exported, FALSE);
 311     while ((sym = kxld_symtab_iterator_get_next(&iter))) {
 312         if (defined_symbols_by_name) {
 313             rval = kxld_dict_insert(defined_symbols_by_name, sym->name, sym);
 314             require_noerr(rval, finish);
 315         }
 316
 317         if (kxld_sym_is_cxx(sym) && defined_cxx_symbols_by_value) {
 318             rval = kxld_dict_insert(defined_cxx_symbols_by_value,
 319                 &sym->link_addr, sym);
 320             require_noerr(rval, finish);
 321         }
 322     }
 323
 324     rval = KERN_SUCCESS;
 325 finish:
 326     return rval;
 327 }
 328
 329 /*******************************************************************************
 330 *******************************************************************************/
 331 kern_return_t
 332 kxld_kext_export_vtables(KXLDKext *kext, const KXLDDict *defined_cxx_symbols,
 333     const KXLDDict *defined_symbols, KXLDDict *vtables)
 334 {
 335     kern_return_t rval = KERN_FAILURE;
 336     KXLDVTable *vtable = NULL;
 337     u_int i = 0;
 338
 339     check(kext);
 340     check(defined_symbols);
 341     check(defined_cxx_symbols);
 342     check(vtables);
 343
 344     rval = create_vtables(kext, defined_cxx_symbols, defined_symbols);
 345     require_noerr(rval, finish);
 346
 347     for (i = 0; i < kext->vtables.nitems; ++i) {
 348         vtable = kxld_array_get_item(&kext->vtables, i);
 349
 350         rval = kxld_dict_insert(vtables, vtable->name, vtable);
 351         require_noerr(rval, finish);
 352     }
 353
 354     rval = KERN_SUCCESS;
 355 finish:
 356     return rval;
 357 }
 358
 359 /*******************************************************************************
 360 *******************************************************************************/
 361 void
 362 kxld_kext_get_vmsize(const KXLDKext *kext,
 363     u_long *header_size, u_long *vmsize)
 364 {
 365     (void) kxld_object_get_vmsize(kext->kext, header_size, vmsize);
 366 }
 367
 368 /*******************************************************************************
 369 *******************************************************************************/
 370 kern_return_t
 371 kxld_kext_export_linked_object(const KXLDKext *kext,
 372     u_char *linked_object, kxld_addr_t *kmod_info)
 373 {
 374     kern_return_t rval = KERN_FAILURE;
 375     const KXLDSym *kmodsym = NULL;
 376
 377     kmodsym = kxld_symtab_get_locally_defined_symbol_by_name(
 378         kxld_object_get_symtab(kext->kext), KXLD_KMOD_INFO_SYMBOL);
 379     require_action(kmodsym, finish, rval=KERN_FAILURE;
 380         kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogNoKmodInfo));
 381
 382     *kmod_info = kmodsym->link_addr;
 383
 384     rval = kxld_object_export_linked_object(kext->kext, linked_object);
 385 finish:
 386     return rval;
 387 }
 388
 389 /*******************************************************************************
 390 *******************************************************************************/
 391 kern_return_t
 392 kxld_kext_relocate(KXLDKext *kext, kxld_addr_t link_address,
 393     KXLDDict *patched_vtables, const KXLDDict *defined_symbols,
 394     const KXLDDict *obsolete_symbols, const KXLDDict *defined_cxx_symbols)
 395 {
 396     kern_return_t rval = KERN_FAILURE;
 397
 398     check(kext);
 399     check(patched_vtables);
 400     check(defined_symbols);
 401     check(obsolete_symbols);
 402
 403     /* Kexts that are being relocated need symbols indexed by value for vtable
 404      * creation and patching. Note that we don't need to index by value for
 405      * dependencies that have already been linked because their symbols are
 406      * already in the global cxx value table. It's important to index the
 407      * symbols by value before we relocate the symbols because the vtable
 408      * entries will still have unrelocated values.
 409      */
 410     rval = kxld_object_index_cxx_symbols_by_value(kext->kext);
 411     require_noerr(rval, finish);
 412
 413     rval = kxld_object_index_symbols_by_name(kext->kext);
 414     require_noerr(rval, finish);
 415
 416     rval = kxld_object_relocate(kext->kext, link_address);
 417     require_noerr(rval, finish);
 418
 419     rval = resolve_symbols(kext, defined_symbols, obsolete_symbols);
 420     require_noerr(rval, finish);
 421
 422     rval = create_vtables(kext, defined_cxx_symbols, /* defined_symbols */ NULL);
 423     require_noerr(rval, finish);
 424
 425     rval = patch_vtables(kext, patched_vtables, defined_symbols);
 426     require_noerr(rval, finish);
 427
 428     rval = validate_symbols(kext);
 429     require_noerr(rval, finish);
 430
 431     rval = kxld_object_process_relocations(kext->kext, patched_vtables);
 432     require_noerr(rval, finish);
 433
 434     rval = KERN_SUCCESS;
 435 finish:
 436     return rval;
 437 }
 438
 439 /*******************************************************************************
 440 * The defined symbols argument is optional.  When supplied, create_vtables()
 441 * will look for vtable symbols in the defined_symbols dictionary.  Otherwise,
 442 * it will look in the kext's symbol table for vtable symbols.
 443 *
 444 * We do this because there are two types of KXLDKext objects that call
 445 * create_vtables(), those that have been linked, and those that haven't.  The
 446 * linked kexts export their symbols into the global symbol table that is used
 447 * for symbol resolution, so we can look there for vtable symbols without
 448 * having to index their local symbol table separately.
 449 *
 450 * Unlinked kexts haven't yet had their symbols exported into the global table,
 451 * so we have to index their local symbol table separately.
 452 *******************************************************************************/
 453 static kern_return_t
 454 create_vtables(KXLDKext *kext, const KXLDDict *defined_cxx_symbols,
 455     const KXLDDict *defined_symbols)
 456 {
 457     kern_return_t rval = KERN_FAILURE;
 458     const KXLDSymtab *symtab = NULL;
 459     KXLDSymtabIterator iter;
 460     KXLDSym *sym = NULL;
 461     KXLDSym *vtable_sym = NULL;
 462     KXLDSym *meta_vtable_sym = NULL;
 463     KXLDVTable *vtable = NULL;
 464     KXLDVTable *meta_vtable = NULL;
 465     u_int i = 0;
 466     u_int nvtables = 0;
 467
 468     if (kext->vtables_created) {
 469         rval = KERN_SUCCESS;
 470         goto finish;
 471     }
 472
 473     symtab = kxld_object_get_symtab(kext->kext);
 474
 475     if (kxld_object_is_linked(kext->kext)) {
 476         /* Create a vtable object for every vtable symbol */
 477         kxld_symtab_iterator_init(&iter, symtab, kxld_sym_is_vtable, FALSE);
 478         nvtables = kxld_symtab_iterator_get_num_remaining(&iter);
 479     } else {
 480         /* We walk over the super metaclass pointer symbols because classes
 481          * with them are the only ones that need patching.  Then we double the
 482          * number of vtables we're expecting, because every pointer will have a
 483          * class vtable and a MetaClass vtable.
 484          */
 485         kxld_symtab_iterator_init(&iter, symtab,
 486             kxld_sym_is_super_metaclass_pointer, FALSE);
 487         nvtables = kxld_symtab_iterator_get_num_remaining(&iter) * 2;
 488     }
 489
 490     rval = kxld_array_init(&kext->vtables, sizeof(KXLDVTable), nvtables);
 491     require_noerr(rval, finish);
 492
 493     while ((sym = kxld_symtab_iterator_get_next(&iter))) {
 494         if (kxld_object_is_linked(kext->kext)) {
 495             vtable_sym = sym;
 496             meta_vtable_sym = NULL;
 497             meta_vtable = NULL;
 498         } else {
 499             rval = get_vtable_syms_from_smcp(kext, defined_symbols, sym,
 500                 &vtable_sym, &meta_vtable_sym);
 501             require_noerr(rval, finish);
 502         }
 503
 504         vtable = kxld_array_get_item(&kext->vtables, i++);
 505         rval = kxld_vtable_init(vtable, vtable_sym, kext->kext,
 506             defined_cxx_symbols);
 507         require_noerr(rval, finish);
 508
 509         /* meta_vtable_sym will be null when we don't support strict
 510          * patching and can't find the metaclass vtable. If that's the
 511          * case, we just reduce the expect number of vtables by 1.
 512          */
 513         if (!kxld_object_is_linked(kext->kext)) {
 514             if (meta_vtable_sym) {
 515                 meta_vtable = kxld_array_get_item(&kext->vtables, i++);
 516                 rval = kxld_vtable_init(meta_vtable, meta_vtable_sym,
 517                     kext->kext, defined_cxx_symbols);
 518                 require_noerr(rval, finish);
 519             } else {
 520                 kxld_array_resize(&kext->vtables, --nvtables);
 521                 meta_vtable = NULL;
 522             }
 523         }
 524     }
 525     require_action(i == kext->vtables.nitems, finish,
 526         rval=KERN_FAILURE);
 527
 528     kext->vtables_created = TRUE;
 529     rval = KERN_SUCCESS;
 530 finish:
 531     return rval;
 532 }
 533
 534 /*******************************************************************************
 535 *******************************************************************************/
 536 static kern_return_t
 537 get_vtable_syms_from_smcp(KXLDKext *kext, const KXLDDict *defined_symbols,
 538     KXLDSym *super_metaclass_ptr_sym, KXLDSym **vtable_sym_out,
 539     KXLDSym **meta_vtable_sym_out)
 540 {
 541     kern_return_t rval = KERN_FAILURE;
 542     const KXLDSymtab *symtab = NULL;
 543     KXLDSym *vtable_sym = NULL;
 544     KXLDSym *meta_vtable_sym = NULL;
 545     char class_name[KXLD_MAX_NAME_LEN];
 546     char vtable_name[KXLD_MAX_NAME_LEN];
 547     char meta_vtable_name[KXLD_MAX_NAME_LEN];
 548     char *demangled_name1 = NULL;
 549     char *demangled_name2 = NULL;
 550     size_t demangled_length1 = 0;
 551     size_t demangled_length2 = 0;
 552
 553     check(kext);
 554     check(vtable_sym_out);
 555     check(meta_vtable_sym_out);
 556
 557     require(!kxld_object_is_kernel(kext->kext), finish);
 558
 559     symtab = kxld_object_get_symtab(kext->kext);
 560
 561     /* Get the class name from the smc pointer */
 562     rval = kxld_sym_get_class_name_from_super_metaclass_pointer(
 563         super_metaclass_ptr_sym, class_name, sizeof(class_name));
 564     require_noerr(rval, finish);
 565
 566     /* Get the vtable name from the class name */
 567     rval = kxld_sym_get_vtable_name_from_class_name(class_name,
 568         vtable_name, sizeof(vtable_name));
 569     require_noerr(rval, finish);
 570
 571     /* Get the vtable symbol */
 572     if (defined_symbols) {
 573         vtable_sym = kxld_dict_find(defined_symbols, vtable_name);
 574     } else {
 575         vtable_sym = kxld_symtab_get_locally_defined_symbol_by_name(symtab,
 576             vtable_name);
 577     }
 578     require_action(vtable_sym, finish, rval=KERN_FAILURE;
 579         kxld_log(kKxldLogPatching, kKxldLogErr, kKxldLogMissingVtable,
 580         vtable_name, class_name));
 581
 582     /* Get the meta vtable name from the class name */
 583     rval = kxld_sym_get_meta_vtable_name_from_class_name(class_name,
 584         meta_vtable_name, sizeof(meta_vtable_name));
 585     require_noerr(rval, finish);
 586
 587     /* Get the meta vtable symbol */
 588     if (defined_symbols) {
 589         meta_vtable_sym = kxld_dict_find(defined_symbols, meta_vtable_name);
 590     } else {
 591         meta_vtable_sym = kxld_symtab_get_locally_defined_symbol_by_name(symtab,
 592             meta_vtable_name);
 593     }
 594     if (!meta_vtable_sym) {
 595         if (kxld_object_target_supports_strict_patching(kext->kext)) {
 596             kxld_log(kKxldLogPatching, kKxldLogErr,
 597                 kKxldLogMissingVtable,
 598                 meta_vtable_name, class_name);
 599             rval = KERN_FAILURE;
 600             goto finish;
 601         } else {
 602             kxld_log(kKxldLogPatching, kKxldLogErr,
 603                 "Warning: " kKxldLogMissingVtable,
 604                 kxld_demangle(meta_vtable_name, &demangled_name1,
 605                     &demangled_length1),
 606                 kxld_demangle(class_name, &demangled_name2,
 607                     &demangled_length2));
 608         }
 609     }
 610
 611     *vtable_sym_out = vtable_sym;
 612     *meta_vtable_sym_out = meta_vtable_sym;
 613     rval = KERN_SUCCESS;
 614 finish:
 615     if (demangled_name1) kxld_free(demangled_name1, demangled_length1);
 616     if (demangled_name2) kxld_free(demangled_name2, demangled_length2);
 617
 618     return rval;
 619 }
 620
 621 /*******************************************************************************
 622 *******************************************************************************/
 623 static kern_return_t
 624 resolve_symbols(KXLDKext *kext, const KXLDDict *defined_symbols,
 625     const KXLDDict *obsolete_symbols)
 626 {
 627     kern_return_t rval = KERN_FAILURE;
 628     const KXLDSymtab *symtab = NULL;
 629     KXLDSymtabIterator iter;
 630     KXLDSym *sym = NULL;
 631     KXLDSym *defined_sym = NULL;
 632     const char *name = NULL;
 633     boolean_t tests_for_weak = FALSE;
 634     boolean_t error = FALSE;
 635     char *demangled_name = NULL;
 636     size_t demangled_length = 0;
 637
 638     check(kext->kext);
 639     check(defined_symbols);
 640     check(obsolete_symbols);
 641
 642     symtab = kxld_object_get_symtab(kext->kext);
 643
 644     /* Check if the kext tests for weak symbols */
 645     sym = kxld_symtab_get_symbol_by_name(symtab, KXLD_WEAK_TEST_SYMBOL);
 646     tests_for_weak = (sym != NULL);
 647
 648     /* Check for duplicate symbols */
 649     kxld_symtab_iterator_init(&iter, symtab, kxld_sym_is_exported, FALSE);
 650     while ((sym = kxld_symtab_iterator_get_next(&iter))) {
 651         defined_sym = kxld_dict_find(defined_symbols, sym->name);
 652         if (defined_sym) {
 653             /* Not a problem if the symbols have the same address */
 654             if (defined_sym->link_addr == sym->link_addr) {
 655                 continue;
 656             }
 657
 658             if (!error) {
 659                 error = TRUE;
 660                 kxld_log(kKxldLogLinking, kKxldLogErr,
 661                     "The following symbols were defined more than once:");
 662             }
 663
 664             kxld_log(kKxldLogLinking, kKxldLogErr, "\t%s: %p - %p",
 665                 kxld_demangle(sym->name, &demangled_name, &demangled_length),
 666                 (void *) (uintptr_t) sym->link_addr,
 667                 (void *) (uintptr_t) defined_sym->link_addr);
 668         }
 669     }
 670     require_noerr_action(error, finish, rval=KERN_FAILURE);
 671
 672     /* Resolve undefined and indirect symbols */
 673
 674     /* Iterate over all unresolved symbols */
 675     kxld_symtab_iterator_init(&iter, symtab,
 676         kxld_sym_is_unresolved, FALSE);
 677     while ((sym = kxld_symtab_iterator_get_next(&iter))) {
 678
 679         /* Common symbols are not supported */
 680         if (kxld_sym_is_common(sym)) {
 681
 682             if (!error) {
 683                 error = TRUE;
 684                 if (kxld_object_target_supports_common_symbols(kext->kext)) {
 685                     kxld_log(kKxldLogLinking, kKxldLogErr,
 686                         "The following common symbols were not resolved:");
 687                 } else {
 688                     kxld_log(kKxldLogLinking, kKxldLogErr,
 689                         "Common symbols are not supported in kernel extensions. "
 690                          "Use -fno-common to build your kext. "
 691                          "The following are common symbols:");
 692                 }
 693             }
 694             kxld_log(kKxldLogLinking, kKxldLogErr, "\t%s",
 695                 kxld_demangle(sym->name, &demangled_name, &demangled_length));
 696
 697         } else {
 698
 699             /* Find the address of the defined symbol */
 700             if (kxld_sym_is_undefined(sym)) {
 701                 name = sym->name;
 702             } else {
 703                 name = sym->alias;
 704             }
 705             defined_sym = kxld_dict_find(defined_symbols, name);
 706
 707             /* Resolve the symbol.  If a definition cannot be found, then:
 708              * 1) Psuedokexts log a warning and proceed
 709              * 2) Actual kexts delay the error until validation in case vtable
 710              *    patching replaces the undefined symbol.
 711              */
 712
 713             if (defined_sym) {
 714
 715                 rval = kxld_sym_resolve(sym, defined_sym->link_addr);
 716                 require_noerr(rval, finish);
 717
 718                 if (obsolete_symbols && kxld_dict_find(obsolete_symbols, name)) {
 719                     kxld_log(kKxldLogLinking, kKxldLogWarn,
 720                         "This kext uses obsolete symbol %s.",
 721                         kxld_demangle(name, &demangled_name, &demangled_length));
 722                 }
 723
 724             } else if (kxld_sym_is_weak(sym)) {
 725                 kxld_addr_t addr = 0;
 726
 727                 /* Make sure that the kext has referenced gOSKextUnresolved.
 728                  */
 729                 require_action(tests_for_weak, finish,
 730                    rval=KERN_FAILURE;
 731                    kxld_log(kKxldLogLinking, kKxldLogErr,
 732                       "This kext has weak references but does not test for "
 733                       "them. Test for weak references with "
 734                       "OSKextIsSymbolResolved()."));
 735
 736 #if KERNEL
 737                 /* Get the address of the default weak address.
 738                  */
 739                 addr = (kxld_addr_t) &kext_weak_symbol_referenced;
 740 #else
 741                 /* This is run during symbol generation only, so we only
 742                  * need a filler value here.
 743                  */
 744                 addr = 0xF00DD00D;
 745 #endif /* KERNEL */
 746
 747                 rval = kxld_sym_resolve(sym, addr);
 748                 require_noerr(rval, finish);
 749             }
 750         }
 751     }
 752     require_noerr_action(error, finish, rval=KERN_FAILURE);
 753
 754     rval = KERN_SUCCESS;
 755
 756 finish:
 757     if (demangled_name) kxld_free(demangled_name, demangled_length);
 758
 759     return rval;
 760 }
 761
 762 /*******************************************************************************
 763 * We must patch vtables to ensure binary compatibility, and to perform that
 764 * patching, we have to determine the vtables' inheritance relationships.  The
 765 * MetaClass system gives us a way to do that:
 766 *   1) Iterate over all of the super MetaClass pointer symbols.  Every class
 767 *      that inherits from OSObject will have a pointer in its MetaClass that
 768 *      points to the MetaClass's super MetaClass.
 769 *   2) Derive the name of the class from the super MetaClass pointer.
 770 *   3) Derive the name of the class's vtable from the name of the class
 771 *   4) Follow the super MetaClass pointer to get the address of the super
 772 *      MetaClass's symbol
 773 *   5) Look up the super MetaClass symbol by address
 774 *   6) Derive the super class's name from the super MetaClass name
 775 *   7) Derive the super class's vtable from the super class's name
 776 * This procedure will allow us to find all of the OSObject-derived classes and
 777 * their super classes, and thus patch all of the vtables.
 778 *
 779 * We also have to take care to patch up the MetaClass's vtables.  The
 780 * MetaClasses follow a parallel hierarchy to the classes, so once we have the
 781 * class name and super class name, we can also derive the MetaClass name and
 782 * the super MetaClass name, and thus find and patch their vtables as well.
 783 *******************************************************************************/
 784
 785 #define kOSMetaClassVTableName "__ZTV11OSMetaClass"
 786
 787 static kern_return_t
 788 patch_vtables(KXLDKext *kext, KXLDDict *patched_vtables,
 789     const KXLDDict *defined_symbols)
 790 {
 791     kern_return_t rval = KERN_FAILURE;
 792     KXLDSymtabIterator iter;
 793     const KXLDSymtab *symtab = NULL;
 794     const KXLDSym *metaclass = NULL;
 795     KXLDSym *super_metaclass_pointer = NULL;
 796     KXLDSym *final_sym = NULL;
 797     KXLDVTable *vtable = NULL;
 798     KXLDVTable *super_vtable = NULL;
 799     char class_name[KXLD_MAX_NAME_LEN];
 800     char super_class_name[KXLD_MAX_NAME_LEN];
 801     char vtable_name[KXLD_MAX_NAME_LEN];
 802     char super_vtable_name[KXLD_MAX_NAME_LEN];
 803     char final_sym_name[KXLD_MAX_NAME_LEN];
 804     char *demangled_name1 = NULL;
 805     char *demangled_name2 = NULL;
 806     size_t demangled_length1 = 0;;
 807     size_t demangled_length2 = 0;
 808     size_t len = 0;
 809     u_int nvtables = 0;
 810     u_int npatched = 0;
 811     u_int nprogress = 0;
 812     boolean_t failure = FALSE;
 813
 814     check(kext);
 815     check(patched_vtables);
 816
 817     symtab = kxld_object_get_symtab(kext->kext);
 818
 819     rval = create_vtable_index(kext);
 820     require_noerr(rval, finish);
 821
 822     /* Find each super meta class pointer symbol */
 823
 824     kxld_symtab_iterator_init(&iter, symtab,
 825         kxld_sym_is_super_metaclass_pointer, FALSE);
 826     nvtables = kxld_symtab_iterator_get_num_remaining(&iter);
 827
 828     while (npatched < nvtables) {
 829         npatched = 0;
 830         nprogress = 0;
 831         kxld_symtab_iterator_reset(&iter);
 832         while((super_metaclass_pointer = kxld_symtab_iterator_get_next(&iter)))
 833         {
 834             /* Get the class name from the smc pointer */
 835             rval = kxld_sym_get_class_name_from_super_metaclass_pointer(
 836                 super_metaclass_pointer, class_name, sizeof(class_name));
 837             require_noerr(rval, finish);
 838
 839             /* Get the vtable name from the class name */
 840             rval = kxld_sym_get_vtable_name_from_class_name(class_name,
 841                 vtable_name, sizeof(vtable_name));
 842             require_noerr(rval, finish);
 843
 844             /* Get the vtable and make sure it hasn't been patched */
 845             vtable = kxld_dict_find(&kext->vtable_index, vtable_name);
 846             require_action(vtable, finish, rval=KERN_FAILURE;
 847                 kxld_log(kKxldLogPatching, kKxldLogErr, kKxldLogMissingVtable,
 848                     vtable_name, class_name));
 849
 850             if (!vtable->is_patched) {
 851
 852                 /* Find the SMCP's meta class symbol */
 853                 metaclass = get_metaclass_symbol_from_super_meta_class_pointer_symbol(
 854                     kext, super_metaclass_pointer);
 855                 require_action(metaclass, finish, rval=KERN_FAILURE);
 856
 857                 /* Get the super class name from the super metaclass */
 858                 rval = kxld_sym_get_class_name_from_metaclass(metaclass,
 859                     super_class_name, sizeof(super_class_name));
 860                 require_noerr(rval, finish);
 861
 862                 /* Get the super vtable name from the class name */
 863                 rval = kxld_sym_get_vtable_name_from_class_name(super_class_name,
 864                     super_vtable_name, sizeof(super_vtable_name));
 865                 require_noerr(rval, finish);
 866
 867                 /* Get the super vtable if it's been patched */
 868                 super_vtable = kxld_dict_find(patched_vtables, super_vtable_name);
 869
 870                 if (failure) {
 871                     const KXLDVTable *unpatched_super_vtable;
 872                     unpatched_super_vtable = kxld_dict_find(&kext->vtable_index,
 873                         super_vtable_name);
 874
 875                     /* If the parent's vtable hasn't been patched, warn that
 876                      * this vtable is unpatchable because of the parent.
 877                      */
 878                     if (!super_vtable) {
 879                         kxld_log(kKxldLogPatching, kKxldLogErr,
 880                             "The %s was not patched because its parent, "
 881                             "the %s, was not %s.",
 882                             kxld_demangle(vtable_name, &demangled_name1,
 883                                 &demangled_length1),
 884                             kxld_demangle(super_vtable_name, &demangled_name2,
 885                                 &demangled_length2),
 886                             (unpatched_super_vtable) ? "patchable" : "found");
 887                     }
 888                     continue;
 889                 }
 890
 891                 if (!super_vtable) continue;
 892
 893                 /* Get the final symbol's name from the super vtable */
 894                 rval = kxld_sym_get_final_sym_name_from_class_name(super_class_name,
 895                     final_sym_name, sizeof(final_sym_name));
 896                 require_noerr(rval, finish);
 897
 898                 /* Verify that the final symbol does not exist.  First check
 899                  * all the externally defined symbols, then check locally.
 900                  */
 901                 final_sym = kxld_dict_find(defined_symbols, final_sym_name);
 902                 if (!final_sym) {
 903                     final_sym = kxld_symtab_get_locally_defined_symbol_by_name(
 904                         symtab, final_sym_name);
 905                 }
 906                 if (final_sym) {
 907                     kxld_log(kKxldLogPatching, kKxldLogErr,
 908                         "Class '%s' is a subclass of final class '%s'.",
 909                         kxld_demangle(class_name, &demangled_name1,
 910                             &demangled_length1),
 911                         kxld_demangle(super_class_name, &demangled_name2,
 912                             &demangled_length2));
 913                     continue;
 914                 }
 915
 916                 /* Patch the class's vtable */
 917                 rval = kxld_vtable_patch(vtable, super_vtable, kext->kext);
 918                 if (rval) continue;
 919
 920                 /* Add the class's vtable to the set of patched vtables */
 921                 rval = kxld_dict_insert(patched_vtables, vtable->name, vtable);
 922                 require_noerr(rval, finish);
 923
 924                 /* Get the meta vtable name from the class name */
 925                 rval = kxld_sym_get_meta_vtable_name_from_class_name(class_name,
 926                     vtable_name, sizeof(vtable_name));
 927                 require_noerr(rval, finish);
 928
 929                 /* Get the meta vtable.  Whether or not it should exist has already
 930                  * been tested in create_vtables(), so if it doesn't exist and we're
 931                  * still running, we can safely skip it.
 932                  */
 933                 vtable = kxld_dict_find(&kext->vtable_index, vtable_name);
 934                 if (!vtable) {
 935                     ++nprogress;
 936                     ++npatched;
 937                     continue;
 938                 }
 939                 require_action(!vtable->is_patched, finish, rval=KERN_FAILURE);
 940
 941                 /* There is no way to look up a metaclass vtable at runtime, but
 942                  * we know that every class's metaclass inherits directly from
 943                  * OSMetaClass, so we just hardcode that vtable name here.
 944                  */
 945                 len = strlcpy(super_vtable_name, kOSMetaClassVTableName,
 946                     sizeof(super_vtable_name));
 947                 require_action(len == const_strlen(kOSMetaClassVTableName),
 948                     finish, rval=KERN_FAILURE);
 949
 950                 /* Get the super meta vtable */
 951                 super_vtable = kxld_dict_find(patched_vtables, super_vtable_name);
 952                 require_action(super_vtable && super_vtable->is_patched,
 953                     finish, rval=KERN_FAILURE);
 954
 955                 /* Patch the meta class's vtable */
 956                 rval = kxld_vtable_patch(vtable, super_vtable, kext->kext);
 957                 require_noerr(rval, finish);
 958
 959                 /* Add the MetaClass's vtable to the set of patched vtables */
 960                 rval = kxld_dict_insert(patched_vtables, vtable->name, vtable);
 961                 require_noerr(rval, finish);
 962
 963                 ++nprogress;
 964             }
 965
 966             ++npatched;
 967         }
 968
 969         require_action(!failure, finish, rval=KERN_FAILURE);
 970         failure = (nprogress == 0);
 971     }
 972
 973     rval = KERN_SUCCESS;
 974 finish:
 975     if (demangled_name1) kxld_free(demangled_name1, demangled_length1);
 976     if (demangled_name2) kxld_free(demangled_name2, demangled_length2);
 977
 978     return rval;
 979 }
 980
 981 /*******************************************************************************
 982 *******************************************************************************/
 983 static kern_return_t
 984 create_vtable_index(KXLDKext *kext)
 985 {
 986     kern_return_t rval = KERN_FAILURE;
 987     KXLDVTable *vtable = NULL;
 988     u_int i = 0;
 989
 990     if (kext->vtable_index_created) {
 991         rval = KERN_SUCCESS;
 992         goto finish;
 993     }
 994
 995     /* Map vtable names to the vtable structures */
 996     rval = kxld_dict_init(&kext->vtable_index, kxld_dict_string_hash,
 997         kxld_dict_string_cmp, kext->vtables.nitems);
 998     require_noerr(rval, finish);
 999
1000     for (i = 0; i < kext->vtables.nitems; ++i) {
1001         vtable = kxld_array_get_item(&kext->vtables, i);
1002         rval = kxld_dict_insert(&kext->vtable_index, vtable->name, vtable);
1003         require_noerr(rval, finish);
1004     }
1005
1006     kext->vtable_index_created = TRUE;
1007     rval = KERN_SUCCESS;
1008 finish:
1009     return rval;
1010 }
1011
1012 /*******************************************************************************
1013 *******************************************************************************/
1014 static const KXLDSym *
1015 get_metaclass_symbol_from_super_meta_class_pointer_symbol(KXLDKext *kext,
1016     KXLDSym *super_metaclass_pointer_sym)
1017 {
1018     kern_return_t rval = KERN_FAILURE;
1019     const KXLDReloc *reloc = NULL;
1020     const KXLDSect *sect = NULL;
1021     const KXLDSym *metaclass = NULL;
1022
1023     check(kext);
1024     check(super_metaclass_pointer_sym);
1025
1026     /* Get the relocation entry that fills in the super metaclass pointer. */
1027     reloc = kxld_object_get_reloc_at_symbol(kext->kext,
1028         super_metaclass_pointer_sym);
1029     require_action(reloc, finish, rval=KERN_FAILURE);
1030
1031     /* Get the section of the super metaclass pointer. */
1032     sect = kxld_object_get_section_by_index(kext->kext,
1033         super_metaclass_pointer_sym->sectnum);
1034     require_action(sect, finish, rval=KERN_FAILURE);
1035
1036     /* Get the symbol that will be filled into the super metaclass pointer. */
1037     metaclass = kxld_object_get_symbol_of_reloc(kext->kext, reloc, sect);
1038 finish:
1039     return metaclass;
1040 }
1041
1042 /*******************************************************************************
1043 *******************************************************************************/
1044 static kern_return_t
1045 validate_symbols(KXLDKext *kext)
1046 {
1047     kern_return_t rval = KERN_FAILURE;
1048     KXLDSymtabIterator iter;
1049     KXLDSym *sym = NULL;
1050     u_int error = FALSE;
1051     char *demangled_name = NULL;
1052     size_t demangled_length = 0;
1053
1054     /* Check for any unresolved symbols */
1055     kxld_symtab_iterator_init(&iter, kxld_object_get_symtab(kext->kext),
1056         kxld_sym_is_unresolved, FALSE);
1057     while ((sym = kxld_symtab_iterator_get_next(&iter))) {
1058         if (!error) {
1059             error = TRUE;
1060             kxld_log(kKxldLogLinking, kKxldLogErr,
1061                 "The following symbols are unresolved for this kext:");
1062         }
1063         kxld_log(kKxldLogLinking, kKxldLogErr, "\t%s",
1064             kxld_demangle(sym->name, &demangled_name, &demangled_length));
1065     }
1066     require_noerr_action(error, finish, rval=KERN_FAILURE);
1067
1068     rval = KERN_SUCCESS;
1069
1070 finish:
1071     if (demangled_name) kxld_free(demangled_name, demangled_length);
1072     return rval;
1073 }
1074