xnu-4903.241.1.tar.gz

[apple/xnu.git] / iokit / Kernel / IORegistryEntry.cpp

diff --git a/iokit/Kernel/IORegistryEntry.cpp b/iokit/Kernel/IORegistryEntry.cpp
index f039c28adef3a69569c91ca9391a7c124132efb0..03bb8724f1f3f672ea84a618de44ca48bd90cefd 100644 (file)
--- a/iokit/Kernel/IORegistryEntry.cpp
+++ b/iokit/Kernel/IORegistryEntry.cpp
@@ -25,23 +25,19 @@
  * 
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
  * 
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */

-/*
- * Copyright (c) 1998 Apple Computer, Inc.  All rights reserved. 
- *
- * HISTORY
- * 12 Nov 98 sdouglas created.
- *
- */

 
 #include <IOKit/IORegistryEntry.h>
 #include <libkern/c++/OSContainers.h>
 #include <IOKit/IOService.h>
 #include <IOKit/IOKitKeys.h>
 
 #include <IOKit/IORegistryEntry.h>
 #include <libkern/c++/OSContainers.h>
 #include <IOKit/IOService.h>
 #include <IOKit/IOKitKeys.h>

+#include <IOKit/IOTimeStamp.h>

 
 #include <IOKit/IOLib.h>
 
 #include <IOKit/IOLib.h>

-
+#include <stdatomic.h>

 #include <IOKit/assert.h>
 
 #include <IOKit/assert.h>
 

+#include "IOKitKernelInternal.h"
+

 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #define super OSObject
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #define super OSObject


@@ -60,11 +56,24 @@ OSDefineMetaClassAndStructors(IORegistryEntry, OSObject)
 #define kIORegPlaneNameSuffixLen       (sizeof(kIORegPlaneNameSuffix) - 1)
 #define kIORegPlaneLocationSuffixLen   (sizeof(kIORegPlaneLocationSuffix) - 1)
 
 #define kIORegPlaneNameSuffixLen       (sizeof(kIORegPlaneNameSuffix) - 1)
 #define kIORegPlaneLocationSuffixLen   (sizeof(kIORegPlaneLocationSuffix) - 1)
 

+#define KASLR_IOREG_DEBUG 0
+
+struct IORegistryEntry::ExpansionData
+{
+    IORecursiveLock *        fLock;
+    uint64_t                fRegistryEntryID;
+    SInt32                   fRegistryEntryGenerationCount;
+    OSObject       **_Atomic fIndexedProperties;
+};
+
+

 static IORegistryEntry * gRegistryRoot;
 static OSDictionary *   gIORegistryPlanes;
 
 const OSSymbol *       gIONameKey;
 const OSSymbol *       gIOLocationKey;
 static IORegistryEntry * gRegistryRoot;
 static OSDictionary *   gIORegistryPlanes;
 
 const OSSymbol *       gIONameKey;
 const OSSymbol *       gIOLocationKey;

