]> git.saurik.com Git - apple/xnu.git/blobdiff - iokit/Kernel/IOService.cpp
projects / apple / xnu.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
xnu-3789.31.2.tar.gz
[apple/xnu.git] / iokit / Kernel / IOService.cpp
diff --git a/iokit/Kernel/IOService.cpp b/iokit/Kernel/IOService.cpp
index a23e683ec9a0a1824e0bc8f819f3e2d1d6e82f63..440b5c589e6ae26ab33a18098a2e85e88ab8cc31 100644 (file)
--- a/iokit/Kernel/IOService.cpp
+++ b/iokit/Kernel/IOService.cpp
@@ -1,5 +1,5 @@
 /*
 /*
- * Copyright (c) 1998-2014 Apple Inc. All rights reserved.
+ * Copyright (c) 1998-2016 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
@@ -50,9 +50,13 @@
 #include <IOKit/IOHibernatePrivate.h>
 #include <IOKit/IOInterruptAccountingPrivate.h>
 #include <IOKit/IOKernelReporters.h>
 #include <IOKit/IOHibernatePrivate.h>
 #include <IOKit/IOInterruptAccountingPrivate.h>
 #include <IOKit/IOKernelReporters.h>
+#include <IOKit/AppleKeyStoreInterface.h>
+#include <IOKit/IOCPU.h>
 #include <mach/sync_policy.h>
 #include <IOKit/assert.h>
 #include <sys/errno.h>
 #include <mach/sync_policy.h>
 #include <IOKit/assert.h>
 #include <sys/errno.h>
+#include <sys/kdebug.h>
+#include <string.h>
 
 #include <machine/pal_routines.h>
 
 
 #include <machine/pal_routines.h>
 
@@ -73,6 +77,7 @@
 OSDefineMetaClassAndStructors(IOService, IORegistryEntry)
 
 OSDefineMetaClassAndStructors(_IOServiceNotifier, IONotifier)
 OSDefineMetaClassAndStructors(IOService, IORegistryEntry)
 
 OSDefineMetaClassAndStructors(_IOServiceNotifier, IONotifier)
+OSDefineMetaClassAndStructors(_IOServiceNullNotifier, IONotifier)
 
 OSDefineMetaClassAndStructors(_IOServiceInterestNotifier, IONotifier)
 
 
 OSDefineMetaClassAndStructors(_IOServiceInterestNotifier, IONotifier)
 
@@ -98,10 +103,12 @@ const OSSymbol *           gIOInterruptSpecifiersKey;
 
 const OSSymbol *               gIOResourcesKey;
 const OSSymbol *               gIOResourceMatchKey;
 
 const OSSymbol *               gIOResourcesKey;
 const OSSymbol *               gIOResourceMatchKey;
+const OSSymbol *               gIOResourceMatchedKey;
 const OSSymbol *               gIOProviderClassKey;
 const OSSymbol *               gIONameMatchKey;
 const OSSymbol *               gIONameMatchedKey;
 const OSSymbol *               gIOPropertyMatchKey;
 const OSSymbol *               gIOProviderClassKey;
 const OSSymbol *               gIONameMatchKey;
 const OSSymbol *               gIONameMatchedKey;
 const OSSymbol *               gIOPropertyMatchKey;
+const OSSymbol *               gIOPropertyExistsMatchKey;
 const OSSymbol *               gIOLocationMatchKey;
 const OSSymbol *               gIOParentMatchKey;
 const OSSymbol *               gIOPathMatchKey;
 const OSSymbol *               gIOLocationMatchKey;
 const OSSymbol *               gIOParentMatchKey;
 const OSSymbol *               gIOPathMatchKey;
@@ -124,10 +131,11 @@ const OSSymbol *          gIOConsoleSessionOnConsoleKey;
 const OSSymbol *               gIOConsoleSessionLoginDoneKey;
 const OSSymbol *               gIOConsoleSessionSecureInputPIDKey;
 const OSSymbol *               gIOConsoleSessionScreenLockedTimeKey;
 const OSSymbol *               gIOConsoleSessionLoginDoneKey;
 const OSSymbol *               gIOConsoleSessionSecureInputPIDKey;
 const OSSymbol *               gIOConsoleSessionScreenLockedTimeKey;
-
+const OSSymbol *               gIOConsoleSessionScreenIsLockedKey;
 clock_sec_t                    gIOConsoleLockTime;
 static bool                    gIOConsoleLoggedIn;
 #if HIBERNATION
 clock_sec_t                    gIOConsoleLockTime;
 static bool                    gIOConsoleLoggedIn;
 #if HIBERNATION
+static OSBoolean *             gIOConsoleBooterLockState;
 static uint32_t                        gIOScreenLockState;
 #endif
 static IORegistryEntry *        gIOChosenEntry;
 static uint32_t                        gIOScreenLockState;
 #endif
 static IORegistryEntry *        gIOChosenEntry;
@@ -147,6 +155,17 @@ const OSSymbol *           gIOAppPowerStateInterest;
 const OSSymbol *               gIOPriorityPowerStateInterest;
 const OSSymbol *               gIOConsoleSecurityInterest;
 
 const OSSymbol *               gIOPriorityPowerStateInterest;
 const OSSymbol *               gIOConsoleSecurityInterest;
 
+const OSSymbol *               gIOBSDKey;
+const OSSymbol *               gIOBSDNameKey;
+const OSSymbol *               gIOBSDMajorKey;
+const OSSymbol *               gIOBSDMinorKey;
+const OSSymbol *               gIOBSDUnitKey;
+
+const  OSSymbol *               gAKSGetKey;
+#if defined(__i386__) || defined(__x86_64__)
+const OSSymbol *                gIOCreateEFIDevicePathSymbol;
+#endif
+
 static OSDictionary *          gNotifications;
 static IORecursiveLock *       gNotificationLock;
 
 static OSDictionary *          gNotifications;
 static IORecursiveLock *       gNotificationLock;
 
@@ -160,6 +179,7 @@ static int                  gOutstandingJobs;
 static int                     gNumConfigThreads;
 static int                     gNumWaitingThreads;
 static IOLock *                        gIOServiceBusyLock;
 static int                     gNumConfigThreads;
 static int                     gNumWaitingThreads;
 static IOLock *                        gIOServiceBusyLock;
+static bool             gCPUsRunning;
 
 static thread_t                        gIOTerminateThread;
 static UInt32                  gIOTerminateWork;
 
 static thread_t                        gIOTerminateThread;
 static UInt32                  gIOTerminateWork;
@@ -173,16 +193,11 @@ static OSData *                   gIOConsoleUsersSeedValue;
 
 extern const OSSymbol *                gIODTPHandleKey;
 
 
 extern const OSSymbol *                gIODTPHandleKey;
 
-const OSSymbol *               gIOPlatformSleepActionKey;
-const OSSymbol *               gIOPlatformWakeActionKey;
-const OSSymbol *               gIOPlatformQuiesceActionKey;
-const OSSymbol *               gIOPlatformActiveActionKey;
-const OSSymbol *               gIOPlatformHaltRestartActionKey;
-
 const OSSymbol *               gIOPlatformFunctionHandlerSet;
 
 static IOLock *                        gIOConsoleUsersLock;
 static thread_call_t           gIOConsoleLockCallout;
 const OSSymbol *               gIOPlatformFunctionHandlerSet;
 
 static IOLock *                        gIOConsoleUsersLock;
 static thread_call_t           gIOConsoleLockCallout;
+static IONotifier *             gIOServiceNullNotifier;
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
@@ -266,6 +281,7 @@ static IORecursiveLock *sCpuDelayLock = IORecursiveLockAlloc();
 static OSArray         *sCpuLatencyHandlers[kCpuNumDelayTypes];
 const OSSymbol         *sCPULatencyFunctionName[kCpuNumDelayTypes];
 static OSNumber * sCPULatencyHolder[kCpuNumDelayTypes];
 static OSArray         *sCpuLatencyHandlers[kCpuNumDelayTypes];
 const OSSymbol         *sCPULatencyFunctionName[kCpuNumDelayTypes];
 static OSNumber * sCPULatencyHolder[kCpuNumDelayTypes];
+static char sCPULatencyHolderName[kCpuNumDelayTypes][128];
 static OSNumber * sCPULatencySet[kCpuNumDelayTypes];
 
 static void
 static OSNumber * sCPULatencySet[kCpuNumDelayTypes];
 
 static void
@@ -288,6 +304,7 @@ void IOService::initialize( void )
     gIONameMatchKey    = OSSymbol::withCStringNoCopy( kIONameMatchKey );
     gIONameMatchedKey  = OSSymbol::withCStringNoCopy( kIONameMatchedKey );
     gIOPropertyMatchKey        = OSSymbol::withCStringNoCopy( kIOPropertyMatchKey );
     gIONameMatchKey    = OSSymbol::withCStringNoCopy( kIONameMatchKey );
     gIONameMatchedKey  = OSSymbol::withCStringNoCopy( kIONameMatchedKey );
     gIOPropertyMatchKey        = OSSymbol::withCStringNoCopy( kIOPropertyMatchKey );
+    gIOPropertyExistsMatchKey = OSSymbol::withCStringNoCopy( kIOPropertyExistsMatchKey );
     gIOPathMatchKey    = OSSymbol::withCStringNoCopy( kIOPathMatchKey );
     gIOLocationMatchKey        = OSSymbol::withCStringNoCopy( kIOLocationMatchKey );
     gIOParentMatchKey  = OSSymbol::withCStringNoCopy( kIOParentMatchKey );
     gIOPathMatchKey    = OSSymbol::withCStringNoCopy( kIOPathMatchKey );
     gIOLocationMatchKey        = OSSymbol::withCStringNoCopy( kIOLocationMatchKey );
     gIOParentMatchKey  = OSSymbol::withCStringNoCopy( kIOParentMatchKey );
@@ -300,8 +317,9 @@ void IOService::initialize( void )
 
     gIOUserClientClassKey = OSSymbol::withCStringNoCopy( kIOUserClientClassKey );
 
 
     gIOUserClientClassKey = OSSymbol::withCStringNoCopy( kIOUserClientClassKey );
 
-    gIOResourcesKey    = OSSymbol::withCStringNoCopy( kIOResourcesClass );
-    gIOResourceMatchKey        = OSSymbol::withCStringNoCopy( kIOResourceMatchKey );
+    gIOResourcesKey      = OSSymbol::withCStringNoCopy( kIOResourcesClass );
+    gIOResourceMatchKey          = OSSymbol::withCStringNoCopy( kIOResourceMatchKey );
+    gIOResourceMatchedKey = OSSymbol::withCStringNoCopy( kIOResourceMatchedKey );
 
     gIODeviceMemoryKey = OSSymbol::withCStringNoCopy( "IODeviceMemory" );
     gIOInterruptControllersKey
 
     gIODeviceMemoryKey = OSSymbol::withCStringNoCopy( "IODeviceMemory" );
     gIOInterruptControllersKey
@@ -321,6 +339,12 @@ void IOService::initialize( void )
     gIOPriorityPowerStateInterest      = OSSymbol::withCStringNoCopy( kIOPriorityPowerStateInterest );
     gIOConsoleSecurityInterest         = OSSymbol::withCStringNoCopy( kIOConsoleSecurityInterest );
 
     gIOPriorityPowerStateInterest      = OSSymbol::withCStringNoCopy( kIOPriorityPowerStateInterest );
     gIOConsoleSecurityInterest         = OSSymbol::withCStringNoCopy( kIOConsoleSecurityInterest );
 
+    gIOBSDKey     = OSSymbol::withCStringNoCopy(kIOBSDKey);
+    gIOBSDNameKey  = OSSymbol::withCStringNoCopy(kIOBSDNameKey);
+    gIOBSDMajorKey = OSSymbol::withCStringNoCopy(kIOBSDMajorKey);
+    gIOBSDMinorKey = OSSymbol::withCStringNoCopy(kIOBSDMinorKey);
+    gIOBSDUnitKey  = OSSymbol::withCStringNoCopy(kIOBSDUnitKey);
+
     gNotifications             = OSDictionary::withCapacity( 1 );
     gIOPublishNotification     = OSSymbol::withCStringNoCopy(
                                                 kIOPublishNotification );
     gNotifications             = OSDictionary::withCapacity( 1 );
     gIOPublishNotification     = OSSymbol::withCStringNoCopy(
                                                 kIOPublishNotification );
@@ -344,14 +368,9 @@ void IOService::initialize( void )
     gIOConsoleSessionLoginDoneKey        = OSSymbol::withCStringNoCopy(kIOConsoleSessionLoginDoneKey);
     gIOConsoleSessionSecureInputPIDKey   = OSSymbol::withCStringNoCopy(kIOConsoleSessionSecureInputPIDKey);
     gIOConsoleSessionScreenLockedTimeKey = OSSymbol::withCStringNoCopy(kIOConsoleSessionScreenLockedTimeKey);
     gIOConsoleSessionLoginDoneKey        = OSSymbol::withCStringNoCopy(kIOConsoleSessionLoginDoneKey);
     gIOConsoleSessionSecureInputPIDKey   = OSSymbol::withCStringNoCopy(kIOConsoleSessionSecureInputPIDKey);
     gIOConsoleSessionScreenLockedTimeKey = OSSymbol::withCStringNoCopy(kIOConsoleSessionScreenLockedTimeKey);
+    gIOConsoleSessionScreenIsLockedKey   = OSSymbol::withCStringNoCopy(kIOConsoleSessionScreenIsLockedKey);
 
     gIOConsoleUsersSeedValue          = OSData::withBytesNoCopy(&gIOConsoleUsersSeed, sizeof(gIOConsoleUsersSeed));
 
     gIOConsoleUsersSeedValue          = OSData::withBytesNoCopy(&gIOConsoleUsersSeed, sizeof(gIOConsoleUsersSeed));
-       
-    gIOPlatformSleepActionKey      = OSSymbol::withCStringNoCopy(kIOPlatformSleepActionKey);
-    gIOPlatformWakeActionKey       = OSSymbol::withCStringNoCopy(kIOPlatformWakeActionKey);
-    gIOPlatformQuiesceActionKey            = OSSymbol::withCStringNoCopy(kIOPlatformQuiesceActionKey);
-    gIOPlatformActiveActionKey     = OSSymbol::withCStringNoCopy(kIOPlatformActiveActionKey);
-    gIOPlatformHaltRestartActionKey = OSSymbol::withCStringNoCopy(kIOPlatformHaltRestartActionKey);
 
     gIOPlatformFunctionHandlerSet              = OSSymbol::withCStringNoCopy(kIOPlatformFunctionHandlerSet);
 #if defined(__i386__) || defined(__x86_64__)
 
     gIOPlatformFunctionHandlerSet              = OSSymbol::withCStringNoCopy(kIOPlatformFunctionHandlerSet);
 #if defined(__i386__) || defined(__x86_64__)
@@ -364,9 +383,12 @@ void IOService::initialize( void )
        sCPULatencyHolder[idx] = OSNumber::withNumber(0ULL, 64);
         assert(sCPULatencySet[idx] && sCPULatencyHolder[idx]);
     }
        sCPULatencyHolder[idx] = OSNumber::withNumber(0ULL, 64);
         assert(sCPULatencySet[idx] && sCPULatencyHolder[idx]);
     }
+    gIOCreateEFIDevicePathSymbol = OSSymbol::withCString("CreateEFIDevicePath");
 #endif
     gNotificationLock          = IORecursiveLockAlloc();
 
 #endif
     gNotificationLock          = IORecursiveLockAlloc();
 
+    gAKSGetKey                   = OSSymbol::withCStringNoCopy(AKS_PLATFORM_FUNCTION_GETKEY);
+
     assert( gIOServicePlane && gIODeviceMemoryKey
         && gIOInterruptControllersKey && gIOInterruptSpecifiersKey
         && gIOResourcesKey && gNotifications && gNotificationLock
     assert( gIOServicePlane && gIODeviceMemoryKey
         && gIOInterruptControllersKey && gIOInterruptSpecifiersKey
         && gIOResourcesKey && gNotifications && gNotificationLock
@@ -397,6 +419,9 @@ void IOService::initialize( void )
     gIOResources = IOResources::resources();
     assert( gIOResources );
 
     gIOResources = IOResources::resources();
     assert( gIOResources );
 
+    gIOServiceNullNotifier = OSTypeAlloc(_IOServiceNullNotifier);
+    assert(gIOServiceNullNotifier);
+
     gArbitrationLockQueueLock = IOLockAlloc();
     queue_init(&gArbitrationLockQueueActive);
     queue_init(&gArbitrationLockQueueWaiting);
     gArbitrationLockQueueLock = IOLockAlloc();
     queue_init(&gArbitrationLockQueueActive);
     queue_init(&gArbitrationLockQueueWaiting);
@@ -413,6 +438,17 @@ void IOService::initialize( void )
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
+#if defined(__i386__) || defined(__x86_64__)
+extern "C" {
+
+const char *getCpuDelayBusStallHolderName(void);
+const char *getCpuDelayBusStallHolderName(void) {
+    return sCPULatencyHolderName[kCpuDelayBusStall];
+}
+
+}
+#endif
+
 #if IOMATCHDEBUG
 static UInt64 getDebugFlags( OSDictionary * props )
 {
 #if IOMATCHDEBUG
 static UInt64 getDebugFlags( OSDictionary * props )
 {
@@ -453,20 +489,14 @@ void IOService::stop( IOService * provider )
 
 bool IOService::init( OSDictionary * dictionary )
 {
 
 bool IOService::init( OSDictionary * dictionary )
 {
-    bool ret = false;
+    bool ret;
 
     ret = super::init(dictionary);
 
     ret = super::init(dictionary);
-
-    if (!ret)
-        goto done;
+    if (!ret)     return (false);
+    if (reserved) return (true);
 
     reserved = IONew(ExpansionData, 1);
 
     reserved = IONew(ExpansionData, 1);
-
-    if (!reserved) {
-        ret = false;
-        goto done;
-    }
-
+    if (!reserved) return (false);
     bzero(reserved, sizeof(*reserved));
 
     /*
     bzero(reserved, sizeof(*reserved));
 
     /*
@@ -480,33 +510,22 @@ bool IOService::init( OSDictionary * dictionary )
      * which should be unlikely).
      */
     reserved->interruptStatisticsLock = IOLockAlloc(); 
      * which should be unlikely).
      */
     reserved->interruptStatisticsLock = IOLockAlloc(); 
