libkern/kxld/kxld.c

   1 /*
   2  * Copyright (c) 2007-2008, 2012 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 <sys/types.h>
  30 #include <mach/vm_param.h>  /* For PAGE_SIZE */
  31
  32 #define DEBUG_ASSERT_COMPONENT_NAME_STRING "kxld"
  33 #include <AssertMacros.h>
  34
  35 #if KERNEL
  36 #define __KXLD_KERNEL_UNUSED __unused
  37 #else
  38 #define __KXLD_KERNEL_UNUSED
  39 #endif
  40
  41 #if !KERNEL
  42     #include "kxld.h"
  43     #include "kxld_types.h"
  44 #else
  45     #include <libkern/kxld.h>
  46     #include <libkern/kxld_types.h>
  47 #endif /* KERNEL */
  48
  49 #include "kxld_array.h"
  50 #include "kxld_dict.h"
  51 #include "kxld_kext.h"
  52 #include "kxld_object.h"
  53 #include "kxld_sym.h"
  54 #include "kxld_symtab.h"
  55 #include "kxld_util.h"
  56 #include "kxld_vtable.h"
  57
  58 struct kxld_vtable;
  59
  60 struct kxld_context {
  61     KXLDKext *kext;
  62     KXLDArray *section_order;
  63     KXLDArray objects;
  64     KXLDArray dependencies;
  65     KXLDDict defined_symbols_by_name;
  66     KXLDDict defined_cxx_symbols_by_value;
  67     KXLDDict obsolete_symbols_by_name;
  68     KXLDDict vtables_by_name;
  69     KXLDFlags flags;
  70     KXLDAllocateCallback allocate_callback;
  71     cpu_type_t cputype;
  72     cpu_subtype_t cpusubtype;
  73 };
  74
  75 /*******************************************************************************
  76 * Globals
  77 *******************************************************************************/
  78
  79 /* Certain architectures alter the order of a kext's sections from its input
  80  * binary, so we track that order in a dictionary of arrays, with one array for
  81  * each architecture.  Since the kernel only has one architecture, we can
  82  * eliminate the dictionary and use a simple array.
  83  * XXX: If we ever use the linker in a multithreaded environment, we will need
  84  * locks around these global structures.
  85  */
  86 #if KXLD_USER_OR_OBJECT
  87 #if KERNEL
  88 static KXLDArray *s_section_order;
  89 #else
  90 static KXLDDict *s_order_dict;
  91 #endif
  92 #endif
  93
  94 /*******************************************************************************
  95 * Prototypes
  96 *******************************************************************************/
  97
  98 static kern_return_t init_context(KXLDContext *context, u_int ndependencies);
  99 static kern_return_t init_kext_objects(KXLDContext *context, u_char *file,
 100     u_long size, const char *name, KXLDDependency *dependencies,
 101     u_int ndependencies);
 102 static KXLDObject * get_object_for_file(KXLDContext *context,
 103     u_char *file, u_long size, const char *name);
 104 static u_char * allocate_kext(KXLDContext *context, void *callback_data,
 105     kxld_addr_t *vmaddr, u_long *vmsize, u_char **linked_object_alloc_out);
 106 static void clear_context(KXLDContext *context);
 107
 108 /*******************************************************************************
 109 *******************************************************************************/
 110 kern_return_t
 111 kxld_create_context(KXLDContext **_context,
 112     KXLDAllocateCallback allocate_callback, KXLDLoggingCallback logging_callback,
 113     KXLDFlags flags, cpu_type_t cputype, cpu_subtype_t cpusubtype,
 114     vm_size_t pagesize __KXLD_KERNEL_UNUSED)
 115 {
 116     kern_return_t rval = KERN_FAILURE;
 117     KXLDContext       * context         = NULL;
 118     KXLDArray         * section_order   = NULL;
 119 #if !KERNEL
 120     cpu_type_t        * cputype_p       = NULL;
 121 #endif
 122
 123     check(_context);
 124     check(allocate_callback);
 125     check(logging_callback);
 126     *_context = NULL;
 127
 128     context = kxld_alloc(sizeof(*context));
 129     require_action(context, finish, rval=KERN_RESOURCE_SHORTAGE);
 130     bzero(context, sizeof(*context));
 131
 132     context->flags = flags;
 133     context->allocate_callback = allocate_callback;
 134     context->cputype = cputype;
 135     context->cpusubtype = cpusubtype;
 136
 137 #if !KERNEL
 138     if (pagesize) {
 139         kxld_set_cross_link_page_size(pagesize);
 140     }
 141 #endif /* !KERNEL */
 142
 143     kxld_set_logging_callback(logging_callback);
 144
 145     context->kext = kxld_alloc(kxld_kext_sizeof());
 146     require_action(context->kext, finish, rval=KERN_RESOURCE_SHORTAGE);
 147     bzero(context->kext, kxld_kext_sizeof());
 148
 149     /* Check if we already have an order array for this arch */
 150
 151 #if KXLD_USER_OR_OBJECT
 152 #if KERNEL
 153     context->section_order = s_section_order;
 154 #else
 155     /* In userspace, create the dictionary if it doesn't already exist */
 156     if (!s_order_dict) {
 157         s_order_dict = kxld_alloc(sizeof(*s_order_dict));
 158         require_action(s_order_dict, finish, rval=KERN_RESOURCE_SHORTAGE);
 159         bzero(s_order_dict, sizeof(*s_order_dict));
 160
 161         rval = kxld_dict_init(s_order_dict, kxld_dict_uint32_hash,
 162             kxld_dict_uint32_cmp, 0);
 163         require_noerr(rval, finish);
 164     }
 165
 166     context->section_order = kxld_dict_find(s_order_dict, &cputype);
 167 #endif /* KERNEL */
 168
 169     /* Create an order array for this arch if needed */
 170
 171     if (!context->section_order) {
 172
 173         section_order = kxld_alloc(sizeof(*section_order));
 174         require_action(section_order, finish, rval=KERN_RESOURCE_SHORTAGE);
 175         bzero(section_order, sizeof(*section_order));
 176
 177 #if KERNEL
 178         s_section_order = section_order;
 179 #else
 180         /* In userspace, add the new array to the order dictionary */
 181         cputype_p = kxld_alloc(sizeof(*cputype_p));
 182         require_action(cputype_p, finish, rval=KERN_RESOURCE_SHORTAGE);
 183         *cputype_p = cputype;
 184
 185         rval = kxld_dict_insert(s_order_dict, cputype_p, section_order);
 186         require_noerr(rval, finish);
 187
 188         cputype_p = NULL;
 189 #endif /* KERNEL */
 190
 191         context->section_order = section_order;
 192
 193         section_order = NULL;
 194     }
 195 #endif /* KXLD_USER_OR_OBJECT */
 196
 197     rval = KERN_SUCCESS;
 198     *_context = context;
 199     context = NULL;
 200
 201 finish:
 202     if (context) kxld_destroy_context(context);
 203     if (section_order) kxld_free(section_order, sizeof(*section_order));
 204 #if !KERNEL
 205     if (cputype_p) kxld_free(cputype_p, sizeof(*cputype_p));
 206 #endif
 207
 208     return rval;
 209 }
 210
 211 /*******************************************************************************
 212 *******************************************************************************/
 213 void
 214 kxld_destroy_context(KXLDContext *context)
 215 {
 216     KXLDObject *object = NULL;
 217     KXLDKext *dep = NULL;
 218     u_int i = 0;
 219
 220     check(context);
 221
 222     kxld_kext_deinit(context->kext);
 223
 224     for (i = 0; i < context->objects.maxitems; ++i) {
 225         object = kxld_array_get_slot(&context->objects, i);
 226         kxld_object_deinit(object);
 227     }
 228     kxld_array_deinit(&context->objects);
 229
 230     for (i = 0; i < context->dependencies.maxitems; ++i) {
 231         dep = kxld_array_get_slot(&context->dependencies, i);
 232         kxld_kext_deinit(dep);
 233     }
 234     kxld_array_deinit(&context->dependencies);
 235
 236     kxld_dict_deinit(&context->defined_symbols_by_name);
 237     kxld_dict_deinit(&context->defined_cxx_symbols_by_value);
 238     kxld_dict_deinit(&context->obsolete_symbols_by_name);
 239     kxld_dict_deinit(&context->vtables_by_name);
 240
 241     kxld_free(context->kext, kxld_kext_sizeof());
 242     kxld_free(context, sizeof(*context));
 243
 244     kxld_print_memory_report();
 245 }
 246
 247 /*******************************************************************************
 248 *******************************************************************************/
 249 kern_return_t
 250 kxld_link_file(
 251     KXLDContext       * context,
 252     u_char            * file,
 253     u_long              size,
 254     const char        * name,
 255     void              * callback_data,
 256     KXLDDependency    * dependencies,
 257     u_int               ndependencies,
 258     u_char           ** linked_object_out,
 259     kxld_addr_t       * kmod_info_kern)
 260 {
 261     kern_return_t       rval                    = KERN_FAILURE;
 262     kxld_addr_t         vmaddr                  = 0;
 263     u_long              vmsize                  = 0;
 264     u_char            * linked_object           = NULL;
 265     u_char            * linked_object_alloc     = NULL;
 266
 267     kxld_set_logging_callback_data(name, callback_data);
 268
 269     kxld_log(kKxldLogLinking, kKxldLogBasic, "Linking kext %s", name);
 270
 271     require_action(context, finish, rval=KERN_INVALID_ARGUMENT);
 272     require_action(file, finish, rval=KERN_INVALID_ARGUMENT);
 273     require_action(size, finish, rval=KERN_INVALID_ARGUMENT);
 274     require_action(dependencies, finish, rval=KERN_INVALID_ARGUMENT);
 275     require_action(ndependencies, finish, rval=KERN_INVALID_ARGUMENT);
 276     require_action(linked_object_out, finish, rval=KERN_INVALID_ARGUMENT);
 277     require_action(kmod_info_kern, finish, rval=KERN_INVALID_ARGUMENT);
 278
 279     rval = init_context(context, ndependencies);
 280     require_noerr(rval, finish);
 281
 282     rval = init_kext_objects(context, file, size, name,
 283         dependencies, ndependencies);
 284     require_noerr(rval, finish);
 285
 286     linked_object = allocate_kext(context, callback_data,
 287         &vmaddr, &vmsize, &linked_object_alloc);
 288     require_action(linked_object, finish, rval=KERN_RESOURCE_SHORTAGE);
 289
 290     rval = kxld_kext_relocate(context->kext, vmaddr,
 291         &context->vtables_by_name,
 292         &context->defined_symbols_by_name,
 293         &context->obsolete_symbols_by_name,
 294         &context->defined_cxx_symbols_by_value);
 295     require_noerr(rval, finish);
 296
 297     rval = kxld_kext_export_linked_object(context->kext,
 298         linked_object, kmod_info_kern);
 299     require_noerr(rval, finish);
 300
 301     *linked_object_out = linked_object;
 302     linked_object_alloc = NULL;
 303
 304     rval = KERN_SUCCESS;
 305 finish:
 306     if (linked_object_alloc) {
 307         kxld_page_free_untracked(linked_object_alloc, vmsize);
 308     }
 309
 310     clear_context(context);
 311     kxld_set_logging_callback_data(NULL, NULL);
 312
 313     return rval;
 314 }
 315
 316 /*******************************************************************************
 317 *******************************************************************************/
 318 static kern_return_t
 319 init_context(KXLDContext *context, u_int ndependencies)
 320 {
 321     kern_return_t rval = KERN_FAILURE;
 322
 323     /* Create an array of objects large enough to hold an object
 324      * for every dependency, an interface for each dependency, and a kext. */
 325     rval = kxld_array_init(&context->objects,
 326         kxld_object_sizeof(), 2 * ndependencies + 1);
 327     require_noerr(rval, finish);
 328
 329     rval = kxld_array_init(&context->dependencies,
 330         kxld_kext_sizeof(), ndependencies);
 331     require_noerr(rval, finish);
 332
 333     rval = kxld_dict_init(&context->defined_symbols_by_name,
 334         kxld_dict_string_hash, kxld_dict_string_cmp, 0);
 335     require_noerr(rval, finish);
 336
 337     rval = kxld_dict_init(&context->defined_cxx_symbols_by_value,
 338         kxld_dict_kxldaddr_hash, kxld_dict_kxldaddr_cmp, 0);
 339     require_noerr(rval, finish);
 340
 341     rval = kxld_dict_init(&context->obsolete_symbols_by_name,
 342         kxld_dict_string_hash, kxld_dict_string_cmp, 0);
 343     require_noerr(rval, finish);
 344
 345     rval = kxld_dict_init(&context->vtables_by_name, kxld_dict_string_hash,
 346         kxld_dict_string_cmp, 0);
 347     require_noerr(rval, finish);
 348
 349     rval = KERN_SUCCESS;
 350 finish:
 351     return rval;
 352 }
 353
 354 /*******************************************************************************
 355 *******************************************************************************/
 356 static kern_return_t
 357 init_kext_objects(KXLDContext *context, u_char *file, u_long size,
 358     const char *name, KXLDDependency *dependencies, u_int ndependencies)
 359 {
 360     kern_return_t rval = KERN_FAILURE;
 361     KXLDKext *kext = NULL;
 362     KXLDObject *kext_object = NULL;
 363     KXLDObject *interface_object = NULL;
 364     u_int i = 0;
 365
 366     /* Create a kext object for each dependency.  If it's a direct dependency,
 367      * export its symbols by name by value.  If it's indirect, just export the
 368      * C++ symbols by value.
 369      */
 370     for (i = 0; i < ndependencies; ++i) {
 371         kext = kxld_array_get_item(&context->dependencies, i);
 372         kext_object = NULL;
 373         interface_object = NULL;
 374
 375         kext_object = get_object_for_file(context, dependencies[i].kext,
 376             dependencies[i].kext_size, dependencies[i].kext_name);
 377         require_action(kext_object, finish, rval=KERN_FAILURE);
 378
 379         if (dependencies[i].interface) {
 380             interface_object = get_object_for_file(context,
 381                 dependencies[i].interface, dependencies[i].interface_size,
 382                 dependencies[i].interface_name);
 383             require_action(interface_object, finish, rval=KERN_FAILURE);
 384         }
 385
 386         rval = kxld_kext_init(kext, kext_object, interface_object);
 387         require_noerr(rval, finish);
 388
 389         if (dependencies[i].is_direct_dependency) {
 390             rval = kxld_kext_export_symbols(kext,
 391                 &context->defined_symbols_by_name,
 392                 &context->obsolete_symbols_by_name,
 393                 &context->defined_cxx_symbols_by_value);
 394             require_noerr(rval, finish);
 395         } else {
 396             rval = kxld_kext_export_symbols(kext,
 397                 /* defined_symbols */ NULL, /* obsolete_symbols */ NULL,
 398                 &context->defined_cxx_symbols_by_value);
 399             require_noerr(rval, finish);
 400         }
 401     }
 402
 403     /* Export the vtables for all of the dependencies. */
 404     for (i = 0; i < context->dependencies.nitems; ++i) {
 405         kext = kxld_array_get_item(&context->dependencies, i);
 406
 407         rval = kxld_kext_export_vtables(kext,
 408             &context->defined_cxx_symbols_by_value,
 409             &context->defined_symbols_by_name,
 410             &context->vtables_by_name);
 411         require_noerr(rval, finish);
 412     }
 413
 414     /* Create a kext object for the kext we're linking and export its locally
 415      * defined C++ symbols.
 416      */
 417     kext_object = get_object_for_file(context, file, size, name);
 418     require_action(kext_object, finish, rval=KERN_FAILURE);
 419
 420     rval = kxld_kext_init(context->kext, kext_object, /* interface */ NULL);
 421     require_noerr(rval, finish);
 422
 423     rval = kxld_kext_export_symbols(context->kext,
 424         /* defined_symbols */ NULL, /* obsolete_symbols */ NULL,
 425         &context->defined_cxx_symbols_by_value);
 426     require_noerr(rval, finish);
 427
 428     rval = KERN_SUCCESS;
 429 finish:
 430     return rval;
 431 }
 432
 433 /*******************************************************************************
 434 *******************************************************************************/
 435 static KXLDObject *
 436 get_object_for_file(KXLDContext *context, u_char *file, u_long size,
 437     const char *name)
 438 {
 439     KXLDObject *rval = NULL;
 440     KXLDObject *object = NULL;
 441     kern_return_t result = 0;
 442     u_int i = 0;
 443
 444     for (i = 0; i < context->objects.nitems; ++i) {
 445         object = kxld_array_get_item(&context->objects, i);
 446
 447         if (!kxld_object_get_file(object)) {
 448             result = kxld_object_init_from_macho(object, file, size, name,
 449                 context->section_order, context->cputype, context->cpusubtype, context->flags);
 450             require_noerr(result, finish);
 451
 452             rval = object;
 453             break;
 454         }
 455
 456         if (kxld_object_get_file(object) == file) {
 457             rval = object;
 458             break;
 459         }
 460     }
 461
 462 finish:
 463     return rval;
 464 }
 465
 466 /*******************************************************************************
 467 *******************************************************************************/
 468 static u_char *
 469 allocate_kext(KXLDContext *context, void *callback_data,
 470     kxld_addr_t *vmaddr_out, u_long *vmsize_out,
 471     u_char **linked_object_alloc_out)
 472 {
 473     KXLDAllocateFlags   flags                   = 0;
 474     kxld_addr_t         vmaddr                  = 0;
 475     u_long              vmsize                  = 0;
 476     u_long              header_size             = 0;
 477     u_char            * linked_object           = NULL;
 478
 479     *linked_object_alloc_out = NULL;
 480
 481     kxld_kext_get_vmsize(context->kext, &header_size, &vmsize);
 482     vmaddr = context->allocate_callback(vmsize, &flags, callback_data);
 483     require_action(!(vmaddr & (kxld_get_effective_page_size()-1)), finish,
 484         kxld_log(kKxldLogLinking, kKxldLogErr,
 485             "Load address %p is not page-aligned.",
 486             (void *) (uintptr_t) vmaddr));
 487
 488     if (flags & kKxldAllocateWritable) {
 489         linked_object = (u_char *) (u_long) vmaddr;
 490     } else {
 491         linked_object = kxld_page_alloc_untracked(vmsize);
 492         require(linked_object, finish);
 493
 494         *linked_object_alloc_out = linked_object;
 495     }
 496
 497     kxld_kext_set_linked_object_size(context->kext, vmsize);
 498
 499     /* Zero out the memory before we fill it.  We fill this buffer in a
 500      * sparse fashion, and it's simpler to clear it now rather than
 501      * track and zero any pieces we didn't touch after we've written
 502      * all of the sections to memory.
 503      */
 504     bzero(linked_object, vmsize);
 505     *vmaddr_out = vmaddr;
 506     *vmsize_out = vmsize;
 507
 508 finish:
 509     return linked_object;
 510 }
 511
 512 /*******************************************************************************
 513 *******************************************************************************/
 514 static void
 515 clear_context(KXLDContext *context)
 516 {
 517     KXLDObject * object = NULL;
 518     KXLDKext   * dep     = NULL;
 519     u_int i = 0;
 520
 521     check(context);
 522
 523     kxld_kext_clear(context->kext);
 524
 525     for (i = 0; i < context->objects.nitems; ++i) {
 526         object = kxld_array_get_item(&context->objects, i);
 527         kxld_object_clear(object);
 528     }
 529     kxld_array_reset(&context->objects);
 530
 531     for (i = 0; i < context->dependencies.nitems; ++i) {
 532         dep = kxld_array_get_item(&context->dependencies, i);
 533         kxld_kext_clear(dep);
 534     }
 535     kxld_array_reset(&context->dependencies);
 536
 537     kxld_dict_clear(&context->defined_symbols_by_name);
 538     kxld_dict_clear(&context->defined_cxx_symbols_by_value);
 539     kxld_dict_clear(&context->obsolete_symbols_by_name);
 540     kxld_dict_clear(&context->vtables_by_name);
 541 }
 542