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