+const OSSymbol *       gIORegistryEntryIDKey;
+const OSSymbol *       gIORegistryEntryPropertyKeysKey;

 
 enum {
     kParentSetIndex    = 0,
 
 enum {
     kParentSetIndex    = 0,


@@ -75,6 +84,10 @@ enum {
     kIOMaxPlaneName    = 32
 };
 
     kIOMaxPlaneName    = 32
 };
 

+enum { kIORegistryIDReserved = (1ULL << 32) + 255 };
+
+static uint64_t gIORegistryLastID = kIORegistryIDReserved;
+

 class IORegistryPlane : public OSObject {
 
     friend class IORegistryEntry;
 class IORegistryPlane : public OSObject {
 
     friend class IORegistryEntry;


@@ -88,7 +101,7 @@ class IORegistryPlane : public OSObject {
     int                        reserved[2];
 
 public:
     int                        reserved[2];
 
 public:

-    virtual bool serialize(OSSerialize *s) const;
+    virtual bool serialize(OSSerialize *s) const APPLE_KEXT_OVERRIDE;

 };
 
 OSDefineMetaClassAndStructors(IORegistryPlane, OSObject)
 };
 
 OSDefineMetaClassAndStructors(IORegistryPlane, OSObject)


@@ -103,8 +116,8 @@ static SInt32                       gIORegistryGenerationCount;
                gIORegistryGenerationCount++
                // make atomic
 
                gIORegistryGenerationCount++
                // make atomic
 

-#define PUNLOCK        IORecursiveLockUnlock( gPropertiesLock )
-#define PLOCK  IORecursiveLockLock( gPropertiesLock )
+#define PUNLOCK        IORecursiveLockUnlock( reserved->fLock )
+#define PLOCK  IORecursiveLockLock( reserved->fLock )

 
 #define IOREGSPLITTABLES
 
 
 #define IOREGSPLITTABLES
 


@@ -149,8 +162,13 @@ IORegistryEntry * IORegistryEntry::initialize( void )
                && gIORegistryPlanes );
         ok = gRegistryRoot->init();
 
                && gIORegistryPlanes );
         ok = gRegistryRoot->init();
 

+       if (ok)
+           gRegistryRoot->reserved->fRegistryEntryID = ++gIORegistryLastID;
+

        gIONameKey = OSSymbol::withCStringNoCopy( "IOName" );
        gIOLocationKey = OSSymbol::withCStringNoCopy( "IOLocation" );
        gIONameKey = OSSymbol::withCStringNoCopy( "IOName" );
        gIOLocationKey = OSSymbol::withCStringNoCopy( "IOLocation" );

+       gIORegistryEntryIDKey = OSSymbol::withCStringNoCopy( kIORegistryEntryIDKey );
+        gIORegistryEntryPropertyKeysKey = OSSymbol::withCStringNoCopy( kIORegistryEntryPropertyKeysKey );

 
        assert( ok && gIONameKey && gIOLocationKey );
 
 
        assert( ok && gIONameKey && gIOLocationKey );
 


@@ -171,6 +189,10 @@ SInt32 IORegistryEntry::getGenerationCount( void )
     return( gIORegistryGenerationCount );
 }
 
     return( gIORegistryGenerationCount );
 }
 

