![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOService.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Kernel|
Return to IOService.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Kernel |
1.1 root 1: /*
2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * Copyright (c) 1991-1999 Apple Computer, Inc. All rights reserved.
24: *
25: * HISTORY
26: *
27: * 29-Jan-91 Portions from IODevice.m, Doug Mitchell at NeXT, Created.
28: * 18-Jun-98 start IOKit objc
29: * 10-Nov-98 start iokit cpp
30: * 25-Feb-99 sdouglas, add threads and locks to ensure deadlock
31: *
32: */
33:
34: #include <IOKit/system.h>
35:
36: #include <IOKit/IOService.h>
37: #include <libkern/c++/OSContainers.h>
38: #include <libkern/c++/OSUnserialize.h>
39: #include <IOKit/IOCatalogue.h>
40: #include <IOKit/IODeviceMemory.h>
41: #include <IOKit/IOInterrupts.h>
42: #include <IOKit/IOInterruptController.h>
43: #include <IOKit/IOPlatformExpert.h>
44: #include <IOKit/IOMessage.h>
45: #include <IOKit/IOLib.h>
46: #include <IOKit/IOKitKeys.h>
47: #include <IOKit/IOBSD.h>
48: #include <IOKit/IOUserClient.h>
49:
50: //#define LESS_THREAD_CREATE
51: //#define LOG kprintf
52: #define LOG IOLog
53:
54: #include "IOServicePrivate.h"
55: #include <mach/sync_policy.h>
56:
57: #include <IOKit/assert.h>
58:
59: #include <sys/errno.h>
60:
61: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
62:
63: #define super IORegistryEntry
64:
65: OSDefineMetaClassAndStructors(IOService, IORegistryEntry)
66:
67: OSDefineMetaClassAndStructors(_IOServiceNotifier, IONotifier)
68:
69: OSDefineMetaClassAndStructors(_IOServiceInterestNotifier, IONotifier)
70:
71: OSDefineMetaClassAndStructors(_IOConfigThread, OSObject)
72:
73: OSDefineMetaClassAndStructors(_IOServiceJob, OSObject)
74:
75: OSDefineMetaClassAndStructors(IOResources, IOService)
76:
77: OSDefineMetaClassAndStructors(_IOOpenServiceIterator, OSIterator)
78:
79: OSDefineMetaClass(IONotifier, OSObject)
80: OSDefineAbstractStructors(IONotifier, OSObject)
81:
82: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
83:
84: static IOPlatformExpert * gIOPlatform;
85: const IORegistryPlane * gIOServicePlane;
86: const IORegistryPlane * gIOPowerPlane;
87: const OSSymbol * gIODeviceMemoryKey;
88: const OSSymbol * gIOInterruptControllersKey;
89: const OSSymbol * gIOInterruptSpecifiersKey;
90:
91: const OSSymbol * gIOResourcesKey;
92: const OSSymbol * gIOResourceMatchKey;
93: const OSSymbol * gIOProviderClassKey;
94: const OSSymbol * gIONameMatchKey;
95: const OSSymbol * gIONameMatchedKey;
96: const OSSymbol * gIOLocationMatchKey;
97: const OSSymbol * gIOPathMatchKey;
98: const OSSymbol * gIOMatchCategoryKey;
99: const OSSymbol * gIODefaultMatchCategoryKey;
100: const OSSymbol * gIOKitDebugKey;
101:
102: static int gIOResourceGenerationCount;
103:
104: const OSSymbol * gIOServiceKey;
105: const OSSymbol * gIOPublishNotification;
106: const OSSymbol * gIOFirstPublishNotification;
107: const OSSymbol * gIOMatchedNotification;
108: const OSSymbol * gIOFirstMatchNotification;
109: const OSSymbol * gIOTerminatedNotification;
110:
111: const OSSymbol * gIOGeneralInterest;
112: const OSSymbol * gIOBusyInterest;
113:
114: static OSDictionary * gNotifications;
115: static IORecursiveLock * gNotificationLock;
116:
117: static IOService * gIOResources;
118: static IOService * gIOServiceRoot;
119:
120: static OSOrderedSet * gJobs;
121: static semaphore_port_t gJobsSemaphore;
122: static IOLock * gJobsLock;
123: static int gOutstandingJobs;
124: static int gNumConfigThreads;
125: static int gNumWaitingThreads;
126: static IOLock * gIOServiceBusyLock;
127:
128: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
129:
130: #define LOCKREADNOTIFY() \
131: IORecursiveLockLock( gNotificationLock )
132: #define LOCKWRITENOTIFY() \
133: IORecursiveLockLock( gNotificationLock )
134: #define LOCKWRITE2READNOTIFY()
135: #define UNLOCKNOTIFY() \
136: IORecursiveLockUnlock( gNotificationLock )
137:
138: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
139:
140: struct ArbitrationLockQueueElement {
141: queue_chain_t link;
142: IOThread thread;
143: IOService * service;
144: unsigned count;
145: bool required;
146: bool aborted;
147: };
148:
149: static queue_head_t gArbitrationLockQueueActive;
150: static queue_head_t gArbitrationLockQueueWaiting;
151: static queue_head_t gArbitrationLockQueueFree;
152: static IOLock * gArbitrationLockQueueLock;
153:
154: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
155:
156: void IOService::initialize( void )
157: {
158: kern_return_t err;
159:
160: gIOServicePlane = IORegistryEntry::makePlane( kIOServicePlane );
161: gIOPowerPlane = IORegistryEntry::makePlane( kIOPowerPlane );
162:
163: gIOProviderClassKey = OSSymbol::withCStringNoCopy( kIOProviderClassKey );
164: gIONameMatchKey = OSSymbol::withCStringNoCopy( kIONameMatchKey );
165: gIONameMatchedKey = OSSymbol::withCStringNoCopy( kIONameMatchedKey );
166: gIOPathMatchKey = OSSymbol::withCStringNoCopy( kIOPathMatchKey );
167: gIOLocationMatchKey = OSSymbol::withCStringNoCopy( kIOLocationMatchKey );
168:
169: gIOMatchCategoryKey = OSSymbol::withCStringNoCopy( kIOMatchCategoryKey );
170: gIODefaultMatchCategoryKey = OSSymbol::withCStringNoCopy(
171: kIODefaultMatchCategoryKey );
172:
173: gIOResourcesKey = OSSymbol::withCStringNoCopy( kIOResourcesClass );
174: gIOResourceMatchKey = OSSymbol::withCStringNoCopy( kIOResourceMatchKey );
175:
176: gIODeviceMemoryKey = OSSymbol::withCStringNoCopy( "IODeviceMemory" );
177: gIOInterruptControllersKey
178: = OSSymbol::withCStringNoCopy("IOInterruptControllers");
179: gIOInterruptSpecifiersKey
180: = OSSymbol::withCStringNoCopy("IOInterruptSpecifiers");
181:
182: gIOKitDebugKey = OSSymbol::withCStringNoCopy( kIOKitDebugKey );
183:
184: gIOGeneralInterest = OSSymbol::withCStringNoCopy( kIOGeneralInterest );
185: gIOBusyInterest = OSSymbol::withCStringNoCopy( kIOBusyInterest );
186:
187: gNotifications = OSDictionary::withCapacity( 1 );
188: gIOPublishNotification = OSSymbol::withCStringNoCopy(
189: kIOPublishNotification );
190: gIOFirstPublishNotification = OSSymbol::withCStringNoCopy(
191: kIOFirstPublishNotification );
192: gIOMatchedNotification = OSSymbol::withCStringNoCopy(
193: kIOMatchedNotification );
194: gIOFirstMatchNotification = OSSymbol::withCStringNoCopy(
195: kIOFirstMatchNotification );
196: gIOTerminatedNotification = OSSymbol::withCStringNoCopy(
197: kIOTerminatedNotification );
198: gIOServiceKey = OSSymbol::withCStringNoCopy( kIOServiceClass);
199:
200: gNotificationLock = IORecursiveLockAlloc();
201:
202: assert( gIOServicePlane && gIODeviceMemoryKey
203: && gIOInterruptControllersKey && gIOInterruptSpecifiersKey
204: && gIOResourcesKey && gNotifications && gNotificationLock
205: && gIOProviderClassKey && gIONameMatchKey && gIONameMatchedKey
206: && gIOMatchCategoryKey && gIODefaultMatchCategoryKey
207: && gIOPublishNotification && gIOMatchedNotification
208: && gIOTerminatedNotification && gIOServiceKey );
209:
210: gJobsLock = IOLockAlloc();
211: gJobs = OSOrderedSet::withCapacity( 10 );
212:
213: gIOServiceBusyLock = IOLockAlloc();
214:
215: err = semaphore_create(kernel_task, &gJobsSemaphore, SYNC_POLICY_FIFO, 0);
216:
217: assert( gIOServiceBusyLock && gJobs && gJobsLock && (err == KERN_SUCCESS) );
218:
219: gIOResources = IOResources::resources();
220: assert( gIOResources );
221:
222: gArbitrationLockQueueLock = IOLockAlloc();
223: queue_init(&gArbitrationLockQueueActive);
224: queue_init(&gArbitrationLockQueueWaiting);
225: queue_init(&gArbitrationLockQueueFree);
226:
227: assert( gArbitrationLockQueueLock );
228:
229: #ifdef LESS_THREAD_CREATE
230: for( int i = 0; i < kMaxConfigThreads; i++)
231: _IOConfigThread::configThread();
232: #endif
233:
234: }
235:
236: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
237:
238: #ifdef DEBUG
239: static UInt64 getDebugFlags( OSDictionary * props )
240: {
241: OSNumber * debugProp;
242: UInt64 debugFlags;
243:
244: debugProp = OSDynamicCast( OSNumber,
245: props->getObject( gIOKitDebugKey ));
246: if( debugProp)
247: debugFlags = debugProp->unsigned64BitValue();
248: else
249: debugFlags = gIOKitDebug;
250:
251: return( debugFlags );
252: }
253: #endif
254:
255: /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
256:
257: // Probe a matched service and return an instance to be started.
258: // The default score is from the property table, & may be altered
259: // during probe to change the start order.
260:
261: IOService * IOService::probe( IOService * /* provider */,
262: SInt32 * /* score */)
263: {
264: return( this );
265: }
266:
267: bool IOService::start( IOService * provider )
268: {
269: return( true );
270: }
271:
272: void IOService::stop( IOService * /* provider */ )
273: {
274: }
275:
276: /*
277: * Attach in service plane
278: */
279: bool IOService::attach( IOService * provider )
280: {
281: bool ok;
282:
283: if( provider) {
284:
285: if( gIOKitDebug & kIOLogAttach)
286: LOG( "%s::attach(%s)\n", getName(),
287: provider->getName());
288:
289: provider->lockForArbitration();
290: if( provider->__state[0] & kIOServiceInactiveState)
291: ok = false;
292: else
293: ok = attachToParent( provider, gIOServicePlane);
294: provider->unlockForArbitration();
295:
296: } else {
297:
298: gIOServiceRoot = this;
299: ok = attachToParent( getRegistryRoot(), gIOServicePlane);
300: gIOResources->attachToParent( getRegistryRoot(),
301: gIOServicePlane );
302: publishResource("IOKit");
303: }
304:
305: return( ok );
306: }
307:
308: IOService * IOService::getServiceRoot( void )
309: {
310: return( gIOServiceRoot );
311: }
312:
313: void IOService::detach( IOService * provider )
314: {
315: if( gIOKitDebug & kIOLogAttach)
316: LOG("%s::detach(%s)\n", getName(), provider->getName());
317:
318: detachFromParent( provider, gIOServicePlane );
319: }
320:
321: /*
322: * Register instance - publish it for matching
323: */
324:
325: void IOService::registerService( IOOptionBits options = 0 )
326: {
327: char * pathBuf;
328: const char * path;
329: char * skip;
330: int len;
331: enum { kMaxPathLen = 256 };
332: enum { kMaxChars = 63 };
333:
334: // Allow the Platform Expert to adjust this node.
335: if (gIOPlatform)
336: if (!gIOPlatform->platformAdjustService(this))
337: return;
338:
339: if( (this != gIOResources)
340: && (kIOLogRegister & gIOKitDebug)) {
341:
342: pathBuf = (char *) IOMalloc( kMaxPathLen );
343:
344: IOLog( "Registering: " );
345:
346: len = kMaxPathLen;
347: if( pathBuf && getPath( pathBuf, &len, gIOServicePlane)) {
348:
349: path = pathBuf;
350: if( len > kMaxChars) {
351: IOLog("..");
352: len -= kMaxChars;
353: path += len;
354: if( (skip = strchr( path, '/')))
355: path = skip;
356: }
357: } else
358: path = getName();
359:
360: IOLog( "%s\n", path );
361:
362: if( pathBuf)
363: IOFree( pathBuf, kMaxPathLen );
364: }
365:
366: startMatching( options );
367: }
368:
369: void IOService::startMatching( IOOptionBits options = 0 )
370: {
371: IOService * provider;
372: bool needConfig;
373: bool ok;
374: bool sync;
375:
376: lockForArbitration();
377:
378: sync = (options & kIOServiceSynchronous)
379: || ((provider = getProvider())
380: && (provider->__state[1] & kIOServiceSynchronousState));
381: if( sync)
382: __state[1] |= kIOServiceSynchronousState;
383: else
384: __state[1] &= ~kIOServiceSynchronousState;
385:
386: needConfig = (0 == (__state[1] & kIOServiceConfigState))
387: && (0 == (__state[0] & kIOServiceInactiveState))
388: && (kIOServiceRegisteredState !=
389: (__state[0] & (kIOServiceRegisteredState
390: | kIOServiceMatchedState)));
391: __state[1] |= kIOServiceConfigState;
392: // __state[0] &= ~kIOServiceInactiveState;
393:
394: // if( sync) LOG("OSKernelStackRemaining = %08x @ %s\n",
395: // OSKernelStackRemaining(), getName());
396:
397: unlockForArbitration();
398:
399: if( needConfig) {
400: adjustBusy( 1 );
401: if( sync) {
402: doServiceMatch();
403: waitQuiet();
404: } else
405: ok = (0 != _IOServiceJob::startJob( this, kMatchNubJob ));
406: }
407: }
408:
409: IOReturn IOService::catalogNewDrivers( OSOrderedSet * newTables )
410: {
411: OSDictionary * table;
412: OSIterator * iter;
413: IOService * service;
414: #ifdef DEBUG
415: SInt32 count = 0;
416: #endif
417:
418: newTables->retain();
419:
420: while( (table = (OSDictionary *) newTables->getFirstObject())) {
421:
422: LOCKWRITENOTIFY();
423: iter = (OSIterator *) getExistingServices( table,
424: kIOServiceMatchedState );
425: UNLOCKNOTIFY();
426: if( iter) {
427: while( (service = (IOService *) iter->getNextObject())) {
428: service->startMatching();
429: #ifdef DEBUG
430: count++;
431: #endif
432: }
433: iter->release();
434: }
435: #ifdef DEBUG
436: if( getDebugFlags( table ) & kIOLogMatch)
437: LOG("Matching service count = %ld\n", count);
438: #endif
439: newTables->removeObject(table);
440: }
441:
442: newTables->release();
443:
444: return( kIOReturnSuccess );
445: }
446:
447: _IOServiceJob * _IOServiceJob::startJob( IOService * nub, int type,
448: IOOptionBits options = 0 )
449: {
450: _IOServiceJob * job;
451:
452: job = new _IOServiceJob;
453: if( job && !job->init()) {
454: job->release();
455: job = 0;
456: }
457:
458: if( job) {
459: job->type = type;
460: job->nub = nub;
461: job->options = options;
462: nub->retain(); // thread will release()
463: pingConfig( job );
464: }
465:
466: return( job );
467: }
468:
469: /*
470: * Called on a registered service to see if it matches
471: * a property table.
472: */
473:
474: bool IOService::matchPropertyTable( OSDictionary * table )
475: {
476: return( true );
477: }
478:
479: /*
480: * Called on a matched service to allocate resources
481: * before first driver is attached.
482: */
483:
484: IOReturn IOService::getResources( void )
485: {
486: return( kIOReturnSuccess);
487: }
488:
489: /*
490: * Client/provider accessors
491: */
492:
493: IOService * IOService::getProvider( void ) const
494: {
495: IOService * self = (IOService *) this;
496: IOService * parent;
497: SInt32 generation;
498:
499: parent = __provider;
500: generation = getGenerationCount();
501: if( __providerGeneration == generation)
502: return( parent );
503:
504: parent = (IOService *) getParentEntry( gIOServicePlane);
505: if( parent == IORegistryEntry::getRegistryRoot())
506: /* root is not an IOService */
507: parent = 0;
508:
509: self->__provider = parent;
510: // save the count before getParentEntry()
511: self->__providerGeneration = generation;
512:
513: return( parent );
514: }
515:
516: IOWorkLoop * IOService::getWorkLoop() const
517: {
518: return getProvider()->getWorkLoop();
519: }
520:
521: OSIterator * IOService::getProviderIterator( void ) const
522: {
523: return( getParentIterator( gIOServicePlane));
524: }
525:
526: IOService * IOService::getClient( void ) const
527: {
528: return( (IOService *) getChildEntry( gIOServicePlane));
529: }
530:
531: OSIterator * IOService::getClientIterator( void ) const
532: {
533: return( getChildIterator( gIOServicePlane));
534: }
535:
536: OSIterator * _IOOpenServiceIterator::iterator( OSIterator * _iter,
537: const IOService * client,
538: const IOService * provider )
539: {
540: _IOOpenServiceIterator * inst;
541:
542: if( !_iter)
543: return( 0 );
544:
545: inst = new _IOOpenServiceIterator;
546:
547: if( inst && !inst->init()) {
548: inst->release();
549: inst = 0;
550: }
551: if( inst) {
552: inst->iter = _iter;
553: inst->client = client;
554: inst->provider = provider;
555: }
556:
557: return( inst );
558: }
559:
560: void _IOOpenServiceIterator::free()
561: {
562: iter->release();
563: if( last)
564: last->unlockForArbitration();
565: OSIterator::free();
566: }
567:
568: OSObject * _IOOpenServiceIterator::getNextObject()
569: {
570: IOService * next;
571:
572: if( last)
573: last->unlockForArbitration();
574:
575: while( (next = (IOService *) iter->getNextObject())) {
576:
577: next->lockForArbitration();
578: if( (client && (next->isOpen( client )))
579: || (provider && (provider->isOpen( next ))) )
580: break;
581: next->unlockForArbitration();
582: }
583:
584: last = next;
585:
586: return( next );
587: }
588:
589: bool _IOOpenServiceIterator::isValid()
590: {
591: return( iter->isValid() );
592: }
593:
594: void _IOOpenServiceIterator::reset()
595: {
596: if( last) {
597: last->unlockForArbitration();
598: last = 0;
599: }
600: iter->reset();
601: }
602:
603: OSIterator * IOService::getOpenProviderIterator( void ) const
604: {
605: return( _IOOpenServiceIterator::iterator( getProviderIterator(), this, 0 ));
606: }
607:
608: OSIterator * IOService::getOpenClientIterator( void ) const
609: {
610: return( _IOOpenServiceIterator::iterator( getClientIterator(), 0, this ));
611: }
612:
613:
614: /*
615: * Platform expert accessors
616: */
617:
618: IOPlatformExpert * IOService::getPlatform( void )
619: {
620: return( gIOPlatform);
621: }
622:
623: void IOService::setPlatform( IOPlatformExpert * platform)
624: {
625: gIOPlatform = platform;
626: }
627:
628: /*
629: * Stacking change
630: */
631:
632: bool IOService::lockForArbitration( bool isSuccessRequired = true )
633: {
634: bool found;
635: bool success;
636: ArbitrationLockQueueElement * element;
637: ArbitrationLockQueueElement * active;
638: ArbitrationLockQueueElement * waiting;
639:
640: enum { kPutOnFreeQueue, kPutOnActiveQueue, kPutOnWaitingQueue } action;
641:
642: // lock global access
643: IOTakeLock( gArbitrationLockQueueLock );
644:
645: // obtain an unused queue element
646: if( !queue_empty( &gArbitrationLockQueueFree )) {
647: queue_remove_first( &gArbitrationLockQueueFree,
648: element,
649: ArbitrationLockQueueElement *,
650: link );
651: } else {
652: element = IONew( ArbitrationLockQueueElement, 1 );
653: assert( element );
654: }
655:
656: // prepare the queue element
657: element->thread = IOThreadSelf();
658: element->service = this;
659: element->count = 1;
660: element->required = isSuccessRequired;
661: element->aborted = false;
662:
663: // determine whether this object is already locked (ie. on active queue)
664: found = false;
665: queue_iterate( &gArbitrationLockQueueActive,
666: active,
667: ArbitrationLockQueueElement *,
668: link )
669: {
670: if( active->service == element->service ) {
671: found = true;
672: break;
673: }
674: }
675:
676: if( found ) { // this object is already locked
677:
678: // determine whether it is the same or a different thread trying to lock
679: if( active->thread != element->thread ) { // it is a different thread
680:
681: ArbitrationLockQueueElement * victim = 0;
682:
683: // before placing this new thread on the waiting queue, we look for
684: // a deadlock cycle...
685:
686: while( 1 ) {
687: // determine whether the active thread holding the object we
688: // want is waiting for another object to be unlocked
689: found = false;
690: queue_iterate( &gArbitrationLockQueueWaiting,
691: waiting,
692: ArbitrationLockQueueElement *,
693: link )
694: {
695: if( waiting->thread == active->thread ) {
696: assert( false == waiting->aborted );
697: found = true;
698: break;
699: }
700: }
701:
702: if( found ) { // yes, active thread waiting for another object
703:
704: // this may be a candidate for rejection if the required
705: // flag is not set, should we detect a deadlock later on
706: if( false == waiting->required )
707: victim = waiting;
708:
709: // find the thread that is holding this other object, that
710: // is blocking the active thread from proceeding (fun :-)
711: found = false;
712: queue_iterate( &gArbitrationLockQueueActive,
713: active, // (reuse active queue element)
714: ArbitrationLockQueueElement *,
715: link )
716: {
717: if( active->service == waiting->service ) {
718: found = true;
719: break;
720: }
721: }
722:
723: // someone must be holding it or it wouldn't be waiting
724: assert( found );
725:
726: if( active->service == element->service ) {
727:
728: // doh, it's waiting for the thread that originated
729: // this whole lock (ie. current thread) -> deadlock
730: if( false == element->required ) { // willing to fail?
731:
732: // the originating thread doesn't have the required
733: // flag, so it can fail
734: success = false; // (fail originating lock request)
735: break; // (out of while)
736:
737: } else { // originating thread is not willing to fail
738:
739: // see if we came across a waiting thread that did
740: // not have the 'required' flag set: we'll fail it
741: if( victim ) {
742:
743: // we do have a willing victim, fail it's lock
744: victim->aborted = true;
745:
746: // take the victim off the waiting queue
747: queue_remove( &gArbitrationLockQueueWaiting,
748: victim,
749: ArbitrationLockQueueElement *,
750: link );
751:
752: // wake the victim
753: thread_wakeup_one(victim);
754:
755: // allow this thread to proceed (ie. wait)
756: success = true; // (put request on wait queue)
757: break; // (out of while)
758: } else {
759:
760: // all the waiting threads we came across in
761: // finding this loop had the 'required' flag
762: // set, so we've got a deadlock we can't avoid
763: panic("I/O Kit: Unrecoverable deadlock.");
764: }
765: }
766: } else {
767: // repeat while loop, redefining active thread to be the
768: // thread holding "this other object" (see above), and
769: // looking for threads waiting on it; note the active
770: // variable points to "this other object" already... so
771: // there nothing to do in this else clause.
772: }
773: } else { // no, active thread is not waiting for another object
774:
775: success = true; // (put request on wait queue)
776: break; // (out of while)
777: }
778: } // while forever
779:
780: if( success ) { // put the request on the waiting queue?
781:
782: // place this thread on the waiting queue and put it to sleep;
783: // we place it at the tail of the queue...
784: queue_enter( &gArbitrationLockQueueWaiting,
785: element,
786: ArbitrationLockQueueElement *,
787: link );
788:
789: // declare that this thread will wait for an given event
790: assert_wait(element, THREAD_UNINT);
791:
792: // unlock global access
793: IOUnlock( gArbitrationLockQueueLock );
794:
795: // put thread to sleep, waiting for the our event to fire...
796: thread_block((void (*)(void)) 0);
797:
798: assert( THREAD_AWAKENED == thread_wait_result() );
799:
800: // ...and we've been woken up; we might be one of two states:
801: // (a) we've been aborted and our queue element is not on
802: // any of the three queues, but is floating around
803: // (b) we're allowed to proceed with the lock and we have
804: // already been moved from the waiting queue to the
805: // active queue.
806:
807: // determine whether we've been aborted while we were asleep
808: if( element->aborted ) {
809: assert( false == element->required );
810:
811: // re-lock global access
812: IOTakeLock( gArbitrationLockQueueLock );
813:
814: action = kPutOnFreeQueue;
815: success = false;
816: } else { // we weren't aborted, so we must be ready to go :-)
817:
818: // we've already been moved from waiting to active queue
819: return true;
820: }
821:
822: } else { // the lock request is to be failed
823:
824: // return unused queue element to queue
825: action = kPutOnFreeQueue;
826: }
827: } else { // it is the same thread, recursive access is allowed
828:
829: // add one level of recursion
830: active->count++;
831:
832: // return unused queue element to queue
833: action = kPutOnFreeQueue;
834: success = true;
835: }
836: } else { // this object is not already locked, so let this thread through
837: action = kPutOnActiveQueue;
838: success = true;
839: }
840:
841: // put the new element on a queue
842: if( kPutOnActiveQueue == action ) {
843: queue_enter( &gArbitrationLockQueueActive,
844: element,
845: ArbitrationLockQueueElement *,
846: link );
847: } else if( kPutOnFreeQueue == action ) {
848: queue_enter( &gArbitrationLockQueueFree,
849: element,
850: ArbitrationLockQueueElement *,
851: link );
852: } else {
853: assert( 0 ); // kPutOnWaitingQueue never occurs, handled specially above
854: }
855:
856: // unlock global access
857: IOUnlock( gArbitrationLockQueueLock );
858:
859: return( success );
860: }
861:
862: void IOService::unlockForArbitration( void )
863: {
864: bool found;
865: ArbitrationLockQueueElement * element;
866:
867: // lock global access
868: IOTakeLock( gArbitrationLockQueueLock );
869:
870: // find the lock element for this object (ie. on active queue)
871: found = false;
872: queue_iterate( &gArbitrationLockQueueActive,
873: element,
874: ArbitrationLockQueueElement *,
875: link )
876: {
877: if( element->service == this ) {
878: found = true;
879: break;
880: }
881: }
882:
883: assert( found );
884:
885: // determine whether the lock has been taken recursively
886: if( element->count > 1 ) {
887: // undo one level of recursion
888: element->count--;
889:
890: } else {
891:
892: // remove it from the active queue
893: queue_remove( &gArbitrationLockQueueActive,
894: element,
895: ArbitrationLockQueueElement *,
896: link );
897:
898: // put it on the free queue
899: queue_enter( &gArbitrationLockQueueFree,
900: element,
901: ArbitrationLockQueueElement *,
902: link );
903:
904: // determine whether a thread is waiting for object (head to tail scan)
905: found = false;
906: queue_iterate( &gArbitrationLockQueueWaiting,
907: element,
908: ArbitrationLockQueueElement *,
909: link )
910: {
911: if( element->service == this ) {
912: found = true;
913: break;
914: }
915: }
916:
917: if ( found ) { // we found an interested thread on waiting queue
918:
919: // remove it from the waiting queue
920: queue_remove( &gArbitrationLockQueueWaiting,
921: element,
922: ArbitrationLockQueueElement *,
923: link );
924:
925: // put it on the active queue
926: queue_enter( &gArbitrationLockQueueActive,
927: element,
928: ArbitrationLockQueueElement *,
929: link );
930:
931: // wake the waiting thread
932: thread_wakeup_one(element);
933: }
934: }
935:
936: // unlock global access
937: IOUnlock( gArbitrationLockQueueLock );
938: }
939:
940: void IOService::applyToProviders( IOServiceApplierFunction applier,
941: void * context )
942: {
943: applyToParents( (IORegistryEntryApplierFunction) applier,
944: context, gIOServicePlane );
945: }
946:
947: void IOService::applyToClients( IOServiceApplierFunction applier,
948: void * context )
949: {
950: applyToChildren( (IORegistryEntryApplierFunction) applier,
951: context, gIOServicePlane );
952: }
953:
954:
955: /*
956: * Client messages
957: */
958:
959:
960: // send a message to a client or interested party of this service
961: IOReturn IOService::messageClient( UInt32 type, OSObject * client,
962: void * argument = 0, vm_size_t argSize = 0 )
963: {
964: IOReturn ret;
965: IOService * service;
966: _IOServiceInterestNotifier * interested;
967:
968: if( (service = OSDynamicCast( IOService, client)))
969: ret = service->message( type, this, argument );
970:
971: else if( (interested = OSDynamicCast( _IOServiceInterestNotifier, client))) {
972: if( interested->fEnable)
973: ret = (*interested->handler)( interested->target, interested->ref,
974: type, this, argument, argSize );
975: else
976: ret = kIOReturnSuccess;
977:
978: } else
979: ret = kIOReturnBadArgument;
980:
981: return( ret );
982: }
983:
984: void IOService::applyToInterested( const OSSymbol * typeOfInterest,
985: OSObjectApplierFunction applier,
986: void * context )
987: {
988: OSArray * array;
989: unsigned int index;
990: OSObject * next;
991:
992: applyToClients( (IOServiceApplierFunction) applier, context );
993:
994: array = OSDynamicCast( OSArray, getProperty( typeOfInterest ));
995: if( array) {
996: LOCKREADNOTIFY();
997: for( index = 0;
998: (next = array->getObject( index ));
999: index++) {
1000: (*applier)(next, context);
1001: }
1002: UNLOCKNOTIFY();
1003: }
1004: }
1005:
1006: struct MessageClientsContext {
1007: IOService * service;
1008: UInt32 type;
1009: void * argument;
1010: vm_size_t argSize;
1011: IOReturn ret;
1012: };
1013:
1014: static void messageClientsApplier( OSObject * object, void * ctx )
1015: {
1016: IOReturn ret;
1017: MessageClientsContext * context = (MessageClientsContext *) ctx;
1018:
1019: ret = context->service->messageClient( context->type,
1020: object, context->argument, context->argSize );
1021: if( kIOReturnSuccess != ret)
1022: context->ret = ret;
1023: }
1024:
1025: // send a message to all clients
1026: IOReturn IOService::messageClients( UInt32 type,
1027: void * argument = 0, vm_size_t argSize = 0 )
1028: {
1029: MessageClientsContext context;
1030:
1031: context.service = this;
1032: context.type = type;
1033: context.argument = argument;
1034: context.argSize = argSize;
1035: context.ret = kIOReturnSuccess;
1036:
1037: applyToInterested( gIOGeneralInterest,
1038: &messageClientsApplier, &context );
1039:
1040: return( context.ret );
1041: }
1042:
1043: IOReturn IOService::acknowledgeNotification( IONotificationRef notification,
1044: IOOptionBits response )
1045: {
1046: return( kIOReturnUnsupported );
1047: }
1048:
1049: IONotifier * IOService::registerInterest( const OSSymbol * typeOfInterest,
1050: IOServiceInterestHandler handler, void * target, void * ref )
1051: {
1052: _IOServiceInterestNotifier * notify = 0;
1053: OSArray * set;
1054:
1055: if( (typeOfInterest != gIOGeneralInterest)
1056: && (typeOfInterest != gIOBusyInterest))
1057: return( 0 );
1058:
1059: lockForArbitration();
1060: if( 0 == (__state[0] & kIOServiceInactiveState)) {
1061:
1062: notify = new _IOServiceInterestNotifier;
1063: if( notify && !notify->init()) {
1064: notify->release();
1065: notify = 0;
1066: }
1067:
1068: if( notify) {
1069: notify->handler = handler;
1070: notify->target = target;
1071: notify->ref = ref;
1072: notify->fEnable = true;
1073:
1074: ////// queue
1075:
1076: LOCKWRITENOTIFY();
1077: if( 0 == (set = (OSArray *) getProperty( typeOfInterest ))) {
1078: set = OSArray::withCapacity( 1 );
1079: if( set) {
1080: setProperty( typeOfInterest, set );
1081: set->release();
1082: }
1083: }
1084: notify->whence = set;
1085: if( set)
1086: set->setObject( notify );
1087: UNLOCKNOTIFY();
1088: }
1089: }
1090: unlockForArbitration();
1091:
1092: return( notify );
1093: }
1094:
1095: static void cleanInterestArray( OSObject * object )
1096: {
1097: OSArray * array;
1098: unsigned int index;
1099: _IOServiceInterestNotifier * next;
1100:
1101: if( (array = OSDynamicCast( OSArray, object))) {
1102: LOCKWRITENOTIFY();
1103: for( index = 0;
1104: (next = (_IOServiceInterestNotifier *)
1105: array->getObject( index ));
1106: index++) {
1107: next->whence = 0;
1108: }
1109: UNLOCKNOTIFY();
1110: }
1111: }
1112:
1113: void IOService::unregisterAllInterest( void )
1114: {
1115: cleanInterestArray( getProperty( gIOGeneralInterest ));
1116: cleanInterestArray( getProperty( gIOBusyInterest ));
1117: }
1118:
1119: /*
1120: * _IOServiceInterestNotifier
1121: */
1122:
1123: void _IOServiceInterestNotifier::remove()
1124: {
1125: LOCKWRITENOTIFY();
1126:
1127: if( whence) {
1128: whence->removeObject(whence->getNextIndexOfObject(
1129: (OSObject *) this, 0 ));
1130: whence = 0;
1131: }
1132:
1133: fEnable = false;
1134:
1135: UNLOCKNOTIFY();
1136:
1137: release();
1138: }
1139:
1140: bool _IOServiceInterestNotifier::disable()
1141: {
1142: bool ret;
1143:
1144: LOCKWRITENOTIFY();
1145: ret = fEnable;
1146: fEnable = false;
1147: UNLOCKNOTIFY();
1148:
1149: return( ret );
1150: }
1151:
1152: void _IOServiceInterestNotifier::enable( bool was )
1153: {
1154: LOCKWRITENOTIFY();
1155: fEnable = was;
1156: UNLOCKNOTIFY();
1157: }
1158:
1159: /*
1160: * Terminate
1161: */
1162:
1163: // a method in case someone needs to override it
1164: bool IOService::terminateClient( IOService * client, IOOptionBits options )
1165: {
1166: bool ok;
1167:
1168: if( client->isParent( this, gIOServicePlane, true))
1169: // we are the clients only provider
1170: ok = client->terminate( options );
1171: else
1172: ok = true;
1173:
1174: return( ok );
1175: }
1176:
1177: struct TerminateClientsContext {
1178: IOService * provider;
1179: IOOptionBits options;
1180: };
1181:
1182: static void terminateClientsApplier( OSObject * object, void * ctx )
1183: {
1184: TerminateClientsContext * context = (TerminateClientsContext *) ctx;
1185: IOService * client;
1186:
1187: context->provider->messageClient( kIOMessageServiceIsTerminated,
1188: object, (void *) context->options );
1189:
1190: if( (client = OSDynamicCast( IOService, object))){
1191: if( gIOKitDebug & kIOLogYield)
1192: LOG("%s::terminateClient(%s,%08lx)\n",
1193: context->provider->getName(),
1194: client->getName(), context->options);
1195:
1196: context->provider->terminateClient(
1197: client, ((context->options) | kIOServiceRecursing)
1198: & ~kIOServiceSynchronous );
1199: }
1200: }
1201:
1202: bool IOService::terminate( IOOptionBits options = 0 )
1203: {
1204: bool ok;
1205: bool wasClosed;
1206: bool madeInactive;
1207: TerminateClientsContext context;
1208:
1209: if( false == lockForArbitration( (options & kIOServiceRequired) ))
1210: return false;
1211:
1212: retain();
1213:
1214: ok = (options & kIOServiceRequired);
1215: wasClosed = (false == handleIsOpen( 0 ));
1216: if( !ok)
1217: ok = wasClosed;
1218:
1219: if( ok) {
1220: madeInactive = (0 == (__state[0] & kIOServiceInactiveState));
1221: if( madeInactive) {
1222: __state[0] |= kIOServiceInactiveState;
1223: __state[0] &= ~(kIOServiceRegisteredState | kIOServiceMatchedState);
1224: if( 0 == (options & kIOServiceRecursing))
1225: __state[1] |= kIOServiceTerminatedState;
1226: }
1227: } else
1228: madeInactive = false;
1229:
1230: unlockForArbitration();
1231:
1232: if( madeInactive) {
1233:
1234: adjustBusy( 1 );
1235: context.provider = this;
1236: context.options = options;
1237: applyToInterested( gIOGeneralInterest,
1238: &terminateClientsApplier, (void *) &context );
1239:
1240: if( wasClosed && (0 == (options & kIOServiceRecursing))) {
1241: if( options & kIOServiceSynchronous)
1242: doServiceTerminate( 0 );
1243: else
1244: ok = (0 != _IOServiceJob::startJob( this, kTerminateNubJob, 0 ));
1245: }
1246: if( options & kIOServiceSynchronous)
1247: waitQuiet();
1248: }
1249:
1250: release();
1251:
1252: return( ok );
1253: }
1254:
1255: void IOService::doServiceTerminate( IOOptionBits options )
1256: {
1257: IOService * next;
1258: OSIterator * iter;
1259: IOService * client;
1260: OSArray * deathList = 0;
1261: unsigned int index;
1262: bool finalize;
1263: bool ok = true;
1264:
1265: next = this;
1266: deathList = OSArray::withObjects( (OSObject **)&next, 1, 1 );
1267: assert( deathList );
1268: if( !deathList)
1269: return;
1270:
1271: index = 0;
1272: do {
1273: iter = next->getClientIterator();
1274: assert( iter );
1275: if( iter) {
1276:
1277: while( (client = (IOService *) iter->getNextObject())) {
1278:
1279: if( gIOKitDebug & kIOLogYield)
1280: LOG("%s::actionClients(%s)\n",
1281: next->getName(), client->getName());
1282:
1283: client->stop( next );
1284:
1285: if( next->isOpen( client ))
1286: next->close( client );
1287:
1288: client->detach( next );
1289:
1290: client->lockForArbitration();
1291: if( (client->__state[0] & kIOServiceInactiveState)
1292: && (0 == (client->__state[1] & kIOServiceTerminatedState))
1293: && (0 == client->getProvider()) ) {
1294: client->__state[1] |= kIOServiceTerminatedState;
1295: finalize = (false == client->handleIsOpen( 0 ));
1296: } else
1297: finalize = false;
1298: client->unlockForArbitration();
1299:
1300: if( finalize) {
1301: next->adjustBusy( -1 ); // because the client is detached now
1302: // and won't adjust its provider busy count
1303: deathList->setObject( client );
1304: }
1305: }
1306: iter->release();
1307: }
1308:
1309: } while( (next = (IOService *) deathList->getObject( ++index )) );
1310:
1311: while( index--) {
1312:
1313: next = (IOService *) deathList->getObject( index );
1314: assert( next );
1315: next->retain();
1316: deathList->removeObject( index );
1317:
1318: next->deliverNotification( gIOTerminatedNotification, 0, 0xffffffff );
1319:
1320: IOUserClient::destroyUserReferences( next );
1321:
1322: next->unregisterAllInterest();
1323:
1324: ok = next->finalize( options );
1325: assert( ok );
1326:
1327: if( gIOKitDebug & kIOLogYield)
1328: LOG("%s __state = %08lx:%08lx\n", next->getName(),
1329: next->__state[0], next->__state[1]);
1330: next->adjustBusy( -1 );
1331:
1332: next->release();
1333: }
1334:
1335: deathList->release();
1336: }
1337:
1338: bool IOService::finalize( IOOptionBits options )
1339: {
1340: OSIterator * iter;
1341: IOService * provider;
1342:
1343: iter = getProviderIterator();
1344: assert( iter );
1345:
1346: if( iter) {
1347: while( (provider = (IOService *) iter->getNextObject())) {
1348: stop( provider );
1349: if( provider->isOpen( this ))
1350: provider->close( this );
1351: detach( provider );
1352: provider->adjustBusy( -1 );
1353: }
1354: iter->release();
1355: }
1356:
1357: return( true );
1358: }
1359:
1360: /*
1361: * Open & close
1362: */
1363:
1364: bool IOService::open( IOService * forClient,
1365: IOOptionBits options = 0,
1366: void * arg = 0 )
1367: {
1368: bool ok;
1369:
1370: if( false == lockForArbitration(false) )
1371: return false;
1372:
1373: ok = (0 == (__state[0] & kIOServiceInactiveState));
1374: if( ok)
1375: ok = handleOpen( forClient, options, arg );
1376:
1377: unlockForArbitration();
1378:
1379: return( ok );
1380: }
1381:
1382: void IOService::close( IOService * forClient,
1383: IOOptionBits options = 0 )
1384: {
1385: bool ok;
1386: bool wasClosed;
1387: bool last = false;
1388: OSIterator * iter;
1389: IOService * client;
1390:
1391: lockForArbitration();
1392:
1393: wasClosed = handleIsOpen( forClient );
1394: if( wasClosed) {
1395: handleClose( forClient, options );
1396:
1397: last = ( (__state[1] & kIOServiceTerminatedState)
1398: && (false == handleIsOpen( 0 )) );
1399: }
1400:
1401: unlockForArbitration();
1402:
1403: if( last) {
1404: ok = (0 != _IOServiceJob::startJob( this, kTerminateNubJob, 0 ));
1405: assert( ok );
1406:
1407: } else if( wasClosed) {
1408:
1409: iter = getClientIterator();
1410: assert( iter );
1411:
1412: if( iter) {
1413: while( (client = (IOService *) iter->getNextObject())) {
1414: if( client != forClient)
1415: messageClient( kIOMessageServiceWasClosed, client, 0 );
1416: }
1417: iter->release();
1418: }
1419: }
1420: }
1421:
1422: bool IOService::isOpen( const IOService * forClient = 0 ) const
1423: {
1424: IOService * self = (IOService *) this;
1425: bool ok;
1426:
1427: self->lockForArbitration();
1428:
1429: ok = handleIsOpen( forClient );
1430:
1431: self->unlockForArbitration();
1432:
1433: return( ok );
1434: }
1435:
1436: bool IOService::handleOpen( IOService * forClient,
1437: IOOptionBits options,
1438: void * arg )
1439: {
1440: bool ok;
1441:
1442: ok = (0 == __owner);
1443: if( ok )
1444: __owner = forClient;
1445:
1446: else if( options & kIOServiceSeize ) {
1447: ok = (kIOReturnSuccess == messageClient( kIOMessageServiceIsRequestingClose,
1448: __owner, (void *) options ));
1449: if( ok && (0 == __owner ))
1450: __owner = forClient;
1451: }
1452:
1453: return( ok );
1454: }
1455:
1456: void IOService::handleClose( IOService * forClient,
1457: IOOptionBits options )
1458: {
1459: if( __owner == forClient)
1460: __owner = 0;
1461: }
1462:
1463: bool IOService::handleIsOpen( const IOService * forClient ) const
1464: {
1465: if( forClient)
1466: return( __owner == forClient );
1467: else
1468: return( __owner != forClient );
1469: }
1470:
1471: /*
1472: * Probing & starting
1473: */
1474:
1475: SInt32 IONotifyOrdering( OSObject * obj1, OSObject * obj2, void * ref)
1476: {
1477: SInt32 val1;
1478: SInt32 val2;
1479:
1480: val1 = 0;
1481: val2 = 0;
1482:
1483: if ( obj1 )
1484: val1 = ((_IOServiceNotifier *)obj1)->priority;
1485:
1486: if ( obj2 )
1487: val2 = ((_IOServiceNotifier *)obj2)->priority;
1488:
1489: return ( val1 - val2 );
1490: }
1491:
1492: static SInt32 IOServiceObjectOrder( OSObject * entry, void * ref)
1493: {
1494: OSDictionary * dict;
1495: IOService * service;
1496: _IOServiceNotifier * notify;
1497: OSSymbol * key = (OSSymbol *) ref;
1498: OSNumber * offset;
1499:
1500: if( (notify = OSDynamicCast( _IOServiceNotifier, entry)))
1501: return( notify->priority );
1502:
1503: else if( (service = OSDynamicCast( IOService, entry)))
1504: offset = OSDynamicCast(OSNumber, service->getProperty( key ));
1505: else if( (dict = OSDynamicCast( OSDictionary, entry)))
1506: offset = OSDynamicCast(OSNumber, dict->getObject( key ));
1507: else {
1508: assert( false );
1509: offset = 0;
1510: }
1511:
1512: if( offset)
1513: return( (SInt32) offset->unsigned32BitValue());
1514: else
1515: return( kIODefaultProbeScore );
1516: }
1517:
1518: SInt32 IOServiceOrdering( OSObject * obj1, OSObject * obj2, void * ref )
1519: {
1520: SInt32 val1;
1521: SInt32 val2;
1522:
1523: val1 = 0;
1524: val2 = 0;
1525:
1526: if ( obj1 )
1527: val1 = IOServiceObjectOrder( obj1, ref );
1528:
1529: if ( obj2 )
1530: val2 = IOServiceObjectOrder( obj2, ref );
1531:
1532: return ( val1 - val2 );
1533: }
1534:
1535: IOService * IOService::getClientWithCategory( const OSSymbol * category )
1536: {
1537: IOService * service = 0;
1538: OSIterator * iter;
1539: const OSSymbol * nextCat;
1540:
1541: iter = getClientIterator();
1542: if( iter) {
1543: while( (service = (IOService *) iter->getNextObject())) {
1544: if( kIOServiceInactiveState & service->__state[0])
1545: continue;
1546: nextCat = (const OSSymbol *) OSDynamicCast( OSSymbol,
1547: service->getProperty( gIOMatchCategoryKey ));
1548: if( category == nextCat)
1549: break;
1550: }
1551: iter->release();
1552: }
1553: return( service );
1554: }
1555:
1556: /*
1557: * Alloc and probe matching classes,
1558: * called on the provider instance
1559: */
1560:
1561: void IOService::probeCandidates( OSOrderedSet * matches )
1562: {
1563: OSDictionary * match;
1564: OSSymbol * symbol;
1565: IOService * inst;
1566: IOService * newInst;
1567: OSDictionary * props;
1568: SInt32 score;
1569: OSNumber * newPri;
1570: OSOrderedSet * startList;
1571: OSDictionary * startDict = 0;
1572: const OSSymbol * category;
1573: OSIterator * iter;
1574: _IOServiceNotifier * notify;
1575: OSObject * nextMatch;
1576: bool started;
1577: bool needReloc = false;
1578: bool needsCat;
1579: #ifdef DEBUG
1580: SInt64 debugFlags;
1581: #endif
1582:
1583: assert( matches );
1584: while( (nextMatch = matches->getFirstObject())) {
1585:
1586: nextMatch->retain();
1587: matches->removeObject(nextMatch);
1588:
1589: if( (notify = OSDynamicCast( _IOServiceNotifier, nextMatch ))) {
1590:
1591: lockForArbitration();
1592: LOCKREADNOTIFY();
1593: if( notify->fEnable
1594: && (0 == (__state[0] & kIOServiceInactiveState)))
1595: (*notify->handler)( notify->target, notify->ref, this );
1596: UNLOCKNOTIFY();
1597: unlockForArbitration();
1598: nextMatch->release();
1599: continue;
1600:
1601: } else if( !(match = OSDynamicCast( OSDictionary, nextMatch ))) {
1602: nextMatch->release();
1603: continue;
1604: }
1605:
1606: props = 0;
1607: inst = 0;
1608: newInst = 0;
1609: #ifdef DEBUG
1610: debugFlags = getDebugFlags( match );
1611: #endif
1612:
1613: do {
1614: category = OSDynamicCast( OSSymbol,
1615: match->getObject( gIOMatchCategoryKey ));
1616: needsCat = (0 == category);
1617: if( needsCat)
1618: category = gIODefaultMatchCategoryKey;
1619:
1620: if( getClientWithCategory( category )) {
1621: #ifdef DEBUG
1622: if( debugFlags & kIOLogMatch)
1623: LOG("%s: match category %s exists\n", getName(),
1624: category->getCStringNoCopy());
1625: #endif
1626: nextMatch->release();
1627: continue;
1628: }
1629:
1630: // create a copy now in case its modified during matching
1631: props = OSDictionary::withDictionary( match, match->getCount());
1632: nextMatch->release();
1633: if( 0 == props)
1634: continue;
1635: props->setCapacityIncrement(1);
1636:
1637: // check the nub matches
1638: if( false == passiveMatch( props, true ))
1639: continue;
1640:
1641: // Check to see if driver reloc has been loaded.
1642: needReloc = (false == gIOCatalogue->isModuleLoaded( match ));
1643: if( needReloc) {
1644: #ifdef DEBUG
1645: if( debugFlags & kIOLogCatalogue)
1646: LOG("%s: stalling for module\n", getName());
1647: #endif
1648: continue;
1649: }
1650:
1651: symbol = OSDynamicCast( OSSymbol,
1652: props->getObject( gIOClassKey));
1653: if( !symbol)
1654: continue;
1655:
1656: // alloc the driver instance
1657: inst = (IOService *) OSMetaClass::allocClassWithName( symbol);
1658:
1659: if( !inst) {
1660: IOLog("Couldn't alloc %s; class not ",
1661: symbol->getCStringNoCopy());
1662: if( OSMetaClass::getMetaClassWithName( symbol))
1663: IOLog("using default constructor\n");
1664: else
1665: IOLog("available\n");
1666: continue;
1667: }
1668:
1669: // init driver instance
1670: if( !(inst->init( props ))) {
1671: #ifdef DEBUG
1672: if( debugFlags & kIOLogStart)
1673: IOLog("%s::init fails\n", symbol->getCStringNoCopy());
1674: #endif
1675: continue;
1676: }
1677: if( __state[1] & kIOServiceSynchronousState)
1678: inst->__state[1] |= kIOServiceSynchronousState;
1679:
1680: // give the driver the default match category if not specified
1681: if( needsCat)
1682: inst->setProperty( gIOMatchCategoryKey, (OSObject *) category );
1683:
1684: // attach driver instance
1685: if( !(inst->attach( this )))
1686: continue;
1687:
1688: // pass in score from property table
1689: score = matches->orderObject( match );
1690:
1691: // & probe the new driver instance
1692: #ifdef DEBUG
1693: if( debugFlags & kIOLogProbe)
1694: LOG("%s::probe(%s)\n",
1695: inst->getMetaClass()->getClassName(), getName());
1696: #endif
1697:
1698: #if 1
1699: newInst = inst->probe( this, &score );
1700: inst->detach( this );
1701: if( 0 == newInst) {
1702: #ifdef DEBUG
1703: if( debugFlags & kIOLogProbe)
1704: IOLog("%s::probe fails\n", symbol->getCStringNoCopy());
1705: #endif
1706: continue;
1707: }
1708: #else
1709: if( 0 == (newInst = inst->probe( this, &score ))) {
1710: #ifdef DEBUG
1711: if( debugFlags & kIOLogProbe)
1712: IOLog("%s::probe fails\n", symbol->getCStringNoCopy());
1713: #endif
1714: inst->detach( this );
1715: continue;
1716: }
1717:
1718: if( newInst != inst) {
1719: // instance substitution
1720: inst->detach( this );
1721: // attach the returned instance
1722: if( !(newInst->attach( this )))
1723: continue;
1724: }
1725: #endif
1726:
1727: // save the score
1728: newPri = OSNumber::withNumber( score, 32 );
1729: if( newPri) {
1730: newInst->setProperty( gIOProbeScoreKey, newPri );
1731: newPri->release();
1732: }
1733:
1734: // add to start list for the match category
1735: if( 0 == startDict)
1736: startDict = OSDictionary::withCapacity( 1 );
1737: assert( startDict );
1738: startList = (OSOrderedSet *)
1739: startDict->getObject( category );
1740: if( 0 == startList) {
1741: startList = OSOrderedSet::withCapacity( 1,
1742: IOServiceOrdering, (void *) gIOProbeScoreKey );
1743: if( startDict && startList) {
1744: startDict->setObject( category, startList );
1745: startList->release();
1746: }
1747: }
1748: assert( startList );
1749: if( startList)
1750: startList->setObject( newInst );
1751:
1752: } while( false );
1753:
1754: if( props)
1755: props->release();
1756: if( inst)
1757: inst->release();
1758:
1759: // If reloc hasn't been loaded, exit out of function cleanly.
1760: // Re-probing will occur after reloc has been loaded.
1761: if( needReloc ) {
1762: if( startDict ) {
1763: startDict->release();
1764: startDict = 0;
1765: }
1766: break;
1767: }
1768: }
1769: matches->release();
1770:
1771: // start the best (until success) of each category
1772:
1773: iter = OSCollectionIterator::withCollection( startDict );
1774: if( iter) {
1775: while( (category = (const OSSymbol *) iter->getNextObject())) {
1776:
1777: startList = (OSOrderedSet *) startDict->getObject( category );
1778: assert( startList );
1779: if( !startList)
1780: continue;
1781:
1782: started = false;
1783: while( true // (!started)
1784: && (inst = (IOService *)startList->getFirstObject())) {
1785:
1786: inst->retain();
1787: startList->removeObject(inst);
1788:
1789: #ifdef DEBUG
1790: debugFlags = getDebugFlags( inst->getPropertyTable() );
1791:
1792: if( debugFlags & kIOLogStart) {
1793: if( started)
1794: LOG( "match category exists, skipping " );
1795: LOG( "%s::start(%s) <%d>\n", inst->getName(),
1796: getName(), inst->getRetainCount());
1797: }
1798: #endif
1799: if( false == started)
1800: started = startCandidate( inst );
1801: #ifdef DEBUG
1802: if( (debugFlags & kIOLogStart) && (false == started))
1803: LOG( "%s::start(%s) <%d> failed\n", inst->getName(), getName(),
1804: inst->getRetainCount());
1805: #endif
1806: inst->release();
1807: }
1808: }
1809: iter->release();
1810: }
1811:
1812: if( startDict)
1813: startDict->release();
1814: }
1815:
1816: /*
1817: * Start a previously attached & probed instance,
1818: * called on exporting object instance
1819: */
1820:
1821: bool IOService::startCandidate( IOService * service )
1822: {
1823: bool ok;
1824:
1825: ok = service->attach( this );
1826:
1827: if( ok) {
1828: // stall for any nub resources
1829: checkResources();
1830: // stall for any driver resources
1831: service->checkResources();
1832:
1833: ok = service->start( this );
1834: if( !ok)
1835: service->detach( this );
1836: }
1837: return( ok );
1838: }
1839:
1840: IOService * IOService::resources( void )
1841: {
1842: return( gIOResources );
1843: }
1844:
1845: void IOService::publishResource( const char * key, OSObject * value = 0 )
1846: {
1847: const OSSymbol * sym;
1848:
1849: if( (sym = OSSymbol::withCString( key))) {
1850: publishResource( sym, value);
1851: sym->release();
1852: }
1853: }
1854:
1855: void IOService::publishResource( const OSSymbol * key, OSObject * value = 0 )
1856: {
1857: if( 0 == value)
1858: value = (OSObject *) gIOServiceKey;
1859:
1860: gIOResources->setProperty( key, value);
1861:
1862: gIOResourceGenerationCount++;
1863: gIOResources->registerService();
1864: }
1865:
1866: bool IOService::addNeededResource( const char * key )
1867: {
1868: OSObject * resources;
1869: OSSet * set;
1870: OSString * newKey;
1871: bool ret;
1872:
1873: resources = getProperty( gIOResourceMatchKey );
1874:
1875: newKey = OSString::withCString( key );
1876: if( (0 == resources) || (0 == newKey))
1877: return( false);
1878:
1879: set = OSDynamicCast( OSSet, resources );
1880: if( !set) {
1881: set = OSSet::withCapacity( 1 );
1882: if( set)
1883: set->setObject( resources );
1884: }
1885: else
1886: set->retain();
1887:
1888: set->setObject( newKey );
1889: newKey->release();
1890: ret = setProperty( gIOResourceMatchKey, set );
1891: set->release();
1892:
1893: return( ret );
1894: }
1895:
1896: bool IOService::checkResource( OSObject * matching )
1897: {
1898: OSString * str;
1899: OSDictionary * table;
1900:
1901: if( (str = OSDynamicCast( OSString, matching ))) {
1902: if( gIOResources->getProperty( str ))
1903: return( true );
1904: }
1905:
1906: if( str)
1907: table = resourceMatching( str );
1908: else if( (table = OSDynamicCast( OSDictionary, matching )))
1909: table->retain();
1910: else {
1911: IOLog("%s: Can't match using: %s\n", getName(),
1912: matching->getMetaClass()->getClassName());
1913: /* false would stall forever */
1914: return( true );
1915: }
1916:
1917: if( gIOKitDebug & kIOLogConfig)
1918: LOG("config(%x): stalling %s\n", (int) IOThreadSelf(), getName());
1919:
1920: waitForService( table );
1921:
1922: if( gIOKitDebug & kIOLogConfig)
1923: LOG("config(%x): waking\n", (int) IOThreadSelf() );
1924:
1925: return( true );
1926: }
1927:
1928: bool IOService::checkResources( void )
1929: {
1930: OSObject * resources;
1931: OSSet * set;
1932: OSIterator * iter;
1933: bool ok;
1934:
1935: resources = getProperty( gIOResourceMatchKey );
1936: if( 0 == resources)
1937: return( true );
1938:
1939: if( (set = OSDynamicCast( OSSet, resources ))) {
1940:
1941: iter = OSCollectionIterator::withCollection( set );
1942: ok = (0 != iter);
1943: while( ok && (resources = iter->getNextObject()) )
1944: ok = checkResource( resources );
1945: if( iter)
1946: iter->release();
1947:
1948: } else
1949: ok = checkResource( resources );
1950:
1951: return( ok );
1952: }
1953:
1954:
1955: _IOConfigThread * _IOConfigThread::configThread( void )
1956: {
1957: _IOConfigThread * inst;
1958:
1959: do {
1960: if( !(inst = new _IOConfigThread))
1961: continue;
1962: if( !inst->init())
1963: continue;
1964: if( !(inst->thread = IOCreateThread
1965: ( (IOThreadFunc) &_IOConfigThread::main, inst )))
1966: continue;
1967:
1968: return( inst );
1969:
1970: } while( false);
1971:
1972: if( inst)
1973: inst->release();
1974:
1975: return( 0 );
1976: }
1977:
1978: void _IOConfigThread::free( void )
1979: {
1980: OSObject::free();
1981: }
1982:
1983: void IOService::doServiceMatch( void )
1984: {
1985: _IOServiceNotifier * notify;
1986: OSIterator * iter;
1987: OSOrderedSet * matches;
1988: SInt32 catalogGeneration;
1989: bool keepGuessing = true;
1990: bool reRegistered = true;
1991:
1992: // job->nub->deliverNotification( gIOPublishNotification,
1993: // kIOServiceRegisteredState, 0xffffffff );
1994:
1995: while( keepGuessing ) {
1996:
1997: matches = gIOCatalogue->findDrivers( this, &catalogGeneration );
1998: // the matches list should always be created by findDrivers()
1999: if( matches) {
2000:
2001: lockForArbitration();
2002: if( 0 == (__state[0] & kIOServiceFirstPublishState))
2003: deliverNotification( gIOFirstPublishNotification,
2004: kIOServiceFirstPublishState, 0xffffffff );
2005: LOCKREADNOTIFY();
2006: __state[1] &= ~kIOServiceConfigState;
2007: __state[0] |= kIOServiceRegisteredState;
2008:
2009: if( reRegistered && (0 == (__state[0] & kIOServiceInactiveState))) {
2010:
2011: iter = OSCollectionIterator::withCollection( (OSOrderedSet *)
2012: gNotifications->getObject( gIOPublishNotification ) );
2013: if( iter) {
2014: while((notify = (_IOServiceNotifier *)
2015: iter->getNextObject())) {
2016: if( passiveMatch( notify->matching ))
2017: matches->setObject( notify );
2018: }
2019: iter->release();
2020: }
2021: }
2022:
2023: UNLOCKNOTIFY();
2024: unlockForArbitration();
2025:
2026: if( matches->getCount() && (kIOReturnSuccess == getResources()))
2027: probeCandidates( matches );
2028: else
2029: matches->release();
2030: }
2031:
2032: lockForArbitration();
2033: reRegistered = (0 != (__state[1] & kIOServiceConfigState));
2034: keepGuessing =
2035: (reRegistered || (catalogGeneration !=
2036: gIOCatalogue->getGenerationCount()))
2037: && (0 == (__state[0] & kIOServiceInactiveState));
2038:
2039: if( keepGuessing)
2040: unlockForArbitration();
2041: }
2042:
2043: if( 0 == (__state[0] & kIOServiceInactiveState)) {
2044: deliverNotification( gIOMatchedNotification,
2045: kIOServiceMatchedState, 0xffffffff );
2046: if( 0 == (__state[0] & kIOServiceFirstMatchState))
2047: deliverNotification( gIOFirstMatchNotification,
2048: kIOServiceFirstMatchState, 0xffffffff );
2049: }
2050:
2051: unlockForArbitration();
2052:
2053: adjustBusy( -1 );
2054: }
2055:
2056: void IOService::adjustBusy( SInt32 delta )
2057: {
2058: IOService * next;
2059: UInt32 count;
2060: bool wasQuiet, nowQuiet;
2061:
2062: if( 0 == delta)
2063: return;
2064:
2065: IOTakeLock( gIOServiceBusyLock );
2066: next = this;
2067:
2068: do {
2069: count = next->__state[1] & kIOServiceBusyStateMask;
2070: assert( count < kIOServiceBusyMax);
2071: wasQuiet = (0 == count);
2072: assert( (!wasQuiet) || (delta > 0));
2073: next->__state[1] += delta;
2074: nowQuiet = (0 == (next->__state[1] & kIOServiceBusyStateMask));
2075:
2076: if( nowQuiet)
2077: thread_wakeup( (event_t) next);
2078:
2079: if( (wasQuiet || nowQuiet) ) {
2080: OSArray * array;
2081: unsigned int index;
2082: OSObject * interested;
2083:
2084: array = OSDynamicCast( OSArray, next->getProperty( gIOBusyInterest ));
2085: if( array) {
2086: LOCKREADNOTIFY();
2087: for( index = 0;
2088: (interested = array->getObject( index ));
2089: index++) {
2090: next->messageClient(kIOMessageServiceBusyStateChange,
2091: interested, (void *) wasQuiet /* busy now */);
2092: }
2093: UNLOCKNOTIFY();
2094: }
2095: }
2096:
2097: delta = nowQuiet ? -1 : +1;
2098:
2099: } while( (wasQuiet || nowQuiet) && (next = next->getProvider()));
2100:
2101: IOUnlock( gIOServiceBusyLock );
2102: }
2103:
2104: UInt32 IOService::getBusyState( void )
2105: {
2106: return( __state[1] & kIOServiceBusyStateMask );
2107: }
2108:
2109: IOReturn IOService::waitForState( UInt32 mask, UInt32 value,
2110: mach_timespec_t * timeout = 0 )
2111: {
2112: bool wait;
2113:
2114: do {
2115: IOTakeLock( gIOServiceBusyLock );
2116: wait = (value != (__state[1] & mask));
2117: if( wait)
2118: assert_wait( (event_t) this, THREAD_UNINT );
2119: IOUnlock( gIOServiceBusyLock );
2120: if( wait)
2121: thread_block((void (*)(void)) -6);
2122:
2123: } while( wait );
2124:
2125: return( kIOReturnSuccess );
2126: }
2127:
2128: IOReturn IOService::waitQuiet( mach_timespec_t * timeout = 0 )
2129: {
2130: return( waitForState( kIOServiceBusyStateMask, 0, timeout ));
2131: }
2132:
2133: bool IOService::serializeProperties( OSSerialize * s ) const
2134: {
2135: #if 0
2136: ((IOService *)this)->setProperty( ((IOService *)this)->__state,
2137: sizeof( __state), "__state");
2138: #endif
2139: return( super::serializeProperties(s) );
2140: }
2141:
2142:
2143: void _IOConfigThread::main( _IOConfigThread * self )
2144: {
2145: _IOServiceJob * job;
2146: IOService * nub;
2147: bool alive = true;
2148:
2149: do {
2150:
2151: #if 0
2152: #define randomDelay() \
2153: int del = read_processor_clock(); \
2154: del = (((int)IOThreadSelf()) ^ del ^ (del >> 10)) & 0x3ff; \
2155: IOSleep( del );
2156: randomDelay();
2157: #endif
2158:
2159: semaphore_wait( gJobsSemaphore );
2160:
2161: IOTakeLock( gJobsLock );
2162: job = (_IOServiceJob *) gJobs->getFirstObject();
2163: job->retain();
2164: gJobs->removeObject(job);
2165: if( job) {
2166: gOutstandingJobs--;
2167: #ifndef LESS_THREAD_CREATE
2168: // gNumConfigThreads--; // we're out of service
2169: gNumWaitingThreads--; // we're out of service
2170: #endif
2171: }
2172: IOUnlock( gJobsLock );
2173:
2174: if( job) {
2175:
2176: nub = job->nub;
2177:
2178: if( gIOKitDebug & kIOLogConfig)
2179: LOG("config(%x): starting on %s, %d\n",
2180: (int) IOThreadSelf(), job->nub->getName(), job->type);
2181:
2182: switch( job->type) {
2183:
2184: case kMatchNubJob:
2185: nub->doServiceMatch();
2186: break;
2187:
2188: case kTerminateNubJob:
2189: nub->doServiceTerminate( job->options );
2190: break;
2191:
2192: default:
2193: LOG("config(%x): strange type (%d)\n",
2194: (int) IOThreadSelf(), job->type );
2195: break;
2196: }
2197:
2198: nub->release();
2199: job->release();
2200:
2201: IOTakeLock( gJobsLock );
2202: #ifndef LESS_THREAD_CREATE
2203: alive = (gOutstandingJobs > gNumWaitingThreads);
2204: if( alive)
2205: gNumWaitingThreads++; // back in service
2206: // gNumConfigThreads++;
2207: else
2208: gNumConfigThreads--;
2209: #endif
2210: IOUnlock( gJobsLock );
2211: }
2212:
2213: } while( alive );
2214:
2215: if( gIOKitDebug & kIOLogConfig)
2216: LOG("config(%x): terminating\n", (int) IOThreadSelf() );
2217:
2218: self->release();
2219: }
2220:
2221: void _IOServiceJob::pingConfig( _IOServiceJob * job )
2222: {
2223: int count;
2224: bool create;
2225:
2226: assert( job );
2227:
2228: IOTakeLock( gJobsLock );
2229:
2230: gOutstandingJobs++;
2231: gJobs->setLastObject( job );
2232:
2233: count = gNumWaitingThreads;
2234: // if( gNumConfigThreads) count++;// assume we're called from a config thread
2235:
2236: create = ( (gOutstandingJobs > count)
2237: && (gNumConfigThreads < kMaxConfigThreads) );
2238: if( create) {
2239: gNumConfigThreads++;
2240: gNumWaitingThreads++;
2241: }
2242:
2243: IOUnlock( gJobsLock );
2244:
2245: job->release();
2246:
2247: if( create) {
2248: if( gIOKitDebug & kIOLogConfig)
2249: LOG("config(%d): creating\n", gNumConfigThreads - 1);
2250: _IOConfigThread::configThread();
2251: }
2252:
2253: semaphore_signal( gJobsSemaphore );
2254: }
2255:
2256:
2257: // internal - call with gNotificationLock
2258: OSObject * IOService::getExistingServices( OSDictionary * matching,
2259: IOOptionBits inState, IOOptionBits options = 0 )
2260: {
2261: OSObject * current = 0;
2262: OSIterator * iter;
2263: IOService * service;
2264:
2265: if( !matching)
2266: return( 0 );
2267:
2268: iter = IORegistryIterator::iterateOver( gIOServicePlane,
2269: kIORegistryIterateRecursively );
2270: if( iter) {
2271: do {
2272: iter->reset();
2273: while( (service = (IOService *) iter->getNextObject())) {
2274: if( (inState == (service->__state[0] & inState))
2275: && (0 == (service->__state[0] & kIOServiceInactiveState))
2276: && service->passiveMatch( matching )) {
2277:
2278: if( options & kIONotifyOnce) {
2279: current = service;
2280: break;
2281: }
2282: if( current)
2283: ((OSSet *)current)->setObject( service );
2284: else
2285: current = OSSet::withObjects(
2286: (OSObject **) &service, 1, 1 );
2287: }
2288: }
2289: } while( !service && !iter->isValid());
2290: iter->release();
2291: }
2292:
2293: if( current && (0 == (options & kIONotifyOnce))) {
2294: iter = OSCollectionIterator::withCollection( (OSSet *)current );
2295: current->release();
2296: current = iter;
2297: }
2298:
2299: return( current );
2300: }
2301:
2302: // public version
2303: OSIterator * IOService::getMatchingServices( OSDictionary * matching )
2304: {
2305: OSIterator * iter;
2306:
2307: // is a lock even needed?
2308: LOCKWRITENOTIFY();
2309:
2310: iter = (OSIterator *) getExistingServices( matching,
2311: kIOServiceRegisteredState );
2312:
2313: UNLOCKNOTIFY();
2314:
2315: return( iter );
2316: }
2317:
2318:
2319: // internal - call with gNotificationLock
2320: IONotifier * IOService::setNotification(
2321: const OSSymbol * type, OSDictionary * matching,
2322: IOServiceNotificationHandler handler, void * target, void * ref,
2323: SInt32 priority = 0 )
2324: {
2325: _IOServiceNotifier * notify = 0;
2326: OSOrderedSet * set;
2327:
2328: if( !matching)
2329: return( 0 );
2330:
2331: notify = new _IOServiceNotifier;
2332: if( notify && !notify->init()) {
2333: notify->release();
2334: notify = 0;
2335: }
2336:
2337: if( notify) {
2338: notify->matching = matching;
2339: notify->handler = handler;
2340: notify->target = target;
2341: notify->ref = ref;
2342: notify->priority = priority;
2343: notify->fEnable = true;
2344:
2345: ////// queue
2346:
2347: if( 0 == (set = (OSOrderedSet *) gNotifications->getObject( type ))) {
2348: set = OSOrderedSet::withCapacity( 1,
2349: IONotifyOrdering, 0 );
2350: if( set) {
2351: gNotifications->setObject( type, set );
2352: set->release();
2353: }
2354: }
2355: notify->whence = set;
2356: if( set)
2357: set->setObject( notify );
2358: }
2359:
2360: return( notify );
2361: }
2362:
2363: // internal - call with gNotificationLock
2364: IONotifier * IOService::doInstallNotification(
2365: const OSSymbol * type, OSDictionary * matching,
2366: IOServiceNotificationHandler handler,
2367: void * target, void * ref,
2368: SInt32 priority, OSIterator ** existing )
2369: {
2370: OSIterator * exist;
2371: IONotifier * notify;
2372: IOOptionBits inState;
2373:
2374: if( !matching)
2375: return( 0 );
2376:
2377: if( (type == gIOPublishNotification)
2378: || (type == gIOFirstPublishNotification))
2379: inState = kIOServiceRegisteredState;
2380: else if( (type == gIOMatchedNotification)
2381: || (type == gIOFirstMatchNotification))
2382: inState = kIOServiceMatchedState;
2383: else if( type == gIOTerminatedNotification)
2384: inState = 0;
2385: else
2386: return( 0 );
2387:
2388: notify = setNotification( type, matching, handler, target, ref, priority );
2389:
2390: if( inState)
2391: // get the current set
2392: exist = (OSIterator *) getExistingServices( matching, inState );
2393: else
2394: exist = 0;
2395:
2396: *existing = exist;
2397:
2398: return( notify );
2399: }
2400:
2401:
2402: IONotifier * IOService::installNotification(
2403: const OSSymbol * type, OSDictionary * matching,
2404: IOServiceNotificationHandler handler,
2405: void * target, void * ref,
2406: SInt32 priority, OSIterator ** existing )
2407: {
2408: IONotifier * notify;
2409:
2410: LOCKWRITENOTIFY();
2411:
2412: notify = doInstallNotification( type, matching, handler, target, ref,
2413: priority, existing );
2414:
2415: UNLOCKNOTIFY();
2416:
2417: return( notify );
2418: }
2419:
2420: IONotifier * IOService::addNotification(
2421: const OSSymbol * type, OSDictionary * matching,
2422: IOServiceNotificationHandler handler,
2423: void * target, void * ref = 0,
2424: SInt32 priority = 0 )
2425: {
2426: OSIterator * existing;
2427: IONotifier * notify;
2428: IOService * next;
2429:
2430: notify = installNotification( type, matching,
2431: handler, target, ref, priority, &existing );
2432:
2433: // send notifications for existing set
2434: if( existing) {
2435:
2436: while( (next = (IOService *) existing->getNextObject())) {
2437:
2438: next->lockForArbitration();
2439: LOCKWRITENOTIFY();
2440: if( 0 == (next->__state[0] & kIOServiceInactiveState))
2441: (*handler)( target, ref, next );
2442: UNLOCKNOTIFY();
2443: next->unlockForArbitration();
2444: }
2445: existing->release();
2446: }
2447:
2448: return( notify );
2449: }
2450:
2451: struct SyncNotifyVars {
2452: semaphore_port_t waitHere;
2453: IOService * result;
2454: };
2455:
2456: bool IOService::syncNotificationHandler(
2457: void * /* target */, void * ref,
2458: IOService * newService )
2459: {
2460:
2461: // result may get written more than once before the
2462: // notification is removed!
2463: ((SyncNotifyVars *) ref)->result = newService;
2464: semaphore_signal( ((SyncNotifyVars *) ref)->waitHere );
2465:
2466: return( false );
2467: }
2468:
2469: IOService * IOService::waitForService( OSDictionary * matching,
2470: mach_timespec_t * timeout = 0 )
2471: {
2472: IONotifier * notify = 0;
2473: // priority doesn't help us much since we need a thread wakeup
2474: SInt32 priority = 0;
2475: SyncNotifyVars state;
2476: kern_return_t err = kIOReturnBadArgument;
2477:
2478: if( !matching)
2479: return( 0 );
2480:
2481: state.waitHere = 0;
2482: state.result = 0;
2483:
2484: LOCKWRITENOTIFY();
2485:
2486: do {
2487:
2488: state.result = (IOService *) getExistingServices( matching,
2489: kIOServiceMatchedState, kIONotifyOnce );
2490: if( state.result)
2491: continue;
2492:
2493: err = semaphore_create( kernel_task, &state.waitHere,
2494: SYNC_POLICY_FIFO, 0 );
2495: if( KERN_SUCCESS != err)
2496: continue;
2497:
2498: notify = IOService::setNotification( gIOMatchedNotification, matching,
2499: &IOService::syncNotificationHandler, (void *) 0,
2500: (void *) &state, priority );
2501:
2502: } while( false );
2503:
2504: UNLOCKNOTIFY();
2505:
2506: if( notify) {
2507: if( timeout)
2508: err = semaphore_timedwait( state.waitHere, *timeout );
2509: else
2510: err = semaphore_wait( state.waitHere );
2511: }
2512:
2513: if( notify)
2514: notify->remove(); // dequeues
2515: if( state.waitHere)
2516: semaphore_destroy( kernel_task, state.waitHere );
2517:
2518: return( state.result );
2519: }
2520:
2521: void IOService::deliverNotification( const OSSymbol * type,
2522: IOOptionBits orNewState, IOOptionBits andNewState )
2523: {
2524: _IOServiceNotifier * notify;
2525: OSIterator * iter;
2526:
2527: lockForArbitration();
2528:
2529: if( (0 == (__state[0] & kIOServiceInactiveState))
2530: || (type == gIOTerminatedNotification)) {
2531:
2532: LOCKREADNOTIFY();
2533:
2534: iter = OSCollectionIterator::withCollection( (OSOrderedSet *)
2535: gNotifications->getObject( type ) );
2536:
2537: if( iter) {
2538: while( (notify = (_IOServiceNotifier *) iter->getNextObject())) {
2539:
2540: if( passiveMatch( notify->matching)
2541: && notify->fEnable)
2542: (*notify->handler)( notify->target, notify->ref, this );
2543: }
2544: iter->release();
2545: }
2546:
2547: __state[0] = (__state[0] | orNewState) & andNewState;
2548:
2549: UNLOCKNOTIFY();
2550: }
2551:
2552: unlockForArbitration();
2553: }
2554:
2555: IOOptionBits IOService::getState( void ) const
2556: {
2557: return( __state[0] );
2558: }
2559:
2560: /*
2561: * Helpers to make matching objects for simple cases
2562: */
2563:
2564: OSDictionary * IOService::serviceMatching( const OSString * name,
2565: OSDictionary * table = 0 )
2566: {
2567: if( !table)
2568: table = OSDictionary::withCapacity( 2 );
2569: if( table)
2570: table->setObject(gIOProviderClassKey, (OSObject *)name );
2571:
2572: return( table );
2573: }
2574:
2575: OSDictionary * IOService::serviceMatching( const char * name,
2576: OSDictionary * table = 0 )
2577: {
2578: const OSString * str;
2579:
2580: str = OSSymbol::withCString( name );
2581: if( !str)
2582: return( 0 );
2583:
2584: table = serviceMatching( str, table );
2585: str->release();
2586: return( table );
2587: }
2588:
2589: OSDictionary * IOService::nameMatching( const OSString * name,
2590: OSDictionary * table = 0 )
2591: {
2592: if( !table)
2593: table = OSDictionary::withCapacity( 2 );
2594: if( table)
2595: table->setObject( gIONameMatchKey, (OSObject *)name );
2596:
2597: return( table );
2598: }
2599:
2600: OSDictionary * IOService::nameMatching( const char * name,
2601: OSDictionary * table = 0 )
2602: {
2603: const OSString * str;
2604:
2605: str = OSSymbol::withCString( name );
2606: if( !str)
2607: return( 0 );
2608:
2609: table = nameMatching( str, table );
2610: str->release();
2611: return( table );
2612: }
2613:
2614: OSDictionary * IOService::resourceMatching( const OSString * str,
2615: OSDictionary * table = 0 )
2616: {
2617: table = serviceMatching( gIOResourcesKey, table );
2618: if( table)
2619: table->setObject( gIOResourceMatchKey, (OSObject *) str );
2620:
2621: return( table );
2622: }
2623:
2624: OSDictionary * IOService::resourceMatching( const char * name,
2625: OSDictionary * table = 0 )
2626: {
2627: const OSSymbol * str;
2628:
2629: str = OSSymbol::withCString( name );
2630: if( !str)
2631: return( 0 );
2632:
2633: table = resourceMatching( str, table );
2634: str->release();
2635:
2636: return( table );
2637: }
2638:
2639: /*
2640: * _IOServiceNotifier
2641: */
2642:
2643: void _IOServiceNotifier::remove()
2644: {
2645: LOCKWRITENOTIFY();
2646:
2647: if( whence) {
2648: whence->removeObject( (OSObject *) this );
2649: whence = 0;
2650: }
2651: if( matching) {
2652: matching->release();
2653: matching = 0;
2654: }
2655:
2656: fEnable = false;
2657:
2658: UNLOCKNOTIFY();
2659:
2660: release();
2661: }
2662:
2663: bool _IOServiceNotifier::disable()
2664: {
2665: bool ret;
2666:
2667: LOCKWRITENOTIFY();
2668: ret = fEnable;
2669: fEnable = false;
2670: UNLOCKNOTIFY();
2671:
2672: return( ret );
2673: }
2674:
2675: void _IOServiceNotifier::enable( bool was )
2676: {
2677: LOCKWRITENOTIFY();
2678: fEnable = was;
2679: UNLOCKNOTIFY();
2680: }
2681:
2682: /*
2683: * IOResources
2684: */
2685:
2686: IOService * IOResources::resources( void )
2687: {
2688: IOResources * inst;
2689:
2690: inst = new IOResources;
2691: if( inst && !inst->init()) {
2692: inst->release();
2693: inst = 0;
2694: }
2695:
2696: return( inst );
2697: }
2698:
2699: bool IOResources::matchPropertyTable( OSDictionary * table )
2700: {
2701: OSObject * prop;
2702: OSString * str;
2703: OSSet * set;
2704: OSIterator * iter;
2705: bool ok = false;
2706:
2707: prop = table->getObject( gIOResourceMatchKey );
2708: str = OSDynamicCast( OSString, prop );
2709: if( str)
2710: ok = (0 != getProperty( str ));
2711:
2712: else if( (set = OSDynamicCast( OSSet, prop))) {
2713:
2714: iter = OSCollectionIterator::withCollection( set );
2715: ok = (iter != 0);
2716: while( ok && (str = OSDynamicCast( OSString, iter->getNextObject()) ))
2717: ok = (0 != getProperty( str ));
2718:
2719: if( iter)
2720: iter->release();
2721: }
2722:
2723: return( ok );
2724: }
2725:
2726: /*
2727: * Helpers for matching dictionaries.
2728: * Keys existing in matching are checked in properties.
2729: * Keys may be a string or OSCollection of IOStrings
2730: */
2731:
2732: bool IOService::compareProperty( OSDictionary * matching,
2733: const char * key )
2734: {
2735: OSObject * value;
2736: bool ok;
2737:
2738: value = matching->getObject( key );
2739: if( value)
2740: ok = value->isEqualTo( getProperty( key ));
2741: else
2742: ok = true;
2743:
2744: return( ok );
2745: }
2746:
2747:
2748: bool IOService::compareProperty( OSDictionary * matching,
2749: const OSString * key )
2750: {
2751: OSObject * value;
2752: bool ok;
2753:
2754: value = matching->getObject( key );
2755: if( value)
2756: ok = value->isEqualTo( getProperty( key ));
2757: else
2758: ok = true;
2759:
2760: return( ok );
2761: }
2762:
2763: bool IOService::compareProperties( OSDictionary * matching,
2764: OSCollection * keys )
2765: {
2766: OSCollectionIterator * iter;
2767: const OSString * key;
2768: bool ok = true;
2769:
2770: if( !matching || !keys)
2771: return( false );
2772:
2773: iter = OSCollectionIterator::withCollection( keys );
2774:
2775: if( iter) {
2776: while( ok && (key = OSDynamicCast( OSString, iter->getNextObject())))
2777: ok = compareProperty( matching, key );
2778:
2779: iter->release();
2780: }
2781: keys->release(); // !! consume a ref !!
2782:
2783: return( ok );
2784: }
2785:
2786: /* Helper to add a location matching dict to the table */
2787:
2788: OSDictionary * IOService::addLocation( OSDictionary * table )
2789: {
2790: OSDictionary * dict;
2791:
2792: if( !table)
2793: return( 0 );
2794:
2795: dict = OSDictionary::withCapacity( 1 );
2796: if( dict) {
2797: table->setObject( gIOLocationMatchKey, dict );
2798: dict->release();
2799: }
2800:
2801: return( dict );
2802: }
2803:
2804: /*
2805: * Go looking for a provider to match a location dict.
2806: */
2807:
2808: IOService * IOService::matchLocation( IOService * /* client */ )
2809: {
2810: IOService * parent;
2811:
2812: parent = getProvider();
2813:
2814: if( parent)
2815: parent = parent->matchLocation( this );
2816:
2817: return( parent );
2818: }
2819:
2820: bool IOService::passiveMatch( OSDictionary * table, bool changesOK )
2821: {
2822: IOService * where;
2823: OSString * matched;
2824: OSObject * nameMatch;
2825: OSString * str1;
2826: OSString * str2;
2827: IORegistryEntry * entry;
2828: bool match = true;
2829:
2830: assert( table );
2831:
2832: where = this;
2833:
2834: do {
2835: entry = 0;
2836: str1 = OSDynamicCast( OSString, table->getObject( gIOProviderClassKey));
2837: if( str1 && !(match = (0 != where->metaCast( str1 ))))
2838: break;
2839:
2840: nameMatch = table->getObject( gIONameMatchKey );
2841: if( nameMatch && !(match = compareNames( nameMatch,
2842: changesOK ? &matched : 0 )))
2843: break;
2844: if( changesOK && nameMatch && matched) {
2845: // leave a hint as to which name matched
2846: table->setObject( gIONameMatchedKey, matched );
2847: matched->release();
2848: }
2849:
2850: str2 = OSDynamicCast( OSString, table->getObject( gIOPathMatchKey ));
2851: if( str2) {
2852: entry = IORegistryEntry::fromPath( str2->getCStringNoCopy() );
2853: match = (where == entry);
2854: if( entry)
2855: entry->release();
2856: if( !match)
2857: break;
2858: }
2859:
2860: if( (str1 || str2 || nameMatch) && (1 == table->getCount()))
2861: // only do the imports/path check - don't call family.
2862: break;
2863:
2864: // do family specific matching
2865: match = where->matchPropertyTable( table );
2866:
2867: if( !match) {
2868: #ifdef DEBUG
2869: if( kIOLogMatch & getDebugFlags( table ))
2870: LOG("%s: family specific matching fails\n", where->getName());
2871: #endif
2872: break;
2873: }
2874:
2875: if( !(match = where->compareProperty( table, kIOBSDName )))
2876: break;
2877:
2878: table = OSDynamicCast( OSDictionary,
2879: table->getObject( gIOLocationMatchKey ));
2880: if( table) {
2881: match = false;
2882: where = where->getProvider();
2883: if( where)
2884: where = where->matchLocation( where );
2885: }
2886:
2887: } while( table && where );
2888:
2889: if( kIOLogMatch & gIOKitDebug)
2890: if( where != this)
2891: LOG("match location @ %s = %d\n",
2892: where->getName(), match );
2893:
2894: return( match );
2895: }
2896:
2897:
2898: IOReturn IOService::newUserClient( task_t /* owningTask */,
2899: void * /* security_id */,
2900: UInt32 /* type */,
2901: IOUserClient ** /* handler */ )
2902: {
2903: return( kIOReturnUnsupported);
2904: }
2905:
2906: IOReturn IOService::requestProbe( IOOptionBits options )
2907: {
2908: return( kIOReturnUnsupported);
2909: }
2910:
2911: /*
2912: * Convert an IOReturn to text. Subclasses which add additional
2913: * IOReturn's should override this method and call
2914: * [super stringFromReturn] if the desired value is not found.
2915: */
2916:
2917: const char * IOService::stringFromReturn( IOReturn rtn )
2918: {
2919: static const IONamedValue IOReturn_values[] = {
2920: {kIOReturnSuccess, "success" },
2921: {kIOReturnError, "general error" },
2922: {kIOReturnNoMemory, "memory allocation error" },
2923: {kIOReturnNoResources, "resource shortage" },
2924: {kIOReturnIPCError, "Mach IPC failure" },
2925: {kIOReturnNoDevice, "no such device" },
2926: {kIOReturnNotPrivileged, "privilege violation" },
2927: {kIOReturnBadArgument, "invalid argument" },
2928: {kIOReturnLockedRead, "device is read locked" },
2929: {kIOReturnLockedWrite, "device is write locked" },
2930: {kIOReturnExclusiveAccess, "device is exclusive access" },
2931: {kIOReturnBadMessageID, "bad IPC message ID" },
2932: {kIOReturnUnsupported, "unsupported function" },
2933: {kIOReturnVMError, "virtual memory error" },
2934: {kIOReturnInternalError, "internal driver error" },
2935: {kIOReturnIOError, "I/O error" },
2936: {kIOReturnCannotLock, "cannot acquire lock" },
2937: {kIOReturnNotOpen, "device is not open" },
2938: {kIOReturnNotReadable, "device is not readable" },
2939: {kIOReturnNotWritable, "device is not writeable" },
2940: {kIOReturnNotAligned, "alignment error" },
2941: {kIOReturnBadMedia, "media error" },
2942: {kIOReturnStillOpen, "device is still open" },
2943: {kIOReturnRLDError, "rld failure" },
2944: {kIOReturnDMAError, "DMA failure" },
2945: {kIOReturnBusy, "device is busy" },
2946: {kIOReturnTimeout, "I/O timeout" },
2947: {kIOReturnOffline, "device is offline" },
2948: {kIOReturnNotReady, "device is not ready" },
2949: {kIOReturnNotAttached, "device/channel is not attached" },
2950: {kIOReturnNoChannels, "no DMA channels available" },
2951: {kIOReturnNoSpace, "no space for data" },
2952: {kIOReturnPortExists, "device port already exists" },
2953: {kIOReturnCannotWire, "cannot wire physical memory" },
2954: {kIOReturnNoInterrupt, "no interrupt attached" },
2955: {kIOReturnNoFrames, "no DMA frames enqueued" },
2956: {kIOReturnMessageTooLarge, "message is too large" },
2957: {kIOReturnNotPermitted, "operation is not permitted" },
2958: {kIOReturnNoPower, "device is without power" },
2959: {kIOReturnNoMedia, "media is not present" },
2960: {kIOReturnUnformattedMedia, "media is not formatted" },
2961: {kIOReturnUnsupportedMode, "unsupported mode" },
2962: {kIOReturnUnderrun, "data underrun" },
2963: {kIOReturnOverrun, "data overrun" },
2964: {kIOReturnDeviceError, "device error" },
2965: {kIOReturnNoCompletion, "no completion routine" },
2966: {kIOReturnAborted, "operation was aborted" },
2967: {kIOReturnNoBandwidth, "bus bandwidth would be exceeded" },
2968: {kIOReturnNotResponding, "device is not responding" },
2969: {kIOReturnInvalid, "unanticipated driver error" },
2970: {0, NULL }
2971: };
2972:
2973: return IOFindNameForValue(rtn, IOReturn_values);
2974: }
2975:
2976: /*
2977: * Convert an IOReturn to an errno.
2978: */
2979: int IOService::errnoFromReturn( IOReturn rtn )
2980: {
2981: switch(rtn) {
2982: // (obvious match)
2983: case kIOReturnSuccess:
2984: return(0);
2985: case kIOReturnNoMemory:
2986: return(ENOMEM);
2987: case kIOReturnNoDevice:
2988: return(ENXIO);
2989: case kIOReturnVMError:
2990: return(EFAULT);
2991: case kIOReturnNotPermitted:
2992: return(EPERM);
2993: case kIOReturnNotPrivileged:
2994: return(EACCES);
2995: case kIOReturnIOError:
2996: return(EIO);
2997: case kIOReturnNotWritable:
2998: return(EROFS);
2999: case kIOReturnBadArgument:
3000: return(EINVAL);
3001: case kIOReturnUnsupported:
3002: return(EOPNOTSUPP);
3003: case kIOReturnBusy:
3004: return(EBUSY);
3005: case kIOReturnNoPower:
3006: return(EPWROFF);
3007: case kIOReturnDeviceError:
3008: return(EDEVERR);
3009: case kIOReturnTimeout:
3010: return(ETIMEDOUT);
3011: case kIOReturnMessageTooLarge:
3012: return(EMSGSIZE);
3013: case kIOReturnNoSpace:
3014: return(ENOSPC);
3015: case kIOReturnCannotLock:
3016: return(ENOLCK);
3017:
3018: // (best match)
3019: case kIOReturnBadMessageID:
3020: case kIOReturnNoCompletion:
3021: case kIOReturnNotAligned:
3022: return(EINVAL);
3023: case kIOReturnNotReady:
3024: return(EBUSY);
3025: case kIOReturnRLDError:
3026: return(EBADMACHO);
3027: case kIOReturnPortExists:
3028: case kIOReturnStillOpen:
3029: return(EEXIST);
3030: case kIOReturnExclusiveAccess:
3031: case kIOReturnLockedRead:
3032: case kIOReturnLockedWrite:
3033: case kIOReturnNotAttached:
3034: case kIOReturnNotOpen:
3035: case kIOReturnNotReadable:
3036: return(EACCES);
3037: case kIOReturnCannotWire:
3038: case kIOReturnNoResources:
3039: return(ENOMEM);
3040: case kIOReturnAborted:
3041: case kIOReturnOffline:
3042: case kIOReturnNotResponding:
3043: return(EBUSY);
3044: case kIOReturnBadMedia:
3045: case kIOReturnNoMedia:
3046: case kIOReturnUnformattedMedia:
3047: return(EIO); // (media error)
3048: case kIOReturnDMAError:
3049: case kIOReturnOverrun:
3050: case kIOReturnUnderrun:
3051: return(EIO); // (transfer error)
3052: case kIOReturnNoBandwidth:
3053: case kIOReturnNoChannels:
3054: case kIOReturnNoFrames:
3055: case kIOReturnNoInterrupt:
3056: return(EIO); // (hardware error)
3057: case kIOReturnError:
3058: case kIOReturnInternalError:
3059: case kIOReturnInvalid:
3060: return(EIO); // (generic error)
3061: case kIOReturnIPCError:
3062: return(EIO); // (ipc error)
3063: default:
3064: return(EIO); // (all other errors)
3065: }
3066: }
3067:
3068: IOReturn IOService::message( UInt32 type, IOService * provider,
3069: void * argument )
3070: {
3071: /*
3072: * Generic entry point for upstream object calls. A return value of
3073: * kIOReturnSuccess indicates the message was successful.
3074: */
3075:
3076: return kIOReturnUnsupported;
3077: }
3078:
3079: /*
3080: * Device memory
3081: */
3082:
3083: IOItemCount IOService::getDeviceMemoryCount( void )
3084: {
3085: OSArray * array;
3086: IOItemCount count;
3087:
3088: array = OSDynamicCast( OSArray, getProperty( gIODeviceMemoryKey));
3089: if( array)
3090: count = array->getCount();
3091: else
3092: count = 0;
3093:
3094: return( count);
3095: }
3096:
3097: IODeviceMemory * IOService::getDeviceMemoryWithIndex( unsigned int index )
3098: {
3099: OSArray * array;
3100: IODeviceMemory * range;
3101:
3102: array = OSDynamicCast( OSArray, getProperty( gIODeviceMemoryKey));
3103: if( array)
3104: range = (IODeviceMemory *) array->getObject( index );
3105: else
3106: range = 0;
3107:
3108: return( range);
3109: }
3110:
3111: IOMemoryMap * IOService::mapDeviceMemoryWithIndex( unsigned int index,
3112: IOOptionBits options = 0 )
3113: {
3114: IODeviceMemory * range;
3115: IOMemoryMap * map;
3116:
3117: range = getDeviceMemoryWithIndex( index );
3118: if( range)
3119: map = range->map( options );
3120: else
3121: map = 0;
3122:
3123: return( map );
3124: }
3125:
3126: OSArray * IOService::getDeviceMemory( void )
3127: {
3128: return( OSDynamicCast( OSArray, getProperty( gIODeviceMemoryKey)));
3129: }
3130:
3131:
3132: void IOService::setDeviceMemory( OSArray * array )
3133: {
3134: setProperty( gIODeviceMemoryKey, array);
3135: }
3136:
3137: /*
3138: * Device interrupts
3139: */
3140:
3141: IOReturn IOService::resolveInterrupt(IOService *nub, int source)
3142: {
3143: IOInterruptController *interruptController;
3144: OSDictionary *propTable;
3145: OSArray *array;
3146: OSData *data;
3147: OSSymbol *interruptControllerName;
3148: long numSources;
3149: IOInterruptSource *interruptSources;
3150:
3151: // Get the property table from the nub.
3152: propTable = nub->getPropertyTable();
3153: if (propTable == 0) return kIOReturnNoResources;
3154:
3155: // Get the parents list from the property table.
3156: array = OSDynamicCast(OSArray,
3157: propTable->getObject(gIOInterruptControllersKey));
3158: if (array == 0) return kIOReturnNoResources;
3159:
3160: // Allocate space for the IOInterruptSources if needed... then return early.
3161: if (nub->_interruptSources == 0) {
3162: numSources = array->getCount();
3163: interruptSources = (IOInterruptSource *)IOMalloc(numSources * sizeof(IOInterruptSource));
3164: if (interruptSources == 0) return kIOReturnNoMemory;
3165:
3166: bzero(interruptSources, numSources * sizeof(IOInterruptSource));
3167:
3168: nub->_numInterruptSources = numSources;
3169: nub->_interruptSources = interruptSources;
3170: return kIOReturnSuccess;
3171: }
3172:
3173: interruptControllerName = OSDynamicCast(OSSymbol,array->getObject(source));
3174: if (interruptControllerName == 0) return kIOReturnNoResources;
3175:
3176: interruptController = getPlatform()->lookUpInterruptController(interruptControllerName);
3177: if (interruptController == 0) return kIOReturnNoResources;
3178:
3179: // Get the interrupt numbers from the property table.
3180: array = OSDynamicCast(OSArray,
3181: propTable->getObject(gIOInterruptSpecifiersKey));
3182: if (array == 0) return kIOReturnNoResources;
3183: data = OSDynamicCast(OSData, array->getObject(source));
3184: if (data == 0) return kIOReturnNoResources;
3185:
3186: // Set the interruptController and interruptSource in the nub's table.
3187: interruptSources = nub->_interruptSources;
3188: interruptSources[source].interruptController = interruptController;
3189: interruptSources[source].vectorData = data;
3190:
3191: return kIOReturnSuccess;
3192: }
3193:
3194: IOReturn IOService::lookupInterrupt(int source, bool resolve, IOInterruptController **interruptController)
3195: {
3196: IOReturn ret;
3197:
3198: /* Make sure the _interruptSources are set */
3199: if (_interruptSources == 0) {
3200: ret = resolveInterrupt(this, source);
3201: if (ret != kIOReturnSuccess) return ret;
3202: }
3203:
3204: /* Make sure the local source number is valid */
3205: if ((source < 0) || (source >= _numInterruptSources))
3206: return kIOReturnNoInterrupt;
3207:
3208: /* Look up the contoller for the local source */
3209: *interruptController = _interruptSources[source].interruptController;
3210:
3211: if (*interruptController == NULL) {
3212: if (!resolve) return kIOReturnNoInterrupt;
3213:
3214: /* Try to reslove the interrupt */
3215: ret = resolveInterrupt(this, source);
3216: if (ret != kIOReturnSuccess) return ret;
3217:
3218: *interruptController = _interruptSources[source].interruptController;
3219: }
3220:
3221: return kIOReturnSuccess;
3222: }
3223:
3224: IOReturn IOService::registerInterrupt(int source, OSObject *target,
3225: IOInterruptAction handler,
3226: void *refCon)
3227: {
3228: IOInterruptController *interruptController;
3229: IOReturn ret;
3230:
3231: ret = lookupInterrupt(source, true, &interruptController);
3232: if (ret != kIOReturnSuccess) return ret;
3233:
3234: /* Register the source */
3235: return interruptController->registerInterrupt(this, source, target,
3236: (IOInterruptHandler)handler,
3237: refCon);
3238: }
3239:
3240: IOReturn IOService::unregisterInterrupt(int source)
3241: {
3242: IOInterruptController *interruptController;
3243: IOReturn ret;
3244:
3245: ret = lookupInterrupt(source, false, &interruptController);
3246: if (ret != kIOReturnSuccess) return ret;
3247:
3248: /* Unregister the source */
3249: return interruptController->unregisterInterrupt(this, source);
3250: }
3251:
3252: IOReturn IOService::getInterruptType(int source, int *interruptType)
3253: {
3254: IOInterruptController *interruptController;
3255: IOReturn ret;
3256:
3257: ret = lookupInterrupt(source, true, &interruptController);
3258: if (ret != kIOReturnSuccess) return ret;
3259:
3260: /* Return the type */
3261: return interruptController->getInterruptType(this, source, interruptType);
3262: }
3263:
3264: IOReturn IOService::enableInterrupt(int source)
3265: {
3266: IOInterruptController *interruptController;
3267: IOReturn ret;
3268:
3269: ret = lookupInterrupt(source, false, &interruptController);
3270: if (ret != kIOReturnSuccess) return ret;
3271:
3272: /* Enable the source */
3273: return interruptController->enableInterrupt(this, source);
3274: }
3275:
3276: IOReturn IOService::disableInterrupt(int source)
3277: {
3278: IOInterruptController *interruptController;
3279: IOReturn ret;
3280:
3281: ret = lookupInterrupt(source, false, &interruptController);
3282: if (ret != kIOReturnSuccess) return ret;
3283:
3284: /* Disable the source */
3285: return interruptController->disableInterrupt(this, source);
3286: }
3287:
3288: IOReturn IOService::causeInterrupt(int source)
3289: {
3290: IOInterruptController *interruptController;
3291: IOReturn ret;
3292:
3293: ret = lookupInterrupt(source, false, &interruptController);
3294: if (ret != kIOReturnSuccess) return ret;
3295:
3296: /* Cause an interrupt for the source */
3297: return interruptController->causeInterrupt(this, source);
3298: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.