+    if (!reserved->interruptStatisticsLock) return (false);
 
 
-    if (!reserved->interruptStatisticsLock) {
-        ret = false;
-        goto done;
-    }
-
-done:
-    return ret;
+    return (true);
 }
 
 bool IOService::init( IORegistryEntry * from,
                       const IORegistryPlane * inPlane )
 {
 }
 
 bool IOService::init( IORegistryEntry * from,
                       const IORegistryPlane * inPlane )
 {
-    bool ret = false;
+    bool ret;
 
     ret = super::init(from, inPlane);
 
     ret = super::init(from, inPlane);
-
-    if (!ret)
-        goto done;
+    if (!ret)     return (false);
+    if (reserved) return (true);
 
     reserved = IONew(ExpansionData, 1);
 
     reserved = IONew(ExpansionData, 1);
-
-    if (!reserved) {
-        ret = false;
-        goto done;
-    }
-
+    if (!reserved) return (false);
     bzero(reserved, sizeof(*reserved));
 
     /*
     bzero(reserved, sizeof(*reserved));
 
     /*
@@ -520,14 +539,9 @@ bool IOService::init( IORegistryEntry * from,
      * which should be unlikely).
      */
     reserved->interruptStatisticsLock = IOLockAlloc(); 
      * which should be unlikely).
      */
     reserved->interruptStatisticsLock = IOLockAlloc(); 
