iokit/Kernel/IOService.cpp

   1 /*
   2  * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * The contents of this file constitute Original Code as defined in and
   7  * are subject to the Apple Public Source License Version 1.1 (the
   8  * "License").  You may not use this file except in compliance with the
   9  * License.  Please obtain a copy of the License at
  10  * http://www.apple.com/publicsource and read it before using this file.
  11  *
  12  * This Original Code and all software distributed under the License are
  13  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17  * License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * @APPLE_LICENSE_HEADER_END@
  21  */
  22
  23 #include <IOKit/system.h>
  24
  25 #include <IOKit/IOService.h>
  26 #include <libkern/c++/OSContainers.h>
  27 #include <libkern/c++/OSUnserialize.h>
  28 #include <IOKit/IOCatalogue.h>
  29 #include <IOKit/IODeviceMemory.h>
  30 #include <IOKit/IOInterrupts.h>
  31 #include <IOKit/IOInterruptController.h>
  32 #include <IOKit/IOPlatformExpert.h>
  33 #include <IOKit/IOMessage.h>
  34 #include <IOKit/IOLib.h>
  35 #include <IOKit/IOKitKeysPrivate.h>
  36 #include <IOKit/IOBSD.h>
  37 #include <IOKit/IOUserClient.h>
  38 #include <IOKit/IOWorkLoop.h>
  39 #include <mach/sync_policy.h>
  40 #include <IOKit/assert.h>
  41 #include <sys/errno.h>
  42
  43 //#define LOG kprintf
  44 #define LOG IOLog
  45
  46 #include "IOServicePrivate.h"
  47
  48 // take lockForArbitration before LOCKNOTIFY
  49
  50 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  51
  52 #define super IORegistryEntry
  53
  54 OSDefineMetaClassAndStructors(IOService, IORegistryEntry)
  55
  56 OSDefineMetaClassAndStructors(_IOServiceNotifier, IONotifier)
  57
  58 OSDefineMetaClassAndStructors(_IOServiceInterestNotifier, IONotifier)
  59
  60 OSDefineMetaClassAndStructors(_IOConfigThread, OSObject)
  61
  62 OSDefineMetaClassAndStructors(_IOServiceJob, OSObject)
  63
  64 OSDefineMetaClassAndStructors(IOResources, IOService)
  65
  66 OSDefineMetaClassAndStructors(_IOOpenServiceIterator, OSIterator)
  67
  68 OSDefineMetaClassAndAbstractStructors(IONotifier, OSObject)
  69
  70 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  71
  72 static IOPlatformExpert *       gIOPlatform;
  73 static class IOPMrootDomain *   gIOPMRootDomain;
  74 const IORegistryPlane *         gIOServicePlane;
  75 const IORegistryPlane *         gIOPowerPlane;
  76 const OSSymbol *                gIODeviceMemoryKey;
  77 const OSSymbol *                gIOInterruptControllersKey;
  78 const OSSymbol *                gIOInterruptSpecifiersKey;
  79
  80 const OSSymbol *                gIOResourcesKey;
  81 const OSSymbol *                gIOResourceMatchKey;
  82 const OSSymbol *                gIOProviderClassKey;
  83 const OSSymbol *                gIONameMatchKey;
  84 const OSSymbol *                gIONameMatchedKey;
  85 const OSSymbol *                gIOPropertyMatchKey;
  86 const OSSymbol *                gIOLocationMatchKey;
  87 const OSSymbol *                gIOParentMatchKey;
  88 const OSSymbol *                gIOPathMatchKey;
  89 const OSSymbol *                gIOMatchCategoryKey;
  90 const OSSymbol *                gIODefaultMatchCategoryKey;
  91 const OSSymbol *                gIOMatchedServiceCountKey;
  92
  93 const OSSymbol *                gIOUserClientClassKey;
  94 const OSSymbol *                gIOKitDebugKey;
  95
  96 const OSSymbol *                gIOCommandPoolSizeKey;
  97
  98 const OSSymbol *                gIOConsoleUsersKey;
  99 const OSSymbol *                gIOConsoleSessionUIDKey;
 100 const OSSymbol *                gIOConsoleUsersSeedKey;
 101
 102 static int                      gIOResourceGenerationCount;
 103
 104 const OSSymbol *                gIOServiceKey;
 105 const OSSymbol *                gIOPublishNotification;
 106 const OSSymbol *                gIOFirstPublishNotification;
 107 const OSSymbol *                gIOMatchedNotification;
 108 const OSSymbol *                gIOFirstMatchNotification;
 109 const OSSymbol *                gIOTerminatedNotification;
 110
 111 const OSSymbol *                gIOGeneralInterest;
 112 const OSSymbol *                gIOBusyInterest;
 113 const OSSymbol *                gIOAppPowerStateInterest;
 114 const OSSymbol *                gIOPriorityPowerStateInterest;
 115
 116 static OSDictionary *           gNotifications;
 117 static IORecursiveLock *        gNotificationLock;
 118
 119 static IOService *              gIOResources;
 120 static IOService *              gIOServiceRoot;
 121
 122 static OSOrderedSet *           gJobs;
 123 static semaphore_port_t         gJobsSemaphore;
 124 static IOLock *                 gJobsLock;
 125 static int                      gOutstandingJobs;
 126 static int                      gNumConfigThreads;
 127 static int                      gNumWaitingThreads;
 128 static IOLock *                 gIOServiceBusyLock;
 129
 130 static thread_t                 gIOTerminateThread;
 131 static UInt32                   gIOTerminateWork;
 132 static OSArray *                gIOTerminatePhase2List;
 133 static OSArray *                gIOStopList;
 134 static OSArray *                gIOStopProviderList;
 135 static OSArray *                gIOFinalizeList;
 136
 137 static SInt32                   gIOConsoleUsersSeed;
 138 static OSData *                 gIOConsoleUsersSeedValue;
 139
 140 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 141
 142 #define LOCKREADNOTIFY()        \
 143     IORecursiveLockLock( gNotificationLock )
 144 #define LOCKWRITENOTIFY()       \
 145     IORecursiveLockLock( gNotificationLock )
 146 #define LOCKWRITE2READNOTIFY()
 147 #define UNLOCKNOTIFY()          \
 148     IORecursiveLockUnlock( gNotificationLock )
 149 #define SLEEPNOTIFY(event) \
 150     IORecursiveLockSleep( gNotificationLock, (void *)(event), THREAD_UNINT )
 151 #define WAKEUPNOTIFY(event) \
 152         IORecursiveLockWakeup( gNotificationLock, (void *)(event), /* wake one */ false )
 153
 154 #define randomDelay()   \
 155         int del = read_processor_clock();                               \
 156         del = (((int)IOThreadSelf()) ^ del ^ (del >> 10)) & 0x3ff;      \
 157         IOSleep( del );
 158
 159 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 160
 161 struct ArbitrationLockQueueElement {
 162     queue_chain_t link;
 163     IOThread      thread;
 164     IOService *   service;
 165     unsigned      count;
 166     bool          required;
 167     bool          aborted;
 168 };
 169
 170 static queue_head_t gArbitrationLockQueueActive;
 171 static queue_head_t gArbitrationLockQueueWaiting;
 172 static queue_head_t gArbitrationLockQueueFree;
 173 static IOLock *     gArbitrationLockQueueLock;
 174
 175 bool IOService::isInactive( void ) const
 176     { return( 0 != (kIOServiceInactiveState & getState())); }
 177
 178 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 179
 180 void IOService::initialize( void )
 181 {
 182     kern_return_t       err;
 183
 184     gIOServicePlane     = IORegistryEntry::makePlane( kIOServicePlane );
 185     gIOPowerPlane       = IORegistryEntry::makePlane( kIOPowerPlane );
 186
 187     gIOProviderClassKey = OSSymbol::withCStringNoCopy( kIOProviderClassKey );
 188     gIONameMatchKey     = OSSymbol::withCStringNoCopy( kIONameMatchKey );
 189     gIONameMatchedKey   = OSSymbol::withCStringNoCopy( kIONameMatchedKey );
 190     gIOPropertyMatchKey = OSSymbol::withCStringNoCopy( kIOPropertyMatchKey );
 191     gIOPathMatchKey     = OSSymbol::withCStringNoCopy( kIOPathMatchKey );
 192     gIOLocationMatchKey = OSSymbol::withCStringNoCopy( kIOLocationMatchKey );
 193     gIOParentMatchKey   = OSSymbol::withCStringNoCopy( kIOParentMatchKey );
 194
 195     gIOMatchCategoryKey = OSSymbol::withCStringNoCopy( kIOMatchCategoryKey );
 196     gIODefaultMatchCategoryKey  = OSSymbol::withCStringNoCopy(
 197                                         kIODefaultMatchCategoryKey );
 198     gIOMatchedServiceCountKey   = OSSymbol::withCStringNoCopy(
 199                                         kIOMatchedServiceCountKey );
 200
 201     gIOUserClientClassKey = OSSymbol::withCStringNoCopy( kIOUserClientClassKey );
 202
 203     gIOResourcesKey     = OSSymbol::withCStringNoCopy( kIOResourcesClass );
 204     gIOResourceMatchKey = OSSymbol::withCStringNoCopy( kIOResourceMatchKey );
 205
 206     gIODeviceMemoryKey  = OSSymbol::withCStringNoCopy( "IODeviceMemory" );
 207     gIOInterruptControllersKey
 208         = OSSymbol::withCStringNoCopy("IOInterruptControllers");
 209     gIOInterruptSpecifiersKey
 210         = OSSymbol::withCStringNoCopy("IOInterruptSpecifiers");
 211
 212     gIOKitDebugKey      = OSSymbol::withCStringNoCopy( kIOKitDebugKey );
 213
 214     gIOCommandPoolSizeKey       = OSSymbol::withCStringNoCopy( kIOCommandPoolSizeKey );
 215
 216     gIOGeneralInterest          = OSSymbol::withCStringNoCopy( kIOGeneralInterest );
 217     gIOBusyInterest             = OSSymbol::withCStringNoCopy( kIOBusyInterest );
 218     gIOAppPowerStateInterest    = OSSymbol::withCStringNoCopy( kIOAppPowerStateInterest );
 219     gIOPriorityPowerStateInterest       = OSSymbol::withCStringNoCopy( kIOPriorityPowerStateInterest );
 220
 221     gNotifications              = OSDictionary::withCapacity( 1 );
 222     gIOPublishNotification      = OSSymbol::withCStringNoCopy(
 223                                                  kIOPublishNotification );
 224     gIOFirstPublishNotification = OSSymbol::withCStringNoCopy(
 225                                                  kIOFirstPublishNotification );
 226     gIOMatchedNotification      = OSSymbol::withCStringNoCopy(
 227                                                  kIOMatchedNotification );
 228     gIOFirstMatchNotification   = OSSymbol::withCStringNoCopy(
 229                                                  kIOFirstMatchNotification );
 230     gIOTerminatedNotification   = OSSymbol::withCStringNoCopy(
 231                                                  kIOTerminatedNotification );
 232     gIOServiceKey               = OSSymbol::withCStringNoCopy( kIOServiceClass);
 233
 234     gIOConsoleUsersKey          = OSSymbol::withCStringNoCopy( kIOConsoleUsersKey);
 235     gIOConsoleSessionUIDKey     = OSSymbol::withCStringNoCopy( kIOConsoleSessionUIDKey);
 236     gIOConsoleUsersSeedKey      = OSSymbol::withCStringNoCopy( kIOConsoleUsersSeedKey);
 237     gIOConsoleUsersSeedValue    = OSData::withBytesNoCopy(&gIOConsoleUsersSeed, sizeof(gIOConsoleUsersSeed));
 238
 239     gNotificationLock           = IORecursiveLockAlloc();
 240
 241     assert( gIOServicePlane && gIODeviceMemoryKey
 242         && gIOInterruptControllersKey && gIOInterruptSpecifiersKey
 243         && gIOResourcesKey && gNotifications && gNotificationLock
 244         && gIOProviderClassKey && gIONameMatchKey && gIONameMatchedKey
 245         && gIOMatchCategoryKey && gIODefaultMatchCategoryKey
 246         && gIOPublishNotification && gIOMatchedNotification
 247         && gIOTerminatedNotification && gIOServiceKey
 248         && gIOConsoleUsersKey && gIOConsoleSessionUIDKey
 249         && gIOConsoleUsersSeedKey && gIOConsoleUsersSeedValue);
 250
 251     gJobsLock   = IOLockAlloc();
 252     gJobs       = OSOrderedSet::withCapacity( 10 );
 253
 254     gIOServiceBusyLock = IOLockAlloc();
 255
 256     err = semaphore_create(kernel_task, &gJobsSemaphore, SYNC_POLICY_FIFO, 0);
 257
 258     assert( gIOServiceBusyLock && gJobs && gJobsLock && (err == KERN_SUCCESS) );
 259
 260     gIOResources = IOResources::resources();
 261     assert( gIOResources );
 262
 263     gArbitrationLockQueueLock = IOLockAlloc();
 264     queue_init(&gArbitrationLockQueueActive);
 265     queue_init(&gArbitrationLockQueueWaiting);
 266     queue_init(&gArbitrationLockQueueFree);
 267
 268     assert( gArbitrationLockQueueLock );
 269
 270     gIOTerminatePhase2List = OSArray::withCapacity( 2 );
 271     gIOStopList            = OSArray::withCapacity( 16 );
 272     gIOStopProviderList    = OSArray::withCapacity( 16 );
 273     gIOFinalizeList        = OSArray::withCapacity( 16 );
 274     assert( gIOTerminatePhase2List && gIOStopList && gIOStopProviderList && gIOFinalizeList );
 275 }
 276
 277 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 278
 279 #if IOMATCHDEBUG
 280 static UInt64 getDebugFlags( OSDictionary * props )
 281 {
 282     OSNumber *  debugProp;
 283     UInt64      debugFlags;
 284
 285     debugProp = OSDynamicCast( OSNumber,
 286                 props->getObject( gIOKitDebugKey ));
 287     if( debugProp)
 288         debugFlags = debugProp->unsigned64BitValue();
 289     else
 290         debugFlags = gIOKitDebug;
 291
 292     return( debugFlags );
 293 }
 294 #endif
 295
 296 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 297
 298 // Probe a matched service and return an instance to be started.
 299 // The default score is from the property table, & may be altered
 300 // during probe to change the start order.
 301
 302 IOService * IOService::probe(   IOService * provider,
 303                                 SInt32    * score )
 304 {
 305     return( this );
 306 }
 307
 308 bool IOService::start( IOService * provider )
 309 {
 310     return( true );
 311 }
 312
 313 void IOService::stop( IOService * provider )
 314 {
 315 }
 316
 317 void IOService::free( void )
 318 {
 319     if( getPropertyTable())
 320         unregisterAllInterest();
 321     PMfree();
 322     super::free();
 323 }
 324
 325 /*
 326  * Attach in service plane
 327  */
 328 bool IOService::attach( IOService * provider )
 329 {
 330     bool        ok;
 331
 332     if( provider) {
 333
 334         if( gIOKitDebug & kIOLogAttach)
 335             LOG( "%s::attach(%s)\n", getName(),
 336                     provider->getName());
 337
 338         provider->lockForArbitration();
 339         if( provider->__state[0] & kIOServiceInactiveState)
 340             ok = false;
 341         else
 342             ok = attachToParent( provider, gIOServicePlane);
 343         provider->unlockForArbitration();
 344
 345     } else {
 346         gIOServiceRoot = this;
 347         ok = attachToParent( getRegistryRoot(), gIOServicePlane);
 348     }
 349
 350     return( ok );
 351 }
 352
 353 IOService * IOService::getServiceRoot( void )
 354 {
 355     return( gIOServiceRoot );
 356 }
 357
 358 void IOService::detach( IOService * provider )
 359 {
 360     IOService * newProvider = 0;
 361     SInt32      busy;
 362     bool        adjParent;
 363
 364     if( gIOKitDebug & kIOLogAttach)
 365         LOG("%s::detach(%s)\n", getName(), provider->getName());
 366
 367     lockForArbitration();
 368
 369     adjParent = ((busy = (__state[1] & kIOServiceBusyStateMask))
 370                && (provider == getProvider()));
 371
 372     detachFromParent( provider, gIOServicePlane );
 373
 374     if( busy) {
 375         newProvider = getProvider();
 376         if( busy && (__state[1] & kIOServiceTermPhase3State) && (0 == newProvider))
 377             _adjustBusy( -busy );
 378     }
 379
 380     unlockForArbitration();
 381
 382     if( newProvider) {
 383         newProvider->lockForArbitration();
 384         newProvider->_adjustBusy(1);
 385         newProvider->unlockForArbitration();
 386     }
 387
 388     // check for last client detach from a terminated service
 389     if( provider->lockForArbitration( true )) {
 390         if( adjParent)
 391             provider->_adjustBusy( -1 );
 392         if( (provider->__state[1] & kIOServiceTermPhase3State)
 393          && (0 == provider->getClient())) {
 394             provider->scheduleFinalize();
 395         }
 396         provider->unlockForArbitration();
 397     }
 398 }
 399
 400 /*
 401  * Register instance - publish it for matching
 402  */
 403
 404 void IOService::registerService( IOOptionBits options )
 405 {
 406     char *              pathBuf;
 407     const char *        path;
 408     char *              skip;
 409     int                 len;
 410     enum { kMaxPathLen  = 256 };
 411     enum { kMaxChars    = 63 };
 412
 413     IORegistryEntry * parent = this;
 414     IORegistryEntry * root = getRegistryRoot();
 415     while( parent && (parent != root))
 416         parent = parent->getParentEntry( gIOServicePlane);
 417
 418     if( parent != root) {
 419         IOLog("%s: not registry member at registerService()\n", getName());
 420         return;
 421     }
 422
 423     // Allow the Platform Expert to adjust this node.
 424     if( gIOPlatform && (!gIOPlatform->platformAdjustService(this)))
 425         return;
 426
 427     if( (this != gIOResources)
 428      && (kIOLogRegister & gIOKitDebug)) {
 429
 430         pathBuf = (char *) IOMalloc( kMaxPathLen );
 431
 432         IOLog( "Registering: " );
 433
 434         len = kMaxPathLen;
 435         if( pathBuf && getPath( pathBuf, &len, gIOServicePlane)) {
 436
 437             path = pathBuf;
 438             if( len > kMaxChars) {
 439                 IOLog("..");
 440                 len -= kMaxChars;
 441                 path += len;
 442                 if( (skip = strchr( path, '/')))
 443                     path = skip;
 444             }
 445         } else
 446             path = getName();
 447
 448         IOLog( "%s\n", path );
 449
 450         if( pathBuf)
 451             IOFree( pathBuf, kMaxPathLen );
 452     }
 453
 454     startMatching( options );
 455 }
 456
 457 void IOService::startMatching( IOOptionBits options )
 458 {
 459     IOService * provider;
 460     UInt32      prevBusy = 0;
 461     bool        needConfig;
 462     bool        needWake = false;
 463     bool        ok;
 464     bool        sync;
 465     bool        waitAgain;
 466
 467     lockForArbitration();
 468
 469     sync = (options & kIOServiceSynchronous)
 470         || ((provider = getProvider())
 471                 && (provider->__state[1] & kIOServiceSynchronousState));
 472
 473
 474     needConfig =  (0 == (__state[1] & (kIOServiceNeedConfigState | kIOServiceConfigState)))
 475                && (0 == (__state[0] & kIOServiceInactiveState));
 476
 477     __state[1] |= kIOServiceNeedConfigState;
 478
 479 //    __state[0] &= ~kIOServiceInactiveState;
 480
 481 //    if( sync) LOG("OSKernelStackRemaining = %08x @ %s\n",
 482 //                      OSKernelStackRemaining(), getName());
 483
 484     if( needConfig) {
 485         prevBusy = _adjustBusy( 1 );
 486         needWake = (0 != (kIOServiceSyncPubState & __state[1]));
 487     }
 488
 489     if( sync)
 490         __state[1] |= kIOServiceSynchronousState;
 491     else
 492         __state[1] &= ~kIOServiceSynchronousState;
 493
 494     unlockForArbitration();
 495
 496     if( needConfig) {
 497
 498         if( needWake) {
 499             IOLockLock( gIOServiceBusyLock );
 500             thread_wakeup( (event_t) this/*&__state[1]*/ );
 501             IOLockUnlock( gIOServiceBusyLock );
 502
 503         } else if( !sync || (kIOServiceAsynchronous & options)) {
 504
 505             ok = (0 != _IOServiceJob::startJob( this, kMatchNubJob, options ));
 506
 507         } else do {
 508
 509             if( (__state[1] & kIOServiceNeedConfigState))
 510                 doServiceMatch( options );
 511
 512             lockForArbitration();
 513             IOLockLock( gIOServiceBusyLock );
 514
 515             waitAgain = (prevBusy != (__state[1] & kIOServiceBusyStateMask));
 516             if( waitAgain)
 517                 __state[1] |= kIOServiceSyncPubState | kIOServiceBusyWaiterState;
 518             else
 519                 __state[1] &= ~kIOServiceSyncPubState;
 520
 521             unlockForArbitration();
 522
 523             if( waitAgain)
 524                 assert_wait( (event_t) this/*&__state[1]*/, THREAD_UNINT);
 525
 526             IOLockUnlock( gIOServiceBusyLock );
 527             if( waitAgain)
 528                 thread_block(THREAD_CONTINUE_NULL);
 529
 530         } while( waitAgain );
 531     }
 532 }
 533
 534 IOReturn IOService::catalogNewDrivers( OSOrderedSet * newTables )
 535 {
 536     OSDictionary *      table;
 537     OSIterator *        iter;
 538     IOService *         service;
 539 #if IOMATCHDEBUG
 540     SInt32              count = 0;
 541 #endif
 542
 543     newTables->retain();
 544
 545     while( (table = (OSDictionary *) newTables->getFirstObject())) {
 546
 547         LOCKWRITENOTIFY();
 548         iter = (OSIterator *) getExistingServices( table,
 549                                                     kIOServiceRegisteredState );
 550         UNLOCKNOTIFY();
 551         if( iter) {
 552             while( (service = (IOService *) iter->getNextObject())) {
 553                 service->startMatching(kIOServiceAsynchronous);
 554 #if IOMATCHDEBUG
 555                 count++;
 556 #endif
 557             }
 558             iter->release();
 559         }
 560 #if IOMATCHDEBUG
 561         if( getDebugFlags( table ) & kIOLogMatch)
 562             LOG("Matching service count = %ld\n", count);
 563 #endif
 564         newTables->removeObject(table);
 565     }
 566
 567     newTables->release();
 568
 569     return( kIOReturnSuccess );
 570 }
 571
 572  _IOServiceJob * _IOServiceJob::startJob( IOService * nub, int type,
 573                                                 IOOptionBits options )
 574 {
 575     _IOServiceJob *     job;
 576
 577     job = new _IOServiceJob;
 578     if( job && !job->init()) {
 579         job->release();
 580         job = 0;
 581     }
 582
 583     if( job) {
 584         job->type       = type;
 585         job->nub        = nub;
 586         job->options    = options;
 587         nub->retain();                  // thread will release()
 588         pingConfig( job );
 589     }
 590
 591     return( job );
 592 }
 593
 594 /*
 595  * Called on a registered service to see if it matches
 596  * a property table.
 597  */
 598
 599 bool IOService::matchPropertyTable( OSDictionary * table, SInt32 * score )
 600 {
 601     return( matchPropertyTable(table) );
 602 }
 603
 604 bool IOService::matchPropertyTable( OSDictionary * table )
 605 {
 606     return( true );
 607 }
 608
 609 /*
 610  * Called on a matched service to allocate resources
 611  * before first driver is attached.
 612  */
 613
 614 IOReturn IOService::getResources( void )
 615 {
 616     return( kIOReturnSuccess);
 617 }
 618
 619 /*
 620  * Client/provider accessors
 621  */
 622
 623 IOService * IOService::getProvider( void ) const
 624 {
 625     IOService * self = (IOService *) this;
 626     IOService * parent;
 627     SInt32      generation;
 628
 629     parent = __provider;
 630     generation = getGenerationCount();
 631     if( __providerGeneration == generation)
 632         return( parent );
 633
 634     parent = (IOService *) getParentEntry( gIOServicePlane);
 635     if( parent == IORegistryEntry::getRegistryRoot())
 636         /* root is not an IOService */
 637         parent = 0;
 638
 639     self->__provider = parent;
 640     // save the count before getParentEntry()
 641     self->__providerGeneration = generation;
 642
 643     return( parent );
 644 }
 645
 646 IOWorkLoop * IOService::getWorkLoop() const
 647 {
 648     IOService *provider = getProvider();
 649
 650     if (provider)
 651         return provider->getWorkLoop();
 652     else
 653         return 0;
 654 }
 655
 656 OSIterator * IOService::getProviderIterator( void ) const
 657 {
 658     return( getParentIterator( gIOServicePlane));
 659 }
 660
 661 IOService * IOService::getClient( void ) const
 662 {
 663     return( (IOService *) getChildEntry( gIOServicePlane));
 664 }
 665
 666 OSIterator * IOService::getClientIterator( void ) const
 667 {
 668     return( getChildIterator( gIOServicePlane));
 669 }
 670
 671 OSIterator * _IOOpenServiceIterator::iterator( OSIterator * _iter,
 672                                                 const IOService * client,
 673                                                 const IOService * provider )
 674 {
 675     _IOOpenServiceIterator * inst;
 676
 677     if( !_iter)
 678         return( 0 );
 679
 680     inst = new _IOOpenServiceIterator;
 681
 682     if( inst && !inst->init()) {
 683         inst->release();
 684         inst = 0;
 685     }
 686     if( inst) {
 687         inst->iter = _iter;
 688         inst->client = client;
 689         inst->provider = provider;
 690     }
 691
 692     return( inst );
 693 }
 694
 695 void _IOOpenServiceIterator::free()
 696 {
 697     iter->release();
 698     if( last)
 699         last->unlockForArbitration();
 700     OSIterator::free();
 701 }
 702
 703 OSObject * _IOOpenServiceIterator::getNextObject()
 704 {
 705     IOService * next;
 706
 707     if( last)
 708         last->unlockForArbitration();
 709
 710     while( (next = (IOService *) iter->getNextObject())) {
 711
 712         next->lockForArbitration();
 713         if( (client && (next->isOpen( client )))
 714          || (provider && (provider->isOpen( next ))) )
 715             break;
 716         next->unlockForArbitration();
 717     }
 718
 719     last = next;
 720
 721     return( next );
 722 }
 723
 724 bool _IOOpenServiceIterator::isValid()
 725 {
 726     return( iter->isValid() );
 727 }
 728
 729 void _IOOpenServiceIterator::reset()
 730 {
 731     if( last) {
 732         last->unlockForArbitration();
 733         last = 0;
 734     }
 735     iter->reset();
 736 }
 737
 738 OSIterator * IOService::getOpenProviderIterator( void ) const
 739 {
 740     return( _IOOpenServiceIterator::iterator( getProviderIterator(), this, 0 ));
 741 }
 742
 743 OSIterator * IOService::getOpenClientIterator( void ) const
 744 {
 745     return( _IOOpenServiceIterator::iterator( getClientIterator(), 0, this ));
 746 }
 747
 748
 749 IOReturn IOService::callPlatformFunction( const OSSymbol * functionName,
 750                                           bool waitForFunction,
 751                                           void *param1, void *param2,
 752                                           void *param3, void *param4 )
 753 {
 754   IOReturn  result = kIOReturnUnsupported;
 755   IOService *provider = getProvider();
 756
 757   if (provider != 0) {
 758     result = provider->callPlatformFunction(functionName, waitForFunction,
 759                                             param1, param2, param3, param4);
 760   }
 761
 762   return result;
 763 }
 764
 765 IOReturn IOService::callPlatformFunction( const char * functionName,
 766                                           bool waitForFunction,
 767                                           void *param1, void *param2,
 768                                           void *param3, void *param4 )
 769 {
 770   IOReturn result = kIOReturnNoMemory;
 771   const OSSymbol *functionSymbol = OSSymbol::withCString(functionName);
 772
 773   if (functionSymbol != 0) {
 774     result = callPlatformFunction(functionSymbol, waitForFunction,
 775                                   param1, param2, param3, param4);
 776     functionSymbol->release();
 777   }
 778
 779   return result;
 780 }
 781
 782
 783 /*
 784  * Accessors for global services
 785  */
 786
 787 IOPlatformExpert * IOService::getPlatform( void )
 788 {
 789     return( gIOPlatform);
 790 }
 791
 792 class IOPMrootDomain * IOService::getPMRootDomain( void )
 793 {
 794     return( gIOPMRootDomain);
 795 }
 796
 797 IOService * IOService::getResourceService( void )
 798 {
 799     return( gIOResources );
 800 }
 801
 802 void IOService::setPlatform( IOPlatformExpert * platform)
 803 {
 804     gIOPlatform = platform;
 805     gIOResources->attachToParent( gIOServiceRoot, gIOServicePlane );
 806 }
 807
 808 void IOService::setPMRootDomain( class IOPMrootDomain * rootDomain)
 809 {
 810     gIOPMRootDomain = rootDomain;
 811     publishResource("IOKit");
 812 }
 813
 814 /*
 815  * Stacking change
 816  */
 817
 818 bool IOService::lockForArbitration( bool isSuccessRequired )
 819 {
 820     bool                          found;
 821     bool                          success;
 822     ArbitrationLockQueueElement * element;
 823     ArbitrationLockQueueElement * active;
 824     ArbitrationLockQueueElement * waiting;
 825
 826     enum { kPutOnFreeQueue, kPutOnActiveQueue, kPutOnWaitingQueue } action;
 827
 828     // lock global access
 829     IOTakeLock( gArbitrationLockQueueLock );
 830
 831     // obtain an unused queue element
 832     if( !queue_empty( &gArbitrationLockQueueFree )) {
 833         queue_remove_first( &gArbitrationLockQueueFree,
 834                             element,
 835                             ArbitrationLockQueueElement *,
 836                             link );
 837     } else {
 838         element = IONew( ArbitrationLockQueueElement, 1 );
 839         assert( element );
 840     }
 841
 842     // prepare the queue element
 843     element->thread   = IOThreadSelf();
 844     element->service  = this;
 845     element->count    = 1;
 846     element->required = isSuccessRequired;
 847     element->aborted  = false;
 848
 849     // determine whether this object is already locked (ie. on active queue)
 850     found = false;
 851     queue_iterate( &gArbitrationLockQueueActive,
 852                     active,
 853                     ArbitrationLockQueueElement *,
 854                     link )
 855     {
 856         if( active->service == element->service ) {
 857             found = true;
 858             break;
 859         }
 860     }
 861
 862     if( found ) { // this object is already locked
 863
 864         // determine whether it is the same or a different thread trying to lock
 865         if( active->thread != element->thread ) { // it is a different thread
 866
 867             ArbitrationLockQueueElement * victim = 0;
 868
 869             // before placing this new thread on the waiting queue, we look for
 870             // a deadlock cycle...
 871
 872             while( 1 ) {
 873                 // determine whether the active thread holding the object we
 874                 // want is waiting for another object to be unlocked
 875                 found = false;
 876                 queue_iterate( &gArbitrationLockQueueWaiting,
 877                                waiting,
 878                                ArbitrationLockQueueElement *,
 879                                link )
 880                 {
 881                     if( waiting->thread == active->thread ) {
 882                         assert( false == waiting->aborted );
 883                         found = true;
 884                         break;
 885                     }
 886                 }
 887
 888                 if( found ) { // yes, active thread waiting for another object
 889
 890                     // this may be a candidate for rejection if the required
 891                     // flag is not set, should we detect a deadlock later on
 892                     if( false == waiting->required )
 893                         victim = waiting;
 894
 895                     // find the thread that is holding this other object, that
 896                     // is blocking the active thread from proceeding (fun :-)
 897                     found = false;
 898                     queue_iterate( &gArbitrationLockQueueActive,
 899                                    active,      // (reuse active queue element)
 900                                    ArbitrationLockQueueElement *,
 901                                    link )
 902                     {
 903                         if( active->service == waiting->service ) {
 904                             found = true;
 905                             break;
 906                         }
 907                     }
 908
 909                     // someone must be holding it or it wouldn't be waiting
 910                     assert( found );
 911
 912                     if( active->thread == element->thread ) {
 913
 914                         // doh, it's waiting for the thread that originated
 915                         // this whole lock (ie. current thread) -> deadlock
 916                         if( false == element->required ) { // willing to fail?
 917
 918                             // the originating thread doesn't have the required
 919                             // flag, so it can fail
 920                             success = false; // (fail originating lock request)
 921                             break; // (out of while)
 922
 923                         } else { // originating thread is not willing to fail
 924
 925                             // see if we came across a waiting thread that did
 926                             // not have the 'required' flag set: we'll fail it
 927                             if( victim ) {
 928
 929                                 // we do have a willing victim, fail it's lock
 930                                 victim->aborted = true;
 931
 932                                 // take the victim off the waiting queue
 933                                 queue_remove( &gArbitrationLockQueueWaiting,
 934                                               victim,
 935                                               ArbitrationLockQueueElement *,
 936                                               link );
 937
 938                                 // wake the victim
 939                                 IOLockWakeup( gArbitrationLockQueueLock,
 940                                               victim,
 941                                               /* one thread */ true );
 942
 943                                 // allow this thread to proceed (ie. wait)
 944                                 success = true; // (put request on wait queue)
 945                                 break; // (out of while)
 946                             } else {
 947
 948                                 // all the waiting threads we came across in
 949                                 // finding this loop had the 'required' flag
 950                                 // set, so we've got a deadlock we can't avoid
 951                                 panic("I/O Kit: Unrecoverable deadlock.");
 952                             }
 953                         }
 954                     } else {
 955                         // repeat while loop, redefining active thread to be the
 956                         // thread holding "this other object" (see above), and
 957                         // looking for threads waiting on it; note the active
 958                         // variable points to "this other object" already... so
 959                         // there nothing to do in this else clause.
 960                     }
 961                 } else { // no, active thread is not waiting for another object
 962
 963                     success = true; // (put request on wait queue)
 964                     break; // (out of while)
 965                 }
 966             } // while forever
 967
 968             if( success ) { // put the request on the waiting queue?
 969                 kern_return_t wait_result;
 970
 971                 // place this thread on the waiting queue and put it to sleep;
 972                 // we place it at the tail of the queue...
 973                 queue_enter( &gArbitrationLockQueueWaiting,
 974                              element,
 975                              ArbitrationLockQueueElement *,
 976                              link );
 977
 978                 // declare that this thread will wait for a given event
 979 restart_sleep:  wait_result = assert_wait( element,
 980                                            element->required ? THREAD_UNINT
 981                                            : THREAD_INTERRUPTIBLE );
 982
 983                 // unlock global access
 984                 IOUnlock( gArbitrationLockQueueLock );
 985
 986                 // put thread to sleep, waiting for our event to fire...
 987                 if (wait_result == THREAD_WAITING)
 988                     wait_result = thread_block(THREAD_CONTINUE_NULL);
 989
 990
 991                 // ...and we've been woken up; we might be in one of two states:
 992                 // (a) we've been aborted and our queue element is not on
 993                 //     any of the three queues, but is floating around
 994                 // (b) we're allowed to proceed with the lock and we have
 995                 //     already been moved from the waiting queue to the
 996                 //     active queue.
 997                 // ...plus a 3rd state, should the thread have been interrupted:
 998                 // (c) we're still on the waiting queue
 999
1000                 // determine whether we were interrupted out of our sleep
1001                 if( THREAD_INTERRUPTED == wait_result ) {
1002
1003                     // re-lock global access
1004                     IOTakeLock( gArbitrationLockQueueLock );
1005
1006                     // determine whether we're still on the waiting queue
1007                     found = false;
1008                     queue_iterate( &gArbitrationLockQueueWaiting,
1009                                    waiting,     // (reuse waiting queue element)
1010                                    ArbitrationLockQueueElement *,
1011                                    link )
1012                     {
1013                         if( waiting == element ) {
1014                             found = true;
1015                             break;
1016                         }
1017                     }
1018
1019                     if( found ) { // yes, we're still on the waiting queue
1020
1021                         // determine whether we're willing to fail
1022                         if( false == element->required ) {
1023
1024                             // mark us as aborted
1025                             element->aborted = true;
1026
1027                             // take us off the waiting queue
1028                             queue_remove( &gArbitrationLockQueueWaiting,
1029                                           element,
1030                                           ArbitrationLockQueueElement *,
1031                                           link );
1032                         } else { // we are not willing to fail
1033
1034                             // ignore interruption, go back to sleep
1035                             goto restart_sleep;
1036                         }
1037                     }
1038
1039                     // unlock global access
1040                     IOUnlock( gArbitrationLockQueueLock );
1041
1042                     // proceed as though this were a normal wake up
1043                     wait_result = THREAD_AWAKENED;
1044                 }
1045
1046                 assert( THREAD_AWAKENED == wait_result );
1047
1048                 // determine whether we've been aborted while we were asleep
1049                 if( element->aborted ) {
1050                     assert( false == element->required );
1051
1052                     // re-lock global access
1053                     IOTakeLock( gArbitrationLockQueueLock );
1054
1055                     action = kPutOnFreeQueue;
1056                     success = false;
1057                 } else { // we weren't aborted, so we must be ready to go :-)
1058
1059                     // we've already been moved from waiting to active queue
1060                     return true;
1061                 }
1062
1063             } else { // the lock request is to be failed
1064
1065                 // return unused queue element to queue
1066                 action = kPutOnFreeQueue;
1067             }
1068         } else { // it is the same thread, recursive access is allowed
1069
1070             // add one level of recursion
1071             active->count++;
1072
1073             // return unused queue element to queue
1074             action = kPutOnFreeQueue;
1075             success = true;
1076         }
1077     } else { // this object is not already locked, so let this thread through
1078         action = kPutOnActiveQueue;
1079         success = true;
1080     }
1081
1082     // put the new element on a queue
1083     if( kPutOnActiveQueue == action ) {
1084         queue_enter( &gArbitrationLockQueueActive,
1085                      element,
1086                      ArbitrationLockQueueElement *,
1087                      link );
1088     } else if( kPutOnFreeQueue == action ) {
1089         queue_enter( &gArbitrationLockQueueFree,
1090                      element,
1091                      ArbitrationLockQueueElement *,
1092                      link );
1093     } else {
1094         assert( 0 ); // kPutOnWaitingQueue never occurs, handled specially above
1095     }
1096
1097     // unlock global access
1098     IOUnlock( gArbitrationLockQueueLock );
1099
1100     return( success );
1101 }
1102
1103 void IOService::unlockForArbitration( void )
1104 {
1105     bool                          found;
1106     ArbitrationLockQueueElement * element;
1107
1108     // lock global access
1109     IOTakeLock( gArbitrationLockQueueLock );
1110
1111     // find the lock element for this object (ie. on active queue)
1112     found = false;
1113     queue_iterate( &gArbitrationLockQueueActive,
1114                     element,
1115                     ArbitrationLockQueueElement *,
1116                     link )
1117     {
1118         if( element->service == this ) {
1119             found = true;
1120             break;
1121         }
1122     }
1123
1124     assert( found );
1125
1126     // determine whether the lock has been taken recursively
1127     if( element->count > 1 ) {
1128         // undo one level of recursion
1129         element->count--;
1130
1131     } else {
1132
1133         // remove it from the active queue
1134         queue_remove( &gArbitrationLockQueueActive,
1135                       element,
1136                       ArbitrationLockQueueElement *,
1137                       link );
1138
1139         // put it on the free queue
1140         queue_enter( &gArbitrationLockQueueFree,
1141                      element,
1142                      ArbitrationLockQueueElement *,
1143                      link );
1144
1145         // determine whether a thread is waiting for object (head to tail scan)
1146         found = false;
1147         queue_iterate( &gArbitrationLockQueueWaiting,
1148                        element,
1149                        ArbitrationLockQueueElement *,
1150                        link )
1151         {
1152             if( element->service == this ) {
1153                 found = true;
1154                 break;
1155             }
1156         }
1157
1158         if ( found ) { // we found an interested thread on waiting queue
1159
1160             // remove it from the waiting queue
1161             queue_remove( &gArbitrationLockQueueWaiting,
1162                           element,
1163                           ArbitrationLockQueueElement *,
1164                           link );
1165
1166             // put it on the active queue
1167             queue_enter( &gArbitrationLockQueueActive,
1168                          element,
1169                          ArbitrationLockQueueElement *,
1170                          link );
1171
1172             // wake the waiting thread
1173             IOLockWakeup( gArbitrationLockQueueLock,
1174                           element,
1175                           /* one thread */ true );
1176         }
1177     }
1178
1179     // unlock global access
1180     IOUnlock( gArbitrationLockQueueLock );
1181 }
1182
1183 void IOService::applyToProviders( IOServiceApplierFunction applier,
1184                                   void * context )
1185 {
1186     applyToParents( (IORegistryEntryApplierFunction) applier,
1187                     context, gIOServicePlane );
1188 }
1189
1190 void IOService::applyToClients( IOServiceApplierFunction applier,
1191                                 void * context )
1192 {
1193     applyToChildren( (IORegistryEntryApplierFunction) applier,
1194                      context, gIOServicePlane );
1195 }
1196
1197
1198 /*
1199  * Client messages
1200  */
1201
1202
1203 // send a message to a client or interested party of this service
1204 IOReturn IOService::messageClient( UInt32 type, OSObject * client,
1205                                    void * argument, vm_size_t argSize )
1206 {
1207     IOReturn                            ret;
1208     IOService *                         service;
1209     _IOServiceInterestNotifier *        notify;
1210
1211     if( (service = OSDynamicCast( IOService, client)))
1212         ret = service->message( type, this, argument );
1213
1214     else if( (notify = OSDynamicCast( _IOServiceInterestNotifier, client))) {
1215
1216         _IOServiceNotifierInvocation invocation;
1217         bool                     willNotify;
1218
1219         invocation.thread = current_thread();
1220
1221         LOCKWRITENOTIFY();
1222         willNotify = (0 != (kIOServiceNotifyEnable & notify->state));
1223
1224         if( willNotify) {
1225             queue_enter( &notify->handlerInvocations, &invocation,
1226                             _IOServiceNotifierInvocation *, link );
1227         }
1228         UNLOCKNOTIFY();
1229
1230         if( willNotify) {
1231
1232             ret = (*notify->handler)( notify->target, notify->ref,
1233                                           type, this, argument, argSize );
1234
1235             LOCKWRITENOTIFY();
1236             queue_remove( &notify->handlerInvocations, &invocation,
1237                             _IOServiceNotifierInvocation *, link );
1238             if( kIOServiceNotifyWaiter & notify->state) {
1239                 notify->state &= ~kIOServiceNotifyWaiter;
1240                 WAKEUPNOTIFY( notify );
1241             }
1242             UNLOCKNOTIFY();
1243
1244         } else
1245             ret = kIOReturnSuccess;
1246
1247     } else
1248         ret = kIOReturnBadArgument;
1249
1250     return( ret );
1251 }
1252
1253 void IOService::applyToInterested( const OSSymbol * typeOfInterest,
1254                                    OSObjectApplierFunction applier,
1255                                    void * context )
1256 {
1257     OSArray *           array;
1258     unsigned int        index;
1259     OSObject *          next;
1260     OSArray *           copyArray;
1261
1262     applyToClients( (IOServiceApplierFunction) applier, context );
1263
1264     LOCKREADNOTIFY();
1265     array = OSDynamicCast( OSArray, getProperty( typeOfInterest ));
1266     if( array) {
1267         copyArray = OSArray::withArray( array );
1268         UNLOCKNOTIFY();
1269         if( copyArray) {
1270             for( index = 0;
1271                 (next = copyArray->getObject( index ));
1272                 index++) {
1273                 (*applier)(next, context);
1274             }
1275             copyArray->release();
1276         }
1277     } else
1278         UNLOCKNOTIFY();
1279 }
1280
1281 struct MessageClientsContext {
1282     IOService * service;
1283     UInt32      type;
1284     void *      argument;
1285     vm_size_t   argSize;
1286     IOReturn    ret;
1287 };
1288
1289 static void messageClientsApplier( OSObject * object, void * ctx )
1290 {
1291     IOReturn                ret;
1292     MessageClientsContext * context = (MessageClientsContext *) ctx;
1293
1294     ret = context->service->messageClient( context->type,
1295                                            object, context->argument, context->argSize );
1296     if( kIOReturnSuccess != ret)
1297         context->ret = ret;
1298 }
1299
1300 // send a message to all clients
1301 IOReturn IOService::messageClients( UInt32 type,
1302                                     void * argument, vm_size_t argSize )
1303 {
1304     MessageClientsContext       context;
1305
1306     context.service     = this;
1307     context.type        = type;
1308     context.argument    = argument;
1309     context.argSize     = argSize;
1310     context.ret         = kIOReturnSuccess;
1311
1312     applyToInterested( gIOGeneralInterest,
1313                        &messageClientsApplier, &context );
1314
1315     return( context.ret );
1316 }
1317
1318 IOReturn IOService::acknowledgeNotification( IONotificationRef notification,
1319                                               IOOptionBits response )
1320 {
1321     return( kIOReturnUnsupported );
1322 }
1323
1324 IONotifier * IOService::registerInterest( const OSSymbol * typeOfInterest,
1325                   IOServiceInterestHandler handler, void * target, void * ref )
1326 {
1327     _IOServiceInterestNotifier * notify = 0;
1328     OSArray *                    set;
1329
1330     if( (typeOfInterest != gIOGeneralInterest)
1331      && (typeOfInterest != gIOBusyInterest)
1332      && (typeOfInterest != gIOAppPowerStateInterest)
1333      && (typeOfInterest != gIOPriorityPowerStateInterest))
1334         return( 0 );
1335
1336     lockForArbitration();
1337     if( 0 == (__state[0] & kIOServiceInactiveState)) {
1338
1339         notify = new _IOServiceInterestNotifier;
1340         if( notify && !notify->init()) {
1341             notify->release();
1342             notify = 0;
1343         }
1344
1345         if( notify) {
1346             notify->handler = handler;
1347             notify->target = target;
1348             notify->ref = ref;
1349             notify->state = kIOServiceNotifyEnable;
1350             queue_init( &notify->handlerInvocations );
1351
1352             ////// queue
1353
1354             LOCKWRITENOTIFY();
1355             if( 0 == (set = (OSArray *) getProperty( typeOfInterest ))) {
1356                 set = OSArray::withCapacity( 1 );
1357                 if( set) {
1358                     setProperty( typeOfInterest, set );
1359                     set->release();
1360                 }
1361             }
1362             notify->whence = set;
1363             if( set)
1364                 set->setObject( notify );
1365             UNLOCKNOTIFY();
1366         }
1367     }
1368     unlockForArbitration();
1369
1370     return( notify );
1371 }
1372
1373 static void cleanInterestArray( OSObject * object )
1374 {
1375     OSArray *                   array;
1376     unsigned int                index;
1377     _IOServiceInterestNotifier * next;
1378
1379     if( (array = OSDynamicCast( OSArray, object))) {
1380         LOCKWRITENOTIFY();
1381         for( index = 0;
1382              (next = (_IOServiceInterestNotifier *)
1383                         array->getObject( index ));
1384              index++) {
1385             next->whence = 0;
1386         }
1387         UNLOCKNOTIFY();
1388     }
1389 }
1390
1391 void IOService::unregisterAllInterest( void )
1392 {
1393     cleanInterestArray( getProperty( gIOGeneralInterest ));
1394     cleanInterestArray( getProperty( gIOBusyInterest ));
1395     cleanInterestArray( getProperty( gIOAppPowerStateInterest ));
1396     cleanInterestArray( getProperty( gIOPriorityPowerStateInterest ));
1397 }
1398
1399 /*
1400  * _IOServiceInterestNotifier
1401  */
1402
1403 // wait for all threads, other than the current one,
1404 //  to exit the handler
1405
1406 void _IOServiceInterestNotifier::wait()
1407 {
1408     _IOServiceNotifierInvocation * next;
1409     bool doWait;
1410
1411     do {
1412         doWait = false;
1413         queue_iterate( &handlerInvocations, next,
1414                         _IOServiceNotifierInvocation *, link) {
1415             if( next->thread != current_thread() ) {
1416                 doWait = true;
1417                 break;
1418             }
1419         }
1420         if( doWait) {
1421             state |= kIOServiceNotifyWaiter;
1422                SLEEPNOTIFY(this);
1423         }
1424
1425     } while( doWait );
1426 }
1427
1428 void _IOServiceInterestNotifier::free()
1429 {
1430     assert( queue_empty( &handlerInvocations ));
1431     OSObject::free();
1432 }
1433
1434 void _IOServiceInterestNotifier::remove()
1435 {
1436     LOCKWRITENOTIFY();
1437
1438     if( whence) {
1439         whence->removeObject(whence->getNextIndexOfObject(
1440                                        (OSObject *) this, 0 ));
1441         whence = 0;
1442     }
1443
1444     state &= ~kIOServiceNotifyEnable;
1445
1446     wait();
1447
1448     UNLOCKNOTIFY();
1449
1450     release();
1451 }
1452
1453 bool _IOServiceInterestNotifier::disable()
1454 {
1455     bool        ret;
1456
1457     LOCKWRITENOTIFY();
1458
1459     ret = (0 != (kIOServiceNotifyEnable & state));
1460     state &= ~kIOServiceNotifyEnable;
1461     if( ret)
1462         wait();
1463
1464     UNLOCKNOTIFY();
1465
1466     return( ret );
1467 }
1468
1469 void _IOServiceInterestNotifier::enable( bool was )
1470 {
1471     LOCKWRITENOTIFY();
1472     if( was)
1473         state |= kIOServiceNotifyEnable;
1474     else
1475         state &= ~kIOServiceNotifyEnable;
1476     UNLOCKNOTIFY();
1477 }
1478
1479 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1480
1481 /*
1482  * Termination
1483  */
1484
1485 #define tailQ(o)                setObject(o)
1486 #define headQ(o)                setObject(0, o)
1487 #define TLOG(fmt, args...)      { if(kIOLogYield & gIOKitDebug) IOLog(fmt, ## args); }
1488
1489 inline void _workLoopAction( IOWorkLoop::Action action,
1490                              IOService * service,
1491                              void * p0 = 0, void * p1 = 0,
1492                              void * p2 = 0, void * p3 = 0 )
1493 {
1494     IOWorkLoop * wl;
1495
1496     if( (wl = service->getWorkLoop())) {
1497         wl->retain();
1498         wl->runAction( action, service, p0, p1, p2, p3 );
1499         wl->release();
1500     } else
1501         (*action)( service, p0, p1, p2, p3 );
1502 }
1503
1504 bool IOService::requestTerminate( IOService * provider, IOOptionBits options )
1505 {
1506     bool ok;
1507
1508     // if its our only provider
1509     ok = isParent( provider, gIOServicePlane, true);
1510
1511     // -- compat
1512     if( ok) {
1513         provider->terminateClient( this, options | kIOServiceRecursing );
1514         ok = (0 != (__state[1] & kIOServiceRecursing));
1515     }
1516     // --
1517
1518     return( ok );
1519 }
1520
1521 bool IOService::terminatePhase1( IOOptionBits options )
1522 {
1523     IOService *         victim;
1524     IOService *         client;
1525     OSIterator *        iter;
1526     OSArray *           makeInactive;
1527     bool                ok;
1528     bool                didInactive;
1529     bool                startPhase2 = false;
1530
1531     TLOG("%s::terminatePhase1(%08lx)\n", getName(), options);
1532
1533     // -- compat
1534     if( options & kIOServiceRecursing) {
1535         __state[1] |= kIOServiceRecursing;
1536         return( true );
1537     }
1538     // --
1539
1540     makeInactive = OSArray::withCapacity( 16 );
1541     if( !makeInactive)
1542         return( false );
1543
1544     victim = this;
1545     victim->retain();
1546
1547     while( victim ) {
1548
1549         didInactive = victim->lockForArbitration( true );
1550         if( didInactive) {
1551             didInactive = (0 == (victim->__state[0] & kIOServiceInactiveState));
1552             if( didInactive) {
1553                 victim->__state[0] |= kIOServiceInactiveState;
1554                 victim->__state[0] &= ~(kIOServiceRegisteredState | kIOServiceMatchedState
1555                                         | kIOServiceFirstPublishState | kIOServiceFirstMatchState);
1556                 victim->_adjustBusy( 1 );
1557             }
1558             victim->unlockForArbitration();
1559         }
1560         if( victim == this)
1561             startPhase2 = didInactive;
1562         if( didInactive) {
1563
1564             victim->deliverNotification( gIOTerminatedNotification, 0, 0xffffffff );
1565             IOUserClient::destroyUserReferences( victim );
1566             victim->unregisterAllInterest();
1567
1568             iter = victim->getClientIterator();
1569             if( iter) {
1570                 while( (client = (IOService *) iter->getNextObject())) {
1571                     TLOG("%s::requestTerminate(%s, %08lx)\n",
1572                             client->getName(), victim->getName(), options);
1573                     ok = client->requestTerminate( victim, options );
1574                     TLOG("%s::requestTerminate(%s, ok = %d)\n",
1575                             client->getName(), victim->getName(), ok);
1576                     if( ok)
1577                         makeInactive->setObject( client );
1578                 }
1579                 iter->release();
1580             }
1581         }
1582         victim->release();
1583         victim = (IOService *) makeInactive->getObject(0);
1584         if( victim) {
1585             victim->retain();
1586             makeInactive->removeObject(0);
1587         }
1588     }
1589
1590     makeInactive->release();
1591
1592     if( startPhase2)
1593         scheduleTerminatePhase2( options );
1594
1595     return( true );
1596 }
1597
1598 void IOService::scheduleTerminatePhase2( IOOptionBits options )
1599 {
1600     AbsoluteTime        deadline;
1601     int                 waitResult;
1602     bool                wait, haveDeadline = false;
1603
1604     options |= kIOServiceRequired;
1605
1606     retain();
1607
1608     IOLockLock( gJobsLock );
1609
1610     if( (options & kIOServiceSynchronous)
1611         && (current_thread() != gIOTerminateThread)) {
1612
1613         do {
1614             wait = (gIOTerminateThread != 0);
1615             if( wait) {
1616                 // wait to become the terminate thread
1617                 IOLockSleep( gJobsLock, &gIOTerminateThread, THREAD_UNINT);
1618             }
1619         } while( wait );
1620
1621         gIOTerminateThread = current_thread();
1622         gIOTerminatePhase2List->setObject( this );
1623         gIOTerminateWork++;
1624
1625         do {
1626             while( gIOTerminateWork )
1627                 terminateWorker( options );
1628             wait = (0 != (__state[1] & kIOServiceBusyStateMask));
1629             if( wait) {
1630                 // wait for the victim to go non-busy
1631                 if( !haveDeadline) {
1632                     clock_interval_to_deadline( 15, kSecondScale, &deadline );
1633                     haveDeadline = true;
1634                 }
1635                 waitResult = IOLockSleepDeadline( gJobsLock, &gIOTerminateWork,
1636                                                   deadline, THREAD_UNINT );
1637                 if( waitResult == THREAD_TIMED_OUT) {
1638                     TLOG("%s::terminate(kIOServiceSynchronous) timeout", getName());
1639                 } else
1640                     thread_cancel_timer();
1641             }
1642         } while(gIOTerminateWork || (wait && (waitResult != THREAD_TIMED_OUT)));
1643
1644         gIOTerminateThread = 0;
1645         IOLockWakeup( gJobsLock, (event_t) &gIOTerminateThread, /* one-thread */ false);
1646
1647     } else {
1648         // ! kIOServiceSynchronous
1649
1650         gIOTerminatePhase2List->setObject( this );
1651         if( 0 == gIOTerminateWork++) {
1652             if( !gIOTerminateThread)
1653                 gIOTerminateThread = IOCreateThread( &terminateThread, (void *) options );
1654             else
1655                 IOLockWakeup(gJobsLock, (event_t) &gIOTerminateWork, /* one-thread */ false );
1656         }
1657     }
1658
1659     IOLockUnlock( gJobsLock );
1660
1661     release();
1662 }
1663
1664 void IOService::terminateThread( void * arg )
1665 {
1666     IOLockLock( gJobsLock );
1667
1668     while (gIOTerminateWork)
1669         terminateWorker( (IOOptionBits) arg );
1670
1671     gIOTerminateThread = 0;
1672     IOLockWakeup( gJobsLock, (event_t) &gIOTerminateThread, /* one-thread */ false);
1673
1674     IOLockUnlock( gJobsLock );
1675 }
1676
1677 void IOService::scheduleStop( IOService * provider )
1678 {
1679     TLOG("%s::scheduleStop(%s)\n", getName(), provider->getName());
1680
1681     IOLockLock( gJobsLock );
1682     gIOStopList->tailQ( this );
1683     gIOStopProviderList->tailQ( provider );
1684
1685     if( 0 == gIOTerminateWork++) {
1686         if( !gIOTerminateThread)
1687             gIOTerminateThread = IOCreateThread( &terminateThread, (void *) 0 );
1688         else
1689             IOLockWakeup(gJobsLock, (event_t) &gIOTerminateWork, /* one-thread */ false );
1690     }
1691
1692     IOLockUnlock( gJobsLock );
1693 }
1694
1695 void IOService::scheduleFinalize( void )
1696 {
1697     TLOG("%s::scheduleFinalize\n", getName());
1698
1699     IOLockLock( gJobsLock );
1700     gIOFinalizeList->tailQ( this );
1701
1702     if( 0 == gIOTerminateWork++) {
1703         if( !gIOTerminateThread)
1704             gIOTerminateThread = IOCreateThread( &terminateThread, (void *) 0 );
1705         else
1706             IOLockWakeup(gJobsLock, (event_t) &gIOTerminateWork, /* one-thread */ false );
1707     }
1708
1709     IOLockUnlock( gJobsLock );
1710 }
1711
1712 bool IOService::willTerminate( IOService * provider, IOOptionBits options )
1713 {
1714     return( true );
1715 }
1716
1717 bool IOService::didTerminate( IOService * provider, IOOptionBits options, bool * defer )
1718 {
1719     if( false == *defer) {
1720
1721         if( lockForArbitration( true )) {
1722             if( false == provider->handleIsOpen( this ))
1723                 scheduleStop( provider );
1724             // -- compat
1725             else {
1726                 message( kIOMessageServiceIsRequestingClose, provider, (void *) options );
1727                 if( false == provider->handleIsOpen( this ))
1728                     scheduleStop( provider );
1729             }
1730             // --
1731             unlockForArbitration();
1732         }
1733     }
1734
1735     return( true );
1736 }
1737
1738 void IOService::actionWillTerminate( IOService * victim, IOOptionBits options,
1739                                     OSArray * doPhase2List )
1740 {
1741     OSIterator * iter;
1742     IOService *  client;
1743     bool         ok;
1744
1745     iter = victim->getClientIterator();
1746     if( iter) {
1747         while( (client = (IOService *) iter->getNextObject())) {
1748             TLOG("%s::willTerminate(%s, %08lx)\n",
1749                     client->getName(), victim->getName(), options);
1750             ok = client->willTerminate( victim, options );
1751             doPhase2List->tailQ( client );
1752         }
1753         iter->release();
1754     }
1755 }
1756
1757 void IOService::actionDidTerminate( IOService * victim, IOOptionBits options )
1758 {
1759     OSIterator * iter;
1760     IOService *  client;
1761     bool defer = false;
1762
1763     victim->messageClients( kIOMessageServiceIsTerminated, (void *) options );
1764
1765     iter = victim->getClientIterator();
1766     if( iter) {
1767         while( (client = (IOService *) iter->getNextObject())) {
1768             TLOG("%s::didTerminate(%s, %08lx)\n",
1769                     client->getName(), victim->getName(), options);
1770             client->didTerminate( victim, options, &defer );
1771             TLOG("%s::didTerminate(%s, defer %d)\n",
1772                     client->getName(), victim->getName(), defer);
1773         }
1774         iter->release();
1775     }
1776 }
1777
1778 void IOService::actionFinalize( IOService * victim, IOOptionBits options )
1779 {
1780     TLOG("%s::finalize(%08lx)\n", victim->getName(), options);
1781     victim->finalize( options );
1782 }
1783
1784 void IOService::actionStop( IOService * provider, IOService * client )
1785 {
1786     TLOG("%s::stop(%s)\n", client->getName(), provider->getName());
1787     client->stop( provider );
1788     if( provider->isOpen( client ))
1789         provider->close( client );
1790     TLOG("%s::detach(%s)\n", client->getName(), provider->getName());
1791     client->detach( provider );
1792 }
1793
1794 void IOService::terminateWorker( IOOptionBits options )
1795 {
1796     OSArray *           doPhase2List;
1797     OSArray *           didPhase2List;
1798     OSSet *             freeList;
1799     UInt32              workDone;
1800     IOService *         victim;
1801     IOService *         client;
1802     IOService *         provider;
1803     unsigned int        idx;
1804     bool                moreToDo;
1805     bool                doPhase2;
1806     bool                doPhase3;
1807
1808     options |= kIOServiceRequired;
1809
1810     doPhase2List  = OSArray::withCapacity( 16 );
1811     didPhase2List = OSArray::withCapacity( 16 );
1812     freeList      = OSSet::withCapacity( 16 );
1813     if( (0 == doPhase2List) || (0 == didPhase2List) || (0 == freeList))
1814         return;
1815
1816     do {
1817         workDone = gIOTerminateWork;
1818
1819         while( (victim = (IOService *) gIOTerminatePhase2List->getObject(0) )) {
1820
1821             victim->retain();
1822             gIOTerminatePhase2List->removeObject(0);
1823             IOLockUnlock( gJobsLock );
1824
1825             while( victim ) {
1826
1827                 doPhase2 = victim->lockForArbitration( true );
1828                 if( doPhase2) {
1829                     doPhase2 = (0 != (kIOServiceInactiveState & victim->__state[0]));
1830                     if( doPhase2) {
1831                         doPhase2 = (0 == (victim->__state[1] & kIOServiceTermPhase2State))
1832                                 && (0 == (victim->__state[1] & kIOServiceConfigState));
1833                         if( doPhase2)
1834                             victim->__state[1] |= kIOServiceTermPhase2State;
1835                     }
1836                     victim->unlockForArbitration();
1837                 }
1838                 if( doPhase2) {
1839                     if( 0 == victim->getClient()) {
1840                         // no clients - will go to finalize
1841                         IOLockLock( gJobsLock );
1842                         gIOFinalizeList->tailQ( victim );
1843                         IOLockUnlock( gJobsLock );
1844                     } else {
1845                         _workLoopAction( (IOWorkLoop::Action) &actionWillTerminate,
1846                                             victim, (void *) options, (void *) doPhase2List );
1847                     }
1848                     didPhase2List->headQ( victim );
1849                 }
1850                 victim->release();
1851                 victim = (IOService *) doPhase2List->getObject(0);
1852                 if( victim) {
1853                     victim->retain();
1854                     doPhase2List->removeObject(0);
1855                 }
1856             }
1857
1858             while( (victim = (IOService *) didPhase2List->getObject(0)) ) {
1859
1860                 if( victim->lockForArbitration( true )) {
1861                     victim->__state[1] |= kIOServiceTermPhase3State;
1862                     victim->unlockForArbitration();
1863                 }
1864                 _workLoopAction( (IOWorkLoop::Action) &actionDidTerminate,
1865                                     victim, (void *) options );
1866                 didPhase2List->removeObject(0);
1867             }
1868             IOLockLock( gJobsLock );
1869         }
1870
1871         // phase 3
1872         do {
1873             doPhase3 = false;
1874             // finalize leaves
1875             while( (victim = (IOService *) gIOFinalizeList->getObject(0))) {
1876
1877                 IOLockUnlock( gJobsLock );
1878                 _workLoopAction( (IOWorkLoop::Action) &actionFinalize,
1879                                     victim, (void *) options );
1880                 IOLockLock( gJobsLock );
1881                 // hold off free
1882                 freeList->setObject( victim );
1883                 // safe if finalize list is append only
1884                 gIOFinalizeList->removeObject(0);
1885             }
1886
1887             for( idx = 0;
1888                  (!doPhase3) && (client = (IOService *) gIOStopList->getObject(idx)); ) {
1889
1890                 provider = (IOService *) gIOStopProviderList->getObject(idx);
1891                 assert( provider );
1892
1893                 if( !provider->isChild( client, gIOServicePlane )) {
1894                     // may be multiply queued - nop it
1895                     TLOG("%s::nop stop(%s)\n", client->getName(), provider->getName());
1896                 } else {
1897                     // not ready for stop if it has clients, skip it
1898                     if( (client->__state[1] & kIOServiceTermPhase3State) && client->getClient()) {
1899                         TLOG("%s::defer stop(%s)\n", client->getName(), provider->getName());
1900                         idx++;
1901                         continue;
1902                     }
1903
1904                     IOLockUnlock( gJobsLock );
1905                     _workLoopAction( (IOWorkLoop::Action) &actionStop,
1906                                      provider, (void *) client );
1907                     IOLockLock( gJobsLock );
1908                     // check the finalize list now
1909                     doPhase3 = true;
1910                 }
1911                 // hold off free
1912                 freeList->setObject( client );
1913                 freeList->setObject( provider );
1914
1915                 // safe if stop list is append only
1916                 gIOStopList->removeObject( idx );
1917                 gIOStopProviderList->removeObject( idx );
1918                 idx = 0;
1919             }
1920
1921         } while( doPhase3 );
1922
1923         gIOTerminateWork -= workDone;
1924         moreToDo = (gIOTerminateWork != 0);
1925
1926         if( !moreToDo) {
1927             TLOG("iokit terminate done, %d stops remain\n", gIOStopList->getCount());
1928         }
1929
1930     } while( moreToDo );
1931
1932     IOLockUnlock( gJobsLock );
1933
1934     freeList->release();
1935     doPhase2List->release();
1936     didPhase2List->release();
1937
1938     IOLockLock( gJobsLock );
1939 }
1940
1941 bool IOService::finalize( IOOptionBits options )
1942 {
1943     OSIterator *        iter;
1944     IOService *         provider;
1945
1946     iter = getProviderIterator();
1947     assert( iter );
1948
1949     if( iter) {
1950         while( (provider = (IOService *) iter->getNextObject())) {
1951
1952             // -- compat
1953             if( 0 == (__state[1] & kIOServiceTermPhase3State)) {
1954                 /* we come down here on programmatic terminate */
1955                 stop( provider );
1956                 if( provider->isOpen( this ))
1957                     provider->close( this );
1958                 detach( provider );
1959             } else {
1960             //--
1961                 if( provider->lockForArbitration( true )) {
1962                     if( 0 == (provider->__state[1] & kIOServiceTermPhase3State))
1963                         scheduleStop( provider );
1964                     provider->unlockForArbitration();
1965                 }
1966             }
1967         }
1968         iter->release();
1969     }
1970
1971     return( true );
1972 }
1973
1974 #undef tailQ
1975 #undef headQ
1976
1977 /*
1978  * Terminate
1979  */
1980
1981 void IOService::doServiceTerminate( IOOptionBits options )
1982 {
1983 }
1984
1985 // a method in case someone needs to override it
1986 bool IOService::terminateClient( IOService * client, IOOptionBits options )
1987 {
1988     bool ok;
1989
1990     if( client->isParent( this, gIOServicePlane, true))
1991         // we are the clients only provider
1992         ok = client->terminate( options );
1993     else
1994         ok = true;
1995
1996     return( ok );
1997 }
1998
1999 bool IOService::terminate( IOOptionBits options )
2000 {
2001     options |= kIOServiceTerminate;
2002
2003     return( terminatePhase1( options ));
2004 }
2005
2006 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007
2008 /*
2009  * Open & close
2010  */
2011
2012 struct ServiceOpenMessageContext
2013 {
2014     IOService *  service;
2015     UInt32       type;
2016     IOService *  excludeClient;
2017     IOOptionBits options;
2018 };
2019
2020 static void serviceOpenMessageApplier( OSObject * object, void * ctx )
2021 {
2022     ServiceOpenMessageContext * context = (ServiceOpenMessageContext *) ctx;
2023
2024     if( object != context->excludeClient)
2025         context->service->messageClient( context->type, object, (void *) context->options );
2026 }
2027
2028 bool IOService::open(   IOService *     forClient,
2029                         IOOptionBits    options,
2030                         void *          arg )
2031 {
2032     bool                        ok;
2033     ServiceOpenMessageContext   context;
2034
2035     context.service             = this;
2036     context.type                = kIOMessageServiceIsAttemptingOpen;
2037     context.excludeClient       = forClient;
2038     context.options             = options;
2039
2040     applyToInterested( gIOGeneralInterest,
2041                         &serviceOpenMessageApplier, &context );
2042
2043     if( false == lockForArbitration(false) )
2044         return false;
2045
2046     ok = (0 == (__state[0] & kIOServiceInactiveState));
2047     if( ok)
2048         ok = handleOpen( forClient, options, arg );
2049
2050     unlockForArbitration();
2051
2052     return( ok );
2053 }
2054
2055 void IOService::close(  IOService *     forClient,
2056                         IOOptionBits    options )
2057 {
2058     bool                wasClosed;
2059     bool                last = false;
2060
2061     lockForArbitration();
2062
2063     wasClosed = handleIsOpen( forClient );
2064     if( wasClosed) {
2065         handleClose( forClient, options );
2066         last = (__state[1] & kIOServiceTermPhase3State);
2067     }
2068
2069     unlockForArbitration();
2070
2071     if( last)
2072         forClient->scheduleStop( this );
2073
2074     else if( wasClosed) {
2075
2076         ServiceOpenMessageContext context;
2077
2078         context.service         = this;
2079         context.type            = kIOMessageServiceWasClosed;
2080         context.excludeClient   = forClient;
2081         context.options         = options;
2082
2083         applyToInterested( gIOGeneralInterest,
2084                             &serviceOpenMessageApplier, &context );
2085     }
2086 }
2087
2088 bool IOService::isOpen( const IOService * forClient ) const
2089 {
2090     IOService * self = (IOService *) this;
2091     bool ok;
2092
2093     self->lockForArbitration();
2094
2095     ok = handleIsOpen( forClient );
2096
2097     self->unlockForArbitration();
2098
2099     return( ok );
2100 }
2101
2102 bool IOService::handleOpen(     IOService *     forClient,
2103                                 IOOptionBits    options,
2104                                 void *          arg )
2105 {
2106     bool        ok;
2107
2108     ok = (0 == __owner);
2109     if( ok )
2110         __owner = forClient;
2111
2112     else if( options & kIOServiceSeize ) {
2113         ok = (kIOReturnSuccess == messageClient( kIOMessageServiceIsRequestingClose,
2114                                 __owner, (void *) options ));
2115         if( ok && (0 == __owner ))
2116             __owner = forClient;
2117         else
2118             ok = false;
2119     }
2120     return( ok );
2121 }
2122
2123 void IOService::handleClose(    IOService *     forClient,
2124                                 IOOptionBits    options )
2125 {
2126     if( __owner == forClient)
2127         __owner = 0;
2128 }
2129
2130 bool IOService::handleIsOpen(   const IOService * forClient ) const
2131 {
2132     if( forClient)
2133         return( __owner == forClient );
2134     else
2135         return( __owner != forClient );
2136 }
2137
2138 /*
2139  * Probing & starting
2140  */
2141 static SInt32 IONotifyOrdering( const OSMetaClassBase * inObj1, const OSMetaClassBase * inObj2, void * ref )
2142 {
2143     const _IOServiceNotifier * obj1 = (const _IOServiceNotifier *) inObj1;
2144     const _IOServiceNotifier * obj2 = (const _IOServiceNotifier *) inObj2;
2145     SInt32             val1;
2146     SInt32             val2;
2147
2148     val1 = 0;
2149     val2 = 0;
2150
2151     if ( obj1 )
2152         val1 = obj1->priority;
2153
2154     if ( obj2 )
2155         val2 = obj2->priority;
2156
2157     return ( val1 - val2 );
2158 }
2159
2160 static SInt32 IOServiceObjectOrder( const OSObject * entry, void * ref)
2161 {
2162     OSDictionary *      dict;
2163     IOService *         service;
2164     _IOServiceNotifier * notify;
2165     OSSymbol *          key = (OSSymbol *) ref;
2166     OSNumber *          offset;
2167
2168     if( (notify = OSDynamicCast( _IOServiceNotifier, entry)))
2169         return( notify->priority );
2170
2171     else if( (service = OSDynamicCast( IOService, entry)))
2172         offset = OSDynamicCast(OSNumber, service->getProperty( key ));
2173     else if( (dict = OSDynamicCast( OSDictionary, entry)))
2174         offset = OSDynamicCast(OSNumber, dict->getObject( key ));
2175     else {
2176         assert( false );
2177         offset = 0;
2178     }
2179
2180     if( offset)
2181         return( (SInt32) offset->unsigned32BitValue());
2182     else
2183         return( kIODefaultProbeScore );
2184 }
2185
2186 SInt32 IOServiceOrdering( const OSMetaClassBase * inObj1, const OSMetaClassBase * inObj2, void * ref )
2187 {
2188     const OSObject *    obj1 = (const OSObject *) inObj1;
2189     const OSObject *    obj2 = (const OSObject *) inObj2;
2190     SInt32               val1;
2191     SInt32               val2;
2192
2193     val1 = 0;
2194     val2 = 0;
2195
2196     if ( obj1 )
2197         val1 = IOServiceObjectOrder( obj1, ref );
2198
2199     if ( obj2 )
2200         val2 = IOServiceObjectOrder( obj2, ref );
2201
2202     return ( val1 - val2 );
2203 }
2204
2205 IOService * IOService::getClientWithCategory( const OSSymbol * category )
2206 {
2207     IOService *         service = 0;
2208     OSIterator *        iter;
2209     const OSSymbol *    nextCat;
2210
2211     iter = getClientIterator();
2212     if( iter) {
2213         while( (service = (IOService *) iter->getNextObject())) {
2214             if( kIOServiceInactiveState & service->__state[0])
2215                 continue;
2216             nextCat = (const OSSymbol *) OSDynamicCast( OSSymbol,
2217                         service->getProperty( gIOMatchCategoryKey ));
2218             if( category == nextCat)
2219                 break;
2220         }
2221         iter->release();
2222     }
2223     return( service );
2224 }
2225
2226 bool IOService::invokeNotifer( _IOServiceNotifier * notify )
2227 {
2228     _IOServiceNotifierInvocation invocation;
2229     bool                         willNotify;
2230     bool                         ret = true;
2231
2232     invocation.thread = current_thread();
2233
2234     LOCKWRITENOTIFY();
2235     willNotify = (0 != (kIOServiceNotifyEnable & notify->state));
2236
2237     if( willNotify) {
2238         queue_enter( &notify->handlerInvocations, &invocation,
2239                         _IOServiceNotifierInvocation *, link );
2240     }
2241     UNLOCKNOTIFY();
2242
2243     if( willNotify) {
2244
2245         ret = (*notify->handler)( notify->target, notify->ref, this );
2246
2247         LOCKWRITENOTIFY();
2248         queue_remove( &notify->handlerInvocations, &invocation,
2249                         _IOServiceNotifierInvocation *, link );
2250         if( kIOServiceNotifyWaiter & notify->state) {
2251             notify->state &= ~kIOServiceNotifyWaiter;
2252             WAKEUPNOTIFY( notify );
2253         }
2254         UNLOCKNOTIFY();
2255     }
2256
2257     return( ret );
2258 }
2259
2260 /*
2261  * Alloc and probe matching classes,
2262  * called on the provider instance
2263  */
2264
2265 void IOService::probeCandidates( OSOrderedSet * matches )
2266 {
2267     OSDictionary        *       match = 0;
2268     OSSymbol            *       symbol;
2269     IOService           *       inst;
2270     IOService           *       newInst;
2271     OSDictionary        *       props;
2272     SInt32                      score;
2273     OSNumber            *       newPri;
2274     OSOrderedSet        *       familyMatches = 0;
2275     OSOrderedSet        *       startList;
2276     OSDictionary        *       startDict = 0;
2277     const OSSymbol      *       category;
2278     OSIterator          *       iter;
2279     _IOServiceNotifier  *               notify;
2280     OSObject            *       nextMatch = 0;
2281     bool                        started;
2282     bool                        needReloc = false;
2283 #if IOMATCHDEBUG
2284     SInt64                      debugFlags;
2285 #endif
2286
2287     assert( matches );
2288     while( !needReloc && (nextMatch = matches->getFirstObject())) {
2289
2290         nextMatch->retain();
2291         matches->removeObject(nextMatch);
2292
2293         if( (notify = OSDynamicCast( _IOServiceNotifier, nextMatch ))) {
2294
2295             lockForArbitration();
2296             if( 0 == (__state[0] & kIOServiceInactiveState))
2297                 invokeNotifer( notify );
2298             unlockForArbitration();
2299             nextMatch->release();
2300             nextMatch = 0;
2301             continue;
2302
2303         } else if( !(match = OSDynamicCast( OSDictionary, nextMatch ))) {
2304             nextMatch->release();
2305             nextMatch = 0;
2306             continue;
2307         }
2308
2309         props = 0;
2310 #if IOMATCHDEBUG
2311         debugFlags = getDebugFlags( match );
2312 #endif
2313
2314         do {
2315             category = OSDynamicCast( OSSymbol,
2316                         match->getObject( gIOMatchCategoryKey ));
2317             if( 0 == category)
2318                 category = gIODefaultMatchCategoryKey;
2319
2320             if( getClientWithCategory( category )) {
2321 #if IOMATCHDEBUG
2322                 if( debugFlags & kIOLogMatch)
2323                     LOG("%s: match category %s exists\n", getName(),
2324                                 category->getCStringNoCopy());
2325 #endif
2326                 nextMatch->release();
2327                 nextMatch = 0;
2328                 continue;
2329             }
2330
2331             // create a copy now in case its modified during matching
2332             props = OSDictionary::withDictionary( match, match->getCount());
2333             if( 0 == props)
2334                 continue;
2335             props->setCapacityIncrement(1);
2336
2337             // check the nub matches
2338             if( false == passiveMatch( props, true ))
2339                 continue;
2340
2341             // Check to see if driver reloc has been loaded.
2342             needReloc = (false == gIOCatalogue->isModuleLoaded( match ));
2343             if( needReloc) {
2344 #if IOMATCHDEBUG
2345                 if( debugFlags & kIOLogCatalogue)
2346                     LOG("%s: stalling for module\n", getName());
2347 #endif
2348                 // If reloc hasn't been loaded, exit;
2349                 // reprobing will occur after reloc has been loaded.
2350                 continue;
2351             }
2352
2353             // reorder on family matchPropertyTable score.
2354             if( 0 == familyMatches)
2355                 familyMatches = OSOrderedSet::withCapacity( 1,
2356                         IOServiceOrdering, (void *) gIOProbeScoreKey );
2357             if( familyMatches)
2358                 familyMatches->setObject( props );
2359
2360         } while( false );
2361
2362         if (nextMatch) {
2363             nextMatch->release();
2364             nextMatch = 0;
2365         }
2366         if( props)
2367             props->release();
2368     }
2369     matches->release();
2370     matches = 0;
2371
2372     if( familyMatches) {
2373
2374         while( !needReloc
2375              && (props = (OSDictionary *) familyMatches->getFirstObject())) {
2376
2377             props->retain();
2378             familyMatches->removeObject( props );
2379
2380             inst = 0;
2381             newInst = 0;
2382 #if IOMATCHDEBUG
2383             debugFlags = getDebugFlags( props );
2384 #endif
2385             do {
2386                 symbol = OSDynamicCast( OSSymbol,
2387                                 props->getObject( gIOClassKey));
2388                 if( !symbol)
2389                     continue;
2390
2391                 // alloc the driver instance
2392                 inst = (IOService *) OSMetaClass::allocClassWithName( symbol);
2393
2394                 if( !inst) {
2395                     IOLog("Couldn't alloc class \"%s\"\n",
2396                         symbol->getCStringNoCopy());
2397                     continue;
2398                 }
2399
2400                 // init driver instance
2401                 if( !(inst->init( props ))) {
2402 #if IOMATCHDEBUG
2403                     if( debugFlags & kIOLogStart)
2404                         IOLog("%s::init fails\n", symbol->getCStringNoCopy());
2405 #endif
2406                     continue;
2407                 }
2408                 if( __state[1] & kIOServiceSynchronousState)
2409                     inst->__state[1] |= kIOServiceSynchronousState;
2410
2411                 // give the driver the default match category if not specified
2412                 category = OSDynamicCast( OSSymbol,
2413                             props->getObject( gIOMatchCategoryKey ));
2414                 if( 0 == category)
2415                     category = gIODefaultMatchCategoryKey;
2416                 inst->setProperty( gIOMatchCategoryKey, (OSObject *) category );
2417
2418                 // attach driver instance
2419                 if( !(inst->attach( this )))
2420                         continue;
2421
2422                 // pass in score from property table
2423                 score = familyMatches->orderObject( props );
2424
2425                 // & probe the new driver instance
2426 #if IOMATCHDEBUG
2427                 if( debugFlags & kIOLogProbe)
2428                     LOG("%s::probe(%s)\n",
2429                         inst->getMetaClass()->getClassName(), getName());
2430 #endif
2431
2432                 newInst = inst->probe( this, &score );
2433                 inst->detach( this );
2434                 if( 0 == newInst) {
2435 #if IOMATCHDEBUG
2436                     if( debugFlags & kIOLogProbe)
2437                         IOLog("%s::probe fails\n", symbol->getCStringNoCopy());
2438 #endif
2439                     continue;
2440                 }
2441
2442                 // save the score
2443                 newPri = OSNumber::withNumber( score, 32 );
2444                 if( newPri) {
2445                     newInst->setProperty( gIOProbeScoreKey, newPri );
2446                     newPri->release();
2447                 }
2448
2449                 // add to start list for the match category
2450                 if( 0 == startDict)
2451                     startDict = OSDictionary::withCapacity( 1 );
2452                 assert( startDict );
2453                 startList = (OSOrderedSet *)
2454                                 startDict->getObject( category );
2455                 if( 0 == startList) {
2456                     startList = OSOrderedSet::withCapacity( 1,
2457                             IOServiceOrdering, (void *) gIOProbeScoreKey );
2458                     if( startDict && startList) {
2459                         startDict->setObject( category, startList );
2460                         startList->release();
2461                     }
2462                 }
2463                 assert( startList );
2464                 if( startList)
2465                     startList->setObject( newInst );
2466
2467             } while( false );
2468
2469             props->release();
2470             if( inst)
2471                 inst->release();
2472         }
2473         familyMatches->release();
2474         familyMatches = 0;
2475     }
2476
2477     // start the best (until success) of each category
2478
2479     iter = OSCollectionIterator::withCollection( startDict );
2480     if( iter) {
2481         while( (category = (const OSSymbol *) iter->getNextObject())) {
2482
2483             startList = (OSOrderedSet *) startDict->getObject( category );
2484             assert( startList );
2485             if( !startList)
2486                 continue;
2487
2488             started = false;
2489             while( true // (!started)
2490                    && (inst = (IOService *)startList->getFirstObject())) {
2491
2492                 inst->retain();
2493                 startList->removeObject(inst);
2494
2495 #if IOMATCHDEBUG
2496                 debugFlags = getDebugFlags( inst->getPropertyTable() );
2497
2498                 if( debugFlags & kIOLogStart) {
2499                     if( started)
2500                         LOG( "match category exists, skipping " );
2501                     LOG( "%s::start(%s) <%d>\n", inst->getName(),
2502                          getName(), inst->getRetainCount());
2503                 }
2504 #endif
2505                 if( false == started)
2506                     started = startCandidate( inst );
2507 #if IOMATCHDEBUG
2508                 if( (debugFlags & kIOLogStart) && (false == started))
2509                     LOG( "%s::start(%s) <%d> failed\n", inst->getName(), getName(),
2510                          inst->getRetainCount());
2511 #endif
2512                 inst->release();
2513             }
2514         }
2515         iter->release();
2516     }
2517
2518
2519     // adjust the busy count by -1 if matching is stalled for a module,
2520     // or +1 if a previously stalled matching is complete.
2521     lockForArbitration();
2522     SInt32 adjBusy = 0;
2523     if( needReloc) {
2524         adjBusy = (__state[1] & kIOServiceModuleStallState) ? 0 : 1;
2525         if( adjBusy)
2526             __state[1] |= kIOServiceModuleStallState;
2527
2528     } else if( __state[1] & kIOServiceModuleStallState) {
2529         __state[1] &= ~kIOServiceModuleStallState;
2530         adjBusy = -1;
2531     }
2532     if( adjBusy)
2533         _adjustBusy( adjBusy );
2534     unlockForArbitration();
2535
2536     if( startDict)
2537         startDict->release();
2538 }
2539
2540 /*
2541  * Start a previously attached & probed instance,
2542  * called on exporting object instance
2543  */
2544
2545 bool IOService::startCandidate( IOService * service )
2546 {
2547     bool                ok;
2548
2549     ok = service->attach( this );
2550
2551     if( ok) {
2552         // stall for any nub resources
2553         checkResources();
2554         // stall for any driver resources
2555         service->checkResources();
2556
2557         AbsoluteTime startTime;
2558         AbsoluteTime endTime;
2559         UInt64       nano;
2560
2561         if (kIOLogStart & gIOKitDebug)
2562             clock_get_uptime(&startTime);
2563
2564         ok = service->start(this);
2565
2566         if (kIOLogStart & gIOKitDebug)
2567         {
2568             clock_get_uptime(&endTime);
2569
2570             if (CMP_ABSOLUTETIME(&endTime, &startTime) > 0)
2571             {
2572                 SUB_ABSOLUTETIME(&endTime, &startTime);
2573                 absolutetime_to_nanoseconds(endTime, &nano);
2574                 if (nano > 500000000ULL)
2575                     IOLog("%s::start took %ld ms\n", service->getName(), (UInt32)(nano / 1000000ULL));
2576             }
2577         }
2578         if( !ok)
2579             service->detach( this );
2580     }
2581     return( ok );
2582 }
2583
2584 IOService * IOService::resources( void )
2585 {
2586     return( gIOResources );
2587 }
2588
2589 void IOService::publishResource( const char * key, OSObject * value )
2590 {
2591     const OSSymbol *    sym;
2592
2593     if( (sym = OSSymbol::withCString( key))) {
2594         publishResource( sym, value);
2595         sym->release();
2596     }
2597 }
2598
2599 void IOService::publishResource( const OSSymbol * key, OSObject * value )
2600 {
2601     if( 0 == value)
2602         value = (OSObject *) gIOServiceKey;
2603
2604     gIOResources->setProperty( key, value);
2605
2606     if( IORecursiveLockHaveLock( gNotificationLock))
2607         return;
2608
2609     gIOResourceGenerationCount++;
2610     gIOResources->registerService();
2611 }
2612
2613 bool IOService::addNeededResource( const char * key )
2614 {
2615     OSObject *  resources;
2616     OSSet *     set;
2617     OSString *  newKey;
2618     bool ret;
2619
2620     resources = getProperty( gIOResourceMatchKey );
2621
2622     newKey = OSString::withCString( key );
2623     if( (0 == resources) || (0 == newKey))
2624         return( false);
2625
2626     set = OSDynamicCast( OSSet, resources );
2627     if( !set) {
2628         set = OSSet::withCapacity( 1 );
2629         if( set)
2630             set->setObject( resources );
2631     }
2632     else
2633         set->retain();
2634
2635     set->setObject( newKey );
2636     newKey->release();
2637     ret = setProperty( gIOResourceMatchKey, set );
2638     set->release();
2639
2640     return( ret );
2641 }
2642
2643 bool IOService::checkResource( OSObject * matching )
2644 {
2645     OSString *          str;
2646     OSDictionary *      table;
2647
2648     if( (str = OSDynamicCast( OSString, matching ))) {
2649         if( gIOResources->getProperty( str ))
2650             return( true );
2651     }
2652
2653     if( str)
2654         table = resourceMatching( str );
2655     else if( (table = OSDynamicCast( OSDictionary, matching )))
2656         table->retain();
2657     else {
2658         IOLog("%s: Can't match using: %s\n", getName(),
2659                 matching->getMetaClass()->getClassName());
2660         /* false would stall forever */
2661         return( true );
2662     }
2663
2664     if( gIOKitDebug & kIOLogConfig)
2665         LOG("config(%x): stalling %s\n", (int) IOThreadSelf(), getName());
2666
2667     waitForService( table );
2668
2669     if( gIOKitDebug & kIOLogConfig)
2670         LOG("config(%x): waking\n", (int) IOThreadSelf() );
2671
2672     return( true );
2673 }
2674
2675 bool IOService::checkResources( void )
2676 {
2677     OSObject *          resources;
2678     OSSet *             set;
2679     OSIterator *        iter;
2680     bool                ok;
2681
2682     resources = getProperty( gIOResourceMatchKey );
2683     if( 0 == resources)
2684         return( true );
2685
2686     if( (set = OSDynamicCast( OSSet, resources ))) {
2687
2688         iter = OSCollectionIterator::withCollection( set );
2689         ok = (0 != iter);
2690         while( ok && (resources = iter->getNextObject()) )
2691             ok = checkResource( resources );
2692         if( iter)
2693             iter->release();
2694
2695     } else
2696         ok = checkResource( resources );
2697
2698     return( ok );
2699 }
2700
2701
2702 _IOConfigThread * _IOConfigThread::configThread( void )
2703 {
2704     _IOConfigThread *   inst;
2705
2706     do {
2707         if( !(inst = new _IOConfigThread))
2708             continue;
2709         if( !inst->init())
2710             continue;
2711         if( !(inst->thread = IOCreateThread
2712                 ( (IOThreadFunc) &_IOConfigThread::main, inst )))
2713             continue;
2714
2715         return( inst );
2716
2717     } while( false);
2718
2719     if( inst)
2720         inst->release();
2721
2722     return( 0 );
2723 }
2724
2725 void _IOConfigThread::free( void )
2726 {
2727     OSObject::free();
2728 }
2729
2730 void IOService::doServiceMatch( IOOptionBits options )
2731 {
2732     _IOServiceNotifier * notify;
2733     OSIterator *        iter;
2734     OSOrderedSet *      matches;
2735     SInt32              catalogGeneration;
2736     bool                keepGuessing = true;
2737     bool                reRegistered = true;
2738
2739 //    job->nub->deliverNotification( gIOPublishNotification,
2740 //                              kIOServiceRegisteredState, 0xffffffff );
2741
2742     while( keepGuessing ) {
2743
2744         matches = gIOCatalogue->findDrivers( this, &catalogGeneration );
2745         // the matches list should always be created by findDrivers()
2746         if( matches) {
2747
2748             lockForArbitration();
2749             if( 0 == (__state[0] & kIOServiceFirstPublishState))
2750                 deliverNotification( gIOFirstPublishNotification,
2751                                      kIOServiceFirstPublishState, 0xffffffff );
2752             LOCKREADNOTIFY();
2753             __state[1] &= ~kIOServiceNeedConfigState;
2754             __state[1] |= kIOServiceConfigState;
2755             __state[0] |= kIOServiceRegisteredState;
2756
2757             if( reRegistered && (0 == (__state[0] & kIOServiceInactiveState))) {
2758
2759                 iter = OSCollectionIterator::withCollection( (OSOrderedSet *)
2760                         gNotifications->getObject( gIOPublishNotification ) );
2761                 if( iter) {
2762                     while((notify = (_IOServiceNotifier *)
2763                            iter->getNextObject())) {
2764
2765                         if( passiveMatch( notify->matching )
2766                          && (kIOServiceNotifyEnable & notify->state))
2767                             matches->setObject( notify );
2768                     }
2769                     iter->release();
2770                 }
2771             }
2772
2773             UNLOCKNOTIFY();
2774             unlockForArbitration();
2775
2776             if( matches->getCount() && (kIOReturnSuccess == getResources()))
2777                 probeCandidates( matches );
2778             else
2779                 matches->release();
2780         }
2781
2782         lockForArbitration();
2783         reRegistered = (0 != (__state[1] & kIOServiceNeedConfigState));
2784         keepGuessing =
2785                    (reRegistered || (catalogGeneration !=
2786                                         gIOCatalogue->getGenerationCount()))
2787                 && (0 == (__state[0] & kIOServiceInactiveState));
2788
2789         if( keepGuessing)
2790             unlockForArbitration();
2791     }
2792
2793     if( (0 == (__state[0] & kIOServiceInactiveState))
2794      && (0 == (__state[1] & kIOServiceModuleStallState)) ) {
2795         deliverNotification( gIOMatchedNotification,
2796                 kIOServiceMatchedState, 0xffffffff );
2797         if( 0 == (__state[0] & kIOServiceFirstMatchState))
2798             deliverNotification( gIOFirstMatchNotification,
2799                 kIOServiceFirstMatchState, 0xffffffff );
2800     }
2801
2802     __state[1] &= ~kIOServiceConfigState;
2803     if( __state[0] & kIOServiceInactiveState)
2804         scheduleTerminatePhase2();
2805
2806     _adjustBusy( -1 );
2807     unlockForArbitration();
2808 }
2809
2810 UInt32 IOService::_adjustBusy( SInt32 delta )
2811 {
2812     IOService * next;
2813     UInt32      count;
2814     UInt32      result;
2815     bool        wasQuiet, nowQuiet, needWake;
2816
2817     next = this;
2818     result = __state[1] & kIOServiceBusyStateMask;
2819
2820     if( delta) do {
2821         if( next != this)
2822             next->lockForArbitration();
2823         count = next->__state[1] & kIOServiceBusyStateMask;
2824         assert( count < kIOServiceBusyMax);
2825         wasQuiet = (0 == count);
2826         assert( (!wasQuiet) || (delta > 0));
2827         next->__state[1] += delta;
2828         nowQuiet = (0 == (next->__state[1] & kIOServiceBusyStateMask));
2829         needWake = (0 != (kIOServiceBusyWaiterState & next->__state[1]));
2830
2831         if( needWake) {
2832             next->__state[1] &= ~kIOServiceBusyWaiterState;
2833             IOLockLock( gIOServiceBusyLock );
2834             thread_wakeup( (event_t) next);
2835             IOLockUnlock( gIOServiceBusyLock );
2836         }
2837         if( next != this)
2838             next->unlockForArbitration();
2839
2840         if( (wasQuiet || nowQuiet) ) {
2841             OSArray *           array;
2842             unsigned int        index;
2843             OSObject *          interested;
2844
2845             array = OSDynamicCast( OSArray, next->getProperty( gIOBusyInterest ));
2846             if( array) {
2847                 LOCKREADNOTIFY();
2848                 for( index = 0;
2849                      (interested = array->getObject( index ));
2850                      index++) {
2851                     next->messageClient(kIOMessageServiceBusyStateChange,
2852                                      interested, (void *) wasQuiet /* busy now */);
2853                 }
2854                 UNLOCKNOTIFY();
2855             }
2856
2857             if( nowQuiet && (next == gIOServiceRoot))
2858                 OSMetaClass::considerUnloads();
2859         }
2860
2861         delta = nowQuiet ? -1 : +1;
2862
2863     } while( (wasQuiet || nowQuiet) && (next = next->getProvider()));
2864
2865     return( result );
2866 }
2867
2868 void IOService::adjustBusy( SInt32 delta )
2869 {
2870     lockForArbitration();
2871     _adjustBusy( delta );
2872     unlockForArbitration();
2873 }
2874
2875 UInt32 IOService::getBusyState( void )
2876 {
2877     return( __state[1] & kIOServiceBusyStateMask );
2878 }
2879
2880 IOReturn IOService::waitForState( UInt32 mask, UInt32 value,
2881                                  mach_timespec_t * timeout )
2882 {
2883     bool            wait;
2884     int             waitResult = THREAD_AWAKENED;
2885     bool            computeDeadline = true;
2886     AbsoluteTime    abstime;
2887
2888     do {
2889         lockForArbitration();
2890         IOLockLock( gIOServiceBusyLock );
2891         wait = (value != (__state[1] & mask));
2892         if( wait) {
2893             __state[1] |= kIOServiceBusyWaiterState;
2894             unlockForArbitration();
2895             assert_wait( (event_t) this, THREAD_UNINT );
2896             if( timeout ) {
2897                 if( computeDeadline ) {
2898                     AbsoluteTime  nsinterval;
2899                     clock_interval_to_absolutetime_interval(
2900                           timeout->tv_sec, kSecondScale, &abstime );
2901                     clock_interval_to_absolutetime_interval(
2902                           timeout->tv_nsec, kNanosecondScale, &nsinterval );
2903                     ADD_ABSOLUTETIME( &abstime, &nsinterval );
2904                     clock_absolutetime_interval_to_deadline(
2905                           abstime, &abstime );
2906                     computeDeadline = false;
2907                 }
2908                 thread_set_timer_deadline( abstime );
2909             }
2910         } else
2911             unlockForArbitration();
2912         IOLockUnlock( gIOServiceBusyLock );
2913         if( wait) {
2914             waitResult = thread_block(THREAD_CONTINUE_NULL);
2915             if( timeout && (waitResult != THREAD_TIMED_OUT))
2916                 thread_cancel_timer();
2917         }
2918
2919     } while( wait && (waitResult != THREAD_TIMED_OUT));
2920
2921     if( waitResult == THREAD_TIMED_OUT)
2922         return( kIOReturnTimeout );
2923     else
2924         return( kIOReturnSuccess );
2925 }
2926
2927 IOReturn IOService::waitQuiet( mach_timespec_t * timeout )
2928 {
2929     return( waitForState( kIOServiceBusyStateMask, 0, timeout ));
2930 }
2931
2932 bool IOService::serializeProperties( OSSerialize * s ) const
2933 {
2934 #if 0
2935     ((IOService *)this)->setProperty( ((IOService *)this)->__state,
2936                 sizeof( __state), "__state");
2937 #endif
2938     return( super::serializeProperties(s) );
2939 }
2940
2941
2942 void _IOConfigThread::main( _IOConfigThread * self )
2943 {
2944     _IOServiceJob *     job;
2945     IOService   *       nub;
2946     bool                alive = true;
2947
2948     do {
2949
2950 //      randomDelay();
2951
2952         semaphore_wait( gJobsSemaphore );
2953
2954         IOTakeLock( gJobsLock );
2955         job = (_IOServiceJob *) gJobs->getFirstObject();
2956         job->retain();
2957         gJobs->removeObject(job);
2958         if( job) {
2959             gOutstandingJobs--;
2960 //          gNumConfigThreads--;        // we're out of service
2961             gNumWaitingThreads--;       // we're out of service
2962         }
2963         IOUnlock( gJobsLock );
2964
2965         if( job) {
2966
2967           nub = job->nub;
2968
2969           if( gIOKitDebug & kIOLogConfig)
2970             LOG("config(%x): starting on %s, %d\n",
2971                         (int) IOThreadSelf(), job->nub->getName(), job->type);
2972
2973           switch( job->type) {
2974
2975             case kMatchNubJob:
2976                 nub->doServiceMatch( job->options );
2977                 break;
2978
2979             default:
2980                 LOG("config(%x): strange type (%d)\n",
2981                         (int) IOThreadSelf(), job->type );
2982                 break;
2983             }
2984
2985             nub->release();
2986             job->release();
2987
2988             IOTakeLock( gJobsLock );
2989             alive = (gOutstandingJobs > gNumWaitingThreads);
2990             if( alive)
2991                 gNumWaitingThreads++;   // back in service
2992 //              gNumConfigThreads++;
2993             else {
2994                 if( 0 == --gNumConfigThreads) {
2995 //                    IOLog("MATCH IDLE\n");
2996                     IOLockWakeup( gJobsLock, (event_t) &gNumConfigThreads, /* one-thread */ false );
2997                 }
2998             }
2999             IOUnlock( gJobsLock );
3000         }
3001
3002     } while( alive );
3003
3004     if( gIOKitDebug & kIOLogConfig)
3005         LOG("config(%x): terminating\n", (int) IOThreadSelf() );
3006
3007     self->release();
3008 }
3009
3010 IOReturn IOService::waitMatchIdle( UInt32 msToWait )
3011 {
3012     bool            wait;
3013     int             waitResult = THREAD_AWAKENED;
3014     bool            computeDeadline = true;
3015     AbsoluteTime    abstime;
3016
3017     IOLockLock( gJobsLock );
3018     do {
3019         wait = (0 != gNumConfigThreads);
3020         if( wait) {
3021             if( msToWait) {
3022                 if( computeDeadline ) {
3023                     clock_interval_to_absolutetime_interval(
3024                           msToWait, kMillisecondScale, &abstime );
3025                     clock_absolutetime_interval_to_deadline(
3026                           abstime, &abstime );
3027                     computeDeadline = false;
3028                 }
3029                           waitResult = IOLockSleepDeadline( gJobsLock, &gNumConfigThreads,
3030                                                                 abstime, THREAD_UNINT );
3031                    } else {
3032                           waitResult = IOLockSleep( gJobsLock, &gNumConfigThreads,
3033                                                                 THREAD_UNINT );
3034                 }
3035         }
3036     } while( wait && (waitResult != THREAD_TIMED_OUT));
3037         IOLockUnlock( gJobsLock );
3038
3039     if( waitResult == THREAD_TIMED_OUT)
3040         return( kIOReturnTimeout );
3041     else
3042         return( kIOReturnSuccess );
3043 }
3044
3045 void _IOServiceJob::pingConfig( _IOServiceJob * job )
3046 {
3047     int         count;
3048     bool        create;
3049
3050     assert( job );
3051
3052     IOTakeLock( gJobsLock );
3053
3054     gOutstandingJobs++;
3055     gJobs->setLastObject( job );
3056
3057     count = gNumWaitingThreads;
3058 //    if( gNumConfigThreads) count++;// assume we're called from a config thread
3059
3060     create = (  (gOutstandingJobs > count)
3061                 && (gNumConfigThreads < kMaxConfigThreads) );
3062     if( create) {
3063         gNumConfigThreads++;
3064         gNumWaitingThreads++;
3065     }
3066
3067     IOUnlock( gJobsLock );
3068
3069     job->release();
3070
3071     if( create) {
3072         if( gIOKitDebug & kIOLogConfig)
3073             LOG("config(%d): creating\n", gNumConfigThreads - 1);
3074         _IOConfigThread::configThread();
3075     }
3076
3077     semaphore_signal( gJobsSemaphore );
3078 }
3079
3080
3081 // internal - call with gNotificationLock
3082 OSObject * IOService::getExistingServices( OSDictionary * matching,
3083                  IOOptionBits inState, IOOptionBits options )
3084 {
3085     OSObject *          current = 0;
3086     OSIterator *        iter;
3087     IOService *         service;
3088
3089     if( !matching)
3090         return( 0 );
3091
3092     iter = IORegistryIterator::iterateOver( gIOServicePlane,
3093                                         kIORegistryIterateRecursively );
3094     if( iter) {
3095         do {
3096             iter->reset();
3097             while( (service = (IOService *) iter->getNextObject())) {
3098                 if( (inState == (service->__state[0] & inState))
3099                  && (0 == (service->__state[0] & kIOServiceInactiveState))
3100                  &&  service->passiveMatch( matching )) {
3101
3102                     if( options & kIONotifyOnce) {
3103                         current = service;
3104                         break;
3105                     }
3106                     if( current)
3107                         ((OSSet *)current)->setObject( service );
3108                     else
3109                         current = OSSet::withObjects(
3110                                         (const OSObject **) &service, 1, 1 );
3111                 }
3112             }
3113         } while( !service && !iter->isValid());
3114         iter->release();
3115     }
3116
3117     if( current && (0 == (options & kIONotifyOnce))) {
3118         iter = OSCollectionIterator::withCollection( (OSSet *)current );
3119         current->release();
3120         current = iter;
3121     }
3122
3123     return( current );
3124 }
3125
3126 // public version
3127 OSIterator * IOService::getMatchingServices( OSDictionary * matching )
3128 {
3129     OSIterator *        iter;
3130
3131     // is a lock even needed?
3132     LOCKWRITENOTIFY();
3133
3134     iter = (OSIterator *) getExistingServices( matching,
3135                                                 kIOServiceMatchedState );
3136
3137     UNLOCKNOTIFY();
3138
3139     return( iter );
3140 }
3141
3142
3143 // internal - call with gNotificationLock
3144 IONotifier * IOService::setNotification(
3145             const OSSymbol * type, OSDictionary * matching,
3146             IOServiceNotificationHandler handler, void * target, void * ref,
3147             SInt32 priority )
3148 {
3149     _IOServiceNotifier * notify = 0;
3150     OSOrderedSet *      set;
3151
3152     if( !matching)
3153         return( 0 );
3154
3155     notify = new _IOServiceNotifier;
3156     if( notify && !notify->init()) {
3157         notify->release();
3158         notify = 0;
3159     }
3160
3161     if( notify) {
3162         notify->matching = matching;
3163         notify->handler = handler;
3164         notify->target = target;
3165         notify->ref = ref;
3166         notify->priority = priority;
3167         notify->state = kIOServiceNotifyEnable;
3168         queue_init( &notify->handlerInvocations );
3169
3170         ////// queue
3171
3172         if( 0 == (set = (OSOrderedSet *) gNotifications->getObject( type ))) {
3173             set = OSOrderedSet::withCapacity( 1,
3174                         IONotifyOrdering, 0 );
3175             if( set) {
3176                 gNotifications->setObject( type, set );
3177                 set->release();
3178             }
3179         }
3180         notify->whence = set;
3181         if( set)
3182             set->setObject( notify );
3183     }
3184
3185     return( notify );
3186 }
3187
3188 // internal - call with gNotificationLock
3189 IONotifier * IOService::doInstallNotification(
3190                         const OSSymbol * type, OSDictionary * matching,
3191                         IOServiceNotificationHandler handler,
3192                         void * target, void * ref,
3193                         SInt32 priority, OSIterator ** existing )
3194 {
3195     OSIterator *        exist;
3196     IONotifier *        notify;
3197     IOOptionBits        inState;
3198
3199     if( !matching)
3200         return( 0 );
3201
3202     if( type == gIOPublishNotification)
3203         inState = kIOServiceRegisteredState;
3204
3205     else if( type == gIOFirstPublishNotification)
3206         inState = kIOServiceFirstPublishState;
3207
3208     else if( (type == gIOMatchedNotification)
3209           || (type == gIOFirstMatchNotification))
3210         inState = kIOServiceMatchedState;
3211     else if( type == gIOTerminatedNotification)
3212         inState = 0;
3213     else
3214         return( 0 );
3215
3216     notify = setNotification( type, matching, handler, target, ref, priority );
3217
3218     if( inState)
3219         // get the current set
3220         exist = (OSIterator *) getExistingServices( matching, inState );
3221     else
3222         exist = 0;
3223
3224     *existing = exist;
3225
3226     return( notify );
3227 }
3228
3229
3230 IONotifier * IOService::installNotification(
3231                         const OSSymbol * type, OSDictionary * matching,
3232                         IOServiceNotificationHandler handler,
3233                         void * target, void * ref,
3234                         SInt32 priority, OSIterator ** existing )
3235 {
3236     IONotifier *        notify;
3237
3238     LOCKWRITENOTIFY();
3239
3240     notify = doInstallNotification( type, matching, handler, target, ref,
3241                 priority, existing );
3242
3243     UNLOCKNOTIFY();
3244
3245     return( notify );
3246 }
3247
3248 IONotifier * IOService::addNotification(
3249                         const OSSymbol * type, OSDictionary * matching,
3250                         IOServiceNotificationHandler handler,
3251                         void * target, void * ref,
3252                         SInt32 priority )
3253 {
3254     OSIterator *                existing;
3255     _IOServiceNotifier *        notify;
3256     IOService *                 next;
3257
3258     notify = (_IOServiceNotifier *) installNotification( type, matching,
3259                 handler, target, ref, priority, &existing );
3260
3261     // send notifications for existing set
3262     if( existing) {
3263
3264         notify->retain();               // in case handler remove()s
3265         while( (next = (IOService *) existing->getNextObject())) {
3266
3267             next->lockForArbitration();
3268             if( 0 == (next->__state[0] & kIOServiceInactiveState))
3269                 next->invokeNotifer( notify );
3270             next->unlockForArbitration();
3271         }
3272         notify->release();
3273         existing->release();
3274     }
3275
3276     return( notify );
3277 }
3278
3279 struct SyncNotifyVars {
3280     semaphore_port_t    waitHere;
3281     IOService *         result;
3282 };
3283
3284 bool IOService::syncNotificationHandler(
3285                         void * /* target */, void * ref,
3286                         IOService * newService )
3287 {
3288
3289     // result may get written more than once before the
3290     // notification is removed!
3291     ((SyncNotifyVars *) ref)->result = newService;
3292     semaphore_signal( ((SyncNotifyVars *) ref)->waitHere );
3293
3294     return( false );
3295 }
3296
3297 IOService * IOService::waitForService( OSDictionary * matching,
3298                                 mach_timespec_t * timeout )
3299 {
3300     IONotifier *        notify = 0;
3301     // priority doesn't help us much since we need a thread wakeup
3302     SInt32              priority = 0;
3303     SyncNotifyVars      state;
3304     kern_return_t       err = kIOReturnBadArgument;
3305
3306     if( !matching)
3307         return( 0 );
3308
3309     state.waitHere = 0;
3310     state.result = 0;
3311
3312     LOCKWRITENOTIFY();
3313
3314     do {
3315
3316         state.result = (IOService *) getExistingServices( matching,
3317                             kIOServiceMatchedState, kIONotifyOnce );
3318         if( state.result)
3319             continue;
3320
3321         err = semaphore_create( kernel_task, &state.waitHere,
3322                                     SYNC_POLICY_FIFO, 0 );
3323         if( KERN_SUCCESS != err)
3324             continue;
3325
3326         notify = IOService::setNotification( gIOMatchedNotification, matching,
3327                     &IOService::syncNotificationHandler, (void *) 0,
3328                     (void *) &state, priority );
3329
3330     } while( false );
3331
3332     UNLOCKNOTIFY();
3333
3334      if( notify) {
3335         if( timeout)
3336             err = semaphore_timedwait( state.waitHere, *timeout );
3337         else
3338             err = semaphore_wait( state.waitHere );
3339     }
3340
3341     if( notify)
3342         notify->remove();       // dequeues
3343     else
3344         matching->release();
3345     if( state.waitHere)
3346         semaphore_destroy( kernel_task, state.waitHere );
3347
3348     return( state.result );
3349 }
3350
3351 void IOService::deliverNotification( const OSSymbol * type,
3352                             IOOptionBits orNewState, IOOptionBits andNewState )
3353 {
3354     _IOServiceNotifier * notify;
3355     OSIterator *         iter;
3356     OSArray *            willSend = 0;
3357
3358     lockForArbitration();
3359
3360     if( (0 == (__state[0] & kIOServiceInactiveState))
3361      || (type == gIOTerminatedNotification)) {
3362
3363         LOCKREADNOTIFY();
3364
3365         iter = OSCollectionIterator::withCollection( (OSOrderedSet *)
3366                     gNotifications->getObject( type ) );
3367
3368         if( iter) {
3369             while( (notify = (_IOServiceNotifier *) iter->getNextObject())) {
3370
3371                 if( passiveMatch( notify->matching)
3372                   && (kIOServiceNotifyEnable & notify->state)) {
3373                     if( 0 == willSend)
3374                         willSend = OSArray::withCapacity(8);
3375                     if( willSend)
3376                         willSend->setObject( notify );
3377                 }
3378             }
3379             iter->release();
3380         }
3381
3382         __state[0] = (__state[0] | orNewState) & andNewState;
3383
3384         UNLOCKNOTIFY();
3385     }
3386
3387     if( willSend) {
3388         for( unsigned int idx = 0;
3389              (notify = (_IOServiceNotifier *) willSend->getObject(idx));
3390              idx++) {
3391             invokeNotifer( notify );
3392         }
3393         willSend->release();
3394     }
3395     unlockForArbitration();
3396 }
3397
3398 IOOptionBits IOService::getState( void ) const
3399 {
3400     return( __state[0] );
3401 }
3402
3403 /*
3404  * Helpers to make matching objects for simple cases
3405  */
3406
3407 OSDictionary * IOService::serviceMatching( const OSString * name,
3408                         OSDictionary * table )
3409 {
3410     if( !table)
3411         table = OSDictionary::withCapacity( 2 );
3412     if( table)
3413         table->setObject(gIOProviderClassKey, (OSObject *)name );
3414
3415     return( table );
3416 }
3417
3418 OSDictionary * IOService::serviceMatching( const char * name,
3419                         OSDictionary * table )
3420 {
3421     const OSString *    str;
3422
3423     str = OSSymbol::withCString( name );
3424     if( !str)
3425         return( 0 );
3426
3427     table = serviceMatching( str, table );
3428     str->release();
3429     return( table );
3430 }
3431
3432 OSDictionary * IOService::nameMatching( const OSString * name,
3433                         OSDictionary * table )
3434 {
3435     if( !table)
3436         table = OSDictionary::withCapacity( 2 );
3437     if( table)
3438         table->setObject( gIONameMatchKey, (OSObject *)name );
3439
3440     return( table );
3441 }
3442
3443 OSDictionary * IOService::nameMatching( const char * name,
3444                         OSDictionary * table )
3445 {
3446     const OSString *    str;
3447
3448     str = OSSymbol::withCString( name );
3449     if( !str)
3450         return( 0 );
3451
3452     table = nameMatching( str, table );
3453     str->release();
3454     return( table );
3455 }
3456
3457 OSDictionary * IOService::resourceMatching( const OSString * str,
3458                         OSDictionary * table )
3459 {
3460     table = serviceMatching( gIOResourcesKey, table );
3461     if( table)
3462         table->setObject( gIOResourceMatchKey, (OSObject *) str );
3463
3464     return( table );
3465 }
3466
3467 OSDictionary * IOService::resourceMatching( const char * name,
3468                         OSDictionary * table )
3469 {
3470     const OSSymbol *    str;
3471
3472     str = OSSymbol::withCString( name );
3473     if( !str)
3474         return( 0 );
3475
3476     table = resourceMatching( str, table );
3477     str->release();
3478
3479     return( table );
3480 }
3481
3482 /*
3483  * _IOServiceNotifier
3484  */
3485
3486 // wait for all threads, other than the current one,
3487 //  to exit the handler
3488
3489 void _IOServiceNotifier::wait()
3490 {
3491     _IOServiceNotifierInvocation * next;
3492     bool doWait;
3493
3494     do {
3495         doWait = false;
3496         queue_iterate( &handlerInvocations, next,
3497                         _IOServiceNotifierInvocation *, link) {
3498             if( next->thread != current_thread() ) {
3499                 doWait = true;
3500                 break;
3501             }
3502         }
3503         if( doWait) {
3504             state |= kIOServiceNotifyWaiter;
3505             SLEEPNOTIFY(this);
3506         }
3507
3508     } while( doWait );
3509 }
3510
3511 void _IOServiceNotifier::free()
3512 {
3513     assert( queue_empty( &handlerInvocations ));
3514     OSObject::free();
3515 }
3516
3517 void _IOServiceNotifier::remove()
3518 {
3519     LOCKWRITENOTIFY();
3520
3521     if( whence) {
3522         whence->removeObject( (OSObject *) this );
3523         whence = 0;
3524     }
3525     if( matching) {
3526         matching->release();
3527         matching = 0;
3528     }
3529
3530     state &= ~kIOServiceNotifyEnable;
3531
3532     wait();
3533
3534     UNLOCKNOTIFY();
3535
3536     release();
3537 }
3538
3539 bool _IOServiceNotifier::disable()
3540 {
3541     bool        ret;
3542
3543     LOCKWRITENOTIFY();
3544
3545     ret = (0 != (kIOServiceNotifyEnable & state));
3546     state &= ~kIOServiceNotifyEnable;
3547     if( ret)
3548         wait();
3549
3550     UNLOCKNOTIFY();
3551
3552     return( ret );
3553 }
3554
3555 void _IOServiceNotifier::enable( bool was )
3556 {
3557     LOCKWRITENOTIFY();
3558     if( was)
3559         state |= kIOServiceNotifyEnable;
3560     else
3561         state &= ~kIOServiceNotifyEnable;
3562     UNLOCKNOTIFY();
3563 }
3564
3565 /*
3566  * IOResources
3567  */
3568
3569 IOService * IOResources::resources( void )
3570 {
3571     IOResources *       inst;
3572
3573     inst = new IOResources;
3574     if( inst && !inst->init()) {
3575         inst->release();
3576         inst = 0;
3577     }
3578
3579     return( inst );
3580 }
3581
3582 IOWorkLoop * IOResources::getWorkLoop() const
3583 {
3584     // If we are the resource root then bringe over to the
3585     // platform to get its workloop
3586     if (this == (IOResources *) gIOResources)
3587         return getPlatform()->getWorkLoop();
3588     else
3589         return IOService::getWorkLoop();
3590 }
3591
3592 bool IOResources::matchPropertyTable( OSDictionary * table )
3593 {
3594     OSObject *          prop;
3595     OSString *          str;
3596     OSSet *             set;
3597     OSIterator *        iter;
3598     bool                ok = false;
3599
3600     prop = table->getObject( gIOResourceMatchKey );
3601     str = OSDynamicCast( OSString, prop );
3602     if( str)
3603         ok = (0 != getProperty( str ));
3604
3605     else if( (set = OSDynamicCast( OSSet, prop))) {
3606
3607         iter = OSCollectionIterator::withCollection( set );
3608         ok = (iter != 0);
3609         while( ok && (str = OSDynamicCast( OSString, iter->getNextObject()) ))
3610             ok = (0 != getProperty( str ));
3611
3612         if( iter)
3613             iter->release();
3614     }
3615
3616     return( ok );
3617 }
3618
3619 IOReturn IOResources::setProperties( OSObject * properties )
3620 {
3621     IOReturn                    err;
3622     const OSSymbol *            key;
3623     OSDictionary *              dict;
3624     OSCollectionIterator *      iter;
3625
3626     err = IOUserClient::clientHasPrivilege(current_task(), kIOClientPrivilegeAdministrator);
3627     if ( kIOReturnSuccess != err)
3628         return( err );
3629
3630     dict = OSDynamicCast(OSDictionary, properties);
3631     if( 0 == dict)
3632         return( kIOReturnBadArgument);
3633
3634     iter = OSCollectionIterator::withCollection( dict);
3635     if( 0 == iter)
3636         return( kIOReturnBadArgument);
3637
3638     while( (key = OSDynamicCast(OSSymbol, iter->getNextObject()))) {
3639
3640         if (gIOConsoleUsersKey == key)
3641         {
3642             IORegistryEntry::getRegistryRoot()->setProperty(key, dict->getObject(key));
3643             OSIncrementAtomic( &gIOConsoleUsersSeed );
3644             publishResource( gIOConsoleUsersSeedKey, gIOConsoleUsersSeedValue );
3645             continue;
3646         }
3647
3648         publishResource( key, dict->getObject(key) );
3649     }
3650
3651     iter->release();
3652
3653     return( kIOReturnSuccess );
3654 }
3655
3656 /*
3657  * Helpers for matching dictionaries.
3658  * Keys existing in matching are checked in properties.
3659  * Keys may be a string or OSCollection of IOStrings
3660  */
3661
3662 bool IOService::compareProperty( OSDictionary * matching,
3663                                  const char *   key )
3664 {
3665     OSObject *  value;
3666     bool        ok;
3667
3668     value = matching->getObject( key );
3669     if( value)
3670         ok = value->isEqualTo( getProperty( key ));
3671     else
3672         ok = true;
3673
3674     return( ok );
3675 }
3676
3677
3678 bool IOService::compareProperty( OSDictionary *   matching,
3679                                  const OSString * key )
3680 {
3681     OSObject *  value;
3682     bool        ok;
3683
3684     value = matching->getObject( key );
3685     if( value)
3686         ok = value->isEqualTo( getProperty( key ));
3687     else
3688         ok = true;
3689
3690     return( ok );
3691 }
3692
3693 bool IOService::compareProperties( OSDictionary * matching,
3694                                    OSCollection * keys )
3695 {
3696     OSCollectionIterator *      iter;
3697     const OSString *            key;
3698     bool                        ok = true;
3699
3700     if( !matching || !keys)
3701         return( false );
3702
3703     iter = OSCollectionIterator::withCollection( keys );
3704
3705     if( iter) {
3706         while( ok && (key = OSDynamicCast( OSString, iter->getNextObject())))
3707             ok = compareProperty( matching, key );
3708
3709         iter->release();
3710     }
3711     keys->release();    // !! consume a ref !!
3712
3713     return( ok );
3714 }
3715
3716 /* Helper to add a location matching dict to the table */
3717
3718 OSDictionary * IOService::addLocation( OSDictionary * table )
3719 {
3720     OSDictionary *      dict;
3721
3722     if( !table)
3723         return( 0 );
3724
3725     dict = OSDictionary::withCapacity( 1 );
3726     if( dict) {
3727         table->setObject( gIOLocationMatchKey, dict );
3728         dict->release();
3729     }
3730
3731     return( dict );
3732 }
3733
3734 /*
3735  * Go looking for a provider to match a location dict.
3736  */
3737
3738 IOService * IOService::matchLocation( IOService * /* client */ )
3739 {
3740     IOService * parent;
3741
3742     parent = getProvider();
3743
3744     if( parent)
3745         parent = parent->matchLocation( this );
3746
3747     return( parent );
3748 }
3749
3750 bool IOService::passiveMatch( OSDictionary * table, bool changesOK )
3751 {
3752     IOService *         where;
3753     OSString *          matched;
3754     OSObject *          obj;
3755     OSString *          str;
3756     IORegistryEntry *   entry;
3757     OSNumber *          num;
3758     SInt32              score;
3759     OSNumber *          newPri;
3760     bool                match = true;
3761     bool                matchParent = false;
3762     UInt32              done;
3763
3764     assert( table );
3765
3766     where = this;
3767
3768     do {
3769         do {
3770             done = 0;
3771
3772             str = OSDynamicCast( OSString, table->getObject( gIOProviderClassKey));
3773             if( str) {
3774                 done++;
3775                 match = (0 != where->metaCast( str ));
3776                 if( !match)
3777                     break;
3778             }
3779
3780             obj = table->getObject( gIONameMatchKey );
3781             if( obj) {
3782                 done++;
3783                 match = where->compareNames( obj, changesOK ? &matched : 0 );
3784                 if( !match)
3785                     break;
3786                 if( changesOK && matched) {
3787                     // leave a hint as to which name matched
3788                     table->setObject( gIONameMatchedKey, matched );
3789                     matched->release();
3790                 }
3791             }
3792
3793             str = OSDynamicCast( OSString, table->getObject( gIOLocationMatchKey ));
3794             if( str) {
3795
3796                 const OSSymbol * sym;
3797
3798                 done++;
3799                 match = false;
3800                 sym = where->copyLocation();
3801                 if( sym) {
3802                     match = sym->isEqualTo( str );
3803                     sym->release();
3804                 }
3805                 if( !match)
3806                     break;
3807             }
3808
3809             obj = table->getObject( gIOPropertyMatchKey );
3810             if( obj) {
3811
3812                 OSDictionary * dict;
3813                 OSDictionary * nextDict;
3814                 OSIterator *   iter;
3815
3816                 done++;
3817                 match = false;
3818                 dict = where->dictionaryWithProperties();
3819                 if( dict) {
3820                     nextDict = OSDynamicCast( OSDictionary, obj);
3821                     if( nextDict)
3822                         iter = 0;
3823                     else
3824                         iter = OSCollectionIterator::withCollection(
3825                                     OSDynamicCast(OSCollection, obj));
3826
3827                     while( nextDict
3828                         || (iter && (0 != (nextDict = OSDynamicCast(OSDictionary,
3829                                                 iter->getNextObject()))))) {
3830                         match = dict->isEqualTo( nextDict, nextDict);
3831                         if( match)
3832                             break;
3833                         nextDict = 0;
3834                     }
3835                     dict->release();
3836                     if( iter)
3837                         iter->release();
3838                 }
3839                 if( !match)
3840                     break;
3841             }
3842
3843             str = OSDynamicCast( OSString, table->getObject( gIOPathMatchKey ));
3844             if( str) {
3845                 done++;
3846                 entry = IORegistryEntry::fromPath( str->getCStringNoCopy() );
3847                 match = (where == entry);
3848                 if( entry)
3849                     entry->release();
3850                 if( !match)
3851                     break;
3852             }
3853
3854             num = OSDynamicCast( OSNumber, table->getObject( gIOMatchedServiceCountKey ));
3855             if( num) {
3856
3857                 OSIterator *    iter;
3858                 IOService *             service = 0;
3859                 UInt32          serviceCount = 0;
3860
3861                 done++;
3862                 iter = where->getClientIterator();
3863                 if( iter) {
3864                     while( (service = (IOService *) iter->getNextObject())) {
3865                         if( kIOServiceInactiveState & service->__state[0])
3866                             continue;
3867                         if( 0 == service->getProperty( gIOMatchCategoryKey ))
3868                             continue;
3869                         ++serviceCount;
3870                     }
3871                     iter->release();
3872                 }
3873                 match = (serviceCount == num->unsigned32BitValue());
3874                 if( !match)
3875                     break;
3876             }
3877
3878             if( done == table->getCount()) {
3879                 // don't call family if we've done all the entries in the table
3880                 matchParent = false;
3881                 break;
3882             }
3883
3884             // pass in score from property table
3885             score = IOServiceObjectOrder( table, (void *) gIOProbeScoreKey);
3886
3887             // do family specific matching
3888             match = where->matchPropertyTable( table, &score );
3889
3890             if( !match) {
3891 #if IOMATCHDEBUG
3892                 if( kIOLogMatch & getDebugFlags( table ))
3893                     LOG("%s: family specific matching fails\n", where->getName());
3894 #endif
3895                 break;
3896             }
3897
3898             if( changesOK) {
3899                 // save the score
3900                 newPri = OSNumber::withNumber( score, 32 );
3901                 if( newPri) {
3902                     table->setObject( gIOProbeScoreKey, newPri );
3903                     newPri->release();
3904                 }
3905             }
3906
3907             if( !(match = where->compareProperty( table, kIOBSDNameKey )))
3908                 break;
3909
3910             matchParent = false;
3911
3912             obj = OSDynamicCast( OSDictionary,
3913                   table->getObject( gIOParentMatchKey ));
3914             if( obj) {
3915                 match = false;
3916                 matchParent = true;
3917                 table = (OSDictionary *) obj;
3918                 break;
3919             }
3920
3921             table = OSDynamicCast( OSDictionary,
3922                     table->getObject( gIOLocationMatchKey ));
3923             if( table) {
3924                 match = false;
3925                 where = where->getProvider();
3926                 if( where)
3927                     where = where->matchLocation( where );
3928             }
3929
3930         } while( table && where );
3931
3932     } while( matchParent && (where = where->getProvider()) );
3933
3934     if( kIOLogMatch & gIOKitDebug)
3935         if( where != this)
3936             LOG("match parent @ %s = %d\n",
3937                         where->getName(), match );
3938
3939     return( match );
3940 }
3941
3942
3943 IOReturn IOService::newUserClient( task_t owningTask, void * securityID,
3944                                     UInt32 type,  OSDictionary * properties,
3945                                     IOUserClient ** handler )
3946 {
3947     const OSSymbol *userClientClass = 0;
3948     IOUserClient *client;
3949     OSObject *temp;
3950
3951     // First try my own properties for a user client class name
3952     temp = getProperty(gIOUserClientClassKey);
3953     if (temp) {
3954         if (OSDynamicCast(OSSymbol, temp))
3955             userClientClass = (const OSSymbol *) temp;
3956         else if (OSDynamicCast(OSString, temp)) {
3957             userClientClass = OSSymbol::withString((OSString *) temp);
3958             if (userClientClass)
3959                 setProperty(kIOUserClientClassKey,
3960                             (OSObject *) userClientClass);
3961         }
3962     }
3963
3964     // Didn't find one so lets just bomb out now without further ado.
3965     if (!userClientClass)
3966         return kIOReturnUnsupported;
3967
3968     temp = OSMetaClass::allocClassWithName(userClientClass);
3969     if (!temp)
3970         return kIOReturnNoMemory;
3971
3972     if (OSDynamicCast(IOUserClient, temp))
3973         client = (IOUserClient *) temp;
3974     else {
3975         temp->release();
3976         return kIOReturnUnsupported;
3977     }
3978
3979     if ( !client->initWithTask(owningTask, securityID, type, properties) ) {
3980         client->release();
3981         return kIOReturnBadArgument;
3982     }
3983
3984     if ( !client->attach(this) ) {
3985         client->release();
3986         return kIOReturnUnsupported;
3987     }
3988
3989     if ( !client->start(this) ) {
3990         client->detach(this);
3991         client->release();
3992         return kIOReturnUnsupported;
3993     }
3994
3995     *handler = client;
3996     return kIOReturnSuccess;
3997 }
3998
3999 IOReturn IOService::newUserClient( task_t owningTask, void * securityID,
4000                                     UInt32 type, IOUserClient ** handler )
4001 {
4002     return( newUserClient( owningTask, securityID, type, 0, handler ));
4003 }
4004
4005 IOReturn IOService::requestProbe( IOOptionBits options )
4006 {
4007     return( kIOReturnUnsupported);
4008 }
4009
4010 /*
4011  * Convert an IOReturn to text. Subclasses which add additional
4012  * IOReturn's should override this method and call
4013  * super::stringFromReturn if the desired value is not found.
4014  */
4015
4016 const char * IOService::stringFromReturn( IOReturn rtn )
4017 {
4018     static const IONamedValue IOReturn_values[] = {
4019         {kIOReturnSuccess,          "success"                           },
4020         {kIOReturnError,            "general error"                     },
4021         {kIOReturnNoMemory,         "memory allocation error"           },
4022         {kIOReturnNoResources,      "resource shortage"                 },
4023         {kIOReturnIPCError,         "Mach IPC failure"                  },
4024         {kIOReturnNoDevice,         "no such device"                    },
4025         {kIOReturnNotPrivileged,    "privilege violation"               },
4026         {kIOReturnBadArgument,      "invalid argument"                  },
4027         {kIOReturnLockedRead,       "device is read locked"             },
4028         {kIOReturnLockedWrite,      "device is write locked"            },
4029         {kIOReturnExclusiveAccess,  "device is exclusive access"        },
4030         {kIOReturnBadMessageID,     "bad IPC message ID"                },
4031         {kIOReturnUnsupported,      "unsupported function"              },
4032         {kIOReturnVMError,          "virtual memory error"              },
4033         {kIOReturnInternalError,    "internal driver error"             },
4034         {kIOReturnIOError,          "I/O error"                         },
4035         {kIOReturnCannotLock,       "cannot acquire lock"               },
4036         {kIOReturnNotOpen,          "device is not open"                },
4037         {kIOReturnNotReadable,      "device is not readable"            },
4038         {kIOReturnNotWritable,      "device is not writeable"           },
4039         {kIOReturnNotAligned,       "alignment error"                   },
4040         {kIOReturnBadMedia,         "media error"                       },
4041         {kIOReturnStillOpen,        "device is still open"              },
4042         {kIOReturnRLDError,         "rld failure"                       },
4043         {kIOReturnDMAError,         "DMA failure"                       },
4044         {kIOReturnBusy,             "device is busy"                    },
4045         {kIOReturnTimeout,          "I/O timeout"                       },
4046         {kIOReturnOffline,          "device is offline"                 },
4047         {kIOReturnNotReady,         "device is not ready"               },
4048         {kIOReturnNotAttached,      "device/channel is not attached"    },
4049         {kIOReturnNoChannels,       "no DMA channels available"         },
4050         {kIOReturnNoSpace,          "no space for data"                 },
4051         {kIOReturnPortExists,       "device port already exists"        },
4052         {kIOReturnCannotWire,       "cannot wire physical memory"       },
4053         {kIOReturnNoInterrupt,      "no interrupt attached"             },
4054         {kIOReturnNoFrames,         "no DMA frames enqueued"            },
4055         {kIOReturnMessageTooLarge,  "message is too large"              },
4056         {kIOReturnNotPermitted,     "operation is not permitted"        },
4057         {kIOReturnNoPower,          "device is without power"           },
4058         {kIOReturnNoMedia,          "media is not present"              },
4059         {kIOReturnUnformattedMedia, "media is not formatted"            },
4060         {kIOReturnUnsupportedMode,  "unsupported mode"                  },
4061         {kIOReturnUnderrun,         "data underrun"                     },
4062         {kIOReturnOverrun,          "data overrun"                      },
4063         {kIOReturnDeviceError,      "device error"                      },
4064         {kIOReturnNoCompletion,     "no completion routine"             },
4065         {kIOReturnAborted,          "operation was aborted"             },
4066         {kIOReturnNoBandwidth,      "bus bandwidth would be exceeded"   },
4067         {kIOReturnNotResponding,    "device is not responding"          },
4068         {kIOReturnInvalid,          "unanticipated driver error"        },
4069         {0,                         NULL                                }
4070     };
4071
4072     return IOFindNameForValue(rtn, IOReturn_values);
4073 }
4074
4075 /*
4076  * Convert an IOReturn to an errno.
4077  */
4078 int IOService::errnoFromReturn( IOReturn rtn )
4079 {
4080     switch(rtn) {
4081         // (obvious match)
4082         case kIOReturnSuccess:
4083             return(0);
4084         case kIOReturnNoMemory:
4085             return(ENOMEM);
4086         case kIOReturnNoDevice:
4087             return(ENXIO);
4088         case kIOReturnVMError:
4089             return(EFAULT);
4090         case kIOReturnNotPermitted:
4091             return(EPERM);
4092         case kIOReturnNotPrivileged:
4093             return(EACCES);
4094         case kIOReturnIOError:
4095             return(EIO);
4096         case kIOReturnNotWritable:
4097             return(EROFS);
4098         case kIOReturnBadArgument:
4099             return(EINVAL);
4100         case kIOReturnUnsupported:
4101             return(EOPNOTSUPP);
4102         case kIOReturnBusy:
4103             return(EBUSY);
4104         case kIOReturnNoPower:
4105             return(EPWROFF);
4106         case kIOReturnDeviceError:
4107             return(EDEVERR);
4108         case kIOReturnTimeout:
4109             return(ETIMEDOUT);
4110         case kIOReturnMessageTooLarge:
4111             return(EMSGSIZE);
4112         case kIOReturnNoSpace:
4113             return(ENOSPC);
4114         case kIOReturnCannotLock:
4115             return(ENOLCK);
4116
4117         // (best match)
4118         case kIOReturnBadMessageID:
4119         case kIOReturnNoCompletion:
4120         case kIOReturnNotAligned:
4121             return(EINVAL);
4122         case kIOReturnNotReady:
4123             return(EBUSY);
4124         case kIOReturnRLDError:
4125             return(EBADMACHO);
4126         case kIOReturnPortExists:
4127         case kIOReturnStillOpen:
4128             return(EEXIST);
4129         case kIOReturnExclusiveAccess:
4130         case kIOReturnLockedRead:
4131         case kIOReturnLockedWrite:
4132         case kIOReturnNotAttached:
4133         case kIOReturnNotOpen:
4134         case kIOReturnNotReadable:
4135             return(EACCES);
4136         case kIOReturnCannotWire:
4137         case kIOReturnNoResources:
4138             return(ENOMEM);
4139         case kIOReturnAborted:
4140         case kIOReturnOffline:
4141         case kIOReturnNotResponding:
4142             return(EBUSY);
4143         case kIOReturnBadMedia:
4144         case kIOReturnNoMedia:
4145         case kIOReturnUnformattedMedia:
4146             return(ENXIO); // (media error)
4147         case kIOReturnDMAError:
4148         case kIOReturnOverrun:
4149         case kIOReturnUnderrun:
4150             return(EIO); // (transfer error)
4151         case kIOReturnNoBandwidth:
4152         case kIOReturnNoChannels:
4153         case kIOReturnNoFrames:
4154         case kIOReturnNoInterrupt:
4155             return(EIO); // (hardware error)
4156         case kIOReturnError:
4157         case kIOReturnInternalError:
4158         case kIOReturnInvalid:
4159             return(EIO); // (generic error)
4160         case kIOReturnIPCError:
4161             return(EIO); // (ipc error)
4162         default:
4163             return(EIO); // (all other errors)
4164     }
4165 }
4166
4167 IOReturn IOService::message( UInt32 type, IOService * provider,
4168                                 void * argument )
4169 {
4170     /*
4171      * Generic entry point for calls from the provider.  A return value of
4172      * kIOReturnSuccess indicates that the message was received, and where
4173      * applicable, that it was successful.
4174      */
4175
4176     return kIOReturnUnsupported;
4177 }
4178
4179 /*
4180  * Device memory
4181  */
4182
4183 IOItemCount IOService::getDeviceMemoryCount( void )
4184 {
4185     OSArray *           array;
4186     IOItemCount         count;
4187
4188     array = OSDynamicCast( OSArray, getProperty( gIODeviceMemoryKey));
4189     if( array)
4190         count = array->getCount();
4191     else
4192         count = 0;
4193
4194     return( count);
4195 }
4196
4197 IODeviceMemory * IOService::getDeviceMemoryWithIndex( unsigned int index )
4198 {
4199     OSArray *           array;
4200     IODeviceMemory *    range;
4201
4202     array = OSDynamicCast( OSArray, getProperty( gIODeviceMemoryKey));
4203     if( array)
4204         range = (IODeviceMemory *) array->getObject( index );
4205     else
4206         range = 0;
4207
4208     return( range);
4209 }
4210
4211 IOMemoryMap * IOService::mapDeviceMemoryWithIndex( unsigned int index,
4212                                                 IOOptionBits options )
4213 {
4214     IODeviceMemory *    range;
4215     IOMemoryMap *       map;
4216
4217     range = getDeviceMemoryWithIndex( index );
4218     if( range)
4219         map = range->map( options );
4220     else
4221         map = 0;
4222
4223     return( map );
4224 }
4225
4226 OSArray * IOService::getDeviceMemory( void )
4227 {
4228     return( OSDynamicCast( OSArray, getProperty( gIODeviceMemoryKey)));
4229 }
4230
4231
4232 void IOService::setDeviceMemory( OSArray * array )
4233 {
4234     setProperty( gIODeviceMemoryKey, array);
4235 }
4236
4237 /*
4238  * Device interrupts
4239  */
4240
4241 IOReturn IOService::resolveInterrupt(IOService *nub, int source)
4242 {
4243   IOInterruptController *interruptController;
4244   OSArray               *array;
4245   OSData                *data;
4246   OSSymbol              *interruptControllerName;
4247   long                  numSources;
4248   IOInterruptSource     *interruptSources;
4249
4250   // Get the parents list from the nub.
4251   array = OSDynamicCast(OSArray, nub->getProperty(gIOInterruptControllersKey));
4252   if (array == 0) return kIOReturnNoResources;
4253
4254   // Allocate space for the IOInterruptSources if needed... then return early.
4255   if (nub->_interruptSources == 0) {
4256     numSources = array->getCount();
4257     interruptSources = (IOInterruptSource *)IOMalloc(numSources * sizeof(IOInterruptSource));
4258     if (interruptSources == 0) return kIOReturnNoMemory;
4259
4260     bzero(interruptSources, numSources * sizeof(IOInterruptSource));
4261
4262     nub->_numInterruptSources = numSources;
4263     nub->_interruptSources = interruptSources;
4264     return kIOReturnSuccess;
4265   }
4266
4267   interruptControllerName = OSDynamicCast(OSSymbol,array->getObject(source));
4268   if (interruptControllerName == 0) return kIOReturnNoResources;
4269
4270   interruptController = getPlatform()->lookUpInterruptController(interruptControllerName);
4271   if (interruptController == 0) return kIOReturnNoResources;
4272
4273   // Get the interrupt numbers from the nub.
4274   array = OSDynamicCast(OSArray, nub->getProperty(gIOInterruptSpecifiersKey));
4275   if (array == 0) return kIOReturnNoResources;
4276   data = OSDynamicCast(OSData, array->getObject(source));
4277   if (data == 0) return kIOReturnNoResources;
4278
4279   // Set the interruptController and interruptSource in the nub's table.
4280   interruptSources = nub->_interruptSources;
4281   interruptSources[source].interruptController = interruptController;
4282   interruptSources[source].vectorData = data;
4283
4284   return kIOReturnSuccess;
4285 }
4286
4287 IOReturn IOService::lookupInterrupt(int source, bool resolve, IOInterruptController **interruptController)
4288 {
4289   IOReturn ret;
4290
4291   /* Make sure the _interruptSources are set */
4292   if (_interruptSources == 0) {
4293     ret = resolveInterrupt(this, source);
4294     if (ret != kIOReturnSuccess) return ret;
4295   }
4296
4297   /* Make sure the local source number is valid */
4298   if ((source < 0) || (source >= _numInterruptSources))
4299     return kIOReturnNoInterrupt;
4300
4301   /* Look up the contoller for the local source */
4302   *interruptController = _interruptSources[source].interruptController;
4303
4304   if (*interruptController == NULL) {
4305     if (!resolve) return kIOReturnNoInterrupt;
4306
4307     /* Try to reslove the interrupt */
4308     ret = resolveInterrupt(this, source);
4309     if (ret != kIOReturnSuccess) return ret;
4310
4311     *interruptController = _interruptSources[source].interruptController;
4312   }
4313
4314   return kIOReturnSuccess;
4315 }
4316
4317 IOReturn IOService::registerInterrupt(int source, OSObject *target,
4318                                       IOInterruptAction handler,
4319                                       void *refCon)
4320 {
4321   IOInterruptController *interruptController;
4322   IOReturn              ret;
4323
4324   ret = lookupInterrupt(source, true, &interruptController);
4325   if (ret != kIOReturnSuccess) return ret;
4326
4327   /* Register the source */
4328   return interruptController->registerInterrupt(this, source, target,
4329                                                 (IOInterruptHandler)handler,
4330                                                 refCon);
4331 }
4332
4333 IOReturn IOService::unregisterInterrupt(int source)
4334 {
4335   IOInterruptController *interruptController;
4336   IOReturn              ret;
4337
4338   ret = lookupInterrupt(source, false, &interruptController);
4339   if (ret != kIOReturnSuccess) return ret;
4340
4341   /* Unregister the source */
4342   return interruptController->unregisterInterrupt(this, source);
4343 }
4344
4345 IOReturn IOService::getInterruptType(int source, int *interruptType)
4346 {
4347   IOInterruptController *interruptController;
4348   IOReturn              ret;
4349
4350   ret = lookupInterrupt(source, true, &interruptController);
4351   if (ret != kIOReturnSuccess) return ret;
4352
4353   /* Return the type */
4354   return interruptController->getInterruptType(this, source, interruptType);
4355 }
4356
4357 IOReturn IOService::enableInterrupt(int source)
4358 {
4359   IOInterruptController *interruptController;
4360   IOReturn              ret;
4361
4362   ret = lookupInterrupt(source, false, &interruptController);
4363   if (ret != kIOReturnSuccess) return ret;
4364
4365   /* Enable the source */
4366   return interruptController->enableInterrupt(this, source);
4367 }
4368
4369 IOReturn IOService::disableInterrupt(int source)
4370 {
4371   IOInterruptController *interruptController;
4372   IOReturn              ret;
4373
4374   ret = lookupInterrupt(source, false, &interruptController);
4375   if (ret != kIOReturnSuccess) return ret;
4376
4377   /* Disable the source */
4378   return interruptController->disableInterrupt(this, source);
4379 }
4380
4381 IOReturn IOService::causeInterrupt(int source)
4382 {
4383   IOInterruptController *interruptController;
4384   IOReturn              ret;
4385
4386   ret = lookupInterrupt(source, false, &interruptController);
4387   if (ret != kIOReturnSuccess) return ret;
4388
4389   /* Cause an interrupt for the source */
4390   return interruptController->causeInterrupt(this, source);
4391 }
4392
4393 OSMetaClassDefineReservedUsed(IOService, 0);
4394 OSMetaClassDefineReservedUsed(IOService, 1);
4395 OSMetaClassDefineReservedUsed(IOService, 2);
4396
4397 OSMetaClassDefineReservedUnused(IOService, 3);
4398 OSMetaClassDefineReservedUnused(IOService, 4);
4399 OSMetaClassDefineReservedUnused(IOService, 5);
4400 OSMetaClassDefineReservedUnused(IOService, 6);
4401 OSMetaClassDefineReservedUnused(IOService, 7);
4402 OSMetaClassDefineReservedUnused(IOService, 8);
4403 OSMetaClassDefineReservedUnused(IOService, 9);
4404 OSMetaClassDefineReservedUnused(IOService, 10);
4405 OSMetaClassDefineReservedUnused(IOService, 11);
4406 OSMetaClassDefineReservedUnused(IOService, 12);
4407 OSMetaClassDefineReservedUnused(IOService, 13);
4408 OSMetaClassDefineReservedUnused(IOService, 14);
4409 OSMetaClassDefineReservedUnused(IOService, 15);
4410 OSMetaClassDefineReservedUnused(IOService, 16);
4411 OSMetaClassDefineReservedUnused(IOService, 17);
4412 OSMetaClassDefineReservedUnused(IOService, 18);
4413 OSMetaClassDefineReservedUnused(IOService, 19);
4414 OSMetaClassDefineReservedUnused(IOService, 20);
4415 OSMetaClassDefineReservedUnused(IOService, 21);
4416 OSMetaClassDefineReservedUnused(IOService, 22);
4417 OSMetaClassDefineReservedUnused(IOService, 23);
4418 OSMetaClassDefineReservedUnused(IOService, 24);
4419 OSMetaClassDefineReservedUnused(IOService, 25);
4420 OSMetaClassDefineReservedUnused(IOService, 26);
4421 OSMetaClassDefineReservedUnused(IOService, 27);
4422 OSMetaClassDefineReservedUnused(IOService, 28);
4423 OSMetaClassDefineReservedUnused(IOService, 29);
4424 OSMetaClassDefineReservedUnused(IOService, 30);
4425 OSMetaClassDefineReservedUnused(IOService, 31);
4426 OSMetaClassDefineReservedUnused(IOService, 32);
4427 OSMetaClassDefineReservedUnused(IOService, 33);
4428 OSMetaClassDefineReservedUnused(IOService, 34);
4429 OSMetaClassDefineReservedUnused(IOService, 35);
4430 OSMetaClassDefineReservedUnused(IOService, 36);
4431 OSMetaClassDefineReservedUnused(IOService, 37);
4432 OSMetaClassDefineReservedUnused(IOService, 38);
4433 OSMetaClassDefineReservedUnused(IOService, 39);
4434 OSMetaClassDefineReservedUnused(IOService, 40);
4435 OSMetaClassDefineReservedUnused(IOService, 41);
4436 OSMetaClassDefineReservedUnused(IOService, 42);
4437 OSMetaClassDefineReservedUnused(IOService, 43);
4438 OSMetaClassDefineReservedUnused(IOService, 44);
4439 OSMetaClassDefineReservedUnused(IOService, 45);
4440 OSMetaClassDefineReservedUnused(IOService, 46);
4441 OSMetaClassDefineReservedUnused(IOService, 47);
4442 OSMetaClassDefineReservedUnused(IOService, 48);
4443 OSMetaClassDefineReservedUnused(IOService, 49);
4444 OSMetaClassDefineReservedUnused(IOService, 50);
4445 OSMetaClassDefineReservedUnused(IOService, 51);
4446 OSMetaClassDefineReservedUnused(IOService, 52);
4447 OSMetaClassDefineReservedUnused(IOService, 53);
4448 OSMetaClassDefineReservedUnused(IOService, 54);
4449 OSMetaClassDefineReservedUnused(IOService, 55);
4450 OSMetaClassDefineReservedUnused(IOService, 56);
4451 OSMetaClassDefineReservedUnused(IOService, 57);
4452 OSMetaClassDefineReservedUnused(IOService, 58);
4453 OSMetaClassDefineReservedUnused(IOService, 59);
4454 OSMetaClassDefineReservedUnused(IOService, 60);
4455 OSMetaClassDefineReservedUnused(IOService, 61);
4456 OSMetaClassDefineReservedUnused(IOService, 62);
4457 OSMetaClassDefineReservedUnused(IOService, 63);