]> git.saurik.com Git - apple/xnu.git/blob - iokit/Kernel/IOService.cpp
projects / apple / xnu.git / blob
? search:


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