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 // set to TRUE if the kext has a vmaddr_TEXT_EXEC != 0
  76 boolean_t   isSplitKext         = FALSE;
  77
  78 // set to TRUE is we come in via kxld_link_file
  79 boolean_t   isOldInterface      = FALSE;
  80 uint32_t    kaslr_offsets_count = 0;
  81 uint32_t   *kaslr_offsets = NULL;
  82 uint32_t    kaslr_offsets_index = 0;
  83
  84 /*******************************************************************************
  85 * Globals
  86 *******************************************************************************/
  87
  88 /* Certain architectures alter the order of a kext's sections from its input
  89  * binary, so we track that order in a dictionary of arrays, with one array for
  90  * each architecture.  Since the kernel only has one architecture, we can
  91  * eliminate the dictionary and use a simple array.
  92  * XXX: If we ever use the linker in a multithreaded environment, we will need
  93  * locks around these global structures.
  94  */
  95 #if KXLD_USER_OR_OBJECT
  96 #if KERNEL
  97 static KXLDArray *s_section_order;
  98 #else
  99 static KXLDDict *s_order_dict;
 100 #endif
 101 #endif
 102
 103 /*******************************************************************************
 104 * Prototypes
 105 *******************************************************************************/
 106
 107 static kern_return_t init_context(KXLDContext *context, u_int ndependencies);
 108 static KXLDObject * get_object_for_file(KXLDContext *context,
 109     u_char *file, u_long size, const char *name);
 110 static kern_return_t allocate_split_kext(KXLDContext *context, splitKextLinkInfo * link_info);
 111 static u_char * allocate_kext(KXLDContext *context, void *callback_data,
 112     kxld_addr_t *vmaddr, u_long *vmsize, u_char **linked_object_alloc_out);
 113 static kern_return_t init_kext_objects(KXLDContext *context, u_char *file,
 114     u_long size, const char *name, KXLDDependency *dependencies,
 115     u_int ndependencies);
 116 static void clear_context(KXLDContext *context);
 117
 118 /*******************************************************************************
 119 *******************************************************************************/
 120 kern_return_t
 121 kxld_create_context(KXLDContext **_context,
 122     KXLDAllocateCallback allocate_callback, KXLDLoggingCallback logging_callback,
 123     KXLDFlags flags, cpu_type_t cputype, cpu_subtype_t cpusubtype,
 124     vm_size_t pagesize __KXLD_KERNEL_UNUSED)
 125 {
 126         kern_return_t rval = KERN_FAILURE;
 127         KXLDContext       * context         = NULL;
 128         KXLDArray         * section_order   = NULL;
 129 #if !KERNEL
 130         cpu_type_t        * cputype_p       = NULL;
 131 #endif
 132
 133         check(_context);
 134         if (isOldInterface) {
 135                 check(allocate_callback);
 136         }
 137         check(logging_callback);
 138         *_context = NULL;
 139
 140         context = kxld_calloc(sizeof(*context));
 141         require_action(context, finish, rval = KERN_RESOURCE_SHORTAGE);
 142
 143         context->flags = flags;
 144         context->allocate_callback = allocate_callback;
 145         context->cputype = cputype;
 146         context->cpusubtype = cpusubtype;
 147
 148 #if !KERNEL
 149         if (pagesize) {
 150                 kxld_set_cross_link_page_size(pagesize);
 151         }
 152 #endif /* !KERNEL */
 153
 154         kxld_set_logging_callback(logging_callback);
 155
 156         context->kext = kxld_calloc(kxld_kext_sizeof());
 157         require_action(context->kext, finish, rval = KERN_RESOURCE_SHORTAGE);
 158
 159         /* Check if we already have an order array for this arch */
 160
 161 #if KXLD_USER_OR_OBJECT
 162 #if KERNEL
 163         context->section_order = s_section_order;
 164 #else
 165         /* In userspace, create the dictionary if it doesn't already exist */
 166         if (!s_order_dict) {
 167                 s_order_dict = kxld_calloc(sizeof(*s_order_dict));
 168                 require_action(s_order_dict, finish, rval = KERN_RESOURCE_SHORTAGE);
 169
 170                 rval = kxld_dict_init(s_order_dict, kxld_dict_uint32_hash,
 171                     kxld_dict_uint32_cmp, 0);
 172                 require_noerr(rval, finish);
 173         }
 174
 175         context->section_order = kxld_dict_find(s_order_dict, &cputype);
 176 #endif /* KERNEL */
 177
 178         /* Create an order array for this arch if needed */
 179
 180         if (!context->section_order) {
 181                 section_order = kxld_calloc(sizeof(*section_order));
 182                 require_action(section_order, finish, rval = KERN_RESOURCE_SHORTAGE);
 183
 184 #if KERNEL
 185                 s_section_order = section_order;
 186 #else
 187                 /* In userspace, add the new array to the order dictionary */
 188                 cputype_p = kxld_alloc(sizeof(*cputype_p));
 189                 require_action(cputype_p, finish, rval = KERN_RESOURCE_SHORTAGE);
 190                 *cputype_p = cputype;
 191
 192                 rval = kxld_dict_insert(s_order_dict, cputype_p, section_order);
 193                 require_noerr(rval, finish);
 194
 195                 cputype_p = NULL;
 196 #endif /* KERNEL */
 197
 198                 context->section_order = section_order;
 199
 200                 section_order = NULL;
 201         }
 202 #endif /* KXLD_USER_OR_OBJECT */
 203
 204         rval = KERN_SUCCESS;
 205         *_context = context;
 206         context = NULL;
 207
 208 finish:
 209         if (context) {
 210                 kxld_destroy_context(context);
 211         }
 212         if (section_order) {
 213                 kxld_free(section_order, sizeof(*section_order));
 214         }
 215 #if !KERNEL
 216         if (cputype_p) {
 217                 kxld_free(cputype_p, sizeof(*cputype_p));
 218         }
 219 #endif
 220
 221         return rval;
 222 }
 223
 224 /*******************************************************************************
 225 *******************************************************************************/
 226 void
 227 kxld_destroy_context(KXLDContext *context)
 228 {
 229         KXLDObject *object = NULL;
 230         KXLDKext *dep = NULL;
 231         u_int i = 0;
 232
 233         check(context);
 234
 235         kxld_kext_deinit(context->kext);
 236
 237         for (i = 0; i < context->objects.maxitems; ++i) {
 238                 object = kxld_array_get_slot(&context->objects, i);
 239                 kxld_object_deinit(object);
 240         }
 241         kxld_array_deinit(&context->objects);
 242
 243         for (i = 0; i < context->dependencies.maxitems; ++i) {
 244                 dep = kxld_array_get_slot(&context->dependencies, i);
 245                 kxld_kext_deinit(dep);
 246         }
 247         kxld_array_deinit(&context->dependencies);
 248
 249         kxld_dict_deinit(&context->defined_symbols_by_name);
 250         kxld_dict_deinit(&context->defined_cxx_symbols_by_value);
 251         kxld_dict_deinit(&context->obsolete_symbols_by_name);
 252         kxld_dict_deinit(&context->vtables_by_name);
 253
 254         kxld_free(context->kext, kxld_kext_sizeof());
 255         kxld_free(context, sizeof(*context));
 256
 257         kxld_print_memory_report();
 258 }
 259
 260 /*******************************************************************************
 261 *******************************************************************************/
 262 kern_return_t
 263 kxld_link_split_file(
 264         KXLDContext       * context,
 265         splitKextLinkInfo *link_info,
 266         const char        * name,
 267         void              * callback_data,
 268         KXLDDependency    * dependencies,
 269         u_int               ndependencies,
 270         kxld_addr_t       * kmod_info_kern)
 271 {
 272         kern_return_t       rval                    = KERN_FAILURE;
 273         KXLDObject *        kext_object             = NULL;
 274         splitKextLinkInfo * my_link_info            = NULL;
 275
 276         isSplitKext = (link_info->vmaddr_TEXT_EXEC != 0);
 277         isOldInterface = FALSE;
 278
 279         kxld_set_logging_callback_data(name, callback_data);
 280
 281         kxld_log(kKxldLogLinking, kKxldLogBasic, "Linking kext %s", name);
 282
 283         kaslr_offsets_count = 0;
 284         kaslr_offsets_index = 0;
 285         kaslr_offsets = NULL;
 286
 287         require_action(context, finish, rval = KERN_INVALID_ARGUMENT);
 288         require_action(link_info, finish, rval = KERN_INVALID_ARGUMENT);
 289         require_action(dependencies, finish, rval = KERN_INVALID_ARGUMENT);
 290         require_action(ndependencies, finish, rval = KERN_INVALID_ARGUMENT);
 291         require_action(kmod_info_kern, finish, rval = KERN_INVALID_ARGUMENT);
 292
 293         rval = init_context(context, ndependencies);
 294         require_noerr(rval, finish);
 295
 296         rval = init_kext_objects(context,
 297             link_info->kextExecutable,
 298             link_info->kextSize,
 299             name,
 300             dependencies, ndependencies);
 301         require_noerr(rval, finish);
 302
 303         kext_object = get_object_for_file(context,
 304             link_info->kextExecutable,
 305             link_info->kextSize,
 306             name);
 307         require_action(kext_object, finish, rval = KERN_FAILURE);
 308
 309         // copy vmaddrs and fileoffsets for split segments into kext_object
 310         kxld_object_set_link_info(kext_object, link_info);
 311
 312         my_link_info = kxld_object_get_link_info(kext_object);
 313
 314         rval = allocate_split_kext(context, my_link_info);
 315         require_noerr(rval, finish);
 316
 317 #if SPLIT_KEXTS_DEBUG
 318         kxld_log(kKxldLogLinking, kKxldLogErr, "Linking kext %s", name);
 319         kxld_show_split_info(link_info);
 320 #endif // SPLIT_KEXTS_DEBUG
 321
 322         rval = kxld_kext_relocate(context->kext,
 323             (kxld_addr_t)my_link_info,
 324             &context->vtables_by_name,
 325             &context->defined_symbols_by_name,
 326             &context->obsolete_symbols_by_name,
 327             &context->defined_cxx_symbols_by_value);
 328         require_noerr(rval, finish);
 329
 330         rval = kxld_kext_export_linked_object(context->kext,
 331             (void *) my_link_info,
 332             kmod_info_kern);
 333         require_noerr(rval, finish);
 334
 335         // pass back info about linked kext
 336         link_info->kaslr_offsets_count = kaslr_offsets_count;
 337         link_info->kaslr_offsets = kaslr_offsets;
 338         link_info->linkedKext = my_link_info->linkedKext;
 339         link_info->linkedKextSize = my_link_info->linkedKextSize;
 340
 341         if (kaslr_offsets_count != kaslr_offsets_index) {
 342                 kxld_log(kKxldLogLinking, kKxldLogErr, "[ERROR] %s: KASLR pointers: count=%d, but only populated %d!", name, kaslr_offsets_count, kaslr_offsets_index);
 343                 rval = KERN_FAILURE;
 344                 goto finish;
 345         }
 346
 347         // the values are now the responsibility of the caller
 348         kaslr_offsets_count = 0;
 349         kaslr_offsets_index = 0;
 350         kaslr_offsets = NULL;
 351
 352         rval = KERN_SUCCESS;
 353 finish:
 354         clear_context(context);
 355         kxld_set_logging_callback_data(NULL, NULL);
 356
 357         return rval;
 358 }
 359
 360 /*******************************************************************************
 361 *******************************************************************************/
 362 kern_return_t
 363 kxld_link_file(
 364         KXLDContext       * context,
 365         u_char            * file,
 366         u_long              size,
 367         const char        * name,
 368         void              * callback_data,
 369         KXLDDependency    * dependencies,
 370         u_int               ndependencies,
 371         u_char           ** linked_object_out,
 372         kxld_addr_t       * kmod_info_kern)
 373 {
 374         kern_return_t       rval                    = KERN_FAILURE;
 375         kxld_addr_t         vmaddr                  = 0;
 376         u_long              vmsize                  = 0;
 377         u_char            * linked_object           = NULL;
 378         u_char            * linked_object_alloc     = NULL;
 379
 380         kaslr_offsets_count = 0;
 381         kaslr_offsets_index = 0;
 382         kaslr_offsets = NULL;
 383
 384         kxld_set_logging_callback_data(name, callback_data);
 385
 386         kxld_log(kKxldLogLinking, kKxldLogBasic, "Linking kext %s", name);
 387
 388         require_action(context, finish, rval = KERN_INVALID_ARGUMENT);
 389         require_action(dependencies, finish, rval = KERN_INVALID_ARGUMENT);
 390         require_action(ndependencies, finish, rval = KERN_INVALID_ARGUMENT);
 391         require_action(file, finish, rval = KERN_INVALID_ARGUMENT);
 392         require_action(size, finish, rval = KERN_INVALID_ARGUMENT);
 393         require_action(linked_object_out, finish, rval = KERN_INVALID_ARGUMENT);
 394         require_action(kmod_info_kern, finish, rval = KERN_INVALID_ARGUMENT);
 395
 396         isSplitKext = FALSE;
 397         isOldInterface = TRUE;
 398
 399         rval = init_context(context, ndependencies);
 400         require_noerr(rval, finish);
 401
 402         rval = init_kext_objects(context, file, size, name,
 403             dependencies, ndependencies);
 404         require_noerr(rval, finish);
 405
 406         linked_object = allocate_kext(context, callback_data,
 407             &vmaddr, &vmsize, &linked_object_alloc);
 408         require_action(linked_object, finish, rval = KERN_RESOURCE_SHORTAGE);
 409
 410
 411         rval = kxld_kext_relocate(context->kext,
 412             vmaddr,
 413             &context->vtables_by_name,
 414             &context->defined_symbols_by_name,
 415             &context->obsolete_symbols_by_name,
 416             &context->defined_cxx_symbols_by_value);
 417         require_noerr(rval, finish);
 418
 419         rval = kxld_kext_export_linked_object(context->kext,
 420             (void *) linked_object,
 421             kmod_info_kern);
 422         require_noerr(rval, finish);
 423         *linked_object_out = linked_object;
 424
 425         linked_object_alloc = NULL;
 426
 427         rval = KERN_SUCCESS;
 428 finish:
 429         if (linked_object_alloc) {
 430                 kxld_page_free_untracked(linked_object_alloc, vmsize);
 431         }
 432
 433         clear_context(context);
 434         kxld_set_logging_callback_data(NULL, NULL);
 435
 436         return rval;
 437 }
 438
 439
 440 /*******************************************************************************
 441 *******************************************************************************/
 442 static kern_return_t
 443 init_context(KXLDContext *context, u_int ndependencies)
 444 {
 445         kern_return_t rval = KERN_FAILURE;
 446
 447         /* Create an array of objects large enough to hold an object
 448          * for every dependency, an interface for each dependency, and a kext. */
 449         rval = kxld_array_init(&context->objects,
 450             kxld_object_sizeof(), 2 * ndependencies + 1);
 451         require_noerr(rval, finish);
 452
 453         rval = kxld_array_init(&context->dependencies,
 454             kxld_kext_sizeof(), ndependencies);
 455         require_noerr(rval, finish);
 456
 457         rval = kxld_dict_init(&context->defined_symbols_by_name,
 458             kxld_dict_string_hash, kxld_dict_string_cmp, 0);
 459         require_noerr(rval, finish);
 460
 461         rval = kxld_dict_init(&context->defined_cxx_symbols_by_value,
 462             kxld_dict_kxldaddr_hash, kxld_dict_kxldaddr_cmp, 0);
 463         require_noerr(rval, finish);
 464
 465         rval = kxld_dict_init(&context->obsolete_symbols_by_name,
 466             kxld_dict_string_hash, kxld_dict_string_cmp, 0);
 467         require_noerr(rval, finish);
 468
 469         rval = kxld_dict_init(&context->vtables_by_name, kxld_dict_string_hash,
 470             kxld_dict_string_cmp, 0);
 471         require_noerr(rval, finish);
 472
 473         rval = KERN_SUCCESS;
 474 finish:
 475         return rval;
 476 }
 477
 478 /*******************************************************************************
 479 *******************************************************************************/
 480 static kern_return_t
 481 init_kext_objects(KXLDContext *context,
 482     u_char *file,
 483     u_long size,
 484     const char *name,
 485     KXLDDependency *dependencies,
 486     u_int ndependencies)
 487 {
 488         kern_return_t rval = KERN_FAILURE;
 489         KXLDKext *kext = NULL;
 490         KXLDObject *kext_object = NULL;
 491         KXLDObject *interface_object = NULL;
 492         u_int i = 0;
 493
 494         /* Create a kext object for each dependency.  If it's a direct dependency,
 495          * export its symbols by name by value.  If it's indirect, just export the
 496          * C++ symbols by value.
 497          */
 498         for (i = 0; i < ndependencies; ++i) {
 499                 kext = kxld_array_get_item(&context->dependencies, i);
 500                 kext_object = NULL;
 501                 interface_object = NULL;
 502
 503                 kext_object = get_object_for_file(context, dependencies[i].kext,
 504                     dependencies[i].kext_size, dependencies[i].kext_name);
 505                 require_action(kext_object, finish, rval = KERN_FAILURE);
 506
 507                 if (dependencies[i].interface) {
 508                         interface_object = get_object_for_file(context,
 509                             dependencies[i].interface, dependencies[i].interface_size,
 510                             dependencies[i].interface_name);
 511                         require_action(interface_object, finish, rval = KERN_FAILURE);
 512                 }
 513
 514                 rval = kxld_kext_init(kext, kext_object, interface_object);
 515                 require_noerr(rval, finish);
 516
 517                 if (dependencies[i].is_direct_dependency) {
 518                         rval = kxld_kext_export_symbols(kext,
 519                             &context->defined_symbols_by_name,
 520                             &context->obsolete_symbols_by_name,
 521                             &context->defined_cxx_symbols_by_value);
 522                         require_noerr(rval, finish);
 523                 } else {
 524                         rval = kxld_kext_export_symbols(kext,
 525                             /* defined_symbols */ NULL, /* obsolete_symbols */ NULL,
 526                             &context->defined_cxx_symbols_by_value);
 527                         require_noerr(rval, finish);
 528                 }
 529         }
 530
 531         /* Export the vtables for all of the dependencies. */
 532         for (i = 0; i < context->dependencies.nitems; ++i) {
 533                 kext = kxld_array_get_item(&context->dependencies, i);
 534
 535                 rval = kxld_kext_export_vtables(kext,
 536                     &context->defined_cxx_symbols_by_value,
 537                     &context->defined_symbols_by_name,
 538                     &context->vtables_by_name);
 539                 require_noerr(rval, finish);
 540         }
 541
 542         /* Create a kext object for the kext we're linking and export its locally
 543          * defined C++ symbols.
 544          */
 545         kext_object = get_object_for_file(context, file, size, name);
 546         require_action(kext_object, finish, rval = KERN_FAILURE);
 547
 548         rval = kxld_kext_init(context->kext, kext_object, /* interface */ NULL);
 549         require_noerr(rval, finish);
 550
 551         rval = kxld_kext_export_symbols(context->kext,
 552             /* defined_symbols */ NULL, /* obsolete_symbols */ NULL,
 553             &context->defined_cxx_symbols_by_value);
 554         require_noerr(rval, finish);
 555
 556         rval = KERN_SUCCESS;
 557 finish:
 558         return rval;
 559 }
 560
 561 /*******************************************************************************
 562 *******************************************************************************/
 563 static KXLDObject *
 564 get_object_for_file(KXLDContext *context, u_char *file, u_long size,
 565     const char *name)
 566 {
 567         KXLDObject *rval = NULL;
 568         KXLDObject *object = NULL;
 569         kern_return_t result = 0;
 570         u_int i = 0;
 571
 572         for (i = 0; i < context->objects.nitems; ++i) {
 573                 object = kxld_array_get_item(&context->objects, i);
 574
 575                 if (!kxld_object_get_file(object)) {
 576                         result = kxld_object_init_from_macho(object, file, size, name,
 577                             context->section_order, context->cputype, context->cpusubtype, context->flags);
 578                         require_noerr(result, finish);
 579
 580                         rval = object;
 581                         break;
 582                 }
 583
 584                 if (kxld_object_get_file(object) == file) {
 585                         rval = object;
 586                         break;
 587                 }
 588         }
 589
 590 finish:
 591         return rval;
 592 }
 593
 594 #include <mach-o/loader.h>
 595
 596 /*******************************************************************************
 597 *******************************************************************************/
 598 static kern_return_t
 599 allocate_split_kext(KXLDContext *context, splitKextLinkInfo * link_info)
 600 {
 601         kern_return_t       rval                    = KERN_FAILURE;
 602         u_long              vmsize                  = 0;
 603         u_long              header_size             = 0;
 604         u_char            * linked_object           = NULL;
 605
 606         kxld_kext_get_vmsize(context->kext, &header_size, &vmsize);
 607
 608         if (isSplitKext) {
 609                 /* get __LINKEDIT vmsize */
 610                 kxld_kext_get_vmsize_for_seg_by_name(context->kext, SEG_LINKEDIT, &vmsize);
 611                 // add in the gaps
 612                 vmsize += (link_info->vmaddr_LINKEDIT - link_info->vmaddr_TEXT);
 613         }
 614         link_info->linkedKextSize = vmsize;
 615
 616         linked_object = kxld_page_alloc_untracked(link_info->linkedKextSize);
 617         require(linked_object, finish);
 618         link_info->linkedKext = linked_object;
 619         rval = KERN_SUCCESS;
 620
 621 finish:
 622         return rval;
 623 }
 624
 625 /*******************************************************************************
 626 *******************************************************************************/
 627 static u_char *
 628 allocate_kext(KXLDContext *context,
 629     void *callback_data,
 630     kxld_addr_t *vmaddr_out,
 631     u_long *vmsize_out,
 632     u_char **linked_object_alloc_out)
 633 {
 634         KXLDAllocateFlags   flags                   = 0;
 635         kxld_addr_t         vmaddr                  = 0;
 636         u_long              vmsize                  = 0;
 637         u_long              header_size             = 0;
 638         u_char            * linked_object           = NULL;
 639
 640         *linked_object_alloc_out = NULL;
 641
 642         kxld_kext_get_vmsize(context->kext, &header_size, &vmsize);
 643
 644         vmaddr = context->allocate_callback(vmsize, &flags, callback_data);
 645         require_action(!(vmaddr & (kxld_get_effective_page_size() - 1)), finish,
 646             kxld_log(kKxldLogLinking, kKxldLogErr,
 647             "Load address %p is not page-aligned.",
 648             (void *) (uintptr_t) vmaddr));
 649
 650         /* Zero out the memory before we fill it.  We fill this buffer in a
 651          * sparse fashion, and it's simpler to clear it now rather than
 652          * track and zero any pieces we didn't touch after we've written
 653          * all of the sections to memory.
 654          */
 655         if (flags & kKxldAllocateWritable) {
 656                 linked_object = (u_char *) (u_long) vmaddr;
 657                 bzero(linked_object, vmsize);
 658         } else {
 659                 linked_object = kxld_page_alloc_untracked(vmsize);
 660                 require(linked_object, finish);
 661
 662                 *linked_object_alloc_out = linked_object;
 663         }
 664
 665         kxld_kext_set_linked_object_size(context->kext, vmsize);
 666
 667         *vmaddr_out = vmaddr;
 668         *vmsize_out = vmsize;
 669
 670 finish:
 671         return linked_object;
 672 }
 673
 674 /*******************************************************************************
 675 *******************************************************************************/
 676 static void
 677 clear_context(KXLDContext *context)
 678 {
 679         KXLDObject * object = NULL;
 680         KXLDKext   * dep     = NULL;
 681         u_int i = 0;
 682
 683         check(context);
 684
 685         kxld_kext_clear(context->kext);
 686
 687         for (i = 0; i < context->objects.nitems; ++i) {
 688                 object = kxld_array_get_item(&context->objects, i);
 689                 kxld_object_clear(object);
 690         }
 691         kxld_array_reset(&context->objects);
 692
 693         for (i = 0; i < context->dependencies.nitems; ++i) {
 694                 dep = kxld_array_get_item(&context->dependencies, i);
 695                 kxld_kext_clear(dep);
 696         }
 697         kxld_array_reset(&context->dependencies);
 698
 699         kxld_dict_clear(&context->defined_symbols_by_name);
 700         kxld_dict_clear(&context->defined_cxx_symbols_by_value);
 701         kxld_dict_clear(&context->obsolete_symbols_by_name);
 702         kxld_dict_clear(&context->vtables_by_name);
 703 }