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