+SInt32 IORegistryEntry::getRegistryEntryGenerationCount(void) const
+{
+    return (reserved->fRegistryEntryGenerationCount);
+}

 
 const IORegistryPlane * IORegistryEntry::makePlane( const char * name )
 {
 
 const IORegistryPlane * IORegistryEntry::makePlane( const char * name )
 {


@@ -261,8 +283,22 @@ bool IORegistryEntry::init( OSDictionary * dict )
     if( !super::init())
        return( false);
 
     if( !super::init())
        return( false);
 

+    if (!reserved)
+    {
+       reserved = IONew(ExpansionData, 1);
+       if (!reserved)
+           return (false);
+       bzero(reserved, sizeof(ExpansionData));
+       reserved->fLock = IORecursiveLockAlloc();
+       if (!reserved->fLock) return (false);
+    }

     if( dict) {
     if( dict) {

-       dict->retain();
+       if (OSCollection::kImmutable & dict->setOptions(0, 0)) {
+           dict = (OSDictionary *) dict->copyCollection();
+           if (!dict)
+               return (false);
+       } else
+           dict->retain();

        if( fPropertyTable)
            fPropertyTable->release();
        fPropertyTable = dict;
        if( fPropertyTable)
            fPropertyTable->release();
        fPropertyTable = dict;


@@ -305,13 +341,23 @@ bool IORegistryEntry::init( IORegistryEntry * old,
     if( !super::init())
        return( false);
 
     if( !super::init())
        return( false);
 

+    if (!reserved)
+    {
+       reserved = IONew(ExpansionData, 1);
+       if (!reserved) return (false);
+       bzero(reserved, sizeof(ExpansionData));
+       reserved->fLock = IORecursiveLockAlloc();
+       if (!reserved->fLock) return (false);
+    }
+

     WLOCK;
 
     WLOCK;
 

-    fPropertyTable = old->getPropertyTable();
-    fPropertyTable->retain();
+    reserved->fRegistryEntryID = old->reserved->fRegistryEntryID;
+
+    fPropertyTable = old->dictionaryWithProperties();

 #ifdef IOREGSPLITTABLES
     fRegistryTable = old->fRegistryTable;
 #ifdef IOREGSPLITTABLES
     fRegistryTable = old->fRegistryTable;

-    old->fRegistryTable = OSDictionary::withDictionary( fRegistryTable );
+    old->fRegistryTable = (OSDictionary *) fRegistryTable->copyCollection();

 #endif /* IOREGSPLITTABLES */
 
     old->registryTable()->removeObject( plane->keys[ kParentSetIndex ] );
 #endif /* IOREGSPLITTABLES */
 
     old->registryTable()->removeObject( plane->keys[ kParentSetIndex ] );


@@ -340,19 +386,11 @@ bool IORegistryEntry::init( IORegistryEntry * old,
 
 void IORegistryEntry::free( void )
 {
 
 void IORegistryEntry::free( void )
 {

-

 #if DEBUG_FREE
 #if DEBUG_FREE

-#define msg ": attached at free()"
-    int len = strlen(msg) + 40;
-    char buf[len];
-

     if( registryTable() && gIOServicePlane) {
         if( getParentSetReference( gIOServicePlane )
             || getChildSetReference( gIOServicePlane )) {
     if( registryTable() && gIOServicePlane) {
         if( getParentSetReference( gIOServicePlane )
             || getChildSetReference( gIOServicePlane )) {

-
-            strlcpy( buf, getName(), 32);
-            strlcat( buf, msg, len );
-            IOPanic( buf );
+            panic("%s: attached at free()", getName());

         }
     }
 #endif
         }
     }
 #endif


@@ -365,15 +403,30 @@ void IORegistryEntry::free( void )
         registryTable()->release();
 #endif /* IOREGSPLITTABLES */
 
         registryTable()->release();
 #endif /* IOREGSPLITTABLES */
 

+    if (reserved)
+    {
+       if (reserved->fIndexedProperties)
+       {
+           for (int idx = 0; idx < kIORegistryEntryIndexedPropertyCount; idx++)
+           {
+               if (reserved->fIndexedProperties[idx]) reserved->fIndexedProperties[idx]->release();
+           }
+           IODelete(reserved->fIndexedProperties, OSObject *, kIORegistryEntryIndexedPropertyCount);
+       }
+       if (reserved->fLock)              IORecursiveLockFree(reserved->fLock);
+       IODelete(reserved, ExpansionData, 1);
+    }
+

     super::free();
 }
 
 void IORegistryEntry::setPropertyTable( OSDictionary * dict )
 {
     super::free();
 }
 
 void IORegistryEntry::setPropertyTable( OSDictionary * dict )
 {

-    if( fPropertyTable)
-       fPropertyTable->release();

     if( dict)
        dict->retain();
     if( dict)
        dict->retain();

+    if( fPropertyTable)
+       fPropertyTable->release();
+

     fPropertyTable = dict;
 }
 
     fPropertyTable = dict;
 }
 


@@ -452,11 +505,22 @@ bool IORegistryEntry::serializeProperties( OSSerialize * s ) const
     OSCollection *snapshotProperties = getPropertyTable()->copyCollection();
     PUNLOCK;
 
     OSCollection *snapshotProperties = getPropertyTable()->copyCollection();
     PUNLOCK;
 

+    if (!snapshotProperties) return (false);
+

     bool ok =  snapshotProperties->serialize( s );
     snapshotProperties->release();
     return( ok );
 }
 
     bool ok =  snapshotProperties->serialize( s );
     snapshotProperties->release();
     return( ok );
 }
 

+OSArray * IORegistryEntry::copyPropertyKeys(void) const
+{
+    PLOCK;
+    OSArray * keys = getPropertyTable()->copyKeys();
+    PUNLOCK;
+
+    return (keys);
+}
+

 OSDictionary * IORegistryEntry::dictionaryWithProperties( void ) const
 {
     OSDictionary *     dict;
 OSDictionary * IORegistryEntry::dictionaryWithProperties( void ) const
 {
     OSDictionary *     dict;


@@ -507,6 +571,15 @@ IORegistryEntry::removeProperty( const OSSymbol * aKey)
     PUNLOCK;
 }
 
     PUNLOCK;
 }
 

+#if KASLR_IOREG_DEBUG
+extern "C" {
+    
+bool ScanForAddrInObject(OSObject * theObject, 
+                         int indent);
+    
+}; /* extern "C" */
+#endif
+

 bool
 IORegistryEntry::setProperty( const OSSymbol * aKey, OSObject * anObject)
 {
 bool
 IORegistryEntry::setProperty( const OSSymbol * aKey, OSObject * anObject)
 {


@@ -524,7 +597,18 @@ IORegistryEntry::setProperty( const OSSymbol * aKey, OSObject * anObject)
 
     ret = getPropertyTable()->setObject( aKey, anObject );
     PUNLOCK;
 
     ret = getPropertyTable()->setObject( aKey, anObject );
     PUNLOCK;

-    
+
+#if KASLR_IOREG_DEBUG
+    if ( anObject && strcmp(kIOKitDiagnosticsKey, aKey->getCStringNoCopy()) != 0 ) {
+        if (ScanForAddrInObject(anObject, 0)) {
+            IOLog("%s: IORegistryEntry name %s with key \"%s\" \n",
+                  __FUNCTION__,
+                  getName(0),
+                  aKey->getCStringNoCopy() );        
+        }
+    }
+#endif
+

     return ret;
 }
 
     return ret;
 }
 


@@ -669,6 +753,40 @@ IORegistryEntry::setProperty( const char *      aKey,
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 

+OSObject * IORegistryEntry::setIndexedProperty(uint32_t index, OSObject * anObject)
+{
+    OSObject ** array;
+    OSObject *  prior;
+
+    if (index >= kIORegistryEntryIndexedPropertyCount) return (0);
+
+    array = atomic_load_explicit(&reserved->fIndexedProperties, memory_order_acquire);
+    if (!array)
+    {
+       array = IONew(OSObject *, kIORegistryEntryIndexedPropertyCount);
+       if (!array) return (0);
+       bzero(array, kIORegistryEntryIndexedPropertyCount * sizeof(array[0]));
+       if (!OSCompareAndSwapPtr(NULL, array, &reserved->fIndexedProperties)) IODelete(array, OSObject *, kIORegistryEntryIndexedPropertyCount);
+    }
+    if (!reserved->fIndexedProperties) return (0);
+
+    prior = reserved->fIndexedProperties[index];
+    if (anObject) anObject->retain();
+    reserved->fIndexedProperties[index] = anObject;
+
+    return (prior);
+}
+
+OSObject * IORegistryEntry::getIndexedProperty(uint32_t index) const
+{
+    if (index >= kIORegistryEntryIndexedPropertyCount) return (0);
+    if (!reserved->fIndexedProperties) return (0);
+
+    return (reserved->fIndexedProperties[index]);
+}
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+

 /* Name, location, paths */
 
 const char * IORegistryEntry::getName( const IORegistryPlane * plane ) const
 /* Name, location, paths */
 
 const char * IORegistryEntry::getName( const IORegistryPlane * plane ) const


@@ -749,6 +867,19 @@ void IORegistryEntry::setName( const OSSymbol * name,
         else
             key = gIONameKey;
 
         else
             key = gIONameKey;
 

+        if (gIOKitTrace && reserved && reserved->fRegistryEntryID)
+        {
+            uint64_t str_id = 0;
+            uint64_t __unused regID = getRegistryEntryID();
+            kernel_debug_string(IODBG_IOREGISTRY(IOREGISTRYENTRY_NAME_STRING), &str_id, name->getCStringNoCopy());
+            KERNEL_DEBUG_CONSTANT(IODBG_IOREGISTRY(IOREGISTRYENTRY_NAME),
+                (uintptr_t) regID,
+                (uintptr_t) (regID >> 32),
+                (uintptr_t) str_id,
+                (uintptr_t) (str_id >> 32),
+                0);
+        }
+

        WLOCK;
         registryTable()->setObject( key, (OSObject *) name);
        UNLOCK;
        WLOCK;
         registryTable()->setObject( key, (OSObject *) name);
        UNLOCK;


@@ -798,7 +929,7 @@ IORegistryEntry::compareName( OSString * name, OSString ** matched ) const
     const OSSymbol *   sym = copyName();
     bool               isEqual;
 
     const OSSymbol *   sym = copyName();
     bool               isEqual;
 

-    isEqual = sym->isEqualTo( name );
+    isEqual = (sym && sym->isEqualTo(name));

 
     if( isEqual && matched) {
        name->retain();
 
     if( isEqual && matched) {
        name->retain();


@@ -845,7 +976,7 @@ bool IORegistryEntry::getPath(      char * path, int * length,
     OSArray *          stack;
     IORegistryEntry *  root;
     const IORegistryEntry * entry;
     OSArray *          stack;
     IORegistryEntry *  root;
     const IORegistryEntry * entry;

-    IORegistryEntry *  parent;
+    const IORegistryEntry * parent;

     const OSSymbol *   alias;
     int                        index;
     int                        len, maxLength, compLen, aliasLen;
     const OSSymbol *   alias;
     int                        index;
     int                        len, maxLength, compLen, aliasLen;


@@ -876,67 +1007,62 @@ bool IORegistryEntry::getPath(   char * path, int * length,
        return( ok );
     }
 
        return( ok );
     }
 

-    entry = this;
-    parent = entry->getParentEntry( plane );
-    if( !parent)
-       // Error if not attached in plane
-       return( false);
-

     stack = OSArray::withCapacity( getDepth( plane ));
     stack = OSArray::withCapacity( getDepth( plane ));

-    if( !stack)
-       return( false);
+    if (!stack) return( false);

 
     RLOCK;
 
 
     RLOCK;
 

+    parent = entry = this;

     root = gRegistryRoot->getChildEntry( plane );
     root = gRegistryRoot->getChildEntry( plane );

-    while( parent && (entry != root)) {
+    while (parent && (parent != root))
+    {

        // stop below root
        // stop below root

-       stack->setObject( (OSObject *) entry );

        entry = parent;
        parent = entry->getParentEntry( plane );
        entry = parent;
        parent = entry->getParentEntry( plane );

+       stack->setObject( (OSObject *) entry );

     }
 
     }
 

-    index = stack->getCount();
-    ok = true;
-
-    if( 0 == index) {
-
-        *nextComp++ = '/';
-        *nextComp = 0;
-        len++;
-
-    } else while( ok && ((--index) >= 0)) {
-
-        entry = (IORegistryEntry *) stack->getObject((unsigned int) index );
-        assert( entry );
-
-        if( (alias = entry->hasAlias( plane ))) {
-            len = plane->nameKey->getLength() + 1;
-            nextComp = path + len;
-
-            compLen = alias->getLength();
-            ok = (maxLength > (len + compLen));
-            if( ok)
-                strlcpy( nextComp, alias->getCStringNoCopy(), compLen + 1);
-        } else {
-            compLen = maxLength - len;
-            ok = entry->getPathComponent( nextComp + 1, &compLen, plane );
-
-            if( ok && compLen) {
-                compLen++;
-                *nextComp = '/';
+    ok = (0 != parent);
+    if (ok)
+    {
+        index = stack->getCount();
+        if( 0 == index) {
+
+            *nextComp++ = '/';
+            *nextComp = 0;
+            len++;
+
+        } else while( ok && ((--index) >= 0)) {
+
+            entry = (IORegistryEntry *) stack->getObject((unsigned int) index );
+            assert( entry );
+
+            if( (alias = entry->hasAlias( plane ))) {
+                len = plane->nameKey->getLength() + 1;
+                nextComp = path + len;
+
+                compLen = alias->getLength();
+                ok = (maxLength > (len + compLen));
+                if( ok)
+                    strlcpy( nextComp, alias->getCStringNoCopy(), compLen + 1);
+            } else {
+                compLen = maxLength - len;
+                ok = entry->getPathComponent( nextComp + 1, &compLen, plane );
+
+                if( ok && compLen) {
+                    compLen++;
+                    *nextComp = '/';
+                }

             }
             }

-        }

 
 

-        if( ok) {
-            len += compLen;
-            nextComp += compLen;
+            if( ok) {
+                len += compLen;
+                nextComp += compLen;
+            }

         }
         }

+        *length = len;

     }
     }

-    *length = len;
-

     UNLOCK;
     UNLOCK;

-

     stack->release();
 
     return( ok );
     stack->release();
 
     return( ok );


@@ -1298,6 +1424,7 @@ bool IORegistryEntry::makeLink( IORegistryEntry * to,
             links->release();
        }
     }
             links->release();
        }
     }

+    reserved->fRegistryEntryGenerationCount++;

 
     return( result);
 }
 
     return( result);
 }


@@ -1318,6 +1445,7 @@ void IORegistryEntry::breakLink( IORegistryEntry * to,
                 registryTable()->removeObject( plane->keys[ relation ]);
            }
     }
                 registryTable()->removeObject( plane->keys[ relation ]);
            }
     }

