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


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