+    if (!reserved->interruptStatisticsLock) return (false);
 
 
-    if (!reserved->interruptStatisticsLock) {
-        ret = false;
-        goto done;
-    }
-
-done:
-    return ret;
+    return (true);
 }
 
 void IOService::free( void )
 }
 
 void IOService::free( void )
@@ -554,6 +568,12 @@ void IOService::free( void )
         IODelete(reserved, ExpansionData, 1);
     }
 
         IODelete(reserved, ExpansionData, 1);
     }
 
+    if (_numInterruptSources && _interruptSources)
+    {
+       IOFree(_interruptSources, _numInterruptSources * sizeof(IOInterruptSource));
+       _interruptSources = 0;
+    }
+
     super::free();
 }
 
     super::free();
 }
 
@@ -562,7 +582,11 @@ void IOService::free( void )
  */
 bool IOService::attach( IOService * provider )
 {
  */
 bool IOService::attach( IOService * provider )
 {
-    bool       ok;
+    bool         ok;
+    uint32_t     count;
+    AbsoluteTime deadline;
+    int                 waitResult = THREAD_AWAKENED;
+    bool        wait, computeDeadline = true;
 
     if( provider) {
 
 
     if( provider) {
 
@@ -570,12 +594,39 @@ bool IOService::attach( IOService * provider )
             LOG( "%s::attach(%s)\n", getName(),
                     provider->getName());
 
             LOG( "%s::attach(%s)\n", getName(),
                     provider->getName());
 
-        provider->lockForArbitration();
-        if( provider->__state[0] & kIOServiceInactiveState)
-            ok = false;
-        else
-            ok = attachToParent( provider, gIOServicePlane);
-        provider->unlockForArbitration();
+       ok   = false;
+       do
+       {
+            wait = false;
+           provider->lockForArbitration();
+           if (provider->__state[0] & kIOServiceInactiveState) ok = false;
+           else
+           {
+               count = provider->getChildCount(gIOServicePlane);
+               wait = (count > (kIOServiceBusyMax - 4));
+               if (!wait) ok = attachToParent(provider, gIOServicePlane);
+               else
+               {
+                   IOLog("stalling for detach from %s\n", provider->getName());
+                   IOLockLock( gIOServiceBusyLock );
+                   provider->__state[1] |= kIOServiceWaitDetachState;
+               }
+           }
+           provider->unlockForArbitration();
+           if (wait)
+           {
+                if (computeDeadline)
+                {
+                    clock_interval_to_deadline(15, kSecondScale, &deadline);
+                    computeDeadline = false;
+                }
+                assert_wait_deadline((event_t)&provider->__provider, THREAD_UNINT, deadline);
+                IOLockUnlock( gIOServiceBusyLock );
+               waitResult = thread_block(THREAD_CONTINUE_NULL);
+               wait = (waitResult != THREAD_TIMED_OUT);
+           }
+       }
+       while (wait);
 
     } else {
        gIOServiceRoot = this;
 
     } else {
        gIOServiceRoot = this;
@@ -603,6 +654,15 @@ void IOService::detach( IOService * provider )
 
     lockForArbitration();
 
 
     lockForArbitration();
 
+    uint64_t regID1 = provider->getRegistryEntryID();
+    uint64_t regID2 = getRegistryEntryID();
+    IOServiceTrace(
+       IOSERVICE_DETACH,
+       (uintptr_t) regID1,
+       (uintptr_t) (regID1 >> 32),
+       (uintptr_t) regID2,
+       (uintptr_t) (regID2 >> 32));
+
     adjParent = ((busy = (__state[1] & kIOServiceBusyStateMask))
                && (provider == getProvider()));
 
     adjParent = ((busy = (__state[1] & kIOServiceBusyStateMask))
                && (provider == getProvider()));
 
@@ -616,6 +676,7 @@ void IOService::detach( IOService * provider )
 
     if (kIOServiceInactiveState & __state[0]) {
        getMetaClass()->removeInstance(this);
 
     if (kIOServiceInactiveState & __state[0]) {
        getMetaClass()->removeInstance(this);
+       IORemoveServicePlatformActions(this);
     }
 
     unlockForArbitration();
     }
 
     unlockForArbitration();
@@ -636,8 +697,17 @@ void IOService::detach( IOService * provider )
         if( adjParent) provider->_adjustBusy( -1 );
         if( (provider->__state[1] & kIOServiceTermPhase3State)
          && (0 == provider->getClient())) {
         if( adjParent) provider->_adjustBusy( -1 );
         if( (provider->__state[1] & kIOServiceTermPhase3State)
          && (0 == provider->getClient())) {
-            provider->scheduleFinalize();
+            provider->scheduleFinalize(false);
         }
         }
+
+        IOLockLock( gIOServiceBusyLock );
+       if (kIOServiceWaitDetachState & provider->__state[1])
+       {
+           provider->__state[1] &= ~kIOServiceWaitDetachState;
+           thread_wakeup(&provider->__provider);
+       }
+        IOLockUnlock( gIOServiceBusyLock );
+
         provider->unlockForArbitration();
     }
 }
         provider->unlockForArbitration();
     }
 }
@@ -669,6 +739,8 @@ void IOService::registerService( IOOptionBits options )
     if( gIOPlatform && (!gIOPlatform->platformAdjustService(this)))
        return;
 
     if( gIOPlatform && (!gIOPlatform->platformAdjustService(this)))
        return;
 