+    reserved->fRegistryEntryGenerationCount++;

 }
 
 
 }
 
 


@@ -1417,6 +1545,18 @@ OSIterator * IORegistryEntry::getChildIterator( const IORegistryPlane * plane )
     return( iter );
 }
 
     return( iter );
 }
 

+uint32_t IORegistryEntry::getChildCount( const IORegistryPlane * plane ) const
+{
+    OSArray * links;
+    uint32_t  count = 0;
+
+    RLOCK;
+    links = getChildSetReference( plane );
+    if (links) count = links->getCount();
+    UNLOCK;
+
+    return (count);
+}

 
 IORegistryEntry * IORegistryEntry::copyChildEntry(
                                const IORegistryPlane * plane ) const
 
 IORegistryEntry * IORegistryEntry::copyChildEntry(
                                const IORegistryPlane * plane ) const


@@ -1587,12 +1727,19 @@ bool IORegistryEntry::attachToParent( IORegistryEntry * parent,
     OSArray *  links;
     bool       ret;
     bool       needParent;
     OSArray *  links;
     bool       ret;
     bool       needParent;

+    bool        traceName = false;

 
     if( this == parent)
        return( false );
 
     WLOCK;
 
 
     if( this == parent)
        return( false );
 
     WLOCK;
 

+    if (!reserved->fRegistryEntryID)
+    {
+       reserved->fRegistryEntryID = ++gIORegistryLastID;
+       traceName = (0 != gIOKitTrace);
+    }
+

     ret = makeLink( parent, kParentSetIndex, plane );
 
     if( (links = parent->getChildSetReference( plane )))
     ret = makeLink( parent, kParentSetIndex, plane );
 
     if( (links = parent->getChildSetReference( plane )))


@@ -1602,6 +1749,19 @@ bool IORegistryEntry::attachToParent( IORegistryEntry * parent,
 
     UNLOCK;
 
 
     UNLOCK;
 

+    if (traceName)
+    {
+        uint64_t str_id = 0;
+        uint64_t __unused regID = getRegistryEntryID();
+        kernel_debug_string(IODBG_IOREGISTRY(IOREGISTRYENTRY_NAME_STRING), &str_id, getName());
+        KERNEL_DEBUG_CONSTANT(IODBG_IOREGISTRY(IOREGISTRYENTRY_NAME),
+            (uintptr_t) regID,
+            (uintptr_t) (regID >> 32),
+            (uintptr_t) str_id,
+            (uintptr_t) (str_id >> 32),
+            0);
+    }
+

     PLOCK;
 
     // Mark any collections in the property list as immutable
     PLOCK;
 
     // Mark any collections in the property list as immutable


@@ -1633,6 +1793,14 @@ bool IORegistryEntry::attachToParent( IORegistryEntry * parent,
     return( ret );
 }
 
     return( ret );
 }
 

+uint64_t IORegistryEntry::getRegistryEntryID( void )
+{
+    if (reserved)
+       return (reserved->fRegistryEntryID);
+    else
+       return (0);
+}
+

 bool IORegistryEntry::attachToChild( IORegistryEntry * child,
                                         const IORegistryPlane * plane )
 {
 bool IORegistryEntry::attachToChild( IORegistryEntry * child,
                                         const IORegistryPlane * plane )
 {


@@ -1717,8 +1885,11 @@ void IORegistryEntry::detachAbove( const IORegistryPlane * plane )
     IORegistryEntry *  parent;
 
     retain();
     IORegistryEntry *  parent;
 
     retain();

-    while( (parent = getParentEntry( plane )))
+    while( (parent = copyParentEntry( plane )))
+    {

        detachFromParent( parent, plane );
        detachFromParent( parent, plane );

+       parent->release();
+    }

     release();
 }
 
     release();
 }
 


@@ -2009,13 +2180,21 @@ OSOrderedSet * IORegistryIterator::iterateAll( void )
     return( done);
 }
 
     return( done);
 }
 

