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