+    IOInstallServicePlatformActions(this);
+
     if( (this != gIOResources)
      && (kIOLogRegister & gIOKitDebug)) {
 
     if( (this != gIOResources)
      && (kIOLogRegister & gIOKitDebug)) {
 
@@ -890,7 +962,7 @@ IOService * IOService::getProvider( void ) const
     IOService *        parent;
     SInt32     generation;
 
     IOService *        parent;
     SInt32     generation;
 
-    generation = getGenerationCount();
+    generation = getRegistryEntryGenerationCount();
     if( __providerGeneration == generation)
        return( __provider );
 
     if( __providerGeneration == generation)
        return( __provider );
 
@@ -1686,15 +1758,18 @@ IOReturn IOService::registerInterestForNotifer( IONotifier *svcNotify, const OSS
         LOCKWRITENOTIFY();
 
         // Get the head of the notifier linked list
         LOCKWRITENOTIFY();
 
         // Get the head of the notifier linked list
-        IOCommand *notifyList = (IOCommand *) getProperty( typeOfInterest );
-        if (!notifyList || !OSDynamicCast(IOCommand, notifyList)) {
+        IOCommand * notifyList;
+        OSObject  * obj = copyProperty( typeOfInterest );
+        if (!(notifyList = OSDynamicCast(IOCommand, obj))) {
             notifyList = OSTypeAlloc(IOCommand);
             if (notifyList) {
                 notifyList->init();
             notifyList = OSTypeAlloc(IOCommand);
             if (notifyList) {
                 notifyList->init();
-                setProperty( typeOfInterest, notifyList);
+                bool ok = setProperty( typeOfInterest, notifyList);
                 notifyList->release();
                 notifyList->release();
+                if (!ok) notifyList = 0;
             }
         }
             }
         }
+        if (obj) obj->release();
 
         if (notifyList) {
             enqueue(&notifyList->fCommandChain, &notify->chain);
 
         if (notifyList) {
             enqueue(&notifyList->fCommandChain, &notify->chain);
@@ -1858,7 +1933,7 @@ bool IOService::requestTerminate( IOService * provider, IOOptionBits options )
     // -- compat
     if( ok) {
         provider->terminateClient( this, options | kIOServiceRecursing );
     // -- compat
     if( ok) {
         provider->terminateClient( this, options | kIOServiceRecursing );
-        ok = (0 != (__state[1] & kIOServiceRecursing));
+        ok = (0 != (kIOServiceInactiveState & __state[0]));
     }
     // --
 
     }
     // --
 
@@ -1871,8 +1946,9 @@ bool IOService::terminatePhase1( IOOptionBits options )
     IOService *         client;
     OSIterator * iter;
     OSArray *   makeInactive;
     IOService *         client;
     OSIterator * iter;
     OSArray *   makeInactive;
-       int          waitResult = THREAD_AWAKENED;
-       bool         wait;
+    OSArray *   waitingInactive;
+    int          waitResult = THREAD_AWAKENED;
+    bool         wait;
     bool                ok;
     bool                didInactive;
     bool                startPhase2 = false;
     bool                ok;
     bool                didInactive;
     bool                startPhase2 = false;
@@ -1890,70 +1966,86 @@ bool IOService::terminatePhase1( IOOptionBits options )
     // -- compat
     if( options & kIOServiceRecursing) {
         lockForArbitration();
     // -- compat
     if( options & kIOServiceRecursing) {
         lockForArbitration();
-       __state[0] |= kIOServiceInactiveState;
-        __state[1] |= kIOServiceRecursing;
+       if (0 == (kIOServiceInactiveState & __state[0]))
+       {
+           __state[0] |= kIOServiceInactiveState;
+           __state[1] |= kIOServiceRecursing | kIOServiceTermPhase1State;
+       }
         unlockForArbitration();
 
         return( true );
     }
     // -- 
 
         unlockForArbitration();
 
         return( true );
     }
     // -- 
 
-    makeInactive = OSArray::withCapacity( 16 );
-    if( !makeInactive)
-        return( false );
+    makeInactive    = OSArray::withCapacity( 16 );
+    waitingInactive = OSArray::withCapacity( 16 );
+    if(!makeInactive || !waitingInactive) return( false );
 
     victim = this;
     victim->retain();
 
 
     victim = this;
     victim->retain();
 
-    while( victim ) {
-
+    while( victim )
+    {
        didInactive = victim->lockForArbitration( true );
        didInactive = victim->lockForArbitration( true );
-        if( didInactive) {
-            didInactive = (0 == (victim->__state[0] & kIOServiceInactiveState))
-                        || (victim->__state[1] & kIOServiceRecursing);
-            if( didInactive) {
-                victim->__state[0] |= kIOServiceInactiveState;
-                victim->__state[0] &= ~(kIOServiceRegisteredState | kIOServiceMatchedState
-                                        | kIOServiceFirstPublishState | kIOServiceFirstMatchState);
-                victim->__state[1] &= ~kIOServiceRecursing;
+        if( didInactive)
+        {
+           uint64_t regID1 = victim->getRegistryEntryID();
+           IOServiceTrace(IOSERVICE_TERM_SET_INACTIVE,
+               (uintptr_t) regID1, 
+               (uintptr_t) (regID1 >> 32),
+               (uintptr_t) victim->__state[1], 
+               (uintptr_t) 0);
 
 
+           enum { kRP1 = kIOServiceRecursing | kIOServiceTermPhase1State };
+            didInactive = (kRP1 == (victim->__state[1] & kRP1))
+                        || (0 == (victim->__state[0] & kIOServiceInactiveState));
+
+           if (!didInactive)
+           {
+               // a multiply attached IOService can be visited twice
+               if (-1U == waitingInactive->getNextIndexOfObject(victim, 0)) do
+               {
+                   IOLockLock(gIOServiceBusyLock);
+                   wait = (victim->__state[1] & kIOServiceTermPhase1State);
+                   if( wait) {
+                       TLOG("%s[0x%qx]::waitPhase1(%s[0x%qx])\n", 
+                           getName(), getRegistryEntryID(), victim->getName(), victim->getRegistryEntryID());
+                       victim->__state[1] |= kIOServiceTerm1WaiterState;
+                       victim->unlockForArbitration();
+                       assert_wait((event_t)&victim->__state[1], THREAD_UNINT);
+                   }
+                   IOLockUnlock(gIOServiceBusyLock);
+                   if( wait) {
+                       waitResult = thread_block(THREAD_CONTINUE_NULL);
+                       TLOG("%s[0x%qx]::did waitPhase1(%s[0x%qx])\n", 
+                           getName(), getRegistryEntryID(), victim->getName(), victim->getRegistryEntryID());
+                       victim->lockForArbitration();
+                   }
+               }
+               while (wait && (waitResult != THREAD_TIMED_OUT));
+           }
+           else
+           {
+               victim->__state[0] |= kIOServiceInactiveState;
+               victim->__state[0] &= ~(kIOServiceRegisteredState | kIOServiceMatchedState
+                                       | kIOServiceFirstPublishState | kIOServiceFirstMatchState);
+               victim->__state[1] &= ~kIOServiceRecursing;
+               victim->__state[1] |= kIOServiceTermPhase1State;
+               waitingInactive->headQ(victim);
                if (victim == this)
                {
                if (victim == this)
                {
-                   victim->__state[1] |= kIOServiceTermPhase1State;
                    if (kIOServiceTerminateNeedWillTerminate & options)
                    {
                        victim->__state[1] |= kIOServiceNeedWillTerminate;
                    }
                }
                    if (kIOServiceTerminateNeedWillTerminate & options)
                    {
                        victim->__state[1] |= kIOServiceNeedWillTerminate;
                    }
                }
-
-                victim->_adjustBusy( 1 );
-
-            } else if (victim != this) do {
-
-               IOLockLock(gIOServiceBusyLock);
-               wait = (victim->__state[1] & kIOServiceTermPhase1State);
-               if( wait) {
-                   TLOG("%s[0x%qx]::waitPhase1(%s[0x%qx])\n", 
-                       getName(), getRegistryEntryID(), victim->getName(), victim->getRegistryEntryID());
-                       victim->__state[1] |= kIOServiceTerm1WaiterState;
-                       victim->unlockForArbitration();
-                       assert_wait((event_t)&victim->__state[1], THREAD_UNINT);
-               }
-               IOLockUnlock(gIOServiceBusyLock);
-               if( wait) {
-                   waitResult = thread_block(THREAD_CONTINUE_NULL);
-                   TLOG("%s[0x%qx]::did waitPhase1(%s[0x%qx])\n", 
-                       getName(), getRegistryEntryID(), victim->getName(), victim->getRegistryEntryID());
-                       victim->lockForArbitration();
-               }
-           } while( wait && (waitResult != THREAD_TIMED_OUT));
-
+               victim->_adjustBusy( 1 );
+           }
            victim->unlockForArbitration();
         }
            victim->unlockForArbitration();
         }
-        if( victim == this)
-            startPhase2 = didInactive;
-        if( didInactive) {
-
+        if( victim == this) startPhase2 = didInactive;
+        if (didInactive)
+        {
             victim->deliverNotification( gIOTerminatedNotification, 0, 0xffffffff );
             IOUserClient::destroyUserReferences( victim );
 
             victim->deliverNotification( gIOTerminatedNotification, 0, 0xffffffff );
             IOUserClient::destroyUserReferences( victim );
 
@@ -1991,23 +2083,35 @@ bool IOService::terminatePhase1( IOOptionBits options )
             makeInactive->removeObject(0);
         }
     }
             makeInactive->removeObject(0);
         }
     }
-
     makeInactive->release();
 
     makeInactive->release();
 
-    if( startPhase2)
+    while ((victim = (IOService *) waitingInactive->getObject(0)))
     {
     {
-       lockForArbitration();
-       __state[1] &= ~kIOServiceTermPhase1State;
-       if (kIOServiceTerm1WaiterState & __state[1])
+       victim->retain();
+       waitingInactive->removeObject(0);
+
+       victim->lockForArbitration();
+       victim->__state[1] &= ~kIOServiceTermPhase1State;
+       if (kIOServiceTerm1WaiterState & victim->__state[1])
        {
        {
-           __state[1] &= ~kIOServiceTerm1WaiterState;
-           TLOG("%s[0x%qx]::wakePhase1\n", getName(), getRegistryEntryID());
+           victim->__state[1] &= ~kIOServiceTerm1WaiterState;
+           TLOG("%s[0x%qx]::wakePhase1\n", victim->getName(), victim->getRegistryEntryID());
            IOLockLock( gIOServiceBusyLock );
            IOLockLock( gIOServiceBusyLock );
-           thread_wakeup( (event_t) &__state[1]);
+           thread_wakeup( (event_t) &victim->__state[1]);
            IOLockUnlock( gIOServiceBusyLock );
        }
            IOLockUnlock( gIOServiceBusyLock );
        }
+       victim->unlockForArbitration();
+        victim->release();
+    }
+    waitingInactive->release();
+
+    if( startPhase2)
+    {
+        retain();
+       lockForArbitration();
+       scheduleTerminatePhase2(options);
        unlockForArbitration();
        unlockForArbitration();
-       scheduleTerminatePhase2( options );
+        release();
     }
 
     return( true );
     }
 
     return( true );
@@ -2032,16 +2136,25 @@ void IOService::setTerminateDefer(IOService * provider, bool defer)
 void IOService::scheduleTerminatePhase2( IOOptionBits options )
 {
     AbsoluteTime       deadline;
 void IOService::scheduleTerminatePhase2( IOOptionBits options )
 {
     AbsoluteTime       deadline;
+    uint64_t           regID1;
     int                        waitResult = THREAD_AWAKENED;
     bool               wait, haveDeadline = false;
 
     int                        waitResult = THREAD_AWAKENED;
     bool               wait, haveDeadline = false;
 
-    if (!(__state[0] & kIOServiceInactiveState)
-      || (__state[1] & kIOServiceTermPhase1State))             return;
+    if (!(__state[0] & kIOServiceInactiveState)) return;
 
 
-    options |= kIOServiceRequired;
+    regID1 = getRegistryEntryID();
+    IOServiceTrace(
+       IOSERVICE_TERM_SCHED_PHASE2,
+       (uintptr_t) regID1,
+       (uintptr_t) (regID1 >> 32),
+       (uintptr_t) __state[1],
+       (uintptr_t) options);
 
 
-    retain();
+    if (__state[1] & kIOServiceTermPhase1State)                return;
 
 
+    retain();
+    unlockForArbitration();
+    options |= kIOServiceRequired;
     IOLockLock( gJobsLock );
 
     if( (options & kIOServiceSynchronous)
     IOLockLock( gJobsLock );
 
     if( (options & kIOServiceSynchronous)
@@ -2093,7 +2206,7 @@ void IOService::scheduleTerminatePhase2( IOOptionBits options )
     }
 
     IOLockUnlock( gJobsLock );
     }
 
     IOLockUnlock( gJobsLock );
-
+    lockForArbitration();
     release();
 }
 
     release();
 }
 
@@ -2138,7 +2251,7 @@ void IOService::scheduleStop( IOService * provider )
     IOLockUnlock( gJobsLock );
 }
 
     IOLockUnlock( gJobsLock );
 }
 
-void IOService::scheduleFinalize( void )
+void IOService::scheduleFinalize(bool now)
 {
     uint64_t regID1 = getRegistryEntryID();
 
 {
     uint64_t regID1 = getRegistryEntryID();
 
@@ -2149,17 +2262,19 @@ void IOService::scheduleFinalize( void )
        (uintptr_t) (regID1 >> 32),
        0, 0);
 
        (uintptr_t) (regID1 >> 32),
        0, 0);
 
-    IOLockLock( gJobsLock );
-    gIOFinalizeList->tailQ( this );
-
-    if( 0 == gIOTerminateWork++) {
-        if( !gIOTerminateThread)
-           kernel_thread_start(&terminateThread, (void *) 0, &gIOTerminateThread);
-        else
-            IOLockWakeup(gJobsLock, (event_t) &gIOTerminateWork, /* one-thread */ false );
+    if (now || IOUserClient::finalizeUserReferences(this))
+    {
+       IOLockLock( gJobsLock );
+       gIOFinalizeList->tailQ(this);
+       if( 0 == gIOTerminateWork++)
+       {
+           if( !gIOTerminateThread)
+               kernel_thread_start(&terminateThread, (void *) 0, &gIOTerminateThread);
+           else
+               IOLockWakeup(gJobsLock, (event_t) &gIOTerminateWork, /* one-thread */ false );
+       }
+       IOLockUnlock( gJobsLock );
     }
     }
-
-    IOLockUnlock( gJobsLock );
 }
 
 bool IOService::willTerminate( IOService * provider, IOOptionBits options )
 }
 
 bool IOService::willTerminate( IOService * provider, IOOptionBits options )
@@ -2226,7 +2341,7 @@ void IOService::actionDidTerminate( IOService * victim, IOOptionBits options,
 {
     OSIterator * iter;
     IOService *         client;
 {
     OSIterator * iter;
     IOService *         client;
-    bool defer = false;
+    bool         defer;
     uint64_t     regID1, regID2 = victim->getRegistryEntryID();
 
     victim->messageClients( kIOMessageServiceIsTerminated, (void *)(uintptr_t) options );
     uint64_t     regID1, regID2 = victim->getRegistryEntryID();
 
     victim->messageClients( kIOMessageServiceIsTerminated, (void *)(uintptr_t) options );
@@ -2239,6 +2354,7 @@ void IOService::actionDidTerminate( IOService * victim, IOOptionBits options,
             TLOG("%s[0x%qx]::didTerminate(%s[0x%qx], %08llx)\n",
                     client->getName(), regID1, 
                     victim->getName(), regID2, (long long)options);
             TLOG("%s[0x%qx]::didTerminate(%s[0x%qx], %08llx)\n",
                     client->getName(), regID1, 
                     victim->getName(), regID2, (long long)options);
+            defer = false;
             client->didTerminate( victim, options, &defer );
 
            IOServiceTrace(
             client->didTerminate( victim, options, &defer );
 
            IOServiceTrace(
@@ -2394,22 +2510,48 @@ void IOService::terminateWorker( IOOptionBits options )
             gIOTerminatePhase2List->removeObject(0);
             IOLockUnlock( gJobsLock );
 
             gIOTerminatePhase2List->removeObject(0);
             IOLockUnlock( gJobsLock );
 
+           uint64_t regID1 = victim->getRegistryEntryID();
+           IOServiceTrace(
+               IOSERVICE_TERM_START_PHASE2,
+               (uintptr_t) regID1,
+               (uintptr_t) (regID1 >> 32),
+               (uintptr_t) 0,
+               (uintptr_t) 0);
+
             while( victim ) {
         
                 doPhase2 = victim->lockForArbitration( true );
                 if( doPhase2) {
                     doPhase2 = (0 != (kIOServiceInactiveState & victim->__state[0]));
                     if( doPhase2) {
             while( victim ) {
         
                 doPhase2 = victim->lockForArbitration( true );
                 if( doPhase2) {
                     doPhase2 = (0 != (kIOServiceInactiveState & victim->__state[0]));
                     if( doPhase2) {
+
+                       uint64_t regID1 = victim->getRegistryEntryID();
+                       IOServiceTrace(
+                           IOSERVICE_TERM_TRY_PHASE2,
+                           (uintptr_t) regID1,
+                           (uintptr_t) (regID1 >> 32),
+                           (uintptr_t) victim->__state[1],
+                           (uintptr_t) 0);
+
                         doPhase2 = (0 == (victim->__state[1] & kIOServiceTermPhase2State))
                                 && (0 == (victim->__state[1] & kIOServiceConfigState));
 
                        if (doPhase2 && (iter = victim->getClientIterator())) {
                            while (doPhase2 && (client = (IOService *) iter->getNextObject())) {
                                doPhase2 = (0 == (client->__state[1] & kIOServiceStartState));
                         doPhase2 = (0 == (victim->__state[1] & kIOServiceTermPhase2State))
                                 && (0 == (victim->__state[1] & kIOServiceConfigState));
 
                        if (doPhase2 && (iter = victim->getClientIterator())) {
                            while (doPhase2 && (client = (IOService *) iter->getNextObject())) {
                                doPhase2 = (0 == (client->__state[1] & kIOServiceStartState));
-
-                               if (!doPhase2) TLOG("%s[0x%qx]::defer phase2(%s[0x%qx])\n", 
-                                              victim->getName(), victim->getRegistryEntryID(), 
-                                              client->getName(), client->getRegistryEntryID());
+                               if (!doPhase2)
+                               {
+                                   uint64_t regID1 = client->getRegistryEntryID();
+                                   IOServiceTrace(
+                                       IOSERVICE_TERM_UC_DEFER,
+                                       (uintptr_t) regID1,
+                                       (uintptr_t) (regID1 >> 32),
+                                       (uintptr_t) client->__state[1],
+                                       (uintptr_t) 0);
+                                   TLOG("%s[0x%qx]::defer phase2(%s[0x%qx])\n",
+                                          victim->getName(), victim->getRegistryEntryID(),
+                                          client->getName(), client->getRegistryEntryID());
+                               }
                            }
                            iter->release();
                        }
                            }
                            iter->release();
                        }
@@ -2426,10 +2568,10 @@ void IOService::terminateWorker( IOOptionBits options )
                    }
 
                     if( 0 == victim->getClient()) {
                    }
 
                     if( 0 == victim->getClient()) {
+
                         // no clients - will go to finalize
                         // no clients - will go to finalize
-                        IOLockLock( gJobsLock );
-                        gIOFinalizeList->tailQ( victim );
-                        IOLockUnlock( gJobsLock );
+                       victim->scheduleFinalize(false);
+
                     } else {
                         _workLoopAction( (IOWorkLoop::Action) &actionWillTerminate,
                                             victim, (void *)(uintptr_t) options, (void *)(uintptr_t) doPhase2List );
                     } else {
                         _workLoopAction( (IOWorkLoop::Action) &actionWillTerminate,
                                             victim, (void *)(uintptr_t) options, (void *)(uintptr_t) doPhase2List );
@@ -3037,7 +3179,7 @@ void IOService::probeCandidates( OSOrderedSet * matches )
                 // alloc the driver instance
                 inst = (IOService *) OSMetaClass::allocClassWithName( symbol);
     
                 // alloc the driver instance
                 inst = (IOService *) OSMetaClass::allocClassWithName( symbol);
     
-                if( !inst) {
+                if( !inst || !OSDynamicCast(IOService, inst)) {
                     IOLog("Couldn't alloc class \"%s\"\n",
                         symbol->getCStringNoCopy());
                     continue;
                     IOLog("Couldn't alloc class \"%s\"\n",
                         symbol->getCStringNoCopy());
                     continue;
@@ -3396,6 +3538,7 @@ void IOService::doServiceMatch( IOOptionBits options )
     _IOServiceNotifier * notify;
     OSIterator *       iter;
     OSOrderedSet *     matches;
     _IOServiceNotifier * notify;
     OSIterator *       iter;
     OSOrderedSet *     matches;
+    OSArray *           resourceKeys = 0;
     SInt32             catalogGeneration;
     bool               keepGuessing = true;
     bool               reRegistered = true;
     SInt32             catalogGeneration;
     bool               keepGuessing = true;
     bool               reRegistered = true;
@@ -3442,7 +3585,14 @@ void IOService::doServiceMatch( IOOptionBits options )
             unlockForArbitration();
 
             if (keepGuessing && matches->getCount() && (kIOReturnSuccess == getResources()))
             unlockForArbitration();
 
             if (keepGuessing && matches->getCount() && (kIOReturnSuccess == getResources()))
+            {
+                if (this == gIOResources)
+                {
+                   if (resourceKeys) resourceKeys->release();
+                   resourceKeys = copyPropertyKeys();
+                }
                 probeCandidates( matches );
                 probeCandidates( matches );
+            }
             else
                 matches->release();
         }
             else
                 matches->release();
         }
@@ -3460,6 +3610,9 @@ void IOService::doServiceMatch( IOOptionBits options )
 
     if( (0 == (__state[0] & kIOServiceInactiveState))
      && (0 == (__state[1] & kIOServiceModuleStallState)) ) {
 
     if( (0 == (__state[0] & kIOServiceInactiveState))
      && (0 == (__state[1] & kIOServiceModuleStallState)) ) {
+
+        if (resourceKeys) setProperty(gIOResourceMatchedKey, resourceKeys);
+
         deliverNotification( gIOMatchedNotification,
                kIOServiceMatchedState, 0xffffffff );
        if( 0 == (__state[0] & kIOServiceFirstMatchState))
         deliverNotification( gIOMatchedNotification,
                kIOServiceMatchedState, 0xffffffff );
        if( 0 == (__state[0] & kIOServiceFirstMatchState))
@@ -3467,6 +3620,8 @@ void IOService::doServiceMatch( IOOptionBits options )
                kIOServiceFirstMatchState, 0xffffffff );
     }
 
                kIOServiceFirstMatchState, 0xffffffff );
     }
 
+    if (resourceKeys) resourceKeys->release();
+
     __state[1] &= ~kIOServiceConfigState;
     scheduleTerminatePhase2();
 
     __state[1] &= ~kIOServiceConfigState;
     scheduleTerminatePhase2();
 
@@ -3507,9 +3662,9 @@ UInt32 IOService::_adjustBusy( SInt32 delta )
             next->unlockForArbitration();
 
         if( (wasQuiet || nowQuiet) ) {
             next->unlockForArbitration();
 
         if( (wasQuiet || nowQuiet) ) {
-           uint64_t regID = next->getRegistryEntryID();
 
 
-               IOServiceTrace(
+           uint64_t regID = next->getRegistryEntryID();
+           IOServiceTrace(
                ((wasQuiet/*nowBusy*/) ? IOSERVICE_BUSY : IOSERVICE_NONBUSY),
                (uintptr_t) regID, 
                (uintptr_t) (regID >> 32),
                ((wasQuiet/*nowBusy*/) ? IOSERVICE_BUSY : IOSERVICE_NONBUSY),
                (uintptr_t) regID, 
                (uintptr_t) (regID >> 32),
@@ -3630,15 +3785,102 @@ IOReturn IOService::waitForState( UInt32 mask, UInt32 value,
         return( kIOReturnSuccess );
 }
 
         return( kIOReturnSuccess );
 }
 
+#if NO_KEXTD
+#define WAITING_KEXTD     false
+#else
+extern bool gIOKextdClearedBusy;
+#define WAITING_KEXTD     (false == gIOKextdClearedBusy)
+#endif
+
 IOReturn IOService::waitQuiet( uint64_t timeout )
 {
 IOReturn IOService::waitQuiet( uint64_t timeout )
 {
-       IOReturn ret;
-    ret = waitForState( kIOServiceBusyStateMask, 0, timeout );
-       if ((kIOReturnTimeout == ret) && (timeout >= 30000000000) && (kIOWaitQuietPanics & gIOKitDebug))
-       {
-               panic("IOService 0x%llx (%s) busy timeout", getRegistryEntryID(), getName());
-       }
-       return (ret);
+    IOReturn ret;
+    uint32_t loops;
+    char * string = NULL;
+    size_t len;
+    uint64_t time;
+    uint64_t nano;
+
+    time = mach_absolute_time();
+    for (loops = 0; loops < 2; loops++)
+    {
+        ret = waitForState( kIOServiceBusyStateMask, 0, timeout );
+
+        if (loops && (kIOReturnSuccess == ret))
+        {
+            time = mach_absolute_time() - time;
+            absolutetime_to_nanoseconds(*(AbsoluteTime *)&time, &nano);
+            IOLog("busy extended ok[%d], (%llds, %llds), kextd wait(%d): %s\n",
+                  loops, timeout / 1000000000ULL, nano / 1000000000ULL, WAITING_KEXTD,
+                  string ? string : "");
+            break;
+        }
+        else if (kIOReturnTimeout != ret) break;
+        else if (timeout < 41000000000)   break;
+
+        if (!loops)
+        {
+            IORegistryIterator * iter;
+            OSOrderedSet       * set;
+            OSOrderedSet       * leaves;
+            IOService          * next;
+            IOService          * nextParent;
+            char               * s;
+            size_t               l;
+
+            len = 256;
+            string = IONew(char, len);
+            set = NULL;
+            iter = IORegistryIterator::iterateOver(this, gIOServicePlane, kIORegistryIterateRecursively);
+            leaves = OSOrderedSet::withCapacity(4);
+            if (iter) set = iter->iterateAll();
+            if (string && leaves && set)
+            {
+                while ((next = (IOService *) set->getLastObject()))
+                {
+                    if (next->getBusyState())
+                    {
+                        leaves->setObject(next);
+                        nextParent = next;
+                        while ((nextParent = nextParent->getProvider()))
+                        {
+                            set->removeObject(nextParent);
+                            leaves->removeObject(nextParent);
+                        }
+                    }
+                    set->removeObject(next);
+                }
+                s = string;
+                while ((next = (IOService *) leaves->getLastObject()))
+                {
+                    l = snprintf(s, len, "%s'%s'", ((s == string) ? "" : ", "), next->getName());
+                    if (l >= len) break;
+                    s += l;
+                    len -= l;
+                    leaves->removeObject(next);
+                }
+            }
+            OSSafeReleaseNULL(leaves);
+            OSSafeReleaseNULL(set);
+            OSSafeReleaseNULL(iter);
+        }
+        if (loops && (kIOWaitQuietPanics & gIOKitDebug))
+        {
+            panic("busy timeout[%d], (%llds), kextd wait(%d): %s",
+                    loops, timeout / 1000000000ULL, WAITING_KEXTD,
+                    string ? string : "");
+        }
+        else
+        {
+            IOLog("busy timeout[%d], (%llds), kextd wait(%d): %s\n",
+                    loops, timeout / 1000000000ULL, WAITING_KEXTD,
+                    string ? string : "");
+        }
+    }
+
+    if (string) IODelete(string, char, 256);
+
+    return (ret);
 }
 
 IOReturn IOService::waitQuiet( mach_timespec_t * timeout )
 }
 
 IOReturn IOService::waitQuiet( mach_timespec_t * timeout )
@@ -3778,6 +4020,11 @@ IOReturn IOService::waitMatchIdle( UInt32 msToWait )
         return( kIOReturnSuccess );
 }
 
         return( kIOReturnSuccess );
 }
 
+void IOService::cpusRunning(void)
+{
+    gCPUsRunning = true;
+}
+
 void _IOServiceJob::pingConfig( _IOServiceJob * job )
 {
     int                count;
 void _IOServiceJob::pingConfig( _IOServiceJob * job )
 {
     int                count;
@@ -3794,7 +4041,9 @@ void _IOServiceJob::pingConfig( _IOServiceJob * job )
 //    if( gNumConfigThreads) count++;// assume we're called from a config thread
 
     create = (  (gOutstandingJobs > count)
 //    if( gNumConfigThreads) count++;// assume we're called from a config thread
 
     create = (  (gOutstandingJobs > count)
-               && (gNumConfigThreads < kMaxConfigThreads) );
+               && ((gNumConfigThreads < kMaxConfigThreads) 
+            || (job->nub == gIOResources) 
+            || !gCPUsRunning));
     if( create) {
        gNumConfigThreads++;
        gNumWaitingThreads++;
     if( create) {
        gNumConfigThreads++;
        gNumWaitingThreads++;
@@ -4131,9 +4380,12 @@ IONotifier * IOService::doInstallNotification(
     else if( type == gIOFirstPublishNotification)
        inState = kIOServiceFirstPublishState;
 
     else if( type == gIOFirstPublishNotification)
        inState = kIOServiceFirstPublishState;
 
-    else if( (type == gIOMatchedNotification)
-         || (type == gIOFirstMatchNotification))
+    else if (type == gIOMatchedNotification)
        inState = kIOServiceMatchedState;
        inState = kIOServiceMatchedState;
+
+    else if (type == gIOFirstMatchNotification)
+       inState = kIOServiceFirstMatchState;
+
     else if( type == gIOTerminatedNotification)
        inState = 0;
     else
     else if( type == gIOTerminatedNotification)
        inState = 0;
     else
@@ -4187,6 +4439,9 @@ IONotifier * IOService::installNotification(
     notify = doInstallNotification( type, matching, handler, target, ref,
                priority, existing );
 
     notify = doInstallNotification( type, matching, handler, target, ref,
                priority, existing );
 
+    // in case handler remove()s
+    if (notify) notify->retain();
+
     UNLOCKNOTIFY();
 
     return( notify );
     UNLOCKNOTIFY();
 
     return( notify );
@@ -4220,16 +4475,17 @@ IONotifier * IOService::addMatchingNotification(
                        SInt32 priority )
 {
     OSIterator *               existing = NULL;
                        SInt32 priority )
 {
     OSIterator *               existing = NULL;
+    IONotifier *                ret;
     _IOServiceNotifier *       notify;
     IOService *                        next;
 
     _IOServiceNotifier *       notify;
     IOService *                        next;
 
-    notify = (_IOServiceNotifier *) installNotification( type, matching,
+    ret = notify = (_IOServiceNotifier *) installNotification( type, matching,
                handler, target, ref, priority, &existing );
                handler, target, ref, priority, &existing );
+    if (!ret) return (0);
 
     // send notifications for existing set
 
     // send notifications for existing set
-    if( existing) {
+    if (existing) {
 
 
-        notify->retain();              // in case handler remove()s
         while( (next = (IOService *) existing->getNextObject())) {
 
            next->lockForArbitration();
         while( (next = (IOService *) existing->getNextObject())) {
 
            next->lockForArbitration();
@@ -4237,11 +4493,16 @@ IONotifier * IOService::addMatchingNotification(
                 next->invokeNotifer( notify );
            next->unlockForArbitration();
        }
                 next->invokeNotifer( notify );
            next->unlockForArbitration();
        }
-        notify->release();
        existing->release();
     }
 
        existing->release();
     }
 
-    return( notify );
+    LOCKWRITENOTIFY();
+    bool removed = (0 == notify->whence);
+    notify->release();
+    if (removed) ret = gIOServiceNullNotifier;
+    UNLOCKNOTIFY();
+
+    return( ret );
 }
 
 bool IOService::syncNotificationHandler(
 }
 
 bool IOService::syncNotificationHandler(
@@ -4596,6 +4857,19 @@ void _IOServiceNotifier::enable( bool was )
     UNLOCKNOTIFY();
 }
 
     UNLOCKNOTIFY();
 }
 
+
+/*
+ * _IOServiceNullNotifier
+ */
+
+void _IOServiceNullNotifier::taggedRetain(const void *tag) const                      {}
+void _IOServiceNullNotifier::taggedRelease(const void *tag, const int when) const     {}
+void _IOServiceNullNotifier::free()                                                   {}
+void _IOServiceNullNotifier::wait()                                                   {}
+void _IOServiceNullNotifier::remove()                                                 {}
+void _IOServiceNullNotifier::enable(bool was)                                         {}
+bool _IOServiceNullNotifier::disable()                                { return(false); }
+
 /*
  * IOResources
  */
 /*
  * IOResources
  */
@@ -4616,7 +4890,7 @@ IOService * IOResources::resources( void )
 bool IOResources::init( OSDictionary * dictionary )
 {
     // Do super init first
 bool IOResources::init( OSDictionary * dictionary )
 {
     // Do super init first
-    if ( !super::init() )
+    if ( !IOService::init() )
         return false;
 
     // Allow PAL layer to publish a value
         return false;
 
     // Allow PAL layer to publish a value
@@ -4641,6 +4915,13 @@ bool IOResources::init( OSDictionary * dictionary )
     return true;
 }
 
     return true;
 }
 
+IOReturn IOResources::newUserClient(task_t owningTask, void * securityID,
+                                    UInt32 type,  OSDictionary * properties,
+                                    IOUserClient ** handler)
+{
+    return( kIOReturnUnsupported );
+}
+
 IOWorkLoop * IOResources::getWorkLoop() const
 {
     // If we are the resource root
 IOWorkLoop * IOResources::getWorkLoop() const
 {
     // If we are the resource root
@@ -4657,6 +4938,7 @@ bool IOResources::matchPropertyTable( OSDictionary * table )
     OSString *         str;
     OSSet *            set;
     OSIterator *       iter;
     OSString *         str;
     OSSet *            set;
     OSIterator *       iter;
+    OSArray *           keys;
     bool               ok = true;
 
     prop = table->getObject( gIOResourceMatchKey );
     bool               ok = true;
 
     prop = table->getObject( gIOResourceMatchKey );
@@ -4674,6 +4956,17 @@ bool IOResources::matchPropertyTable( OSDictionary * table )
         if( iter)
            iter->release();
     }
         if( iter)
            iter->release();
     }
+    else if ((prop = table->getObject(gIOResourceMatchedKey)))
+    {
+        keys = (OSArray *) copyProperty(gIOResourceMatchedKey);
+        ok = false;
+        if (keys)
+        {
+            // assuming OSSymbol
+            ok = ((-1U) != keys->getNextIndexOfObject(prop, 0));
+            keys->release();
+        }
+    }
 
     return( ok );
 }
 
     return( ok );
 }
@@ -4703,9 +4996,25 @@ void IOService::updateConsoleUsers(OSArray * consoleUsers, IOMessage systemMessa
     {
         sSystemPower = systemMessage;
 #if HIBERNATION
     {
         sSystemPower = systemMessage;
 #if HIBERNATION
-       if ((kIOMessageSystemHasPoweredOn == systemMessage) && IOHibernateWasScreenLocked())
+       if (kIOMessageSystemHasPoweredOn == systemMessage)
        {
        {
-           locked = kOSBooleanTrue;
+           uint32_t lockState = IOHibernateWasScreenLocked();
+           switch (lockState)
+           {
+               case 0:
+                   break;
+               case kIOScreenLockLocked:
+               case kIOScreenLockFileVaultDialog:
+                   gIOConsoleBooterLockState = kOSBooleanTrue;
+                   break;
+               case kIOScreenLockNoLock:
+                   gIOConsoleBooterLockState = 0;
+                   break;
+               case kIOScreenLockUnlocked:
+               default:
+                   gIOConsoleBooterLockState = kOSBooleanFalse;
+                   break;
+           }
        }
 #endif /* HIBERNATION */
     }
        }
 #endif /* HIBERNATION */
     }
@@ -4713,6 +5022,8 @@ void IOService::updateConsoleUsers(OSArray * consoleUsers, IOMessage systemMessa
     if (consoleUsers)
     {
         OSNumber * num = 0;
     if (consoleUsers)
     {
         OSNumber * num = 0;
+       bool       loginLocked = true;
+
        gIOConsoleLoggedIn = false;
        for (idx = 0; 
              (user = OSDynamicCast(OSDictionary, consoleUsers->getObject(idx))); 
        gIOConsoleLoggedIn = false;
        for (idx = 0; 
              (user = OSDynamicCast(OSDictionary, consoleUsers->getObject(idx))); 
@@ -4720,11 +5031,16 @@ void IOService::updateConsoleUsers(OSArray * consoleUsers, IOMessage systemMessa
        {
            gIOConsoleLoggedIn |= ((kOSBooleanTrue == user->getObject(gIOConsoleSessionOnConsoleKey))
                        && (kOSBooleanTrue == user->getObject(gIOConsoleSessionLoginDoneKey)));
        {
            gIOConsoleLoggedIn |= ((kOSBooleanTrue == user->getObject(gIOConsoleSessionOnConsoleKey))
                        && (kOSBooleanTrue == user->getObject(gIOConsoleSessionLoginDoneKey)));
+
+           loginLocked &= (kOSBooleanTrue == user->getObject(gIOConsoleSessionScreenIsLockedKey));
            if (!num)
            {
                num = OSDynamicCast(OSNumber, user->getObject(gIOConsoleSessionScreenLockedTimeKey));
            }
        }
            if (!num)
            {
                num = OSDynamicCast(OSNumber, user->getObject(gIOConsoleSessionScreenLockedTimeKey));
            }
        }
+#if HIBERNATION
+        if (!loginLocked) gIOConsoleBooterLockState = 0;
+#endif /* HIBERNATION */
         gIOConsoleLockTime = num ? num->unsigned32BitValue() : 0;
     }
 
         gIOConsoleLockTime = num ? num->unsigned32BitValue() : 0;
     }
 
@@ -4734,6 +5050,12 @@ void IOService::updateConsoleUsers(OSArray * consoleUsers, IOMessage systemMessa
     {
        locked = kOSBooleanTrue;
     }
     {
        locked = kOSBooleanTrue;
     }
+#if HIBERNATION
+    else if (gIOConsoleBooterLockState)
+    {
+       locked = gIOConsoleBooterLockState;
+    }
+#endif /* HIBERNATION */
     else if (gIOConsoleLockTime)
     {
        clock_sec_t  now;
     else if (gIOConsoleLockTime)
     {
        clock_sec_t  now;
@@ -4840,11 +5162,16 @@ bool IOService::compareProperty( OSDictionary * matching,
                                  const char *  key )
 {
     OSObject * value;
                                  const char *  key )
 {
     OSObject * value;
+    OSObject * prop;
     bool       ok;
 
     value = matching->getObject( key );
     if( value)
     bool       ok;
 
     value = matching->getObject( key );
     if( value)
-        ok = value->isEqualTo( getProperty( key ));
+    {
+        prop = copyProperty(key);
+        ok = value->isEqualTo(prop);
+        if (prop) prop->release();
+    }
     else
        ok = true;
 
     else
        ok = true;
 
@@ -4856,11 +5183,16 @@ bool IOService::compareProperty( OSDictionary *   matching,
                                  const OSString * key )
 {
     OSObject * value;
                                  const OSString * key )
 {
     OSObject * value;
+    OSObject * prop;
     bool       ok;
 
     value = matching->getObject( key );
     if( value)
     bool       ok;
 
     value = matching->getObject( key );
     if( value)
-        ok = value->isEqualTo( getProperty( key ));
+    {
+        prop = copyProperty(key);
+        ok = value->isEqualTo(prop);
+        if (prop) prop->release();
+    }
     else
        ok = true;
 
     else
        ok = true;
 
@@ -4940,6 +5272,7 @@ bool IOService::matchInternal(OSDictionary * table, uint32_t options, uint32_t *
     {
        count = table->getCount();
        done = 0;
     {
        count = table->getCount();
        done = 0;
+
        str = OSDynamicCast(OSString, table->getObject(gIOProviderClassKey));
        if (str) {
            done++;
        str = OSDynamicCast(OSString, table->getObject(gIOProviderClassKey));
        if (str) {
            done++;
@@ -5010,6 +5343,38 @@ bool IOService::matchInternal(OSDictionary * table, uint32_t options, uint32_t *
            if ((!match) || (done == count)) break;
        }
 
            if ((!match) || (done == count)) break;
        }
 
+       obj = table->getObject( gIOPropertyExistsMatchKey );
+       if( obj)
+       {
+           OSDictionary * dict;
+           OSString     * nextKey;
+           OSIterator *   iter;
+           done++;
+           match = false;
+           dict = dictionaryWithProperties();
+           if( dict) {
+               nextKey = OSDynamicCast( OSString, obj);
+               if( nextKey)
+                   iter = 0;
+               else
+                   iter = OSCollectionIterator::withCollection(
+                               OSDynamicCast(OSCollection, obj));
+
+               while( nextKey
+                   || (iter && (0 != (nextKey = OSDynamicCast(OSString,
+                                           iter->getNextObject()))))) {
+                   match = (0 != dict->getObject(nextKey));
+                   if( match)
+                       break;
+                   nextKey = 0;
+               }
+               dict->release();
+               if( iter)
+                   iter->release();
+           }
+           if ((!match) || (done == count)) break;
+       }
+
        str = OSDynamicCast( OSString, table->getObject( gIOPathMatchKey ));
        if( str) {
            done++;
        str = OSDynamicCast( OSString, table->getObject( gIOPathMatchKey ));
        if( str) {
            done++;
@@ -5061,10 +5426,10 @@ bool IOService::matchInternal(OSDictionary * table, uint32_t options, uint32_t *
             if (prop) prop->release();                 \
            if ((!match) || (done == count)) break;     \
        }
             if (prop) prop->release();                 \
            if ((!match) || (done == count)) break;     \
        }
-       propMatch(kIOBSDNameKey)
-       propMatch(kIOBSDMajorKey)
-       propMatch(kIOBSDMinorKey)
-       propMatch(kIOBSDUnitKey)
+       propMatch(gIOBSDNameKey)
+       propMatch(gIOBSDMajorKey)
+       propMatch(gIOBSDMinorKey)
+       propMatch(gIOBSDUnitKey)
 #undef propMatch
     }
     while (false);
 #undef propMatch
     }
     while (false);
@@ -5091,7 +5456,10 @@ bool IOService::matchPassive(OSDictionary * table, uint32_t options)
 
     assert( table );
 
 
     assert( table );
 
-#if MATCH_DEBUG 
+    OSArray* aliasServiceRegIds = NULL;
+    IOService* foundAlternateService = NULL;
+
+#if MATCH_DEBUG
     OSDictionary * root = table;
 #endif
 
     OSDictionary * root = table;
 #endif
 
@@ -5155,8 +5523,53 @@ bool IOService::matchPassive(OSDictionary * table, uint32_t options)
             break;
         }
         while (true);
             break;
         }
         while (true);
+
+        if(match == true) {
+            break;
+        }
+
+        if(matchParent == true) {
+            // check if service has an alias to search its other "parents" if a parent match isn't found
+            OSNumber* alternateRegistryID = OSDynamicCast(OSNumber, where->getProperty(kIOServiceLegacyMatchingRegistryIDKey));
+            if(alternateRegistryID != NULL) {
+                if(aliasServiceRegIds == NULL)
+                {
+                    aliasServiceRegIds = OSArray::withCapacity(sizeof(alternateRegistryID));
+                }
+                aliasServiceRegIds->setObject(alternateRegistryID);
+            }
+        }
+        else {
+            break;
+        }
+
+        where = where->getProvider();
+        if(where == NULL) {
+            // there were no matching parent services, check to see if there are aliased services that have a matching parent
+            if(aliasServiceRegIds != NULL) {
+                unsigned int numAliasedServices = aliasServiceRegIds->getCount();
+                if(numAliasedServices != 0) {
+                    OSNumber* alternateRegistryID = OSDynamicCast(OSNumber, aliasServiceRegIds->getObject(numAliasedServices - 1));
+                    if(alternateRegistryID != NULL) {
+                        OSDictionary* alternateMatchingDict = IOService::registryEntryIDMatching(alternateRegistryID->unsigned64BitValue());
+                        aliasServiceRegIds->removeObject(numAliasedServices - 1);
+                        if(alternateMatchingDict != NULL) {
+                            OSSafeReleaseNULL(foundAlternateService);
+                            foundAlternateService = IOService::copyMatchingService(alternateMatchingDict);
+                            alternateMatchingDict->release();
+                            if(foundAlternateService != NULL) {
+                                where = foundAlternateService;
+                            }
+                        }
+                    }
+                }
+            }
+        }
     }
     }
-    while( matchParent && (!match) && (where = where->getProvider()) );
+    while( where != NULL );
+
+    OSSafeReleaseNULL(foundAlternateService);
+    OSSafeReleaseNULL(aliasServiceRegIds);
 
 #if MATCH_DEBUG
     if (where != this) 
 
 #if MATCH_DEBUG
     if (where != this) 
@@ -5565,6 +5978,10 @@ requireMaxCpuDelay(IOService * service, UInt32 ns, UInt32 delayType)
 
     if (setCpuDelay)
     {
 
     if (setCpuDelay)
     {
+        if (holder && debug_boot_arg) {
+            strlcpy(sCPULatencyHolderName[delayType], holder->getName(), sizeof(sCPULatencyHolderName[delayType]));
+        }
+
         // Must be safe to call from locked context
         if (delayType == kCpuDelayBusStall)
         {
         // Must be safe to call from locked context
         if (delayType == kCpuDelayBusStall)
         {
@@ -5782,6 +6199,7 @@ IOReturn IOService::addInterruptStatistics(IOInterruptAccountingData * statistic
   IOReportLegend * legend = NULL;
   IOInterruptAccountingData * oldValue = NULL;
   IOInterruptAccountingReporter * newArray = NULL;
   IOReportLegend * legend = NULL;
   IOInterruptAccountingData * oldValue = NULL;
   IOInterruptAccountingReporter * newArray = NULL;
+  char subgroupName[64];
   int newArraySize = 0;
   int i = 0;
 
   int newArraySize = 0;
   int i = 0;
 
@@ -5859,7 +6277,7 @@ IOReturn IOService::addInterruptStatistics(IOInterruptAccountingData * statistic
      * TODO: Some statistics do in fact have common units (time); should this be
      * split into separate reporters to communicate this?
      */
      * TODO: Some statistics do in fact have common units (time); should this be
      * split into separate reporters to communicate this?
      */
-     reserved->interruptStatisticsArray[source].reporter = IOSimpleReporter::with(this, kIOReportCategoryInterrupt, kIOReportUnitNone);
+     reserved->interruptStatisticsArray[source].reporter = IOSimpleReporter::with(this, kIOReportCategoryPower, kIOReportUnitNone);
 
     /*
      * Each statistic is given an identifier based on the interrupt index (which
 
     /*
      * Each statistic is given an identifier based on the interrupt index (which
@@ -5882,19 +6300,13 @@ IOReturn IOService::addInterruptStatistics(IOInterruptAccountingData * statistic
      */
     legend = IOReportLegend::with(OSDynamicCast(OSArray, getProperty(kIOReportLegendKey)));
 
      */
     legend = IOReportLegend::with(OSDynamicCast(OSArray, getProperty(kIOReportLegendKey)));
 
-    if ((source >= IA_MAX_SUBGROUP_NAME) || (source < 0)) {
-      /*
-       * Either we're using a nonsensical index (should never happen), or the
-       * index is larger than anticipated (may happen, almost certainly won't).
-       * This may move to live generation of the names in the future, but for
-       * now, point both cases to a generic subgroup name (this will confuse
-       * clients, unfortunately).
-       */
-      legend->addReporterLegend(reserved->interruptStatisticsArray[source].reporter, kInterruptAccountingGroupName, kInterruptAccountingGenericSubgroupName);
-    } else {
-      legend->addReporterLegend(reserved->interruptStatisticsArray[source].reporter, kInterruptAccountingGroupName, kInterruptAccountingSubgroupNames[source]);
-    }
-
+    /*
+     * Note that while we compose the subgroup name, we do not need to
+     * manage its lifecycle (the reporter will handle this).
+     */
+    snprintf(subgroupName, sizeof(subgroupName), "%s %d", getName(), source);
+    subgroupName[sizeof(subgroupName) - 1] = 0;
+    legend->addReporterLegend(reserved->interruptStatisticsArray[source].reporter, kInterruptAccountingGroupName, subgroupName);
     setProperty(kIOReportLegendKey, legend->getLegend());
     legend->release();
 
     setProperty(kIOReportLegendKey, legend->getLegend());
     legend->release();
 
mirror of XNU