+#if __LP64__
+OSMetaClassDefineReservedUnused(IORegistryEntry, 0);
+OSMetaClassDefineReservedUnused(IORegistryEntry, 1);
+OSMetaClassDefineReservedUnused(IORegistryEntry, 2);
+OSMetaClassDefineReservedUnused(IORegistryEntry, 3);
+OSMetaClassDefineReservedUnused(IORegistryEntry, 4);
+OSMetaClassDefineReservedUnused(IORegistryEntry, 5);
+#else

 OSMetaClassDefineReservedUsed(IORegistryEntry, 0);
 OSMetaClassDefineReservedUsed(IORegistryEntry, 1);
 OSMetaClassDefineReservedUsed(IORegistryEntry, 2);
 OSMetaClassDefineReservedUsed(IORegistryEntry, 3);
 OSMetaClassDefineReservedUsed(IORegistryEntry, 4);
 OSMetaClassDefineReservedUsed(IORegistryEntry, 5);
 OSMetaClassDefineReservedUsed(IORegistryEntry, 0);
 OSMetaClassDefineReservedUsed(IORegistryEntry, 1);
 OSMetaClassDefineReservedUsed(IORegistryEntry, 2);
 OSMetaClassDefineReservedUsed(IORegistryEntry, 3);
 OSMetaClassDefineReservedUsed(IORegistryEntry, 4);
 OSMetaClassDefineReservedUsed(IORegistryEntry, 5);

-
+#endif

 OSMetaClassDefineReservedUnused(IORegistryEntry, 6);
 OSMetaClassDefineReservedUnused(IORegistryEntry, 7);
 OSMetaClassDefineReservedUnused(IORegistryEntry, 8);
 OSMetaClassDefineReservedUnused(IORegistryEntry, 6);
 OSMetaClassDefineReservedUnused(IORegistryEntry, 7);
 OSMetaClassDefineReservedUnused(IORegistryEntry, 8);