1 /* 2 * Copyright (c) 2000-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 extern "C" { 29 #include <mach/kmod.h> 30 #include <libkern/kernel_mach_header.h> 31 #include <libkern/prelink.h> 32 } 33 34 #include <libkern/version.h> 35 #include <libkern/c++/OSContainers.h> 36 #include <libkern/OSKextLibPrivate.h> 37 #include <libkern/c++/OSKext.h> 38 #include <IOKit/IOLib.h> 39 #include <IOKit/IOService.h> 40 #include <IOKit/IODeviceTreeSupport.h> 41 #include <IOKit/IOCatalogue.h> 42 43 #if __x86_64__ 44 #define KASLR_KEXT_DEBUG 0 45 #endif 46 47 #if PRAGMA_MARK 48 #pragma mark Bootstrap Declarations 49 #endif 50 /********************************************************************* 51 * Bootstrap Declarations 52 * 53 * The ENTIRE point of the libsa/KLD segment is to isolate bootstrap 54 * code from other parts of the kernel, so function symbols are not 55 * exported; rather pointers to those functions are exported. 56 * 57 * xxx - need to think about locking for handling the 'weak' refs. 58 * xxx - do export a non-KLD function that says you've called a 59 * xxx - bootstrap function that has been removed. 60 * 61 * ALL call-ins to this segment of the kernel must be done through 62 * exported pointers. The symbols themselves are private and not to 63 * be linked against. 64 *********************************************************************/ 65 extern "C" { 66 extern void (*record_startup_extensions_function)(void); 67 extern void (*load_security_extensions_function)(void); 68 }; 69 70 static void bootstrapRecordStartupExtensions(void); 71 static void bootstrapLoadSecurityExtensions(void); 72 73 74 #if NO_KEXTD 75 extern "C" bool IORamDiskBSDRoot(void); 76 #endif 77 78 #if PRAGMA_MARK 79 #pragma mark Macros 80 #endif 81 /********************************************************************* 82 * Macros 83 *********************************************************************/ 84 #define CONST_STRLEN(str) (sizeof(str) - 1) 85 86 #if PRAGMA_MARK 87 #pragma mark Kernel Component Kext Identifiers 88 #endif 89 /********************************************************************* 90 * Kernel Component Kext Identifiers 91 * 92 * We could have each kernel resource kext automatically "load" as 93 * it's created, but it's nicer to have them listed in kextstat in 94 * the order of this list. We'll walk through this after setting up 95 * all the boot kexts and have them load up. 96 *********************************************************************/ 97 static const char * sKernelComponentNames[] = { 98 // The kexts for these IDs must have a version matching 'osrelease'. 99 "com.apple.kernel", 100 "com.apple.kpi.bsd", 101 "com.apple.kpi.dsep", 102 "com.apple.kpi.iokit", 103 "com.apple.kpi.libkern", 104 "com.apple.kpi.mach", 105 "com.apple.kpi.private", 106 "com.apple.kpi.unsupported", 107 "com.apple.iokit.IONVRAMFamily", 108 "com.apple.driver.AppleNMI", 109 "com.apple.iokit.IOSystemManagementFamily", 110 "com.apple.iokit.ApplePlatformFamily", 111 NULL 112 }; 113 114 #if PRAGMA_MARK 115 #pragma mark KLDBootstrap Class 116 #endif 117 /********************************************************************* 118 * KLDBootstrap Class 119 * 120 * We use a C++ class here so that it can be a friend of OSKext and 121 * get at private stuff. We can't hide the class itself, but we can 122 * hide the instance through which we invoke the functions. 123 *********************************************************************/ 124 class KLDBootstrap { 125 friend void bootstrapRecordStartupExtensions(void); 126 friend void bootstrapLoadSecurityExtensions(void); 127 128 private: 129 void readStartupExtensions(void); 130 131 void readPrelinkedExtensions( 132 kernel_section_t * prelinkInfoSect); 133 void readBooterExtensions(void); 134 OSReturn readMkextExtensions( 135 OSString * deviceTreeName, 136 OSData * deviceTreeData); 137 138 OSReturn loadKernelComponentKexts(void); 139 void loadKernelExternalComponents(void); 140 void readBuiltinPersonalities(void); 141 142 void loadSecurityExtensions(void); 143 144 public: 145 KLDBootstrap(void); 146 ~KLDBootstrap(void); 147 }; 148 149 static KLDBootstrap sBootstrapObject; 150 151 /********************************************************************* 152 * Set the function pointers for the entry points into the bootstrap 153 * segment upon C++ static constructor invocation. 154 *********************************************************************/ 155 KLDBootstrap::KLDBootstrap(void) 156 { 157 if (this != &sBootstrapObject) { 158 panic("Attempt to access bootstrap segment."); 159 } 160 record_startup_extensions_function = &bootstrapRecordStartupExtensions; 161 load_security_extensions_function = &bootstrapLoadSecurityExtensions; 162 } 163 164 /********************************************************************* 165 * Clear the function pointers for the entry points into the bootstrap 166 * segment upon C++ static destructor invocation. 167 *********************************************************************/ 168 KLDBootstrap::~KLDBootstrap(void) 169 { 170 if (this != &sBootstrapObject) { 171 panic("Attempt to access bootstrap segment."); 172 } 173 174 175 record_startup_extensions_function = 0; 176 load_security_extensions_function = 0; 177 } 178 179 /********************************************************************* 180 *********************************************************************/ 181 void 182 KLDBootstrap::readStartupExtensions(void) 183 { 184 kernel_section_t * prelinkInfoSect = NULL; // do not free 185 186 OSKextLog(/* kext */ NULL, 187 kOSKextLogProgressLevel | 188 kOSKextLogGeneralFlag | kOSKextLogDirectoryScanFlag | 189 kOSKextLogKextBookkeepingFlag, 190 "Reading startup extensions."); 191 192 /* If the prelink info segment has a nonzero size, we are prelinked 193 * and won't have any individual kexts or mkexts to read. 194 * Otherwise, we need to read kexts or the mkext from what the booter 195 * has handed us. 196 */ 197 prelinkInfoSect = getsectbyname(kPrelinkInfoSegment, kPrelinkInfoSection); 198 if (prelinkInfoSect->size) { 199 readPrelinkedExtensions(prelinkInfoSect); 200 } else { 201 readBooterExtensions(); 202 } 203 204 loadKernelComponentKexts(); 205 loadKernelExternalComponents(); 206 readBuiltinPersonalities(); 207 OSKext::sendAllKextPersonalitiesToCatalog(); 208 209 return; 210 } 211 212 /********************************************************************* 213 *********************************************************************/ 214 void 215 KLDBootstrap::readPrelinkedExtensions( 216 kernel_section_t * prelinkInfoSect) 217 { 218 OSArray * infoDictArray = NULL; // do not release 219 OSObject * parsedXML = NULL; // must release 220 OSDictionary * prelinkInfoDict = NULL; // do not release 221 OSString * errorString = NULL; // must release 222 OSKext * theKernel = NULL; // must release 223 224 kernel_segment_command_t * prelinkTextSegment = NULL; // see code 225 kernel_segment_command_t * prelinkInfoSegment = NULL; // see code 226 227 /* We make some copies of data, but if anything fails we're basically 228 * going to fail the boot, so these won't be cleaned up on error. 229 */ 230 void * prelinkData = NULL; // see code 231 vm_size_t prelinkLength = 0; 232 233 234 OSDictionary * infoDict = NULL; // do not release 235 236 IORegistryEntry * registryRoot = NULL; // do not release 237 OSNumber * prelinkCountObj = NULL; // must release 238 239 u_int i = 0; 240 #if NO_KEXTD 241 bool ramDiskBoot; 242 bool developerDevice; 243 bool dontLoad; 244 #endif 245 246 OSKextLog(/* kext */ NULL, 247 kOSKextLogProgressLevel | 248 kOSKextLogDirectoryScanFlag | kOSKextLogArchiveFlag, 249 "Starting from prelinked kernel."); 250 251 prelinkTextSegment = getsegbyname(kPrelinkTextSegment); 252 if (!prelinkTextSegment) { 253 OSKextLog(/* kext */ NULL, 254 kOSKextLogErrorLevel | 255 kOSKextLogDirectoryScanFlag | kOSKextLogArchiveFlag, 256 "Can't find prelinked kexts' text segment."); 257 goto finish; 258 } 259 260 #if KASLR_KEXT_DEBUG 261 unsigned long scratchSize; 262 vm_offset_t scratchAddr; 263 264 IOLog("kaslr: prelinked kernel address info: \n"); 265 266 scratchAddr = (vm_offset_t) getsegdatafromheader(&_mh_execute_header, "__TEXT", &scratchSize); 267 IOLog("kaslr: start 0x%lx end 0x%lx length %lu for __TEXT \n", 268 (unsigned long)scratchAddr, 269 (unsigned long)(scratchAddr + scratchSize), 270 scratchSize); 271 272 scratchAddr = (vm_offset_t) getsegdatafromheader(&_mh_execute_header, "__DATA", &scratchSize); 273 IOLog("kaslr: start 0x%lx end 0x%lx length %lu for __DATA \n", 274 (unsigned long)scratchAddr, 275 (unsigned long)(scratchAddr + scratchSize), 276 scratchSize); 277 278 scratchAddr = (vm_offset_t) getsegdatafromheader(&_mh_execute_header, "__LINKEDIT", &scratchSize); 279 IOLog("kaslr: start 0x%lx end 0x%lx length %lu for __LINKEDIT \n", 280 (unsigned long)scratchAddr, 281 (unsigned long)(scratchAddr + scratchSize), 282 scratchSize); 283 284 scratchAddr = (vm_offset_t) getsegdatafromheader(&_mh_execute_header, "__KLD", &scratchSize); 285 IOLog("kaslr: start 0x%lx end 0x%lx length %lu for __KLD \n", 286 (unsigned long)scratchAddr, 287 (unsigned long)(scratchAddr + scratchSize), 288 scratchSize); 289 290 scratchAddr = (vm_offset_t) getsegdatafromheader(&_mh_execute_header, "__PRELINK_TEXT", &scratchSize); 291 IOLog("kaslr: start 0x%lx end 0x%lx length %lu for __PRELINK_TEXT \n", 292 (unsigned long)scratchAddr, 293 (unsigned long)(scratchAddr + scratchSize), 294 scratchSize); 295 296 scratchAddr = (vm_offset_t) getsegdatafromheader(&_mh_execute_header, "__PRELINK_INFO", &scratchSize); 297 IOLog("kaslr: start 0x%lx end 0x%lx length %lu for __PRELINK_INFO \n", 298 (unsigned long)scratchAddr, 299 (unsigned long)(scratchAddr + scratchSize), 300 scratchSize); 301 #endif 302 303 prelinkData = (void *) prelinkTextSegment->vmaddr; 304 prelinkLength = prelinkTextSegment->vmsize; 305 306 307 /* Unserialize the info dictionary from the prelink info section. 308 */ 309 parsedXML = OSUnserializeXML((const char *)prelinkInfoSect->addr, 310 &errorString); 311 if (parsedXML) { 312 prelinkInfoDict = OSDynamicCast(OSDictionary, parsedXML); 313 } 314 if (!prelinkInfoDict) { 315 const char * errorCString = "(unknown error)"; 316 317 if (errorString && errorString->getCStringNoCopy()) { 318 errorCString = errorString->getCStringNoCopy(); 319 } else if (parsedXML) { 320 errorCString = "not a dictionary"; 321 } 322 OSKextLog(/* kext */ NULL, kOSKextLogErrorLevel | kOSKextLogArchiveFlag, 323 "Error unserializing prelink plist: %s.", errorCString); 324 goto finish; 325 } 326 327 #if NO_KEXTD 328 /* Check if we should keep developer kexts around. 329 * TODO: Check DeviceTree instead of a boot-arg <rdar://problem/10604201> 330 */ 331 developerDevice = true; 332 PE_parse_boot_argn("developer", &developerDevice, sizeof(developerDevice)); 333 334 ramDiskBoot = IORamDiskBSDRoot(); 335 #endif /* NO_KEXTD */ 336 337 infoDictArray = OSDynamicCast(OSArray, 338 prelinkInfoDict->getObject(kPrelinkInfoDictionaryKey)); 339 if (!infoDictArray) { 340 OSKextLog(/* kext */ NULL, kOSKextLogErrorLevel | kOSKextLogArchiveFlag, 341 "The prelinked kernel has no kext info dictionaries"); 342 goto finish; 343 } 344 345 /* Create dictionary of excluded kexts 346 */ 347 OSKext::createExcludeListFromPrelinkInfo(infoDictArray); 348 349 /* Create OSKext objects for each info dictionary. 350 */ 351 for (i = 0; i < infoDictArray->getCount(); ++i) { 352 infoDict = OSDynamicCast(OSDictionary, infoDictArray->getObject(i)); 353 if (!infoDict) { 354 OSKextLog(/* kext */ NULL, 355 kOSKextLogErrorLevel | 356 kOSKextLogDirectoryScanFlag | kOSKextLogArchiveFlag, 357 "Can't find info dictionary for prelinked kext #%d.", i); 358 continue; 359 } 360 361 #if NO_KEXTD 362 dontLoad = false; 363 364 /* If we're not on a developer device, skip and free developer kexts. 365 */ 366 if (developerDevice == false) { 367 OSBoolean *devOnlyBool = OSDynamicCast(OSBoolean, 368 infoDict->getObject(kOSBundleDeveloperOnlyKey)); 369 if (devOnlyBool == kOSBooleanTrue) { 370 dontLoad = true; 371 } 372 } 373 374 /* Skip and free kexts that are only needed when booted from a ram disk. 375 */ 376 if (ramDiskBoot == false) { 377 OSBoolean *ramDiskOnlyBool = OSDynamicCast(OSBoolean, 378 infoDict->getObject(kOSBundleRamDiskOnlyKey)); 379 if (ramDiskOnlyBool == kOSBooleanTrue) { 380 dontLoad = true; 381 } 382 } 383 384 if (dontLoad == true) { 385 OSString *bundleID = OSDynamicCast(OSString, 386 infoDict->getObject(kCFBundleIdentifierKey)); 387 if (bundleID) { 388 OSKextLog(NULL, kOSKextLogWarningLevel | kOSKextLogGeneralFlag, 389 "Kext %s not loading.", bundleID->getCStringNoCopy()); 390 } 391 392 OSNumber *addressNum = OSDynamicCast(OSNumber, 393 infoDict->getObject(kPrelinkExecutableLoadKey)); 394 OSNumber *lengthNum = OSDynamicCast(OSNumber, 395 infoDict->getObject(kPrelinkExecutableSizeKey)); 396 if (addressNum && lengthNum) { 397 #error Pick the right way to free prelinked data on this arch 398 } 399 400 infoDictArray->removeObject(i--); 401 continue; 402 } 403 #endif /* NO_KEXTD */ 404 405 /* Create the kext for the entry, then release it, because the 406 * kext system keeps them around until explicitly removed. 407 * Any creation/registration failures are already logged for us. 408 */ 409 OSKext * newKext = OSKext::withPrelinkedInfoDict(infoDict); 410 OSSafeReleaseNULL(newKext); 411 } 412 413 /* Store the number of prelinked kexts in the registry so we can tell 414 * when the system has been started from a prelinked kernel. 415 */ 416 registryRoot = IORegistryEntry::getRegistryRoot(); 417 assert(registryRoot); 418 419 prelinkCountObj = OSNumber::withNumber( 420 (unsigned long long)infoDictArray->getCount(), 421 8 * sizeof(uint32_t)); 422 assert(prelinkCountObj); 423 if (prelinkCountObj) { 424 registryRoot->setProperty(kOSPrelinkKextCountKey, prelinkCountObj); 425 } 426 427 OSKextLog(/* kext */ NULL, 428 kOSKextLogProgressLevel | 429 kOSKextLogGeneralFlag | kOSKextLogKextBookkeepingFlag | 430 kOSKextLogDirectoryScanFlag | kOSKextLogArchiveFlag, 431 "%u prelinked kexts", 432 infoDictArray->getCount()); 433 434 #if CONFIG_KEXT_BASEMENT 435 /* On CONFIG_KEXT_BASEMENT systems, kexts are copied to their own 436 * special VM region during OSKext init time, so we can free the whole 437 * segment now. 438 */ 439 ml_static_mfree((vm_offset_t) prelinkData, prelinkLength); 440 #endif /* __x86_64__ */ 441 442 /* Free the prelink info segment, we're done with it. 443 */ 444 prelinkInfoSegment = getsegbyname(kPrelinkInfoSegment); 445 if (prelinkInfoSegment) { 446 ml_static_mfree((vm_offset_t)prelinkInfoSegment->vmaddr, 447 (vm_size_t)prelinkInfoSegment->vmsize); 448 } 449 450 finish: 451 OSSafeRelease(errorString); 452 OSSafeRelease(parsedXML); 453 OSSafeRelease(theKernel); 454 OSSafeRelease(prelinkCountObj); 455 return; 456 } 457 458 /********************************************************************* 459 *********************************************************************/ 460 #define BOOTER_KEXT_PREFIX "Driver-" 461 #define BOOTER_MKEXT_PREFIX "DriversPackage-" 462 463 typedef struct _DeviceTreeBuffer { 464 uint32_t paddr; 465 uint32_t length; 466 } _DeviceTreeBuffer; 467 468 void 469 KLDBootstrap::readBooterExtensions(void) 470 { 471 IORegistryEntry * booterMemoryMap = NULL; // must release 472 OSDictionary * propertyDict = NULL; // must release 473 OSCollectionIterator * keyIterator = NULL; // must release 474 OSString * deviceTreeName = NULL; // do not release 475 476 const _DeviceTreeBuffer * deviceTreeBuffer = NULL; // do not free 477 char * booterDataPtr = NULL; // do not free 478 OSData * booterData = NULL; // must release 479 480 OSKext * aKext = NULL; // must release 481 482 OSKextLog(/* kext */ NULL, 483 kOSKextLogProgressLevel | 484 kOSKextLogDirectoryScanFlag | kOSKextLogKextBookkeepingFlag, 485 "Reading startup extensions/mkexts from booter memory."); 486 487 booterMemoryMap = IORegistryEntry::fromPath( "/chosen/memory-map", gIODTPlane); 488 489 if (!booterMemoryMap) { 490 OSKextLog(/* kext */ NULL, 491 kOSKextLogErrorLevel | 492 kOSKextLogGeneralFlag | kOSKextLogDirectoryScanFlag, 493 "Can't read booter memory map."); 494 goto finish; 495 } 496 497 propertyDict = booterMemoryMap->dictionaryWithProperties(); 498 if (!propertyDict) { 499 OSKextLog(/* kext */ NULL, 500 kOSKextLogErrorLevel | 501 kOSKextLogDirectoryScanFlag, 502 "Can't get property dictionary from memory map."); 503 goto finish; 504 } 505 506 keyIterator = OSCollectionIterator::withCollection(propertyDict); 507 if (!keyIterator) { 508 OSKextLog(/* kext */ NULL, 509 kOSKextLogErrorLevel | 510 kOSKextLogGeneralFlag, 511 "Can't allocate iterator for driver images."); 512 goto finish; 513 } 514 515 /* Create dictionary of excluded kexts 516 */ 517 OSKext::createExcludeListFromBooterData(propertyDict, keyIterator); 518 keyIterator->reset(); 519 520 while ( ( deviceTreeName = 521 OSDynamicCast(OSString, keyIterator->getNextObject() ))) { 522 523 boolean_t isMkext = FALSE; 524 const char * devTreeNameCString = deviceTreeName->getCStringNoCopy(); 525 OSData * deviceTreeEntry = OSDynamicCast(OSData, 526 propertyDict->getObject(deviceTreeName)); 527 528 /* Clear out the booterData from the prior iteration. 529 */ 530 OSSafeReleaseNULL(booterData); 531 532 /* If there is no entry for the name, we can't do much with it. */ 533 if (!deviceTreeEntry) { 534 continue; 535 } 536 537 /* Make sure it is either a kext or an mkext */ 538 if (!strncmp(devTreeNameCString, BOOTER_KEXT_PREFIX, 539 CONST_STRLEN(BOOTER_KEXT_PREFIX))) { 540 541 isMkext = FALSE; 542 543 } else if (!strncmp(devTreeNameCString, BOOTER_MKEXT_PREFIX, 544 CONST_STRLEN(BOOTER_MKEXT_PREFIX))) { 545 546 isMkext = TRUE; 547 548 } else { 549 continue; 550 } 551 552 deviceTreeBuffer = (const _DeviceTreeBuffer *) 553 deviceTreeEntry->getBytesNoCopy(0, sizeof(deviceTreeBuffer)); 554 if (!deviceTreeBuffer) { 555 /* We can't get to the data, so we can't do anything, 556 * not even free it from physical memory (if it's there). 557 */ 558 OSKextLog(/* kext */ NULL, 559 kOSKextLogErrorLevel | 560 kOSKextLogDirectoryScanFlag, 561 "Device tree entry %s has NULL pointer.", 562 devTreeNameCString); 563 goto finish; // xxx - continue, panic? 564 } 565 566 booterDataPtr = (char *)ml_static_ptovirt(deviceTreeBuffer->paddr); 567 if (!booterDataPtr) { 568 OSKextLog(/* kext */ NULL, 569 kOSKextLogErrorLevel | 570 kOSKextLogDirectoryScanFlag, 571 "Can't get virtual address for device tree mkext entry %s.", 572 devTreeNameCString); 573 goto finish; 574 } 575 576 /* Wrap the booter data buffer in an OSData and set a dealloc function 577 * so it will take care of the physical memory when freed. Kexts will 578 * retain the booterData for as long as they need it. Remove the entry 579 * from the booter memory map after this is done. 580 */ 581 booterData = OSData::withBytesNoCopy(booterDataPtr, 582 deviceTreeBuffer->length); 583 if (!booterData) { 584 OSKextLog(/* kext */ NULL, 585 kOSKextLogErrorLevel | 586 kOSKextLogGeneralFlag, 587 "Error - Can't allocate OSData wrapper for device tree entry %s.", 588 devTreeNameCString); 589 goto finish; 590 } 591 booterData->setDeallocFunction(osdata_phys_free); 592 593 if (isMkext) { 594 readMkextExtensions(deviceTreeName, booterData); 595 } else { 596 /* Create the kext for the entry, then release it, because the 597 * kext system keeps them around until explicitly removed. 598 * Any creation/registration failures are already logged for us. 599 */ 600 OSKext * newKext = OSKext::withBooterData(deviceTreeName, booterData); 601 OSSafeRelease(newKext); 602 } 603 604 booterMemoryMap->removeProperty(deviceTreeName); 605 606 } /* while ( (deviceTreeName = OSDynamicCast(OSString, ...) ) ) */ 607 608 finish: 609 610 OSSafeRelease(booterMemoryMap); 611 OSSafeRelease(propertyDict); 612 OSSafeRelease(keyIterator); 613 OSSafeRelease(booterData); 614 OSSafeRelease(aKext); 615 return; 616 } 617 618 /********************************************************************* 619 *********************************************************************/ 620 OSReturn 621 KLDBootstrap::readMkextExtensions( 622 OSString * deviceTreeName, 623 OSData * booterData) 624 { 625 OSReturn result = kOSReturnError; 626 627 uint32_t checksum; 628 IORegistryEntry * registryRoot = NULL; // do not release 629 OSData * checksumObj = NULL; // must release 630 631 OSKextLog(/* kext */ NULL, 632 kOSKextLogStepLevel | 633 kOSKextLogDirectoryScanFlag | kOSKextLogArchiveFlag, 634 "Reading startup mkext archive from device tree entry %s.", 635 deviceTreeName->getCStringNoCopy()); 636 637 /* If we successfully read the archive, 638 * then save the mkext's checksum in the IORegistry. 639 * assumes we'll only ever have one mkext to boot 640 */ 641 result = OSKext::readMkextArchive(booterData, &checksum); 642 if (result == kOSReturnSuccess) { 643 644 OSKextLog(/* kext */ NULL, 645 kOSKextLogProgressLevel | 646 kOSKextLogArchiveFlag, 647 "Startup mkext archive has checksum 0x%x.", (int)checksum); 648 649 registryRoot = IORegistryEntry::getRegistryRoot(); 650 assert(registryRoot); 651 checksumObj = OSData::withBytes((void *)&checksum, sizeof(checksum)); 652 assert(checksumObj); 653 if (checksumObj) { 654 registryRoot->setProperty(kOSStartupMkextCRC, checksumObj); 655 } 656 } 657 658 return result; 659 } 660 661 /********************************************************************* 662 *********************************************************************/ 663 #define COM_APPLE "com.apple." 664 665 void 666 KLDBootstrap::loadSecurityExtensions(void) 667 { 668 OSDictionary * extensionsDict = NULL; // must release 669 OSCollectionIterator * keyIterator = NULL; // must release 670 OSString * bundleID = NULL; // don't release 671 OSKext * theKext = NULL; // don't release 672 OSBoolean * isSecurityKext = NULL; // don't release 673 674 OSKextLog(/* kext */ NULL, 675 kOSKextLogStepLevel | 676 kOSKextLogLoadFlag, 677 "Loading security extensions."); 678 679 extensionsDict = OSKext::copyKexts(); 680 if (!extensionsDict) { 681 return; 682 } 683 684 keyIterator = OSCollectionIterator::withCollection(extensionsDict); 685 if (!keyIterator) { 686 OSKextLog(/* kext */ NULL, 687 kOSKextLogErrorLevel | 688 kOSKextLogGeneralFlag, 689 "Failed to allocate iterator for security extensions."); 690 goto finish; 691 } 692 693 while ((bundleID = OSDynamicCast(OSString, keyIterator->getNextObject()))) { 694 695 const char * bundle_id = bundleID->getCStringNoCopy(); 696 697 /* Skip extensions whose bundle IDs don't start with "com.apple.". 698 */ 699 if (!bundle_id || 700 (strncmp(bundle_id, COM_APPLE, CONST_STRLEN(COM_APPLE)) != 0)) { 701 702 continue; 703 } 704 705 theKext = OSDynamicCast(OSKext, extensionsDict->getObject(bundleID)); 706 if (!theKext) { 707 continue; 708 } 709 710 isSecurityKext = OSDynamicCast(OSBoolean, 711 theKext->getPropertyForHostArch(kAppleSecurityExtensionKey)); 712 if (isSecurityKext && isSecurityKext->isTrue()) { 713 OSKextLog(/* kext */ NULL, 714 kOSKextLogStepLevel | 715 kOSKextLogLoadFlag, 716 "Loading security extension %s.", bundleID->getCStringNoCopy()); 717 OSKext::loadKextWithIdentifier(bundleID->getCStringNoCopy(), 718 /* allowDefer */ false); 719 } 720 } 721 722 finish: 723 OSSafeRelease(keyIterator); 724 OSSafeRelease(extensionsDict); 725 726 return; 727 } 728 729 /********************************************************************* 730 * We used to require that all listed kernel components load, but 731 * nowadays we can get them from userland so we only try to load the 732 * ones we have. If an error occurs later, such is life. 733 * 734 * Note that we look the kexts up first, so we can avoid spurious 735 * (in this context, anyhow) log messages about kexts not being found. 736 * 737 * xxx - do we even need to do this any more? Check if the kernel 738 * xxx - compoonents just load in the regular paths 739 *********************************************************************/ 740 OSReturn 741 KLDBootstrap::loadKernelComponentKexts(void) 742 { 743 OSReturn result = kOSReturnSuccess; // optimistic 744 OSKext * theKext = NULL; // must release 745 const char ** kextIDPtr = NULL; // do not release 746 747 for (kextIDPtr = &sKernelComponentNames[0]; *kextIDPtr; kextIDPtr++) { 748 749 OSSafeReleaseNULL(theKext); 750 theKext = OSKext::lookupKextWithIdentifier(*kextIDPtr); 751 752 if (theKext) { 753 if (kOSReturnSuccess != OSKext::loadKextWithIdentifier( 754 *kextIDPtr, /* allowDefer */ false)) { 755 756 // xxx - check KextBookkeeping, might be redundant 757 OSKextLog(/* kext */ NULL, 758 kOSKextLogErrorLevel | 759 kOSKextLogDirectoryScanFlag | kOSKextLogKextBookkeepingFlag, 760 "Failed to initialize kernel component %s.", *kextIDPtr); 761 result = kOSReturnError; 762 } 763 } 764 } 765 766 OSSafeRelease(theKext); 767 return result; 768 } 769 770 /********************************************************************* 771 * Ensure that Kernel External Components are loaded early in boot, 772 * before other kext personalities get sent to the IOCatalogue. These 773 * kexts are treated specially because they may provide the implementation 774 * for kernel-vended KPI, so they must register themselves before 775 * general purpose IOKit probing begins. 776 *********************************************************************/ 777 778 #define COM_APPLE_KEC "com.apple.kec." 779 780 void 781 KLDBootstrap::loadKernelExternalComponents(void) 782 { 783 OSDictionary * extensionsDict = NULL; // must release 784 OSCollectionIterator * keyIterator = NULL; // must release 785 OSString * bundleID = NULL; // don't release 786 OSKext * theKext = NULL; // don't release 787 OSBoolean * isKernelExternalComponent = NULL; // don't release 788 789 OSKextLog(/* kext */ NULL, 790 kOSKextLogStepLevel | 791 kOSKextLogLoadFlag, 792 "Loading Kernel External Components."); 793 794 extensionsDict = OSKext::copyKexts(); 795 if (!extensionsDict) { 796 return; 797 } 798 799 keyIterator = OSCollectionIterator::withCollection(extensionsDict); 800 if (!keyIterator) { 801 OSKextLog(/* kext */ NULL, 802 kOSKextLogErrorLevel | 803 kOSKextLogGeneralFlag, 804 "Failed to allocate iterator for Kernel External Components."); 805 goto finish; 806 } 807 808 while ((bundleID = OSDynamicCast(OSString, keyIterator->getNextObject()))) { 809 810 const char * bundle_id = bundleID->getCStringNoCopy(); 811 812 /* Skip extensions whose bundle IDs don't start with "com.apple.kec.". 813 */ 814 if (!bundle_id || 815 (strncmp(bundle_id, COM_APPLE_KEC, CONST_STRLEN(COM_APPLE_KEC)) != 0)) { 816 817 continue; 818 } 819 820 theKext = OSDynamicCast(OSKext, extensionsDict->getObject(bundleID)); 821 if (!theKext) { 822 continue; 823 } 824 825 isKernelExternalComponent = OSDynamicCast(OSBoolean, 826 theKext->getPropertyForHostArch(kAppleKernelExternalComponentKey)); 827 if (isKernelExternalComponent && isKernelExternalComponent->isTrue()) { 828 OSKextLog(/* kext */ NULL, 829 kOSKextLogStepLevel | 830 kOSKextLogLoadFlag, 831 "Loading kernel external component %s.", bundleID->getCStringNoCopy()); 832 OSKext::loadKextWithIdentifier(bundleID->getCStringNoCopy(), 833 /* allowDefer */ false); 834 } 835 } 836 837 finish: 838 OSSafeRelease(keyIterator); 839 OSSafeRelease(extensionsDict); 840 841 return; 842 } 843 844 /********************************************************************* 845 *********************************************************************/ 846 void 847 KLDBootstrap::readBuiltinPersonalities(void) 848 { 849 OSObject * parsedXML = NULL; // must release 850 OSArray * builtinExtensions = NULL; // do not release 851 OSArray * allPersonalities = NULL; // must release 852 OSString * errorString = NULL; // must release 853 kernel_section_t * infosect = NULL; // do not free 854 OSCollectionIterator * personalitiesIterator = NULL; // must release 855 unsigned int count, i; 856 857 OSKextLog(/* kext */ NULL, 858 kOSKextLogStepLevel | 859 kOSKextLogLoadFlag, 860 "Reading built-in kernel personalities for I/O Kit drivers."); 861 862 /* Look in the __BUILTIN __info segment for an array of Info.plist 863 * entries. For each one, extract the personalities dictionary, add 864 * it to our array, then push them all (without matching) to 865 * the IOCatalogue. This can be used to augment the personalities 866 * in gIOKernelConfigTables, especially when linking entire kexts into 867 * the mach_kernel image. 868 */ 869 infosect = getsectbyname("__BUILTIN", "__info"); 870 if (!infosect) { 871 // this isn't fatal 872 goto finish; 873 } 874 875 parsedXML = OSUnserializeXML((const char *) (uintptr_t)infosect->addr, 876 &errorString); 877 if (parsedXML) { 878 builtinExtensions = OSDynamicCast(OSArray, parsedXML); 879 } 880 if (!builtinExtensions) { 881 const char * errorCString = "(unknown error)"; 882 883 if (errorString && errorString->getCStringNoCopy()) { 884 errorCString = errorString->getCStringNoCopy(); 885 } else if (parsedXML) { 886 errorCString = "not an array"; 887 } 888 OSKextLog(/* kext */ NULL, 889 kOSKextLogErrorLevel | 890 kOSKextLogLoadFlag, 891 "Error unserializing built-in personalities: %s.", errorCString); 892 goto finish; 893 } 894 895 // estimate 3 personalities per Info.plist/kext 896 count = builtinExtensions->getCount(); 897 allPersonalities = OSArray::withCapacity(count * 3); 898 899 for (i = 0; i < count; i++) { 900 OSDictionary * infoDict = NULL; // do not release 901 OSString * moduleName = NULL; // do not release 902 OSDictionary * personalities; // do not release 903 OSString * personalityName; // do not release 904 905 OSSafeReleaseNULL(personalitiesIterator); 906 907 infoDict = OSDynamicCast(OSDictionary, 908 builtinExtensions->getObject(i)); 909 if (!infoDict) { 910 continue; 911 } 912 913 moduleName = OSDynamicCast(OSString, 914 infoDict->getObject(kCFBundleIdentifierKey)); 915 if (!moduleName) { 916 continue; 917 } 918 919 OSKextLog(/* kext */ NULL, 920 kOSKextLogStepLevel | 921 kOSKextLogLoadFlag, 922 "Adding personalities for built-in driver %s:", 923 moduleName->getCStringNoCopy()); 924 925 personalities = OSDynamicCast(OSDictionary, 926 infoDict->getObject("IOKitPersonalities")); 927 if (!personalities) { 928 continue; 929 } 930 931 personalitiesIterator = OSCollectionIterator::withCollection(personalities); 932 if (!personalitiesIterator) { 933 continue; // xxx - well really, what can we do? should we panic? 934 } 935 936 while ((personalityName = OSDynamicCast(OSString, 937 personalitiesIterator->getNextObject()))) { 938 939 OSDictionary * personality = OSDynamicCast(OSDictionary, 940 personalities->getObject(personalityName)); 941 942 OSKextLog(/* kext */ NULL, 943 kOSKextLogDetailLevel | 944 kOSKextLogLoadFlag, 945 "Adding built-in driver personality %s.", 946 personalityName->getCStringNoCopy()); 947 948 if (personality && !personality->getObject(kCFBundleIdentifierKey)) { 949 personality->setObject(kCFBundleIdentifierKey, moduleName); 950 } 951 allPersonalities->setObject(personality); 952 } 953 } 954 955 gIOCatalogue->addDrivers(allPersonalities, false); 956 957 finish: 958 OSSafeRelease(parsedXML); 959 OSSafeRelease(allPersonalities); 960 OSSafeRelease(errorString); 961 OSSafeRelease(personalitiesIterator); 962 return; 963 } 964 965 #if PRAGMA_MARK 966 #pragma mark Bootstrap Functions 967 #endif 968 /********************************************************************* 969 * Bootstrap Functions 970 *********************************************************************/ 971 static void bootstrapRecordStartupExtensions(void) 972 { 973 sBootstrapObject.readStartupExtensions(); 974 return; 975 } 976 977 static void bootstrapLoadSecurityExtensions(void) 978 { 979 sBootstrapObject.loadSecurityExtensions(); 980 return; 981 } 982 983