iokit/Kernel/IORegistryEntry.cpp

   1 /*
   2  * Copyright (c) 1998-2006 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28
  29 #include <IOKit/IORegistryEntry.h>
  30 #include <libkern/c++/OSContainers.h>
  31 #include <IOKit/IOService.h>
  32 #include <IOKit/IOKitKeys.h>
  33 #include <IOKit/IOTimeStamp.h>
  34
  35 #include <IOKit/IOLib.h>
  36 #include <stdatomic.h>
  37 #include <IOKit/assert.h>
  38
  39 #include "IOKitKernelInternal.h"
  40
  41 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  42
  43 #define super OSObject
  44
  45 OSDefineMetaClassAndStructors(IORegistryEntry, OSObject)
  46
  47 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  48
  49 #define kIORegPlaneParentSuffix         "ParentLinks"
  50 #define kIORegPlaneChildSuffix          "ChildLinks"
  51 #define kIORegPlaneNameSuffix           "Name"
  52 #define kIORegPlaneLocationSuffix       "Location"
  53
  54 #define kIORegPlaneParentSuffixLen      (sizeof(kIORegPlaneParentSuffix) - 1)
  55 #define kIORegPlaneChildSuffixLen       (sizeof(kIORegPlaneChildSuffix) - 1)
  56 #define kIORegPlaneNameSuffixLen        (sizeof(kIORegPlaneNameSuffix) - 1)
  57 #define kIORegPlaneLocationSuffixLen    (sizeof(kIORegPlaneLocationSuffix) - 1)
  58
  59 #define KASLR_IOREG_DEBUG 0
  60
  61 struct IORegistryEntry::ExpansionData
  62 {
  63     IORecursiveLock *        fLock;
  64     uint64_t                 fRegistryEntryID;
  65     SInt32                   fRegistryEntryGenerationCount;
  66     OSObject       **_Atomic fIndexedProperties;
  67 };
  68
  69
  70 static IORegistryEntry * gRegistryRoot;
  71 static OSDictionary *    gIORegistryPlanes;
  72
  73 const OSSymbol *        gIONameKey;
  74 const OSSymbol *        gIOLocationKey;
  75 const OSSymbol *        gIORegistryEntryIDKey;
  76 const OSSymbol *        gIORegistryEntryPropertyKeysKey;
  77
  78 enum {
  79     kParentSetIndex     = 0,
  80     kChildSetIndex      = 1,
  81     kNumSetIndex
  82 };
  83 enum {
  84     kIOMaxPlaneName     = 32
  85 };
  86
  87 enum { kIORegistryIDReserved = (1ULL << 32) + 255 };
  88
  89 static uint64_t gIORegistryLastID = kIORegistryIDReserved;
  90
  91 class IORegistryPlane : public OSObject {
  92
  93     friend class IORegistryEntry;
  94
  95     OSDeclareAbstractStructors(IORegistryPlane)
  96
  97     const OSSymbol *    nameKey;
  98     const OSSymbol *    keys[ kNumSetIndex ];
  99     const OSSymbol *    pathNameKey;
 100     const OSSymbol *    pathLocationKey;
 101     int                 reserved[2];
 102
 103 public:
 104     virtual bool serialize(OSSerialize *s) const APPLE_KEXT_OVERRIDE;
 105 };
 106
 107 OSDefineMetaClassAndStructors(IORegistryPlane, OSObject)
 108
 109
 110 static IORecursiveLock *        gPropertiesLock;
 111 static SInt32                   gIORegistryGenerationCount;
 112
 113 #define UNLOCK  lck_rw_done( &gIORegistryLock )
 114 #define RLOCK   lck_rw_lock_shared( &gIORegistryLock )
 115 #define WLOCK   lck_rw_lock_exclusive( &gIORegistryLock );      \
 116                 gIORegistryGenerationCount++
 117                 // make atomic
 118
 119 #define PUNLOCK IORecursiveLockUnlock( reserved->fLock )
 120 #define PLOCK   IORecursiveLockLock( reserved->fLock )
 121
 122 #define IOREGSPLITTABLES
 123
 124 #ifdef IOREGSPLITTABLES
 125 #define registryTable() fRegistryTable
 126 #else
 127 #define registryTable() fPropertyTable
 128 #endif
 129
 130 #define DEBUG_FREE      1
 131
 132 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 133
 134 lck_rw_t        gIORegistryLock;
 135 lck_grp_t       *gIORegistryLockGrp;
 136 lck_grp_attr_t  *gIORegistryLockGrpAttr;
 137 lck_attr_t      *gIORegistryLockAttr;
 138
 139
 140 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 141
 142 IORegistryEntry * IORegistryEntry::initialize( void )
 143 {
 144    bool                 ok;
 145
 146     if( !gRegistryRoot) {
 147
 148
 149         gIORegistryLockGrpAttr = lck_grp_attr_alloc_init();
 150         //lck_grp_attr_setstat(gIORegistryLockGrpAttr);
 151         gIORegistryLockGrp = lck_grp_alloc_init("IORegistryLock",  gIORegistryLockGrpAttr);
 152         gIORegistryLockAttr = lck_attr_alloc_init();
 153         lck_attr_rw_shared_priority(gIORegistryLockAttr);
 154         //lck_attr_setdebug(gIORegistryLockAttr);
 155         lck_rw_init( &gIORegistryLock, gIORegistryLockGrp, gIORegistryLockAttr);
 156
 157         gRegistryRoot = new IORegistryEntry;
 158         gPropertiesLock = IORecursiveLockAlloc();
 159         gIORegistryPlanes = OSDictionary::withCapacity( 1 );
 160
 161         assert( gRegistryRoot && gPropertiesLock
 162                 && gIORegistryPlanes );
 163         ok = gRegistryRoot->init();
 164
 165         if (ok)
 166             gRegistryRoot->reserved->fRegistryEntryID = ++gIORegistryLastID;
 167
 168         gIONameKey = OSSymbol::withCStringNoCopy( "IOName" );
 169         gIOLocationKey = OSSymbol::withCStringNoCopy( "IOLocation" );
 170         gIORegistryEntryIDKey = OSSymbol::withCStringNoCopy( kIORegistryEntryIDKey );
 171         gIORegistryEntryPropertyKeysKey = OSSymbol::withCStringNoCopy( kIORegistryEntryPropertyKeysKey );
 172
 173         assert( ok && gIONameKey && gIOLocationKey );
 174
 175         gRegistryRoot->setName( "Root" );
 176         gRegistryRoot->setProperty( kIORegistryPlanesKey, gIORegistryPlanes );
 177     }
 178
 179     return( gRegistryRoot );
 180 }
 181
 182 IORegistryEntry * IORegistryEntry::getRegistryRoot( void )
 183 {
 184     return( gRegistryRoot );
 185 }
 186
 187 SInt32 IORegistryEntry::getGenerationCount( void )
 188 {
 189     return( gIORegistryGenerationCount );
 190 }
 191
 192 SInt32 IORegistryEntry::getRegistryEntryGenerationCount(void) const
 193 {
 194     return (reserved->fRegistryEntryGenerationCount);
 195 }
 196
 197 const IORegistryPlane * IORegistryEntry::makePlane( const char * name )
 198 {
 199     IORegistryPlane *   plane;
 200     const OSSymbol *    nameKey;
 201     const OSSymbol *    parentKey;
 202     const OSSymbol *    childKey;
 203     const OSSymbol *    pathNameKey;
 204     const OSSymbol *    pathLocationKey;
 205     char                key[ kIOMaxPlaneName + 16 ];
 206     char *              end;
 207
 208     strlcpy( key, name, kIOMaxPlaneName + 1 );
 209     end = key + strlen( key );
 210
 211     nameKey = OSSymbol::withCString( key);
 212
 213     strlcpy( end, kIORegPlaneParentSuffix, kIORegPlaneParentSuffixLen + 1 );
 214     parentKey = OSSymbol::withCString( key);
 215
 216     strlcpy( end, kIORegPlaneChildSuffix, kIORegPlaneChildSuffixLen + 1 );
 217     childKey = OSSymbol::withCString( key);
 218
 219     strlcpy( end, kIORegPlaneNameSuffix, kIORegPlaneNameSuffixLen + 1 );
 220     pathNameKey = OSSymbol::withCString( key);
 221
 222     strlcpy( end, kIORegPlaneLocationSuffix, kIORegPlaneLocationSuffixLen + 1 );
 223     pathLocationKey = OSSymbol::withCString( key);
 224
 225     plane = new IORegistryPlane;
 226
 227     if( plane && plane->init()
 228         && nameKey && parentKey && childKey
 229         && pathNameKey && pathLocationKey ) {
 230
 231         plane->nameKey = nameKey;
 232         plane->keys[ kParentSetIndex ] = parentKey;
 233         plane->keys[ kChildSetIndex ] = childKey;
 234         plane->pathNameKey = pathNameKey;
 235         plane->pathLocationKey = pathLocationKey;
 236
 237         WLOCK;
 238         gIORegistryPlanes->setObject( nameKey, plane );
 239         UNLOCK;
 240
 241     } else {
 242
 243         if( plane)
 244             plane->release();
 245         if( pathLocationKey)
 246             pathLocationKey->release();
 247         if( pathNameKey)
 248             pathNameKey->release();
 249         if( parentKey)
 250             parentKey->release();
 251         if( childKey)
 252             childKey->release();
 253         if( nameKey)
 254             nameKey->release();
 255         plane = 0;
 256     }
 257
 258     return( plane);
 259 }
 260
 261 const IORegistryPlane * IORegistryEntry::getPlane( const char * name )
 262 {
 263     const IORegistryPlane *     plane;
 264
 265     RLOCK;
 266     plane = (const IORegistryPlane *) gIORegistryPlanes->getObject( name );
 267     UNLOCK;
 268
 269     return( plane );
 270 }
 271
 272 bool IORegistryPlane::serialize(OSSerialize *s) const
 273 {
 274     return( nameKey->serialize(s) );
 275 }
 276
 277 enum { kIORegCapacityIncrement = 4 };
 278
 279 bool IORegistryEntry::init( OSDictionary * dict )
 280 {
 281     OSString *  prop;
 282
 283     if( !super::init())
 284         return( false);
 285
 286     if (!reserved)
 287     {
 288         reserved = IONew(ExpansionData, 1);
 289         if (!reserved)
 290             return (false);
 291         bzero(reserved, sizeof(ExpansionData));
 292         reserved->fLock = IORecursiveLockAlloc();
 293         if (!reserved->fLock) return (false);
 294     }
 295     if( dict) {
 296         if (OSCollection::kImmutable & dict->setOptions(0, 0)) {
 297             dict = (OSDictionary *) dict->copyCollection();
 298             if (!dict)
 299                 return (false);
 300         } else
 301             dict->retain();
 302         if( fPropertyTable)
 303             fPropertyTable->release();
 304         fPropertyTable = dict;
 305
 306     } else if( !fPropertyTable) {
 307         fPropertyTable = OSDictionary::withCapacity( kIORegCapacityIncrement );
 308         if( fPropertyTable)
 309             fPropertyTable->setCapacityIncrement( kIORegCapacityIncrement );
 310     }
 311
 312     if( !fPropertyTable)
 313         return( false);
 314
 315 #ifdef IOREGSPLITTABLES
 316     if( !fRegistryTable) {
 317         fRegistryTable = OSDictionary::withCapacity( kIORegCapacityIncrement );
 318         if( fRegistryTable)
 319             fRegistryTable->setCapacityIncrement( kIORegCapacityIncrement );
 320     }
 321
 322     if( (prop = OSDynamicCast( OSString, getProperty( gIONameKey)))) {
 323         OSSymbol * sym = (OSSymbol *)OSSymbol::withString( prop);
 324         // ok for OSSymbol too
 325         setName( sym);
 326         sym->release();
 327     }
 328
 329 #endif /* IOREGSPLITTABLES */
 330
 331     return( true);
 332 }
 333
 334 bool IORegistryEntry::init( IORegistryEntry * old,
 335                                 const IORegistryPlane * plane )
 336 {
 337     OSArray *           all;
 338     IORegistryEntry *           next;
 339     unsigned int        index;
 340
 341     if( !super::init())
 342         return( false);
 343
 344     if (!reserved)
 345     {
 346         reserved = IONew(ExpansionData, 1);
 347         if (!reserved) return (false);
 348         bzero(reserved, sizeof(ExpansionData));
 349         reserved->fLock = IORecursiveLockAlloc();
 350         if (!reserved->fLock) return (false);
 351     }
 352
 353     WLOCK;
 354
 355     reserved->fRegistryEntryID = old->reserved->fRegistryEntryID;
 356
 357     fPropertyTable = old->dictionaryWithProperties();
 358 #ifdef IOREGSPLITTABLES
 359     fRegistryTable = old->fRegistryTable;
 360     old->fRegistryTable = (OSDictionary *) fRegistryTable->copyCollection();
 361 #endif /* IOREGSPLITTABLES */
 362
 363     old->registryTable()->removeObject( plane->keys[ kParentSetIndex ] );
 364     old->registryTable()->removeObject( plane->keys[ kChildSetIndex ] );
 365
 366     all = getParentSetReference( plane );
 367     if( all) for( index = 0;
 368               (next = (IORegistryEntry *) all->getObject(index));
 369               index++ ) {
 370             next->makeLink( this, kChildSetIndex, plane );
 371             next->breakLink( old, kChildSetIndex, plane );
 372     }
 373
 374     all = getChildSetReference( plane );
 375     if( all) for( index = 0;
 376               (next = (IORegistryEntry *) all->getObject(index));
 377               index++ ) {
 378             next->makeLink( this, kParentSetIndex, plane );
 379             next->breakLink( old, kParentSetIndex, plane );
 380     }
 381
 382     UNLOCK;
 383
 384     return( true );
 385 }
 386
 387 void IORegistryEntry::free( void )
 388 {
 389 #if DEBUG_FREE
 390     if( registryTable() && gIOServicePlane) {
 391         if( getParentSetReference( gIOServicePlane )
 392             || getChildSetReference( gIOServicePlane )) {
 393             panic("%s: attached at free()", getName());
 394         }
 395     }
 396 #endif
 397
 398     if( getPropertyTable())
 399         getPropertyTable()->release();
 400
 401 #ifdef IOREGSPLITTABLES
 402     if( registryTable())
 403         registryTable()->release();
 404 #endif /* IOREGSPLITTABLES */
 405
 406     if (reserved)
 407     {
 408         if (reserved->fIndexedProperties)
 409         {
 410             for (int idx = 0; idx < kIORegistryEntryIndexedPropertyCount; idx++)
 411             {
 412                 if (reserved->fIndexedProperties[idx]) reserved->fIndexedProperties[idx]->release();
 413             }
 414             IODelete(reserved->fIndexedProperties, OSObject *, kIORegistryEntryIndexedPropertyCount);
 415         }
 416         if (reserved->fLock)              IORecursiveLockFree(reserved->fLock);
 417         IODelete(reserved, ExpansionData, 1);
 418     }
 419
 420     super::free();
 421 }
 422
 423 void IORegistryEntry::setPropertyTable( OSDictionary * dict )
 424 {
 425     if( dict)
 426         dict->retain();
 427     if( fPropertyTable)
 428         fPropertyTable->release();
 429
 430     fPropertyTable = dict;
 431 }
 432
 433 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 434
 435 /* Wrappers to synchronize property table */
 436
 437 #define wrap2(type, constant)                                           \
 438 OSObject *                                                              \
 439 IORegistryEntry::copyProperty( type * aKey) constant                    \
 440 {                                                                       \
 441     OSObject *  obj;                                                    \
 442                                                                         \
 443     PLOCK;                                                              \
 444     obj = getProperty( aKey );                                          \
 445     if( obj)                                                            \
 446         obj->retain();                                                  \
 447     PUNLOCK;                                                            \
 448                                                                         \
 449     return( obj );                                                      \
 450 }
 451
 452 #define wrap4(type,constant) \
 453 OSObject * \
 454 IORegistryEntry::getProperty( type *                  aKey, \
 455                               const IORegistryPlane * plane, \
 456                               IOOptionBits            options ) constant \
 457 { \
 458     OSObject * obj = getProperty( aKey ); \
 459     \
 460     if ( (0 == obj) && plane && (options & kIORegistryIterateRecursively) ) { \
 461         IORegistryEntry * entry = (IORegistryEntry *) this; \
 462         IORegistryIterator * iter; \
 463         iter = IORegistryIterator::iterateOver( entry, plane, options ); \
 464         \
 465         if(iter) { \
 466             while ( (0 == obj) && (entry = iter->getNextObject()) ) { \
 467                 obj = entry->getProperty( aKey ); \
 468             } \
 469             iter->release(); \
 470         } \
 471     } \
 472     \
 473     return( obj ); \
 474 }
 475
 476 #define wrap5(type,constant) \
 477 OSObject * \
 478 IORegistryEntry::copyProperty( type *                  aKey, \
 479                               const IORegistryPlane * plane, \
 480                               IOOptionBits            options ) constant \
 481 { \
 482     OSObject * obj = copyProperty( aKey ); \
 483     \
 484     if ( (0 == obj) && plane && (options & kIORegistryIterateRecursively) ) { \
 485         IORegistryEntry * entry = (IORegistryEntry *) this; \
 486         IORegistryIterator * iter; \
 487         iter = IORegistryIterator::iterateOver( entry, plane, options ); \
 488         \
 489         if(iter) { \
 490             while ( (0 == obj) && (entry = iter->getNextObject()) ) { \
 491                 obj = entry->copyProperty( aKey ); \
 492             } \
 493             iter->release(); \
 494         } \
 495     } \
 496     \
 497     return( obj ); \
 498 }
 499
 500 bool IORegistryEntry::serializeProperties( OSSerialize * s ) const
 501 {
 502 //    setProperty( getRetainCount(), 32, "__retain" );
 503
 504     PLOCK;
 505     OSCollection *snapshotProperties = getPropertyTable()->copyCollection();
 506     PUNLOCK;
 507
 508     if (!snapshotProperties) return (false);
 509
 510     bool ok =  snapshotProperties->serialize( s );
 511     snapshotProperties->release();
 512     return( ok );
 513 }
 514
 515 OSArray * IORegistryEntry::copyPropertyKeys(void) const
 516 {
 517     PLOCK;
 518     OSArray * keys = getPropertyTable()->copyKeys();
 519     PUNLOCK;
 520
 521     return (keys);
 522 }
 523
 524 OSDictionary * IORegistryEntry::dictionaryWithProperties( void ) const
 525 {
 526     OSDictionary *      dict;
 527
 528     PLOCK;
 529     dict = OSDictionary::withDictionary( getPropertyTable(),
 530                             getPropertyTable()->getCapacity() );
 531     PUNLOCK;
 532
 533     return( dict );
 534 }
 535
 536 IOReturn IORegistryEntry::setProperties( OSObject * properties )
 537 {
 538     return( kIOReturnUnsupported );
 539 }
 540
 541 wrap2(const OSSymbol, const)       // copyProperty() definition
 542 wrap2(const OSString, const)       // copyProperty() definition
 543 wrap2(const char, const)           // copyProperty() definition
 544
 545 wrap4(const OSSymbol, const)       // getProperty() w/plane definition
 546 wrap4(const OSString, const)       // getProperty() w/plane definition
 547 wrap4(const char, const)           // getProperty() w/plane definition
 548
 549 wrap5(const OSSymbol, const)       // copyProperty() w/plane definition
 550 wrap5(const OSString, const)       // copyProperty() w/plane definition
 551 wrap5(const char, const)           // copyProperty() w/plane definition
 552
 553
 554 OSObject *
 555 IORegistryEntry::getProperty( const OSSymbol * aKey) const
 556 {
 557     OSObject * obj;
 558
 559     PLOCK;
 560     obj = getPropertyTable()->getObject( aKey );
 561     PUNLOCK;
 562
 563     return( obj );
 564 }
 565
 566 void
 567 IORegistryEntry::removeProperty( const OSSymbol * aKey)
 568 {
 569     PLOCK;
 570     getPropertyTable()->removeObject( aKey );
 571     PUNLOCK;
 572 }
 573
 574 #if KASLR_IOREG_DEBUG
 575 extern "C" {
 576
 577 bool ScanForAddrInObject(OSObject * theObject,
 578                          int indent);
 579
 580 }; /* extern "C" */
 581 #endif
 582
 583 bool
 584 IORegistryEntry::setProperty( const OSSymbol * aKey, OSObject * anObject)
 585 {
 586     bool ret = false;
 587
 588     // If we are inserting a collection class and the current entry
 589     // is attached into the registry (inPlane()) then mark the collection
 590     // as immutable.
 591     OSCollection *coll = OSDynamicCast(OSCollection, anObject);
 592     bool makeImmutable = (coll && inPlane());
 593
 594     PLOCK;
 595     if( makeImmutable )
 596         coll->setOptions( OSCollection::kMASK, OSCollection::kImmutable );
 597
 598     ret = getPropertyTable()->setObject( aKey, anObject );
 599     PUNLOCK;
 600
 601 #if KASLR_IOREG_DEBUG
 602     if ( anObject && strcmp(kIOKitDiagnosticsKey, aKey->getCStringNoCopy()) != 0 ) {
 603         if (ScanForAddrInObject(anObject, 0)) {
 604             IOLog("%s: IORegistryEntry name %s with key \"%s\" \n",
 605                   __FUNCTION__,
 606                   getName(0),
 607                   aKey->getCStringNoCopy() );
 608         }
 609     }
 610 #endif
 611
 612     return ret;
 613 }
 614
 615 IOReturn IORegistryEntry::
 616 runPropertyAction(Action inAction, OSObject *target,
 617         void *arg0, void *arg1, void *arg2, void *arg3)
 618 {
 619     IOReturn res;
 620
 621     // closeGate is recursive so don't worry if we already hold the lock.
 622     PLOCK;
 623     res = (*inAction)(target, arg0, arg1, arg2, arg3);
 624     PUNLOCK;
 625
 626     return res;
 627 }
 628
 629 OSObject *
 630 IORegistryEntry::getProperty( const OSString * aKey) const
 631 {
 632     const OSSymbol * tmpKey = OSSymbol::withString( aKey );
 633     OSObject * obj = getProperty( tmpKey );
 634
 635     tmpKey->release();
 636     return( obj );
 637 }
 638
 639 OSObject *
 640 IORegistryEntry::getProperty( const char * aKey) const
 641 {
 642     const OSSymbol * tmpKey = OSSymbol::withCString( aKey );
 643     OSObject * obj = getProperty( tmpKey );
 644
 645     tmpKey->release();
 646     return( obj );
 647 }
 648
 649
 650 void
 651 IORegistryEntry::removeProperty( const OSString * aKey)
 652 {
 653     const OSSymbol * tmpKey = OSSymbol::withString( aKey );
 654     removeProperty( tmpKey );
 655     tmpKey->release();
 656 }
 657
 658 void
 659 IORegistryEntry::removeProperty( const char * aKey)
 660 {
 661     const OSSymbol * tmpKey = OSSymbol::withCString( aKey );
 662     removeProperty( tmpKey );
 663     tmpKey->release();
 664 }
 665
 666 bool
 667 IORegistryEntry::setProperty( const OSString * aKey, OSObject * anObject)
 668 {
 669     const OSSymbol * tmpKey = OSSymbol::withString( aKey );
 670     bool ret = setProperty( tmpKey, anObject );
 671
 672     tmpKey->release();
 673     return ret;
 674 }
 675
 676 bool
 677 IORegistryEntry::setProperty( const char * aKey,  OSObject * anObject)
 678 {
 679     const OSSymbol * tmpKey = OSSymbol::withCString( aKey );
 680     bool ret = setProperty( tmpKey, anObject );
 681
 682     tmpKey->release();
 683     return ret;
 684 }
 685
 686 bool
 687 IORegistryEntry::setProperty(const char * aKey, const char * aString)
 688 {
 689     bool ret = false;
 690     OSSymbol * aSymbol = (OSSymbol *) OSSymbol::withCString( aString );
 691
 692     if( aSymbol) {
 693         const OSSymbol * tmpKey = OSSymbol::withCString( aKey );
 694         ret = setProperty( tmpKey, aSymbol );
 695
 696         tmpKey->release();
 697         aSymbol->release();
 698     }
 699     return( ret );
 700 }
 701
 702 bool
 703 IORegistryEntry::setProperty(const char * aKey, bool aBoolean)
 704 {
 705     bool ret = false;
 706     OSBoolean * aBooleanObj = OSBoolean::withBoolean( aBoolean );
 707
 708     if( aBooleanObj) {
 709         const OSSymbol * tmpKey = OSSymbol::withCString( aKey );
 710         ret = setProperty( tmpKey, aBooleanObj );
 711
 712         tmpKey->release();
 713         aBooleanObj->release();
 714     }
 715     return( ret );
 716 }
 717
 718 bool
 719 IORegistryEntry::setProperty( const char *       aKey,
 720                               unsigned long long aValue,
 721                               unsigned int       aNumberOfBits)
 722 {
 723     bool ret = false;
 724     OSNumber * anOffset = OSNumber::withNumber( aValue, aNumberOfBits );
 725
 726     if( anOffset) {
 727         const OSSymbol * tmpKey = OSSymbol::withCString( aKey );
 728         ret = setProperty( tmpKey, anOffset );
 729
 730         tmpKey->release();
 731         anOffset->release();
 732     }
 733     return( ret );
 734 }
 735
 736 bool
 737 IORegistryEntry::setProperty( const char *      aKey,
 738                               void *            bytes,
 739                               unsigned int      length)
 740 {
 741     bool ret = false;
 742     OSData * data = OSData::withBytes( bytes, length );
 743
 744     if( data) {
 745         const OSSymbol * tmpKey = OSSymbol::withCString( aKey );
 746         ret = setProperty( tmpKey, data );
 747
 748         tmpKey->release();
 749         data->release();
 750     }
 751     return( ret );
 752 }
 753
 754 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 755
 756 OSObject * IORegistryEntry::setIndexedProperty(uint32_t index, OSObject * anObject)
 757 {
 758     OSObject ** array;
 759     OSObject *  prior;
 760
 761     if (index >= kIORegistryEntryIndexedPropertyCount) return (0);
 762
 763     array = atomic_load_explicit(&reserved->fIndexedProperties, memory_order_acquire);
 764     if (!array)
 765     {
 766         array = IONew(OSObject *, kIORegistryEntryIndexedPropertyCount);
 767         if (!array) return (0);
 768         bzero(array, kIORegistryEntryIndexedPropertyCount * sizeof(array[0]));
 769         if (!OSCompareAndSwapPtr(NULL, array, &reserved->fIndexedProperties)) IODelete(array, OSObject *, kIORegistryEntryIndexedPropertyCount);
 770     }
 771     if (!reserved->fIndexedProperties) return (0);
 772
 773     prior = reserved->fIndexedProperties[index];
 774     if (anObject) anObject->retain();
 775     reserved->fIndexedProperties[index] = anObject;
 776
 777     return (prior);
 778 }
 779
 780 OSObject * IORegistryEntry::getIndexedProperty(uint32_t index) const
 781 {
 782     if (index >= kIORegistryEntryIndexedPropertyCount) return (0);
 783     if (!reserved->fIndexedProperties) return (0);
 784
 785     return (reserved->fIndexedProperties[index]);
 786 }
 787
 788 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 789
 790 /* Name, location, paths */
 791
 792 const char * IORegistryEntry::getName( const IORegistryPlane * plane ) const
 793 {
 794     OSSymbol *          sym = 0;
 795
 796     RLOCK;
 797     if( plane)
 798         sym = (OSSymbol *) registryTable()->getObject( plane->pathNameKey );
 799     if( !sym)
 800         sym = (OSSymbol *) registryTable()->getObject( gIONameKey );
 801     UNLOCK;
 802
 803     if( sym)
 804         return( sym->getCStringNoCopy());
 805     else
 806         return( (getMetaClass())->getClassName());
 807 }
 808
 809 const OSSymbol * IORegistryEntry::copyName(
 810                         const IORegistryPlane * plane ) const
 811 {
 812     OSSymbol *          sym = 0;
 813
 814     RLOCK;
 815     if( plane)
 816         sym = (OSSymbol *) registryTable()->getObject( plane->pathNameKey );
 817     if( !sym)
 818         sym = (OSSymbol *) registryTable()->getObject( gIONameKey );
 819     if( sym)
 820         sym->retain();
 821     UNLOCK;
 822
 823     if( sym)
 824         return( sym );
 825     else
 826         return( OSSymbol::withCString((getMetaClass())->getClassName()) );
 827 }
 828
 829 const OSSymbol * IORegistryEntry::copyLocation(
 830                         const IORegistryPlane * plane ) const
 831 {
 832     OSSymbol *          sym = 0;
 833
 834     RLOCK;
 835     if( plane)
 836         sym = (OSSymbol *) registryTable()->getObject( plane->pathLocationKey );
 837     if( !sym)
 838         sym = (OSSymbol *) registryTable()->getObject( gIOLocationKey );
 839     if( sym)
 840         sym->retain();
 841     UNLOCK;
 842
 843     return( sym );
 844 }
 845
 846 const char * IORegistryEntry::getLocation( const IORegistryPlane * plane ) const
 847 {
 848     const OSSymbol *    sym = copyLocation( plane );
 849     const char *        result = 0;
 850
 851     if( sym) {
 852         result = sym->getCStringNoCopy();
 853         sym->release();
 854     }
 855
 856     return( result );
 857 }
 858
 859 void IORegistryEntry::setName( const OSSymbol * name,
 860                             const IORegistryPlane * plane )
 861 {
 862     const OSSymbol *    key;
 863
 864     if( name) {
 865         if( plane)
 866             key = plane->pathNameKey;
 867         else
 868             key = gIONameKey;
 869
 870         if (gIOKitTrace && reserved && reserved->fRegistryEntryID)
 871         {
 872             uint64_t str_id = 0;
 873             uint64_t __unused regID = getRegistryEntryID();
 874             kernel_debug_string(IODBG_IOREGISTRY(IOREGISTRYENTRY_NAME_STRING), &str_id, name->getCStringNoCopy());
 875             KERNEL_DEBUG_CONSTANT(IODBG_IOREGISTRY(IOREGISTRYENTRY_NAME),
 876                 (uintptr_t) regID,
 877                 (uintptr_t) (regID >> 32),
 878                 (uintptr_t) str_id,
 879                 (uintptr_t) (str_id >> 32),
 880                 0);
 881         }
 882
 883         WLOCK;
 884         registryTable()->setObject( key, (OSObject *) name);
 885         UNLOCK;
 886     }
 887 }
 888
 889 void IORegistryEntry::setName( const char * name,
 890                             const IORegistryPlane * plane )
 891 {
 892     OSSymbol * sym = (OSSymbol *)OSSymbol::withCString( name );
 893     if ( sym ) {
 894         setName( sym, plane );
 895         sym->release();
 896     }
 897 }
 898
 899 void IORegistryEntry::setLocation( const OSSymbol * location,
 900                             const IORegistryPlane * plane )
 901 {
 902     const OSSymbol *    key;
 903
 904     if( location) {
 905         if( plane)
 906             key = plane->pathLocationKey;
 907         else
 908             key = gIOLocationKey;
 909
 910         WLOCK;
 911         registryTable()->setObject( key, (OSObject *) location);
 912         UNLOCK;
 913     }
 914 }
 915
 916 void IORegistryEntry::setLocation( const char * location,
 917                             const IORegistryPlane * plane )
 918 {
 919     OSSymbol * sym = (OSSymbol *)OSSymbol::withCString( location );
 920     if ( sym ) {
 921         setLocation( sym, plane );
 922         sym->release();
 923     }
 924 }
 925
 926 bool
 927 IORegistryEntry::compareName( OSString * name, OSString ** matched ) const
 928 {
 929     const OSSymbol *    sym = copyName();
 930     bool                isEqual;
 931
 932     isEqual = (sym && sym->isEqualTo(name));
 933
 934     if( isEqual && matched) {
 935         name->retain();
 936         *matched = name;
 937     }
 938
 939     if( sym)
 940         sym->release();
 941
 942     return( isEqual );
 943 }
 944
 945 bool
 946 IORegistryEntry::compareNames( OSObject * names, OSString ** matched ) const
 947 {
 948     OSString *          string;
 949     OSCollection *      collection;
 950     OSIterator *        iter = 0;
 951     bool                result = false;
 952
 953     if( (collection = OSDynamicCast( OSCollection, names))) {
 954         iter = OSCollectionIterator::withCollection( collection );
 955         string = 0;
 956     } else
 957         string = OSDynamicCast( OSString, names);
 958
 959     do {
 960         if( string)
 961             result = compareName( string, matched );
 962
 963     } while( (false == result)
 964         && iter && (string = OSDynamicCast( OSString, iter->getNextObject())));
 965
 966     if( iter)
 967         iter->release();
 968
 969     return( result);
 970 }
 971
 972
 973 bool IORegistryEntry::getPath(  char * path, int * length,
 974                                 const IORegistryPlane * plane ) const
 975 {
 976     OSArray *           stack;
 977     IORegistryEntry *   root;
 978     const IORegistryEntry * entry;
 979     const IORegistryEntry * parent;
 980     const OSSymbol *    alias;
 981     int                 index;
 982     int                 len, maxLength, compLen, aliasLen;
 983     char *              nextComp;
 984     bool                ok;
 985
 986    if( !path || !length || !plane)
 987         return( false);
 988
 989     len = 0;
 990     maxLength = *length - 2;
 991     nextComp = path;
 992
 993     len = plane->nameKey->getLength();
 994     if( len >= maxLength)
 995         return( false);
 996     strlcpy( nextComp, plane->nameKey->getCStringNoCopy(), len + 1);
 997     nextComp[ len++ ] = ':';
 998     nextComp += len;
 999
1000     if( (alias = hasAlias( plane ))) {
1001         aliasLen = alias->getLength();
1002         len += aliasLen;
1003         ok = (maxLength > len);
1004         *length = len;
1005         if( ok)
1006             strlcpy( nextComp, alias->getCStringNoCopy(), aliasLen + 1);
1007         return( ok );
1008     }
1009
1010     stack = OSArray::withCapacity( getDepth( plane ));
1011     if (!stack) return( false);
1012
1013     RLOCK;
1014
1015     parent = entry = this;
1016     root = gRegistryRoot->getChildEntry( plane );
1017     while (parent && (parent != root))
1018     {
1019         // stop below root
1020         entry = parent;
1021         parent = entry->getParentEntry( plane );
1022         stack->setObject( (OSObject *) entry );
1023     }
1024
1025     ok = (0 != parent);
1026     if (ok)
1027     {
1028         index = stack->getCount();
1029         if( 0 == index) {
1030
1031             *nextComp++ = '/';
1032             *nextComp = 0;
1033             len++;
1034
1035         } else while( ok && ((--index) >= 0)) {
1036
1037             entry = (IORegistryEntry *) stack->getObject((unsigned int) index );
1038             assert( entry );
1039
1040             if( (alias = entry->hasAlias( plane ))) {
1041                 len = plane->nameKey->getLength() + 1;
1042                 nextComp = path + len;
1043
1044                 compLen = alias->getLength();
1045                 ok = (maxLength > (len + compLen));
1046                 if( ok)
1047                     strlcpy( nextComp, alias->getCStringNoCopy(), compLen + 1);
1048             } else {
1049                 compLen = maxLength - len;
1050                 ok = entry->getPathComponent( nextComp + 1, &compLen, plane );
1051
1052                 if( ok && compLen) {
1053                     compLen++;
1054                     *nextComp = '/';
1055                 }
1056             }
1057
1058             if( ok) {
1059                 len += compLen;
1060                 nextComp += compLen;
1061             }
1062         }
1063         *length = len;
1064     }
1065     UNLOCK;
1066     stack->release();
1067
1068     return( ok );
1069 }
1070
1071 bool IORegistryEntry::getPathComponent( char * path, int * length,
1072                                         const IORegistryPlane * plane ) const
1073 {
1074     int                 len, locLen, maxLength;
1075     const char *        compName;
1076     const char *        loc;
1077     bool                ok;
1078
1079     maxLength = *length;
1080
1081     compName = getName( plane );
1082     len = strlen( compName );
1083     if( (loc = getLocation( plane )))
1084         locLen = 1 + strlen( loc );
1085     else
1086         locLen = 0;
1087
1088     ok = ((len + locLen + 1) < maxLength);
1089     if( ok) {
1090         strlcpy( path, compName, len + 1 );
1091         if( loc) {
1092             path += len;
1093             len += locLen;
1094             *path++ = '@';
1095             strlcpy( path, loc, locLen );
1096         }
1097         *length = len;
1098     }
1099
1100     return( ok );
1101 }
1102
1103 const char * IORegistryEntry::matchPathLocation( const char * cmp,
1104                                 const IORegistryPlane * plane )
1105 {
1106     const char  *       str;
1107     const char  *       result = 0;
1108     u_quad_t            num1, num2;
1109     char                lastPathChar, lastLocationChar;
1110
1111     str = getLocation( plane );
1112     if( str) {
1113         lastPathChar = cmp[0];
1114         lastLocationChar = str[0];
1115         do {
1116             if( lastPathChar) {
1117                 num1 = strtouq( cmp, (char **) &cmp, 16 );
1118                 lastPathChar = *cmp++;
1119             } else
1120                 num1 = 0;
1121
1122             if( lastLocationChar) {
1123                 num2 = strtouq( str, (char **) &str, 16 );
1124                 lastLocationChar = *str++;
1125             } else
1126                 num2 = 0;
1127
1128             if( num1 != num2)
1129                 break;
1130
1131             if (!lastPathChar && !lastLocationChar) {
1132                 result = cmp - 1;
1133                 break;
1134             }
1135
1136             if( (',' != lastPathChar) && (':' != lastPathChar))
1137                 lastPathChar = 0;
1138
1139             if (lastPathChar && lastLocationChar && (lastPathChar != lastLocationChar))
1140                 break;
1141
1142         } while( true);
1143     }
1144
1145     return( result );
1146 }
1147
1148 IORegistryEntry * IORegistryEntry::getChildFromComponent( const char ** opath,
1149                                 const IORegistryPlane * plane )
1150 {
1151     IORegistryEntry *   entry = 0;
1152     OSArray *           set;
1153     unsigned int        index;
1154     const char *        path;
1155     const char *        cmp = 0;
1156     char                c;
1157     size_t              len;
1158     const char *        str;
1159
1160     set = getChildSetReference( plane );
1161     if( set) {
1162
1163         path = *opath;
1164
1165         for( index = 0;
1166              (entry = (IORegistryEntry *) set->getObject(index));
1167              index++ ) {
1168
1169             cmp = path;
1170
1171             if( *cmp != '@') {
1172                 str = entry->getName( plane );
1173                 len = strlen( str );
1174                 if( strncmp( str, cmp, len ))
1175                     continue;
1176                 cmp += len;
1177
1178                 c = *cmp;
1179                 if( (c == 0) || (c == '/') || (c == ':'))
1180                     break;
1181                 if( c != '@')
1182                     continue;
1183             }
1184             cmp++;
1185             if( (cmp = entry->matchPathLocation( cmp, plane )))
1186                 break;
1187         }
1188         if( entry)
1189             *opath = cmp;
1190     }
1191
1192     return( entry );
1193 }
1194
1195 const OSSymbol * IORegistryEntry::hasAlias( const IORegistryPlane * plane,
1196                                 char * opath, int * length ) const
1197 {
1198     IORegistryEntry *   entry;
1199     IORegistryEntry *   entry2;
1200     const OSSymbol *    key;
1201     const OSSymbol *    bestKey = 0;
1202     OSIterator *        iter;
1203     OSData *            data;
1204     const char *        path = "/aliases";
1205
1206     entry = IORegistryEntry::fromPath( path, plane );
1207     if( entry) {
1208         RLOCK;
1209         if( (iter = OSCollectionIterator::withCollection(
1210                                 entry->getPropertyTable() ))) {
1211
1212             while( (key = (OSSymbol *) iter->getNextObject())) {
1213
1214                 data = (OSData *) entry->getProperty( key );
1215                 path = (const char *) data->getBytesNoCopy();
1216                 if( (entry2 = IORegistryEntry::fromPath( path, plane,
1217                                                 opath, length ))) {
1218                     if( this == entry2) {
1219                         if( !bestKey
1220                          || (bestKey->getLength() > key->getLength()))
1221                             // pick the smallest alias
1222                             bestKey = key;
1223                     }
1224                     entry2->release();
1225                 }
1226             }
1227             iter->release();
1228         }
1229         entry->release();
1230         UNLOCK;
1231     }
1232     return( bestKey );
1233 }
1234
1235 const char * IORegistryEntry::dealiasPath(
1236                         const char **           opath,
1237                         const IORegistryPlane * plane )
1238 {
1239     IORegistryEntry *   entry;
1240     OSData *            data;
1241     const char *        path = *opath;
1242     const char *        rpath = 0;
1243     const char *        end;
1244     char                c;
1245     char                temp[ kIOMaxPlaneName + 1 ];
1246
1247     if( path[0] == '/')
1248         return( rpath );
1249
1250     // check for alias
1251     end = path;
1252     while( (c = *end++) && (c != '/') && (c != ':'))
1253         {}
1254     end--;
1255     if( (end - path) < kIOMaxPlaneName) {
1256         strlcpy( temp, path, end - path + 1 );
1257
1258         RLOCK;
1259         entry = IORegistryEntry::fromPath( "/aliases", plane );
1260         if( entry) {
1261             data = (OSData *) entry->getProperty( temp );
1262             if( data ) {
1263                 rpath = (const char *) data->getBytesNoCopy();
1264                 if( rpath)
1265                     *opath = end;
1266             }
1267             entry->release();
1268         }
1269         UNLOCK;
1270     }
1271
1272     return( rpath );
1273 }
1274
1275 IORegistryEntry * IORegistryEntry::fromPath(
1276                         const char *            path,
1277                         const IORegistryPlane * plane,
1278                         char *                  opath,
1279                         int *                   length,
1280                         IORegistryEntry *       fromEntry )
1281 {
1282     IORegistryEntry *   where = 0;
1283     IORegistryEntry *   aliasEntry = 0;
1284     IORegistryEntry *   next;
1285     const char *        alias;
1286     const char *        end;
1287     int                 len = 0;
1288     int                 len2;
1289     char                c;
1290     char                temp[ kIOMaxPlaneName + 1 ];
1291
1292     if( 0 == path)
1293         return( 0 );
1294
1295     if( 0 == plane) {
1296         // get plane name
1297         end = strchr( path, ':' );
1298         if( end && ((end - path) < kIOMaxPlaneName)) {
1299             strlcpy( temp, path, end - path + 1 );
1300             plane = getPlane( temp );
1301             path = end + 1;
1302         }
1303     }
1304     if( 0 == plane)
1305         return( 0 );
1306
1307     // check for alias
1308     end = path;
1309     if( (alias = dealiasPath( &end, plane))) {
1310         if( length)
1311             len = *length;
1312         aliasEntry = IORegistryEntry::fromPath( alias, plane,
1313                                     opath, &len, fromEntry );
1314         where = aliasEntry;
1315         if( where)
1316             path = end;
1317         else
1318             len = 0;
1319     }
1320
1321     RLOCK;
1322
1323     do {
1324         if( 0 == where) {
1325             if( (0 == fromEntry) && (*path++ == '/'))
1326                 fromEntry = gRegistryRoot->getChildEntry( plane );
1327             where = fromEntry;
1328             if( 0 == where)
1329                 break;
1330         } else {
1331             c = *path++;
1332             if( c != '/') {
1333                 if( c && (c != ':'))    // check valid terminator
1334                     where = 0;
1335                 break;
1336             }
1337         }
1338         next = where->getChildFromComponent( &path, plane );
1339         if( next)
1340             where = next;
1341     } while( next );
1342
1343     if( where) {
1344         // check residual path
1345         if( where != fromEntry)
1346             path--;
1347
1348         if( opath && length) {
1349             // copy out residual path
1350             len2 = strlen( path );
1351             if( (len + len2) < *length)
1352                 strlcpy( opath + len, path, len2 + 1 );
1353             *length = (len + len2);
1354
1355         } else if( path[0])
1356             // no residual path => must be no tail for success
1357             where = 0;
1358     }
1359
1360     if( where)
1361         where->retain();
1362     if( aliasEntry)
1363         aliasEntry->release();
1364
1365     UNLOCK;
1366
1367     return( where );
1368 }
1369
1370 IORegistryEntry * IORegistryEntry::childFromPath(
1371                         const char *            path,
1372                         const IORegistryPlane * plane,
1373                         char *                  opath,
1374                         int *                   len )
1375 {
1376     return( IORegistryEntry::fromPath( path, plane, opath, len, this ));
1377 }
1378
1379 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1380
1381 #define IOLinkIterator OSCollectionIterator
1382
1383 #undef super
1384 #define super OSObject
1385
1386 inline bool IORegistryEntry::arrayMember( OSArray * set,
1387                                           const IORegistryEntry * member,
1388                                         unsigned int * index ) const
1389 {
1390     int         i;
1391     OSObject *  probeObject;
1392
1393     for( i = 0; (probeObject = set->getObject(i)); i++) {
1394         if (probeObject == (OSObject *) member) {
1395             if( index)
1396                 *index = i;
1397             return( true );
1398         }
1399     }
1400     return( false );
1401 }
1402
1403 bool IORegistryEntry::makeLink( IORegistryEntry * to,
1404                                 unsigned int relation,
1405                                 const IORegistryPlane * plane ) const
1406 {
1407     OSArray *   links;
1408     bool        result = false;
1409
1410     if( (links = (OSArray *)
1411                 registryTable()->getObject( plane->keys[ relation ] ))) {
1412
1413         result = arrayMember( links, to );
1414         if( !result)
1415             result = links->setObject( to );
1416
1417     } else {
1418
1419         links = OSArray::withObjects( (const OSObject **) &to, 1, 1 );
1420         result = (links != 0);
1421         if( result) {
1422             result = registryTable()->setObject( plane->keys[ relation ],
1423                                           links );
1424             links->release();
1425         }
1426     }
1427     reserved->fRegistryEntryGenerationCount++;
1428
1429     return( result);
1430 }
1431
1432 void IORegistryEntry::breakLink( IORegistryEntry * to,
1433                                  unsigned int relation,
1434                                  const IORegistryPlane * plane ) const
1435 {
1436     OSArray *           links;
1437     unsigned int        index;
1438
1439     if( (links = (OSArray *)
1440                 registryTable()->getObject( plane->keys[ relation ]))) {
1441
1442         if( arrayMember( links, to, &index )) {
1443             links->removeObject( index );
1444             if( 0 == links->getCount())
1445                 registryTable()->removeObject( plane->keys[ relation ]);
1446             }
1447     }
1448     reserved->fRegistryEntryGenerationCount++;
1449 }
1450
1451
1452 OSArray * IORegistryEntry::getParentSetReference(
1453                                 const IORegistryPlane * plane ) const
1454 {
1455     if( plane)
1456         return( (OSArray *) registryTable()->getObject(
1457                             plane->keys[ kParentSetIndex ]));
1458     else
1459         return( 0 );
1460 }
1461
1462 OSIterator * IORegistryEntry::getParentIterator(
1463                                 const IORegistryPlane * plane ) const
1464 {
1465     OSArray *           links;
1466     OSIterator *        iter;
1467
1468     if( !plane)
1469         return( 0 );
1470
1471     RLOCK;
1472     links = getParentSetReference( plane );
1473     if( 0 == links)
1474         links = OSArray::withCapacity( 1 );
1475     else
1476         links = OSArray::withArray( links, links->getCount() );
1477     UNLOCK;
1478
1479     iter = IOLinkIterator::withCollection( links );
1480
1481     if( links)
1482         links->release();
1483
1484     return( iter );
1485 }
1486
1487 IORegistryEntry * IORegistryEntry::copyParentEntry( const IORegistryPlane * plane ) const
1488 {
1489     IORegistryEntry *   entry = 0;
1490     OSArray *           links;
1491
1492     RLOCK;
1493
1494     if( (links = getParentSetReference( plane ))) {
1495         entry = (IORegistryEntry *) links->getObject( 0 );
1496         entry->retain();
1497     }
1498
1499     UNLOCK;
1500
1501     return( entry);
1502 }
1503
1504 IORegistryEntry * IORegistryEntry::getParentEntry( const IORegistryPlane * plane ) const
1505 {
1506     IORegistryEntry * entry;
1507
1508     entry = copyParentEntry( plane );
1509     if( entry)
1510         entry->release();
1511
1512     return( entry );
1513 }
1514
1515 OSArray * IORegistryEntry::getChildSetReference( const IORegistryPlane * plane ) const
1516 {
1517     if( plane)
1518         return( (OSArray *) registryTable()->getObject(
1519                             plane->keys[ kChildSetIndex ]));
1520     else
1521         return( 0 );
1522 }
1523
1524 OSIterator * IORegistryEntry::getChildIterator( const IORegistryPlane * plane ) const
1525 {
1526     OSArray *           links;
1527     OSIterator *        iter;
1528
1529     if( !plane)
1530         return( 0 );
1531
1532     RLOCK;
1533     links = getChildSetReference( plane );
1534     if( 0 == links)
1535         links = OSArray::withCapacity( 1 );
1536     else
1537         links = OSArray::withArray( links, links->getCount() );
1538     UNLOCK;
1539
1540     iter = IOLinkIterator::withCollection( links );
1541
1542     if( links)
1543         links->release();
1544
1545     return( iter );
1546 }
1547
1548 uint32_t IORegistryEntry::getChildCount( const IORegistryPlane * plane ) const
1549 {
1550     OSArray * links;
1551     uint32_t  count = 0;
1552
1553     RLOCK;
1554     links = getChildSetReference( plane );
1555     if (links) count = links->getCount();
1556     UNLOCK;
1557
1558     return (count);
1559 }
1560
1561 IORegistryEntry * IORegistryEntry::copyChildEntry(
1562                                 const IORegistryPlane * plane ) const
1563 {
1564     IORegistryEntry *   entry = 0;
1565     OSArray *           links;
1566
1567     RLOCK;
1568
1569     if( (links = getChildSetReference( plane ))) {
1570         entry = (IORegistryEntry *) links->getObject( 0 );
1571         entry->retain();
1572     }
1573
1574     UNLOCK;
1575
1576     return( entry);
1577 }
1578
1579 IORegistryEntry * IORegistryEntry::getChildEntry(
1580                                 const IORegistryPlane * plane ) const
1581 {
1582     IORegistryEntry * entry;
1583
1584     entry = copyChildEntry( plane );
1585     if( entry)
1586         entry->release();
1587
1588     return( entry );
1589 }
1590
1591 void IORegistryEntry::applyToChildren( IORegistryEntryApplierFunction applier,
1592                                        void * context,
1593                                        const IORegistryPlane * plane ) const
1594 {
1595     OSArray *           array;
1596     unsigned int        index;
1597     IORegistryEntry *   next;
1598
1599     if( !plane)
1600         return;
1601
1602     RLOCK;
1603     array = OSArray::withArray( getChildSetReference( plane ));
1604     UNLOCK;
1605     if( array) {
1606         for( index = 0;
1607              (next = (IORegistryEntry *) array->getObject( index ));
1608              index++)
1609             (*applier)(next, context);
1610         array->release();
1611     }
1612 }
1613
1614 void IORegistryEntry::applyToParents( IORegistryEntryApplierFunction applier,
1615                                       void * context,
1616                                       const IORegistryPlane * plane ) const
1617 {
1618     OSArray *           array;
1619     unsigned int        index;
1620     IORegistryEntry *   next;
1621
1622     if( !plane)
1623         return;
1624
1625     RLOCK;
1626     array = OSArray::withArray( getParentSetReference( plane ));
1627     UNLOCK;
1628     if( array) {
1629         for( index = 0;
1630              (next = (IORegistryEntry *) array->getObject( index ));
1631              index++)
1632             (*applier)(next, context);
1633         array->release();
1634     }
1635 }
1636
1637 bool IORegistryEntry::isChild( IORegistryEntry * child,
1638                                 const IORegistryPlane * plane,
1639                                 bool onlyChild ) const
1640 {
1641     OSArray *   links;
1642     bool        ret = false;
1643
1644     RLOCK;
1645
1646     if( (links = getChildSetReference( plane ))) {
1647         if( (!onlyChild) || (1 == links->getCount()))
1648             ret = arrayMember( links, child );
1649     }
1650     if( ret && (links = child->getParentSetReference( plane )))
1651         ret = arrayMember( links, this );
1652
1653     UNLOCK;
1654
1655     return( ret);
1656 }
1657
1658 bool IORegistryEntry::isParent( IORegistryEntry * parent,
1659                                 const IORegistryPlane * plane,
1660                                 bool onlyParent ) const
1661
1662 {
1663     OSArray *   links;
1664     bool        ret = false;
1665
1666     RLOCK;
1667
1668     if( (links = getParentSetReference( plane ))) {
1669         if( (!onlyParent) || (1 == links->getCount()))
1670             ret = arrayMember( links, parent );
1671     }
1672     if( ret && (links = parent->getChildSetReference( plane )))
1673         ret = arrayMember( links, this );
1674
1675     UNLOCK;
1676
1677     return( ret);
1678 }
1679
1680 bool IORegistryEntry::inPlane( const IORegistryPlane * plane ) const
1681 {
1682     bool ret;
1683
1684     RLOCK;
1685
1686     if( plane)
1687         ret = (0 != getParentSetReference( plane ));
1688     else {
1689
1690         // Check to see if this is in any plane.  If it is in a plane
1691         // then the registryTable will contain a key with the ParentLinks
1692         // suffix.  When we iterate over the keys looking for that suffix
1693         ret = false;
1694
1695         OSCollectionIterator *iter =
1696             OSCollectionIterator::withCollection( registryTable());
1697         if( iter) {
1698             const OSSymbol *key;
1699
1700             while( (key = (OSSymbol *) iter->getNextObject()) ) {
1701                 size_t keysuffix;
1702
1703                 // Get a pointer to this keys suffix
1704                 keysuffix = key->getLength();
1705                 if (keysuffix <= kIORegPlaneParentSuffixLen)
1706                     continue;
1707                 keysuffix -= kIORegPlaneParentSuffixLen;
1708                 if( !strncmp(key->getCStringNoCopy() + keysuffix,
1709                                 kIORegPlaneParentSuffix,
1710                                 kIORegPlaneParentSuffixLen + 1) ) {
1711                     ret = true;
1712                     break;
1713                 }
1714             }
1715             iter->release();
1716         }
1717     }
1718
1719     UNLOCK;
1720
1721     return( ret );
1722 }
1723
1724 bool IORegistryEntry::attachToParent( IORegistryEntry * parent,
1725                                 const IORegistryPlane * plane )
1726 {
1727     OSArray *   links;
1728     bool        ret;
1729     bool        needParent;
1730     bool        traceName = false;
1731
1732     if( this == parent)
1733         return( false );
1734
1735     WLOCK;
1736
1737     if (!reserved->fRegistryEntryID)
1738     {
1739         reserved->fRegistryEntryID = ++gIORegistryLastID;
1740         traceName = (0 != gIOKitTrace);
1741     }
1742
1743     ret = makeLink( parent, kParentSetIndex, plane );
1744
1745     if( (links = parent->getChildSetReference( plane )))
1746         needParent = (false == arrayMember( links, this ));
1747     else
1748         needParent = true;
1749
1750     UNLOCK;
1751
1752     if (traceName)
1753     {
1754         uint64_t str_id = 0;
1755         uint64_t __unused regID = getRegistryEntryID();
1756         kernel_debug_string(IODBG_IOREGISTRY(IOREGISTRYENTRY_NAME_STRING), &str_id, getName());
1757         KERNEL_DEBUG_CONSTANT(IODBG_IOREGISTRY(IOREGISTRYENTRY_NAME),
1758             (uintptr_t) regID,
1759             (uintptr_t) (regID >> 32),
1760             (uintptr_t) str_id,
1761             (uintptr_t) (str_id >> 32),
1762             0);
1763     }
1764
1765     PLOCK;
1766
1767     // Mark any collections in the property list as immutable
1768     OSDictionary *ptable = getPropertyTable();
1769     OSCollectionIterator *iter =
1770         OSCollectionIterator::withCollection( ptable );
1771     if( iter) {
1772         const OSSymbol *key;
1773
1774         while( (key = (OSSymbol *) iter->getNextObject( ))) {
1775             // Is object for key a collection?
1776             OSCollection *coll =
1777                 OSDynamicCast( OSCollection, ptable->getObject( key ));
1778
1779             if( coll) {
1780                 // Yup so mark it as immutable
1781                 coll->setOptions( OSCollection::kMASK,
1782                                   OSCollection::kImmutable );
1783             }
1784         }
1785         iter->release();
1786     }
1787
1788     PUNLOCK;
1789
1790     if( needParent)
1791         ret &= parent->attachToChild( this, plane );
1792
1793     return( ret );
1794 }
1795
1796 uint64_t IORegistryEntry::getRegistryEntryID( void )
1797 {
1798     if (reserved)
1799         return (reserved->fRegistryEntryID);
1800     else
1801         return (0);
1802 }
1803
1804 bool IORegistryEntry::attachToChild( IORegistryEntry * child,
1805                                         const IORegistryPlane * plane )
1806 {
1807     OSArray *   links;
1808     bool        ret;
1809     bool        needChild;
1810
1811     if( this == child)
1812         return( false );
1813
1814     WLOCK;
1815
1816     ret = makeLink( child, kChildSetIndex, plane );
1817
1818     if( (links = child->getParentSetReference( plane )))
1819         needChild = (false == arrayMember( links, this ));
1820     else
1821         needChild = true;
1822
1823     UNLOCK;
1824
1825     if( needChild)
1826         ret &= child->attachToParent( this, plane );
1827
1828     return( ret );
1829 }
1830
1831 void IORegistryEntry::detachFromParent( IORegistryEntry * parent,
1832                                 const IORegistryPlane * plane )
1833 {
1834     OSArray *   links;
1835     bool        needParent;
1836
1837     WLOCK;
1838
1839     parent->retain();
1840
1841     breakLink( parent, kParentSetIndex, plane );
1842
1843     if( (links = parent->getChildSetReference( plane )))
1844         needParent = arrayMember( links, this );
1845     else
1846         needParent = false;
1847
1848 //    parent->breakLink( this, kChildSetIndex, plane );
1849
1850     UNLOCK;
1851
1852     if( needParent)
1853         parent->detachFromChild( this, plane );
1854
1855     parent->release();
1856 }
1857
1858 void IORegistryEntry::detachFromChild( IORegistryEntry * child,
1859                                 const IORegistryPlane * plane )
1860 {
1861     OSArray *           links;
1862     bool        needChild;
1863
1864     WLOCK;
1865
1866     child->retain();
1867
1868     breakLink( child, kChildSetIndex, plane );
1869
1870     if( (links = child->getParentSetReference( plane )))
1871         needChild = arrayMember( links, this );
1872     else
1873         needChild = false;
1874
1875     UNLOCK;
1876
1877     if( needChild)
1878         child->detachFromParent( this, plane );
1879
1880     child->release();
1881 }
1882
1883 void IORegistryEntry::detachAbove( const IORegistryPlane * plane )
1884 {
1885     IORegistryEntry *   parent;
1886
1887     retain();
1888     while( (parent = copyParentEntry( plane )))
1889     {
1890         detachFromParent( parent, plane );
1891         parent->release();
1892     }
1893     release();
1894 }
1895
1896 void IORegistryEntry::detachAll( const IORegistryPlane * plane )
1897 {
1898     OSOrderedSet *              all;
1899     IORegistryEntry *           next;
1900     IORegistryIterator *        regIter;
1901
1902     regIter = IORegistryIterator::iterateOver( this, plane, true );
1903     if( 0 == regIter)
1904         return;
1905     all = regIter->iterateAll();
1906     regIter->release();
1907
1908     detachAbove( plane );
1909     if( all) {
1910         while( (next = (IORegistryEntry *) all->getLastObject())) {
1911
1912             next->retain();
1913             all->removeObject(next);
1914
1915             next->detachAbove( plane );
1916             next->release();
1917         }
1918         all->release();
1919     }
1920 }
1921
1922 unsigned int IORegistryEntry::getDepth( const IORegistryPlane * plane ) const
1923 {
1924     unsigned int                depth = 1;
1925     OSArray *                   parents;
1926     unsigned int                oneDepth, maxParentDepth, count;
1927     IORegistryEntry *           one;
1928     const IORegistryEntry *     next;
1929     unsigned int                index;
1930
1931     RLOCK;
1932
1933     next = this;
1934     while( (parents = next->getParentSetReference( plane ))) {
1935
1936         count = parents->getCount();
1937         if( 0 == count)
1938             break;
1939         if( 1 == count) {
1940             depth++;
1941             next = (IORegistryEntry *) parents->getObject( 0 );
1942         } else {
1943             // painful
1944             maxParentDepth = 0;
1945             for( index = 0;
1946                  (one = (IORegistryEntry *) parents->getObject( index ));
1947                  index++ ) {
1948                 oneDepth = one->getDepth( plane );
1949                 if( oneDepth > maxParentDepth)
1950                     maxParentDepth = oneDepth;
1951             }
1952             depth += maxParentDepth;
1953             break;
1954         }
1955     }
1956
1957     UNLOCK;
1958
1959     return( depth);
1960 }
1961
1962 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1963
1964 #undef super
1965 #define super OSIterator
1966
1967 OSDefineMetaClassAndStructors(IORegistryIterator, OSIterator)
1968
1969 enum { kIORegistryIteratorInvalidFlag = 0x80000000 };
1970
1971 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1972
1973 IORegistryIterator *
1974 IORegistryIterator::iterateOver( IORegistryEntry * root,
1975                                  const IORegistryPlane * plane,
1976                                  IOOptionBits options )
1977 {
1978     IORegistryIterator *        create;
1979
1980     if( 0 == root)
1981         return( 0);
1982     if( 0 == plane)
1983         return( 0);
1984
1985     create = new IORegistryIterator;
1986     if( create) {
1987         if( create->init()) {
1988
1989             root->retain();
1990             create->root = root;
1991             create->where = &create->start;
1992             create->start.current = root;
1993             create->plane = plane;
1994             create->options = options & ~kIORegistryIteratorInvalidFlag;
1995
1996         } else {
1997             create->release();
1998             create = 0;
1999         }
2000     }
2001     return( create);
2002 }
2003
2004 IORegistryIterator *
2005 IORegistryIterator::iterateOver( const IORegistryPlane * plane,
2006                                  IOOptionBits options )
2007 {
2008     return( iterateOver( gRegistryRoot, plane, options ));
2009 }
2010
2011 bool IORegistryIterator::isValid( void )
2012 {
2013     bool                ok;
2014     IORegCursor *       next;
2015
2016     next = where;
2017
2018     RLOCK;
2019
2020     ok = (0 == (kIORegistryIteratorInvalidFlag & options));
2021
2022     while( ok && next) {
2023         if( where->iter)
2024             ok = where->iter->isValid();
2025         next = next->next;
2026     }
2027     UNLOCK;
2028
2029     return( ok);
2030 }
2031
2032 void IORegistryIterator::enterEntry( const IORegistryPlane * enterPlane )
2033 {
2034     IORegCursor *       prev;
2035
2036     prev = where;
2037     where = (IORegCursor *) IOMalloc( sizeof(IORegCursor));
2038     assert( where);
2039
2040     if( where) {
2041         where->iter = 0;
2042         where->next = prev;
2043         where->current = prev->current;
2044         plane = enterPlane;
2045     }
2046 }
2047
2048 void IORegistryIterator::enterEntry( void )
2049 {
2050     enterEntry( plane );
2051 }
2052
2053 bool IORegistryIterator::exitEntry( void )
2054 {
2055     IORegCursor *       gone;
2056
2057     if( where->iter) {
2058         where->iter->release();
2059         where->iter = 0;
2060         if( where->current)// && (where != &start))
2061             where->current->release();
2062     }
2063
2064     if( where != &start) {
2065         gone = where;
2066         where = gone->next;
2067         IOFree( gone, sizeof(IORegCursor));
2068         return( true);
2069
2070     } else
2071         return( false);
2072 }
2073
2074 void IORegistryIterator::reset( void )
2075 {
2076     while( exitEntry())
2077         {}
2078
2079     if( done) {
2080         done->release();
2081         done = 0;
2082     }
2083
2084     where->current = root;
2085     options &= ~kIORegistryIteratorInvalidFlag;
2086 }
2087
2088 void IORegistryIterator::free( void )
2089 {
2090     reset();
2091
2092     if( root)
2093         root->release();
2094
2095     super::free();
2096 }
2097
2098
2099 IORegistryEntry * IORegistryIterator::getNextObjectFlat( void )
2100 {
2101     IORegistryEntry *   next = 0;
2102     OSArray *           links = 0;
2103
2104     RLOCK;
2105
2106     if( (0 == where->iter)) {
2107         // just entered - create new iter
2108         if( isValid()
2109         &&  where->current
2110         &&  (links = ( (options & kIORegistryIterateParents) ?
2111                         where->current->getParentSetReference( plane ) :
2112                         where->current->getChildSetReference( plane ) )) )
2113
2114             where->iter = OSCollectionIterator::withCollection( links );
2115
2116     } else
2117         // next sibling - release current
2118         if( where->current)
2119             where->current->release();
2120
2121     if( where->iter) {
2122
2123         next = (IORegistryEntry *) where->iter->getNextObject();
2124
2125         if( next)
2126             next->retain();
2127         else if( !where->iter->isValid())
2128             options |= kIORegistryIteratorInvalidFlag;
2129     }
2130
2131     where->current = next;
2132
2133     UNLOCK;
2134
2135     return( next);
2136 }
2137
2138 IORegistryEntry * IORegistryIterator::getNextObjectRecursive( void )
2139 {
2140     IORegistryEntry *   next;
2141
2142     do
2143         next = getNextObjectFlat();
2144     while( (0 == next) && exitEntry());
2145
2146     if( next) {
2147         if( 0 == done)
2148             done = OSOrderedSet::withCapacity( 10 );
2149         if( done->setObject((OSObject *) next)) {
2150             // done set didn't contain this one, so recurse
2151             enterEntry();
2152         }
2153     }
2154     return( next);
2155 }
2156
2157 IORegistryEntry * IORegistryIterator::getNextObject( void )
2158 {
2159     if( options & kIORegistryIterateRecursively)
2160         return( getNextObjectRecursive());
2161     else
2162         return( getNextObjectFlat());
2163 }
2164
2165 IORegistryEntry * IORegistryIterator::getCurrentEntry( void )
2166 {
2167     if( isValid())
2168         return( where->current);
2169     else
2170         return( 0);
2171 }
2172
2173 OSOrderedSet * IORegistryIterator::iterateAll( void )
2174 {
2175     reset();
2176     while( getNextObjectRecursive())
2177         {}
2178     if( done)
2179         done->retain();
2180     return( done);
2181 }
2182
2183 #if __LP64__
2184 OSMetaClassDefineReservedUnused(IORegistryEntry, 0);
2185 OSMetaClassDefineReservedUnused(IORegistryEntry, 1);
2186 OSMetaClassDefineReservedUnused(IORegistryEntry, 2);
2187 OSMetaClassDefineReservedUnused(IORegistryEntry, 3);
2188 OSMetaClassDefineReservedUnused(IORegistryEntry, 4);
2189 OSMetaClassDefineReservedUnused(IORegistryEntry, 5);
2190 #else
2191 OSMetaClassDefineReservedUsed(IORegistryEntry, 0);
2192 OSMetaClassDefineReservedUsed(IORegistryEntry, 1);
2193 OSMetaClassDefineReservedUsed(IORegistryEntry, 2);
2194 OSMetaClassDefineReservedUsed(IORegistryEntry, 3);
2195 OSMetaClassDefineReservedUsed(IORegistryEntry, 4);
2196 OSMetaClassDefineReservedUsed(IORegistryEntry, 5);
2197 #endif
2198 OSMetaClassDefineReservedUnused(IORegistryEntry, 6);
2199 OSMetaClassDefineReservedUnused(IORegistryEntry, 7);
2200 OSMetaClassDefineReservedUnused(IORegistryEntry, 8);
2201 OSMetaClassDefineReservedUnused(IORegistryEntry, 9);
2202 OSMetaClassDefineReservedUnused(IORegistryEntry, 10);
2203 OSMetaClassDefineReservedUnused(IORegistryEntry, 11);
2204 OSMetaClassDefineReservedUnused(IORegistryEntry, 12);
2205 OSMetaClassDefineReservedUnused(IORegistryEntry, 13);
2206 OSMetaClassDefineReservedUnused(IORegistryEntry, 14);
2207 OSMetaClassDefineReservedUnused(IORegistryEntry, 15);
2208 OSMetaClassDefineReservedUnused(IORegistryEntry, 16);
2209 OSMetaClassDefineReservedUnused(IORegistryEntry, 17);
2210 OSMetaClassDefineReservedUnused(IORegistryEntry, 18);
2211 OSMetaClassDefineReservedUnused(IORegistryEntry, 19);
2212 OSMetaClassDefineReservedUnused(IORegistryEntry, 20);
2213 OSMetaClassDefineReservedUnused(IORegistryEntry, 21);
2214 OSMetaClassDefineReservedUnused(IORegistryEntry, 22);
2215 OSMetaClassDefineReservedUnused(IORegistryEntry, 23);
2216 OSMetaClassDefineReservedUnused(IORegistryEntry, 24);
2217 OSMetaClassDefineReservedUnused(IORegistryEntry, 25);
2218 OSMetaClassDefineReservedUnused(IORegistryEntry, 26);
2219 OSMetaClassDefineReservedUnused(IORegistryEntry, 27);
2220 OSMetaClassDefineReservedUnused(IORegistryEntry, 28);
2221 OSMetaClassDefineReservedUnused(IORegistryEntry, 29);
2222 OSMetaClassDefineReservedUnused(IORegistryEntry, 30);
2223 OSMetaClassDefineReservedUnused(IORegistryEntry, 31);
2224
2225 /* inline function implementation */
2226 OSDictionary * IORegistryEntry::getPropertyTable( void ) const
2227 { return(fPropertyTable); }