#include <IOKit/system.h>
#include <IOKit/IOService.h>
#include <libkern/c++/OSContainers.h>
#include <libkern/c++/OSUnserialize.h>
#include <IOKit/IOCatalogue.h>
#include <IOKit/IOCommand.h>
#include <IOKit/IODeviceMemory.h>
#include <IOKit/IOInterrupts.h>
#include <IOKit/IOInterruptController.h>
#include <IOKit/IOPlatformExpert.h>
#include <IOKit/IOMessage.h>
#include <IOKit/IOLib.h>
#include <IOKit/IOKitKeysPrivate.h>
#include <IOKit/IOBSD.h>
#include <IOKit/IOUserClient.h>
#include <IOKit/IOWorkLoop.h>
#include <mach/sync_policy.h>
#include <IOKit/assert.h>
#include <sys/errno.h>
#define LOG IOLog
#include "IOServicePrivate.h"
#define super IORegistryEntry
OSDefineMetaClassAndStructors(IOService, IORegistryEntry)
OSDefineMetaClassAndStructors(_IOServiceNotifier, IONotifier)
OSDefineMetaClassAndStructors(_IOServiceInterestNotifier, IONotifier)
OSDefineMetaClassAndStructors(_IOConfigThread, OSObject)
OSDefineMetaClassAndStructors(_IOServiceJob, OSObject)
OSDefineMetaClassAndStructors(IOResources, IOService)
OSDefineMetaClassAndStructors(_IOOpenServiceIterator, OSIterator)
OSDefineMetaClassAndAbstractStructors(IONotifier, OSObject)
static IOPlatformExpert * gIOPlatform;
static class IOPMrootDomain * gIOPMRootDomain;
const IORegistryPlane * gIOServicePlane;
const IORegistryPlane * gIOPowerPlane;
const OSSymbol * gIODeviceMemoryKey;
const OSSymbol * gIOInterruptControllersKey;
const OSSymbol * gIOInterruptSpecifiersKey;
const OSSymbol * gIOResourcesKey;
const OSSymbol * gIOResourceMatchKey;
const OSSymbol * gIOProviderClassKey;
const OSSymbol * gIONameMatchKey;
const OSSymbol * gIONameMatchedKey;
const OSSymbol * gIOPropertyMatchKey;
const OSSymbol * gIOLocationMatchKey;
const OSSymbol * gIOParentMatchKey;
const OSSymbol * gIOPathMatchKey;
const OSSymbol * gIOMatchCategoryKey;
const OSSymbol * gIODefaultMatchCategoryKey;
const OSSymbol * gIOMatchedServiceCountKey;
const OSSymbol * gIOUserClientClassKey;
const OSSymbol * gIOKitDebugKey;
const OSSymbol * gIOCommandPoolSizeKey;
const OSSymbol * gIOConsoleUsersKey;
const OSSymbol * gIOConsoleSessionUIDKey;
const OSSymbol * gIOConsoleUsersSeedKey;
const OSSymbol * gIOConsoleSessionOnConsoleKey;
const OSSymbol * gIOConsoleSessionSecureInputPIDKey;
static int gIOResourceGenerationCount;
const OSSymbol * gIOServiceKey;
const OSSymbol * gIOPublishNotification;
const OSSymbol * gIOFirstPublishNotification;
const OSSymbol * gIOMatchedNotification;
const OSSymbol * gIOFirstMatchNotification;
const OSSymbol * gIOTerminatedNotification;
const OSSymbol * gIOGeneralInterest;
const OSSymbol * gIOBusyInterest;
const OSSymbol * gIOAppPowerStateInterest;
const OSSymbol * gIOPriorityPowerStateInterest;
static OSDictionary * gNotifications;
static IORecursiveLock * gNotificationLock;
static IOService * gIOResources;
static IOService * gIOServiceRoot;
static OSOrderedSet * gJobs;
static semaphore_port_t gJobsSemaphore;
static IOLock * gJobsLock;
static int gOutstandingJobs;
static int gNumConfigThreads;
static int gNumWaitingThreads;
static IOLock * gIOServiceBusyLock;
static thread_t gIOTerminateThread;
static UInt32 gIOTerminateWork;
static OSArray * gIOTerminatePhase2List;
static OSArray * gIOStopList;
static OSArray * gIOStopProviderList;
static OSArray * gIOFinalizeList;
static SInt32 gIOConsoleUsersSeed;
static OSData * gIOConsoleUsersSeedValue;
extern const OSSymbol * gIODTPHandleKey;
const OSSymbol * gIOPlatformSleepActionKey;
const OSSymbol * gIOPlatformWakeActionKey;
const OSSymbol * gIOPlatformQuiesceActionKey;
const OSSymbol * gIOPlatformActiveActionKey;
const OSSymbol * gIOPlatformFunctionHandlerSet;
#define LOCKREADNOTIFY() \
IORecursiveLockLock( gNotificationLock )
#define LOCKWRITENOTIFY() \
IORecursiveLockLock( gNotificationLock )
#define LOCKWRITE2READNOTIFY()
#define UNLOCKNOTIFY() \
IORecursiveLockUnlock( gNotificationLock )
#define SLEEPNOTIFY(event) \
IORecursiveLockSleep( gNotificationLock, (void *)(event), THREAD_UNINT )
#define WAKEUPNOTIFY(event) \
IORecursiveLockWakeup( gNotificationLock, (void *)(event), false )
#define randomDelay() \
int del = read_processor_clock(); \
del = (((int)IOThreadSelf()) ^ del ^ (del >> 10)) & 0x3ff; \
IOSleep( del );
#define queue_element(entry, element, type, field) do { \
vm_address_t __ele = (vm_address_t) (entry); \
__ele -= -4 + ((size_t)(&((type) 4)->field)); \
(element) = (type) __ele; \
} while(0)
#define iterqueue(que, elt) \
for (queue_entry_t elt = queue_first(que); \
!queue_end(que, elt); \
elt = queue_next(elt))
struct ArbitrationLockQueueElement {
queue_chain_t link;
IOThread thread;
IOService * service;
unsigned count;
bool required;
bool aborted;
};
static queue_head_t gArbitrationLockQueueActive;
static queue_head_t gArbitrationLockQueueWaiting;
static queue_head_t gArbitrationLockQueueFree;
static IOLock * gArbitrationLockQueueLock;
bool IOService::isInactive( void ) const
{ return( 0 != (kIOServiceInactiveState & getState())); }
#if defined(__i386__)
struct CpuDelayEntry
{
IOService * fService;
UInt32 fMaxDelay;
UInt32 fDelayType;
};
enum {
kCpuDelayBusStall, kCpuDelayInterrupt,
kCpuNumDelayTypes
};
static OSData *sCpuDelayData = OSData::withCapacity(8 * sizeof(CpuDelayEntry));
static IORecursiveLock *sCpuDelayLock = IORecursiveLockAlloc();
static OSArray *sCpuLatencyHandlers[kCpuNumDelayTypes];
const OSSymbol *sCPULatencyFunctionName[kCpuNumDelayTypes];
static void
requireMaxCpuDelay(IOService * service, UInt32 ns, UInt32 delayType);
static IOReturn
setLatencyHandler(UInt32 delayType, IOService * target, bool enable);
#endif
void IOService::initialize( void )
{
kern_return_t err;
gIOServicePlane = IORegistryEntry::makePlane( kIOServicePlane );
gIOPowerPlane = IORegistryEntry::makePlane( kIOPowerPlane );
gIOProviderClassKey = OSSymbol::withCStringNoCopy( kIOProviderClassKey );
gIONameMatchKey = OSSymbol::withCStringNoCopy( kIONameMatchKey );
gIONameMatchedKey = OSSymbol::withCStringNoCopy( kIONameMatchedKey );
gIOPropertyMatchKey = OSSymbol::withCStringNoCopy( kIOPropertyMatchKey );
gIOPathMatchKey = OSSymbol::withCStringNoCopy( kIOPathMatchKey );
gIOLocationMatchKey = OSSymbol::withCStringNoCopy( kIOLocationMatchKey );
gIOParentMatchKey = OSSymbol::withCStringNoCopy( kIOParentMatchKey );
gIOMatchCategoryKey = OSSymbol::withCStringNoCopy( kIOMatchCategoryKey );
gIODefaultMatchCategoryKey = OSSymbol::withCStringNoCopy(
kIODefaultMatchCategoryKey );
gIOMatchedServiceCountKey = OSSymbol::withCStringNoCopy(
kIOMatchedServiceCountKey );
gIOUserClientClassKey = OSSymbol::withCStringNoCopy( kIOUserClientClassKey );
gIOResourcesKey = OSSymbol::withCStringNoCopy( kIOResourcesClass );
gIOResourceMatchKey = OSSymbol::withCStringNoCopy( kIOResourceMatchKey );
gIODeviceMemoryKey = OSSymbol::withCStringNoCopy( "IODeviceMemory" );
gIOInterruptControllersKey
= OSSymbol::withCStringNoCopy("IOInterruptControllers");
gIOInterruptSpecifiersKey
= OSSymbol::withCStringNoCopy("IOInterruptSpecifiers");
gIOKitDebugKey = OSSymbol::withCStringNoCopy( kIOKitDebugKey );
gIOCommandPoolSizeKey = OSSymbol::withCStringNoCopy( kIOCommandPoolSizeKey );
gIOGeneralInterest = OSSymbol::withCStringNoCopy( kIOGeneralInterest );
gIOBusyInterest = OSSymbol::withCStringNoCopy( kIOBusyInterest );
gIOAppPowerStateInterest = OSSymbol::withCStringNoCopy( kIOAppPowerStateInterest );
gIOPriorityPowerStateInterest = OSSymbol::withCStringNoCopy( kIOPriorityPowerStateInterest );
gNotifications = OSDictionary::withCapacity( 1 );
gIOPublishNotification = OSSymbol::withCStringNoCopy(
kIOPublishNotification );
gIOFirstPublishNotification = OSSymbol::withCStringNoCopy(
kIOFirstPublishNotification );
gIOMatchedNotification = OSSymbol::withCStringNoCopy(
kIOMatchedNotification );
gIOFirstMatchNotification = OSSymbol::withCStringNoCopy(
kIOFirstMatchNotification );
gIOTerminatedNotification = OSSymbol::withCStringNoCopy(
kIOTerminatedNotification );
gIOServiceKey = OSSymbol::withCStringNoCopy( kIOServiceClass);
gIOConsoleUsersKey = OSSymbol::withCStringNoCopy( kIOConsoleUsersKey);
gIOConsoleSessionUIDKey = OSSymbol::withCStringNoCopy( kIOConsoleSessionUIDKey);
gIOConsoleUsersSeedKey = OSSymbol::withCStringNoCopy( kIOConsoleUsersSeedKey);
gIOConsoleSessionOnConsoleKey = OSSymbol::withCStringNoCopy( kIOConsoleSessionOnConsoleKey);
gIOConsoleSessionSecureInputPIDKey = OSSymbol::withCStringNoCopy( kIOConsoleSessionSecureInputPIDKey);
gIOConsoleUsersSeedValue = OSData::withBytesNoCopy(&gIOConsoleUsersSeed, sizeof(gIOConsoleUsersSeed));
gIOPlatformSleepActionKey = OSSymbol::withCStringNoCopy(kIOPlatformSleepActionKey);
gIOPlatformWakeActionKey = OSSymbol::withCStringNoCopy(kIOPlatformWakeActionKey);
gIOPlatformQuiesceActionKey = OSSymbol::withCStringNoCopy(kIOPlatformQuiesceActionKey);
gIOPlatformActiveActionKey = OSSymbol::withCStringNoCopy(kIOPlatformActiveActionKey);
gIOPlatformFunctionHandlerSet = OSSymbol::withCStringNoCopy(kIOPlatformFunctionHandlerSet);
#if defined(__i386__)
sCPULatencyFunctionName[kCpuDelayBusStall] = OSSymbol::withCStringNoCopy(kIOPlatformFunctionHandlerMaxBusDelay);
sCPULatencyFunctionName[kCpuDelayInterrupt] = OSSymbol::withCStringNoCopy(kIOPlatformFunctionHandlerMaxInterruptDelay);
#endif
gNotificationLock = IORecursiveLockAlloc();
assert( gIOServicePlane && gIODeviceMemoryKey
&& gIOInterruptControllersKey && gIOInterruptSpecifiersKey
&& gIOResourcesKey && gNotifications && gNotificationLock
&& gIOProviderClassKey && gIONameMatchKey && gIONameMatchedKey
&& gIOMatchCategoryKey && gIODefaultMatchCategoryKey
&& gIOPublishNotification && gIOMatchedNotification
&& gIOTerminatedNotification && gIOServiceKey
&& gIOConsoleUsersKey && gIOConsoleSessionUIDKey
&& gIOConsoleSessionOnConsoleKey && gIOConsoleSessionSecureInputPIDKey
&& gIOConsoleUsersSeedKey && gIOConsoleUsersSeedValue);
gJobsLock = IOLockAlloc();
gJobs = OSOrderedSet::withCapacity( 10 );
gIOServiceBusyLock = IOLockAlloc();
err = semaphore_create(kernel_task, &gJobsSemaphore, SYNC_POLICY_FIFO, 0);
assert( gIOServiceBusyLock && gJobs && gJobsLock && (err == KERN_SUCCESS) );
gIOResources = IOResources::resources();
assert( gIOResources );
gArbitrationLockQueueLock = IOLockAlloc();
queue_init(&gArbitrationLockQueueActive);
queue_init(&gArbitrationLockQueueWaiting);
queue_init(&gArbitrationLockQueueFree);
assert( gArbitrationLockQueueLock );
gIOTerminatePhase2List = OSArray::withCapacity( 2 );
gIOStopList = OSArray::withCapacity( 16 );
gIOStopProviderList = OSArray::withCapacity( 16 );
gIOFinalizeList = OSArray::withCapacity( 16 );
assert( gIOTerminatePhase2List && gIOStopList && gIOStopProviderList && gIOFinalizeList );
}
#if IOMATCHDEBUG
static UInt64 getDebugFlags( OSDictionary * props )
{
OSNumber * debugProp;
UInt64 debugFlags;
debugProp = OSDynamicCast( OSNumber,
props->getObject( gIOKitDebugKey ));
if( debugProp)
debugFlags = debugProp->unsigned64BitValue();
else
debugFlags = gIOKitDebug;
return( debugFlags );
}
#endif
IOService * IOService::probe( IOService * provider,
SInt32 * score )
{
return( this );
}
bool IOService::start( IOService * provider )
{
return( true );
}
void IOService::stop( IOService * provider )
{
}
void IOService::free( void )
{
requireMaxBusStall(0);
if( getPropertyTable())
unregisterAllInterest();
PMfree();
super::free();
}
bool IOService::attach( IOService * provider )
{
bool ok;
if( provider) {
if( gIOKitDebug & kIOLogAttach)
LOG( "%s::attach(%s)\n", getName(),
provider->getName());
provider->lockForArbitration();
if( provider->__state[0] & kIOServiceInactiveState)
ok = false;
else
ok = attachToParent( provider, gIOServicePlane);
provider->unlockForArbitration();
} else {
gIOServiceRoot = this;
ok = attachToParent( getRegistryRoot(), gIOServicePlane);
}
return( ok );
}
IOService * IOService::getServiceRoot( void )
{
return( gIOServiceRoot );
}
void IOService::detach( IOService * provider )
{
IOService * newProvider = 0;
SInt32 busy;
bool adjParent;
if( gIOKitDebug & kIOLogAttach)
LOG("%s::detach(%s)\n", getName(), provider->getName());
lockForArbitration();
adjParent = ((busy = (__state[1] & kIOServiceBusyStateMask))
&& (provider == getProvider()));
detachFromParent( provider, gIOServicePlane );
if( busy) {
newProvider = getProvider();
if( busy && (__state[1] & kIOServiceTermPhase3State) && (0 == newProvider))
_adjustBusy( -busy );
}
unlockForArbitration();
if( newProvider) {
newProvider->lockForArbitration();
newProvider->_adjustBusy(1);
newProvider->unlockForArbitration();
}
if( provider->lockForArbitration( true )) {
if( adjParent)
provider->_adjustBusy( -1 );
if( (provider->__state[1] & kIOServiceTermPhase3State)
&& (0 == provider->getClient())) {
provider->scheduleFinalize();
}
provider->unlockForArbitration();
}
}
void IOService::registerService( IOOptionBits options )
{
char * pathBuf;
const char * path;
char * skip;
int len;
enum { kMaxPathLen = 256 };
enum { kMaxChars = 63 };
IORegistryEntry * parent = this;
IORegistryEntry * root = getRegistryRoot();
while( parent && (parent != root))
parent = parent->getParentEntry( gIOServicePlane);
if( parent != root) {
IOLog("%s: not registry member at registerService()\n", getName());
return;
}
if( gIOPlatform && (!gIOPlatform->platformAdjustService(this)))
return;
if( (this != gIOResources)
&& (kIOLogRegister & gIOKitDebug)) {
pathBuf = (char *) IOMalloc( kMaxPathLen );
IOLog( "Registering: " );
len = kMaxPathLen;
if( pathBuf && getPath( pathBuf, &len, gIOServicePlane)) {
path = pathBuf;
if( len > kMaxChars) {
IOLog("..");
len -= kMaxChars;
path += len;
if( (skip = strchr( path, '/')))
path = skip;
}
} else
path = getName();
IOLog( "%s\n", path );
if( pathBuf)
IOFree( pathBuf, kMaxPathLen );
}
startMatching( options );
}
void IOService::startMatching( IOOptionBits options )
{
IOService * provider;
UInt32 prevBusy = 0;
bool needConfig;
bool needWake = false;
bool ok;
bool sync;
bool waitAgain;
lockForArbitration();
sync = (options & kIOServiceSynchronous)
|| ((provider = getProvider())
&& (provider->__state[1] & kIOServiceSynchronousState));
if ( options & kIOServiceAsynchronous )
sync = false;
needConfig = (0 == (__state[1] & (kIOServiceNeedConfigState | kIOServiceConfigState)))
&& (0 == (__state[0] & kIOServiceInactiveState));
__state[1] |= kIOServiceNeedConfigState;
if( needConfig) {
prevBusy = _adjustBusy( 1 );
needWake = (0 != (kIOServiceSyncPubState & __state[1]));
}
if( sync)
__state[1] |= kIOServiceSynchronousState;
else
__state[1] &= ~kIOServiceSynchronousState;
unlockForArbitration();
if( needConfig) {
if( needWake) {
IOLockLock( gIOServiceBusyLock );
thread_wakeup( (event_t) this );
IOLockUnlock( gIOServiceBusyLock );
} else if( !sync || (kIOServiceAsynchronous & options)) {
ok = (0 != _IOServiceJob::startJob( this, kMatchNubJob, options ));
} else do {
if( (__state[1] & kIOServiceNeedConfigState))
doServiceMatch( options );
lockForArbitration();
IOLockLock( gIOServiceBusyLock );
waitAgain = (prevBusy < (__state[1] & kIOServiceBusyStateMask));
if( waitAgain)
__state[1] |= kIOServiceSyncPubState | kIOServiceBusyWaiterState;
else
__state[1] &= ~kIOServiceSyncPubState;
unlockForArbitration();
if( waitAgain)
assert_wait( (event_t) this, THREAD_UNINT);
IOLockUnlock( gIOServiceBusyLock );
if( waitAgain)
thread_block(THREAD_CONTINUE_NULL);
} while( waitAgain );
}
}
IOReturn IOService::catalogNewDrivers( OSOrderedSet * newTables )
{
OSDictionary * table;
OSSet * set;
OSSet * allSet = 0;
IOService * service;
#if IOMATCHDEBUG
SInt32 count = 0;
#endif
newTables->retain();
while( (table = (OSDictionary *) newTables->getFirstObject())) {
LOCKWRITENOTIFY();
set = (OSSet *) getExistingServices( table,
kIOServiceRegisteredState,
kIOServiceExistingSet);
UNLOCKNOTIFY();
if( set) {
#if IOMATCHDEBUG
count += set->getCount();
#endif
if (allSet) {
allSet->merge((const OSSet *) set);
set->release();
}
else
allSet = set;
}
#if IOMATCHDEBUG
if( getDebugFlags( table ) & kIOLogMatch)
LOG("Matching service count = %ld\n", count);
#endif
newTables->removeObject(table);
}
if (allSet) {
while( (service = (IOService *) allSet->getAnyObject())) {
service->startMatching(kIOServiceAsynchronous);
allSet->removeObject(service);
}
allSet->release();
}
newTables->release();
return( kIOReturnSuccess );
}
_IOServiceJob * _IOServiceJob::startJob( IOService * nub, int type,
IOOptionBits options )
{
_IOServiceJob * job;
job = new _IOServiceJob;
if( job && !job->init()) {
job->release();
job = 0;
}
if( job) {
job->type = type;
job->nub = nub;
job->options = options;
nub->retain(); pingConfig( job );
}
return( job );
}
bool IOService::matchPropertyTable( OSDictionary * table, SInt32 * score )
{
return( matchPropertyTable(table) );
}
bool IOService::matchPropertyTable( OSDictionary * table )
{
return( true );
}
IOReturn IOService::getResources( void )
{
return( kIOReturnSuccess);
}
IOService * IOService::getProvider( void ) const
{
IOService * self = (IOService *) this;
IOService * parent;
SInt32 generation;
parent = __provider;
generation = getGenerationCount();
if( __providerGeneration == generation)
return( parent );
parent = (IOService *) getParentEntry( gIOServicePlane);
if( parent == IORegistryEntry::getRegistryRoot())
parent = 0;
self->__provider = parent;
self->__providerGeneration = generation;
return( parent );
}
IOWorkLoop * IOService::getWorkLoop() const
{
IOService *provider = getProvider();
if (provider)
return provider->getWorkLoop();
else
return 0;
}
OSIterator * IOService::getProviderIterator( void ) const
{
return( getParentIterator( gIOServicePlane));
}
IOService * IOService::getClient( void ) const
{
return( (IOService *) getChildEntry( gIOServicePlane));
}
OSIterator * IOService::getClientIterator( void ) const
{
return( getChildIterator( gIOServicePlane));
}
OSIterator * _IOOpenServiceIterator::iterator( OSIterator * _iter,
const IOService * client,
const IOService * provider )
{
_IOOpenServiceIterator * inst;
if( !_iter)
return( 0 );
inst = new _IOOpenServiceIterator;
if( inst && !inst->init()) {
inst->release();
inst = 0;
}
if( inst) {
inst->iter = _iter;
inst->client = client;
inst->provider = provider;
}
return( inst );
}
void _IOOpenServiceIterator::free()
{
iter->release();
if( last)
last->unlockForArbitration();
OSIterator::free();
}
OSObject * _IOOpenServiceIterator::getNextObject()
{
IOService * next;
if( last)
last->unlockForArbitration();
while( (next = (IOService *) iter->getNextObject())) {
next->lockForArbitration();
if( (client && (next->isOpen( client )))
|| (provider && (provider->isOpen( next ))) )
break;
next->unlockForArbitration();
}
last = next;
return( next );
}
bool _IOOpenServiceIterator::isValid()
{
return( iter->isValid() );
}
void _IOOpenServiceIterator::reset()
{
if( last) {
last->unlockForArbitration();
last = 0;
}
iter->reset();
}
OSIterator * IOService::getOpenProviderIterator( void ) const
{
return( _IOOpenServiceIterator::iterator( getProviderIterator(), this, 0 ));
}
OSIterator * IOService::getOpenClientIterator( void ) const
{
return( _IOOpenServiceIterator::iterator( getClientIterator(), 0, this ));
}
IOReturn IOService::callPlatformFunction( const OSSymbol * functionName,
bool waitForFunction,
void *param1, void *param2,
void *param3, void *param4 )
{
IOReturn result = kIOReturnUnsupported;
IOService *provider;
if (gIOPlatformFunctionHandlerSet == functionName)
{
#if defined(__i386__)
const OSSymbol * functionHandlerName = (const OSSymbol *) param1;
IOService * target = (IOService *) param2;
bool enable = (param3 != 0);
if (sCPULatencyFunctionName[kCpuDelayBusStall] == functionHandlerName)
result = setLatencyHandler(kCpuDelayBusStall, target, enable);
else if (sCPULatencyFunctionName[kCpuDelayInterrupt] == param1)
result = setLatencyHandler(kCpuDelayInterrupt, target, enable);
#endif
}
if ((kIOReturnUnsupported == result) && (provider = getProvider())) {
result = provider->callPlatformFunction(functionName, waitForFunction,
param1, param2, param3, param4);
}
return result;
}
IOReturn IOService::callPlatformFunction( const char * functionName,
bool waitForFunction,
void *param1, void *param2,
void *param3, void *param4 )
{
IOReturn result = kIOReturnNoMemory;
const OSSymbol *functionSymbol = OSSymbol::withCString(functionName);
if (functionSymbol != 0) {
result = callPlatformFunction(functionSymbol, waitForFunction,
param1, param2, param3, param4);
functionSymbol->release();
}
return result;
}
IOPlatformExpert * IOService::getPlatform( void )
{
return( gIOPlatform);
}
class IOPMrootDomain * IOService::getPMRootDomain( void )
{
return( gIOPMRootDomain);
}
IOService * IOService::getResourceService( void )
{
return( gIOResources );
}
void IOService::setPlatform( IOPlatformExpert * platform)
{
gIOPlatform = platform;
gIOResources->attachToParent( gIOServiceRoot, gIOServicePlane );
}
void IOService::setPMRootDomain( class IOPMrootDomain * rootDomain)
{
gIOPMRootDomain = rootDomain;
publishResource("IOKit");
}
bool IOService::lockForArbitration( bool isSuccessRequired )
{
bool found;
bool success;
ArbitrationLockQueueElement * element;
ArbitrationLockQueueElement * active;
ArbitrationLockQueueElement * waiting;
enum { kPutOnFreeQueue, kPutOnActiveQueue, kPutOnWaitingQueue } action;
IOTakeLock( gArbitrationLockQueueLock );
if( !queue_empty( &gArbitrationLockQueueFree )) {
queue_remove_first( &gArbitrationLockQueueFree,
element,
ArbitrationLockQueueElement *,
link );
} else {
element = IONew( ArbitrationLockQueueElement, 1 );
assert( element );
}
element->thread = IOThreadSelf();
element->service = this;
element->count = 1;
element->required = isSuccessRequired;
element->aborted = false;
found = false;
queue_iterate( &gArbitrationLockQueueActive,
active,
ArbitrationLockQueueElement *,
link )
{
if( active->service == element->service ) {
found = true;
break;
}
}
if( found ) {
if( active->thread != element->thread ) {
ArbitrationLockQueueElement * victim = 0;
while( 1 ) {
found = false;
queue_iterate( &gArbitrationLockQueueWaiting,
waiting,
ArbitrationLockQueueElement *,
link )
{
if( waiting->thread == active->thread ) {
assert( false == waiting->aborted );
found = true;
break;
}
}
if( found ) {
if( false == waiting->required )
victim = waiting;
found = false;
queue_iterate( &gArbitrationLockQueueActive,
active, ArbitrationLockQueueElement *,
link )
{
if( active->service == waiting->service ) {
found = true;
break;
}
}
assert( found );
if( active->thread == element->thread ) {
if( false == element->required ) {
success = false; break;
} else {
if( victim ) {
victim->aborted = true;
queue_remove( &gArbitrationLockQueueWaiting,
victim,
ArbitrationLockQueueElement *,
link );
IOLockWakeup( gArbitrationLockQueueLock,
victim,
true );
success = true; break; } else {
panic("I/O Kit: Unrecoverable deadlock.");
}
}
} else {
}
} else {
success = true; break; }
}
if( success ) { kern_return_t wait_result;
queue_enter( &gArbitrationLockQueueWaiting,
element,
ArbitrationLockQueueElement *,
link );
restart_sleep: wait_result = assert_wait( element,
element->required ? THREAD_UNINT
: THREAD_INTERRUPTIBLE );
IOUnlock( gArbitrationLockQueueLock );
if (wait_result == THREAD_WAITING)
wait_result = thread_block(THREAD_CONTINUE_NULL);
if( THREAD_INTERRUPTED == wait_result ) {
IOTakeLock( gArbitrationLockQueueLock );
found = false;
queue_iterate( &gArbitrationLockQueueWaiting,
waiting, ArbitrationLockQueueElement *,
link )
{
if( waiting == element ) {
found = true;
break;
}
}
if( found ) {
if( false == element->required ) {
element->aborted = true;
queue_remove( &gArbitrationLockQueueWaiting,
element,
ArbitrationLockQueueElement *,
link );
} else {
goto restart_sleep;
}
}
IOUnlock( gArbitrationLockQueueLock );
wait_result = THREAD_AWAKENED;
}
assert( THREAD_AWAKENED == wait_result );
if( element->aborted ) {
assert( false == element->required );
IOTakeLock( gArbitrationLockQueueLock );
action = kPutOnFreeQueue;
success = false;
} else {
return true;
}
} else {
action = kPutOnFreeQueue;
}
} else {
active->count++;
action = kPutOnFreeQueue;
success = true;
}
} else { action = kPutOnActiveQueue;
success = true;
}
if( kPutOnActiveQueue == action ) {
queue_enter( &gArbitrationLockQueueActive,
element,
ArbitrationLockQueueElement *,
link );
} else if( kPutOnFreeQueue == action ) {
queue_enter( &gArbitrationLockQueueFree,
element,
ArbitrationLockQueueElement *,
link );
} else {
assert( 0 ); }
IOUnlock( gArbitrationLockQueueLock );
return( success );
}
void IOService::unlockForArbitration( void )
{
bool found;
ArbitrationLockQueueElement * element;
IOTakeLock( gArbitrationLockQueueLock );
found = false;
queue_iterate( &gArbitrationLockQueueActive,
element,
ArbitrationLockQueueElement *,
link )
{
if( element->service == this ) {
found = true;
break;
}
}
assert( found );
if( element->count > 1 ) {
element->count--;
} else {
queue_remove( &gArbitrationLockQueueActive,
element,
ArbitrationLockQueueElement *,
link );
queue_enter( &gArbitrationLockQueueFree,
element,
ArbitrationLockQueueElement *,
link );
found = false;
queue_iterate( &gArbitrationLockQueueWaiting,
element,
ArbitrationLockQueueElement *,
link )
{
if( element->service == this ) {
found = true;
break;
}
}
if ( found ) {
queue_remove( &gArbitrationLockQueueWaiting,
element,
ArbitrationLockQueueElement *,
link );
queue_enter( &gArbitrationLockQueueActive,
element,
ArbitrationLockQueueElement *,
link );
IOLockWakeup( gArbitrationLockQueueLock,
element,
true );
}
}
IOUnlock( gArbitrationLockQueueLock );
}
void IOService::applyToProviders( IOServiceApplierFunction applier,
void * context )
{
applyToParents( (IORegistryEntryApplierFunction) applier,
context, gIOServicePlane );
}
void IOService::applyToClients( IOServiceApplierFunction applier,
void * context )
{
applyToChildren( (IORegistryEntryApplierFunction) applier,
context, gIOServicePlane );
}
IOReturn IOService::messageClient( UInt32 type, OSObject * client,
void * argument, vm_size_t argSize )
{
IOReturn ret;
IOService * service;
_IOServiceInterestNotifier * notify;
if( (service = OSDynamicCast( IOService, client)))
ret = service->message( type, this, argument );
else if( (notify = OSDynamicCast( _IOServiceInterestNotifier, client))) {
_IOServiceNotifierInvocation invocation;
bool willNotify;
invocation.thread = current_thread();
LOCKWRITENOTIFY();
willNotify = (0 != (kIOServiceNotifyEnable & notify->state));
if( willNotify) {
queue_enter( ¬ify->handlerInvocations, &invocation,
_IOServiceNotifierInvocation *, link );
}
UNLOCKNOTIFY();
if( willNotify) {
ret = (*notify->handler)( notify->target, notify->ref,
type, this, argument, argSize );
LOCKWRITENOTIFY();
queue_remove( ¬ify->handlerInvocations, &invocation,
_IOServiceNotifierInvocation *, link );
if( kIOServiceNotifyWaiter & notify->state) {
notify->state &= ~kIOServiceNotifyWaiter;
WAKEUPNOTIFY( notify );
}
UNLOCKNOTIFY();
} else
ret = kIOReturnSuccess;
} else
ret = kIOReturnBadArgument;
return( ret );
}
static void
applyToInterestNotifiers(const IORegistryEntry *target,
const OSSymbol * typeOfInterest,
OSObjectApplierFunction applier,
void * context )
{
OSArray * copyArray = 0;
LOCKREADNOTIFY();
IOCommand *notifyList =
OSDynamicCast( IOCommand, target->getProperty( typeOfInterest ));
if( notifyList) {
copyArray = OSArray::withCapacity(1);
iterqueue(¬ifyList->fCommandChain, entry) {
_IOServiceInterestNotifier * notify;
queue_element(entry, notify, _IOServiceInterestNotifier *, chain);
copyArray->setObject(notify);
}
}
UNLOCKNOTIFY();
if( copyArray) {
unsigned int index;
OSObject * next;
for( index = 0; (next = copyArray->getObject( index )); index++)
(*applier)(next, context);
copyArray->release();
}
}
void IOService::applyToInterested( const OSSymbol * typeOfInterest,
OSObjectApplierFunction applier,
void * context )
{
if (gIOGeneralInterest == typeOfInterest)
applyToClients( (IOServiceApplierFunction) applier, context );
applyToInterestNotifiers(this, typeOfInterest, applier, context);
}
struct MessageClientsContext {
IOService * service;
UInt32 type;
void * argument;
vm_size_t argSize;
IOReturn ret;
};
static void messageClientsApplier( OSObject * object, void * ctx )
{
IOReturn ret;
MessageClientsContext * context = (MessageClientsContext *) ctx;
ret = context->service->messageClient( context->type,
object, context->argument, context->argSize );
if( kIOReturnSuccess != ret)
context->ret = ret;
}
IOReturn IOService::messageClients( UInt32 type,
void * argument, vm_size_t argSize )
{
MessageClientsContext context;
context.service = this;
context.type = type;
context.argument = argument;
context.argSize = argSize;
context.ret = kIOReturnSuccess;
applyToInterested( gIOGeneralInterest,
&messageClientsApplier, &context );
return( context.ret );
}
IOReturn IOService::acknowledgeNotification( IONotificationRef notification,
IOOptionBits response )
{
return( kIOReturnUnsupported );
}
IONotifier * IOService::registerInterest( const OSSymbol * typeOfInterest,
IOServiceInterestHandler handler, void * target, void * ref )
{
_IOServiceInterestNotifier * notify = 0;
if( (typeOfInterest != gIOGeneralInterest)
&& (typeOfInterest != gIOBusyInterest)
&& (typeOfInterest != gIOAppPowerStateInterest)
&& (typeOfInterest != gIOPriorityPowerStateInterest))
return( 0 );
lockForArbitration();
if( 0 == (__state[0] & kIOServiceInactiveState)) {
notify = new _IOServiceInterestNotifier;
if( notify && !notify->init()) {
notify->release();
notify = 0;
}
if( notify) {
notify->handler = handler;
notify->target = target;
notify->ref = ref;
notify->state = kIOServiceNotifyEnable;
queue_init( ¬ify->handlerInvocations );
LOCKWRITENOTIFY();
IOCommand *notifyList = (IOCommand *) getProperty( typeOfInterest );
if (!notifyList || !OSDynamicCast(IOCommand, notifyList)) {
notifyList = OSTypeAlloc(IOCommand);
if (notifyList) {
notifyList->init();
setProperty( typeOfInterest, notifyList);
notifyList->release();
}
}
if (notifyList) {
enqueue(¬ifyList->fCommandChain, ¬ify->chain);
notify->retain(); }
UNLOCKNOTIFY();
}
}
unlockForArbitration();
return( notify );
}
static void cleanInterestList( OSObject * head )
{
IOCommand *notifyHead = OSDynamicCast(IOCommand, head);
if (!notifyHead)
return;
LOCKWRITENOTIFY();
while ( queue_entry_t entry = dequeue(¬ifyHead->fCommandChain) ) {
queue_next(entry) = queue_prev(entry) = 0;
_IOServiceInterestNotifier * notify;
queue_element(entry, notify, _IOServiceInterestNotifier *, chain);
notify->release();
}
UNLOCKNOTIFY();
}
void IOService::unregisterAllInterest( void )
{
cleanInterestList( getProperty( gIOGeneralInterest ));
cleanInterestList( getProperty( gIOBusyInterest ));
cleanInterestList( getProperty( gIOAppPowerStateInterest ));
cleanInterestList( getProperty( gIOPriorityPowerStateInterest ));
}
void _IOServiceInterestNotifier::wait()
{
_IOServiceNotifierInvocation * next;
bool doWait;
do {
doWait = false;
queue_iterate( &handlerInvocations, next,
_IOServiceNotifierInvocation *, link) {
if( next->thread != current_thread() ) {
doWait = true;
break;
}
}
if( doWait) {
state |= kIOServiceNotifyWaiter;
SLEEPNOTIFY(this);
}
} while( doWait );
}
void _IOServiceInterestNotifier::free()
{
assert( queue_empty( &handlerInvocations ));
OSObject::free();
}
void _IOServiceInterestNotifier::remove()
{
LOCKWRITENOTIFY();
if( queue_next( &chain )) {
remqueue( 0, &chain);
queue_next( &chain) = queue_prev( &chain) = 0;
release();
}
state &= ~kIOServiceNotifyEnable;
wait();
UNLOCKNOTIFY();
release();
}
bool _IOServiceInterestNotifier::disable()
{
bool ret;
LOCKWRITENOTIFY();
ret = (0 != (kIOServiceNotifyEnable & state));
state &= ~kIOServiceNotifyEnable;
if( ret)
wait();
UNLOCKNOTIFY();
return( ret );
}
void _IOServiceInterestNotifier::enable( bool was )
{
LOCKWRITENOTIFY();
if( was)
state |= kIOServiceNotifyEnable;
else
state &= ~kIOServiceNotifyEnable;
UNLOCKNOTIFY();
}
#define tailQ(o) setObject(o)
#define headQ(o) setObject(0, o)
#define TLOG(fmt, args...) { if(kIOLogYield & gIOKitDebug) IOLog(fmt, ## args); }
inline void _workLoopAction( IOWorkLoop::Action action,
IOService * service,
void * p0 = 0, void * p1 = 0,
void * p2 = 0, void * p3 = 0 )
{
IOWorkLoop * wl;
if( (wl = service->getWorkLoop())) {
wl->retain();
wl->runAction( action, service, p0, p1, p2, p3 );
wl->release();
} else
(*action)( service, p0, p1, p2, p3 );
}
bool IOService::requestTerminate( IOService * provider, IOOptionBits options )
{
bool ok;
ok = isParent( provider, gIOServicePlane, true);
if( ok) {
provider->terminateClient( this, options | kIOServiceRecursing );
ok = (0 != (__state[1] & kIOServiceRecursing));
}
return( ok );
}
bool IOService::terminatePhase1( IOOptionBits options )
{
IOService * victim;
IOService * client;
OSIterator * iter;
OSArray * makeInactive;
bool ok;
bool didInactive;
bool startPhase2 = false;
TLOG("%s::terminatePhase1(%08lx)\n", getName(), options);
if( options & kIOServiceRecursing) {
__state[1] |= kIOServiceRecursing;
return( true );
}
makeInactive = OSArray::withCapacity( 16 );
if( !makeInactive)
return( false );
victim = this;
victim->retain();
while( victim ) {
didInactive = victim->lockForArbitration( true );
if( didInactive) {
didInactive = (0 == (victim->__state[0] & kIOServiceInactiveState));
if( didInactive) {
victim->__state[0] |= kIOServiceInactiveState;
victim->__state[0] &= ~(kIOServiceRegisteredState | kIOServiceMatchedState
| kIOServiceFirstPublishState | kIOServiceFirstMatchState);
victim->_adjustBusy( 1 );
}
victim->unlockForArbitration();
}
if( victim == this)
startPhase2 = didInactive;
if( didInactive) {
victim->deliverNotification( gIOTerminatedNotification, 0, 0xffffffff );
IOUserClient::destroyUserReferences( victim );
iter = victim->getClientIterator();
if( iter) {
while( (client = (IOService *) iter->getNextObject())) {
TLOG("%s::requestTerminate(%s, %08lx)\n",
client->getName(), victim->getName(), options);
ok = client->requestTerminate( victim, options );
TLOG("%s::requestTerminate(%s, ok = %d)\n",
client->getName(), victim->getName(), ok);
if( ok)
makeInactive->setObject( client );
}
iter->release();
}
}
victim->release();
victim = (IOService *) makeInactive->getObject(0);
if( victim) {
victim->retain();
makeInactive->removeObject(0);
}
}
makeInactive->release();
if( startPhase2)
scheduleTerminatePhase2( options );
return( true );
}
void IOService::scheduleTerminatePhase2( IOOptionBits options )
{
AbsoluteTime deadline;
int waitResult = THREAD_AWAKENED;
bool wait, haveDeadline = false;
options |= kIOServiceRequired;
retain();
IOLockLock( gJobsLock );
if( (options & kIOServiceSynchronous)
&& (current_thread() != gIOTerminateThread)) {
do {
wait = (gIOTerminateThread != 0);
if( wait) {
IOLockSleep( gJobsLock, &gIOTerminateThread, THREAD_UNINT);
}
} while( wait );
gIOTerminateThread = current_thread();
gIOTerminatePhase2List->setObject( this );
gIOTerminateWork++;
do {
while( gIOTerminateWork )
terminateWorker( options );
wait = (0 != (__state[1] & kIOServiceBusyStateMask));
if( wait) {
if( !haveDeadline) {
clock_interval_to_deadline( 15, kSecondScale, &deadline );
haveDeadline = true;
}
waitResult = IOLockSleepDeadline( gJobsLock, &gIOTerminateWork,
deadline, THREAD_UNINT );
if( waitResult == THREAD_TIMED_OUT) {
TLOG("%s::terminate(kIOServiceSynchronous) timeout", getName());
}
}
} while(gIOTerminateWork || (wait && (waitResult != THREAD_TIMED_OUT)));
gIOTerminateThread = 0;
IOLockWakeup( gJobsLock, (event_t) &gIOTerminateThread, false);
} else {
gIOTerminatePhase2List->setObject( this );
if( 0 == gIOTerminateWork++) {
if( !gIOTerminateThread)
gIOTerminateThread = IOCreateThread( &terminateThread, (void *) options );
else
IOLockWakeup(gJobsLock, (event_t) &gIOTerminateWork, false );
}
}
IOLockUnlock( gJobsLock );
release();
}
void IOService::terminateThread( void * arg )
{
IOLockLock( gJobsLock );
while (gIOTerminateWork)
terminateWorker( (IOOptionBits) arg );
gIOTerminateThread = 0;
IOLockWakeup( gJobsLock, (event_t) &gIOTerminateThread, false);
IOLockUnlock( gJobsLock );
}
void IOService::scheduleStop( IOService * provider )
{
TLOG("%s::scheduleStop(%s)\n", getName(), provider->getName());
IOLockLock( gJobsLock );
gIOStopList->tailQ( this );
gIOStopProviderList->tailQ( provider );
if( 0 == gIOTerminateWork++) {
if( !gIOTerminateThread)
gIOTerminateThread = IOCreateThread( &terminateThread, (void *) 0 );
else
IOLockWakeup(gJobsLock, (event_t) &gIOTerminateWork, false );
}
IOLockUnlock( gJobsLock );
}
void IOService::scheduleFinalize( void )
{
TLOG("%s::scheduleFinalize\n", getName());
IOLockLock( gJobsLock );
gIOFinalizeList->tailQ( this );
if( 0 == gIOTerminateWork++) {
if( !gIOTerminateThread)
gIOTerminateThread = IOCreateThread( &terminateThread, (void *) 0 );
else
IOLockWakeup(gJobsLock, (event_t) &gIOTerminateWork, false );
}
IOLockUnlock( gJobsLock );
}
bool IOService::willTerminate( IOService * provider, IOOptionBits options )
{
return( true );
}
bool IOService::didTerminate( IOService * provider, IOOptionBits options, bool * defer )
{
if( false == *defer) {
if( lockForArbitration( true )) {
if( false == provider->handleIsOpen( this ))
scheduleStop( provider );
else {
message( kIOMessageServiceIsRequestingClose, provider, (void *) options );
if( false == provider->handleIsOpen( this ))
scheduleStop( provider );
}
unlockForArbitration();
}
}
return( true );
}
void IOService::actionWillTerminate( IOService * victim, IOOptionBits options,
OSArray * doPhase2List )
{
OSIterator * iter;
IOService * client;
bool ok;
iter = victim->getClientIterator();
if( iter) {
while( (client = (IOService *) iter->getNextObject())) {
TLOG("%s::willTerminate(%s, %08lx)\n",
client->getName(), victim->getName(), options);
ok = client->willTerminate( victim, options );
doPhase2List->tailQ( client );
}
iter->release();
}
}
void IOService::actionDidTerminate( IOService * victim, IOOptionBits options )
{
OSIterator * iter;
IOService * client;
bool defer = false;
victim->messageClients( kIOMessageServiceIsTerminated, (void *) options );
iter = victim->getClientIterator();
if( iter) {
while( (client = (IOService *) iter->getNextObject())) {
TLOG("%s::didTerminate(%s, %08lx)\n",
client->getName(), victim->getName(), options);
client->didTerminate( victim, options, &defer );
TLOG("%s::didTerminate(%s, defer %d)\n",
client->getName(), victim->getName(), defer);
}
iter->release();
}
}
void IOService::actionFinalize( IOService * victim, IOOptionBits options )
{
TLOG("%s::finalize(%08lx)\n", victim->getName(), options);
victim->finalize( options );
}
void IOService::actionStop( IOService * provider, IOService * client )
{
TLOG("%s::stop(%s)\n", client->getName(), provider->getName());
client->stop( provider );
if( provider->isOpen( client ))
provider->close( client );
TLOG("%s::detach(%s)\n", client->getName(), provider->getName());
client->detach( provider );
}
void IOService::terminateWorker( IOOptionBits options )
{
OSArray * doPhase2List;
OSArray * didPhase2List;
OSSet * freeList;
UInt32 workDone;
IOService * victim;
IOService * client;
IOService * provider;
unsigned int idx;
bool moreToDo;
bool doPhase2;
bool doPhase3;
options |= kIOServiceRequired;
doPhase2List = OSArray::withCapacity( 16 );
didPhase2List = OSArray::withCapacity( 16 );
freeList = OSSet::withCapacity( 16 );
if( (0 == doPhase2List) || (0 == didPhase2List) || (0 == freeList))
return;
do {
workDone = gIOTerminateWork;
while( (victim = (IOService *) gIOTerminatePhase2List->getObject(0) )) {
victim->retain();
gIOTerminatePhase2List->removeObject(0);
IOLockUnlock( gJobsLock );
while( victim ) {
doPhase2 = victim->lockForArbitration( true );
if( doPhase2) {
doPhase2 = (0 != (kIOServiceInactiveState & victim->__state[0]));
if( doPhase2) {
doPhase2 = (0 == (victim->__state[1] & kIOServiceTermPhase2State))
&& (0 == (victim->__state[1] & kIOServiceConfigState));
if( doPhase2)
victim->__state[1] |= kIOServiceTermPhase2State;
}
victim->unlockForArbitration();
}
if( doPhase2) {
if( 0 == victim->getClient()) {
IOLockLock( gJobsLock );
gIOFinalizeList->tailQ( victim );
IOLockUnlock( gJobsLock );
} else {
_workLoopAction( (IOWorkLoop::Action) &actionWillTerminate,
victim, (void *) options, (void *) doPhase2List );
}
didPhase2List->headQ( victim );
}
victim->release();
victim = (IOService *) doPhase2List->getObject(0);
if( victim) {
victim->retain();
doPhase2List->removeObject(0);
}
}
while( (victim = (IOService *) didPhase2List->getObject(0)) ) {
if( victim->lockForArbitration( true )) {
victim->__state[1] |= kIOServiceTermPhase3State;
victim->unlockForArbitration();
}
_workLoopAction( (IOWorkLoop::Action) &actionDidTerminate,
victim, (void *) options );
didPhase2List->removeObject(0);
}
IOLockLock( gJobsLock );
}
do {
doPhase3 = false;
while( (victim = (IOService *) gIOFinalizeList->getObject(0))) {
IOLockUnlock( gJobsLock );
_workLoopAction( (IOWorkLoop::Action) &actionFinalize,
victim, (void *) options );
IOLockLock( gJobsLock );
freeList->setObject( victim );
gIOFinalizeList->removeObject(0);
}
for( idx = 0;
(!doPhase3) && (client = (IOService *) gIOStopList->getObject(idx)); ) {
provider = (IOService *) gIOStopProviderList->getObject(idx);
assert( provider );
if( !provider->isChild( client, gIOServicePlane )) {
TLOG("%s::nop stop(%s)\n", client->getName(), provider->getName());
} else {
if( (client->__state[1] & kIOServiceTermPhase3State) && client->getClient()) {
TLOG("%s::defer stop(%s)\n", client->getName(), provider->getName());
idx++;
continue;
}
IOLockUnlock( gJobsLock );
_workLoopAction( (IOWorkLoop::Action) &actionStop,
provider, (void *) client );
IOLockLock( gJobsLock );
doPhase3 = true;
}
freeList->setObject( client );
freeList->setObject( provider );
gIOStopList->removeObject( idx );
gIOStopProviderList->removeObject( idx );
idx = 0;
}
} while( doPhase3 );
gIOTerminateWork -= workDone;
moreToDo = (gIOTerminateWork != 0);
if( !moreToDo) {
TLOG("iokit terminate done, %d stops remain\n", gIOStopList->getCount());
}
} while( moreToDo );
IOLockUnlock( gJobsLock );
freeList->release();
doPhase2List->release();
didPhase2List->release();
IOLockLock( gJobsLock );
}
bool IOService::finalize( IOOptionBits options )
{
OSIterator * iter;
IOService * provider;
iter = getProviderIterator();
assert( iter );
if( iter) {
while( (provider = (IOService *) iter->getNextObject())) {
if( 0 == (__state[1] & kIOServiceTermPhase3State)) {
stop( provider );
if( provider->isOpen( this ))
provider->close( this );
detach( provider );
} else {
if( provider->lockForArbitration( true )) {
if( 0 == (provider->__state[1] & kIOServiceTermPhase3State))
scheduleStop( provider );
provider->unlockForArbitration();
}
}
}
iter->release();
}
return( true );
}
#undef tailQ
#undef headQ
void IOService::doServiceTerminate( IOOptionBits options )
{
}
bool IOService::terminateClient( IOService * client, IOOptionBits options )
{
bool ok;
if( client->isParent( this, gIOServicePlane, true))
ok = client->terminate( options );
else
ok = true;
return( ok );
}
bool IOService::terminate( IOOptionBits options )
{
options |= kIOServiceTerminate;
return( terminatePhase1( options ));
}
struct ServiceOpenMessageContext
{
IOService * service;
UInt32 type;
IOService * excludeClient;
IOOptionBits options;
};
static void serviceOpenMessageApplier( OSObject * object, void * ctx )
{
ServiceOpenMessageContext * context = (ServiceOpenMessageContext *) ctx;
if( object != context->excludeClient)
context->service->messageClient( context->type, object, (void *) context->options );
}
bool IOService::open( IOService * forClient,
IOOptionBits options,
void * arg )
{
bool ok;
ServiceOpenMessageContext context;
context.service = this;
context.type = kIOMessageServiceIsAttemptingOpen;
context.excludeClient = forClient;
context.options = options;
applyToInterested( gIOGeneralInterest,
&serviceOpenMessageApplier, &context );
if( false == lockForArbitration(false) )
return false;
ok = (0 == (__state[0] & kIOServiceInactiveState));
if( ok)
ok = handleOpen( forClient, options, arg );
unlockForArbitration();
return( ok );
}
void IOService::close( IOService * forClient,
IOOptionBits options )
{
bool wasClosed;
bool last = false;
lockForArbitration();
wasClosed = handleIsOpen( forClient );
if( wasClosed) {
handleClose( forClient, options );
last = (__state[1] & kIOServiceTermPhase3State);
}
unlockForArbitration();
if( last)
forClient->scheduleStop( this );
else if( wasClosed) {
ServiceOpenMessageContext context;
context.service = this;
context.type = kIOMessageServiceWasClosed;
context.excludeClient = forClient;
context.options = options;
applyToInterested( gIOGeneralInterest,
&serviceOpenMessageApplier, &context );
}
}
bool IOService::isOpen( const IOService * forClient ) const
{
IOService * self = (IOService *) this;
bool ok;
self->lockForArbitration();
ok = handleIsOpen( forClient );
self->unlockForArbitration();
return( ok );
}
bool IOService::handleOpen( IOService * forClient,
IOOptionBits options,
void * arg )
{
bool ok;
ok = (0 == __owner);
if( ok )
__owner = forClient;
else if( options & kIOServiceSeize ) {
ok = (kIOReturnSuccess == messageClient( kIOMessageServiceIsRequestingClose,
__owner, (void *) options ));
if( ok && (0 == __owner ))
__owner = forClient;
else
ok = false;
}
return( ok );
}
void IOService::handleClose( IOService * forClient,
IOOptionBits options )
{
if( __owner == forClient)
__owner = 0;
}
bool IOService::handleIsOpen( const IOService * forClient ) const
{
if( forClient)
return( __owner == forClient );
else
return( __owner != forClient );
}
static SInt32 IONotifyOrdering( const OSMetaClassBase * inObj1, const OSMetaClassBase * inObj2, void * ref )
{
const _IOServiceNotifier * obj1 = (const _IOServiceNotifier *) inObj1;
const _IOServiceNotifier * obj2 = (const _IOServiceNotifier *) inObj2;
SInt32 val1;
SInt32 val2;
val1 = 0;
val2 = 0;
if ( obj1 )
val1 = obj1->priority;
if ( obj2 )
val2 = obj2->priority;
return ( val1 - val2 );
}
static SInt32 IOServiceObjectOrder( const OSObject * entry, void * ref)
{
OSDictionary * dict;
IOService * service;
_IOServiceNotifier * notify;
OSSymbol * key = (OSSymbol *) ref;
OSNumber * offset;
if( (notify = OSDynamicCast( _IOServiceNotifier, entry)))
return( notify->priority );
else if( (service = OSDynamicCast( IOService, entry)))
offset = OSDynamicCast(OSNumber, service->getProperty( key ));
else if( (dict = OSDynamicCast( OSDictionary, entry)))
offset = OSDynamicCast(OSNumber, dict->getObject( key ));
else {
assert( false );
offset = 0;
}
if( offset)
return( (SInt32) offset->unsigned32BitValue());
else
return( kIODefaultProbeScore );
}
SInt32 IOServiceOrdering( const OSMetaClassBase * inObj1, const OSMetaClassBase * inObj2, void * ref )
{
const OSObject * obj1 = (const OSObject *) inObj1;
const OSObject * obj2 = (const OSObject *) inObj2;
SInt32 val1;
SInt32 val2;
val1 = 0;
val2 = 0;
if ( obj1 )
val1 = IOServiceObjectOrder( obj1, ref );
if ( obj2 )
val2 = IOServiceObjectOrder( obj2, ref );
return ( val1 - val2 );
}
IOService * IOService::getClientWithCategory( const OSSymbol * category )
{
IOService * service = 0;
OSIterator * iter;
const OSSymbol * nextCat;
iter = getClientIterator();
if( iter) {
while( (service = (IOService *) iter->getNextObject())) {
if( kIOServiceInactiveState & service->__state[0])
continue;
nextCat = (const OSSymbol *) OSDynamicCast( OSSymbol,
service->getProperty( gIOMatchCategoryKey ));
if( category == nextCat)
break;
}
iter->release();
}
return( service );
}
bool IOService::invokeNotifer( _IOServiceNotifier * notify )
{
_IOServiceNotifierInvocation invocation;
bool willNotify;
bool ret = true;
invocation.thread = current_thread();
LOCKWRITENOTIFY();
willNotify = (0 != (kIOServiceNotifyEnable & notify->state));
if( willNotify) {
queue_enter( ¬ify->handlerInvocations, &invocation,
_IOServiceNotifierInvocation *, link );
}
UNLOCKNOTIFY();
if( willNotify) {
ret = (*notify->handler)( notify->target, notify->ref, this );
LOCKWRITENOTIFY();
queue_remove( ¬ify->handlerInvocations, &invocation,
_IOServiceNotifierInvocation *, link );
if( kIOServiceNotifyWaiter & notify->state) {
notify->state &= ~kIOServiceNotifyWaiter;
WAKEUPNOTIFY( notify );
}
UNLOCKNOTIFY();
}
return( ret );
}
void IOService::probeCandidates( OSOrderedSet * matches )
{
OSDictionary * match = 0;
OSSymbol * symbol;
IOService * inst;
IOService * newInst;
OSDictionary * props;
SInt32 score;
OSNumber * newPri;
OSOrderedSet * familyMatches = 0;
OSOrderedSet * startList;
OSDictionary * startDict = 0;
const OSSymbol * category;
OSIterator * iter;
_IOServiceNotifier * notify;
OSObject * nextMatch = 0;
bool started;
bool needReloc = false;
#if CONFIG_MACF_KEXT
OSBoolean * isSandbox = 0;
bool useSandbox = false;
#endif
#if IOMATCHDEBUG
SInt64 debugFlags;
#endif
assert( matches );
while( !needReloc && (nextMatch = matches->getFirstObject())) {
nextMatch->retain();
matches->removeObject(nextMatch);
if( (notify = OSDynamicCast( _IOServiceNotifier, nextMatch ))) {
lockForArbitration();
if( 0 == (__state[0] & kIOServiceInactiveState))
invokeNotifer( notify );
unlockForArbitration();
nextMatch->release();
nextMatch = 0;
continue;
} else if( !(match = OSDynamicCast( OSDictionary, nextMatch ))) {
nextMatch->release();
nextMatch = 0;
continue;
}
props = 0;
#if IOMATCHDEBUG
debugFlags = getDebugFlags( match );
#endif
do {
category = OSDynamicCast( OSSymbol,
match->getObject( gIOMatchCategoryKey ));
if( 0 == category)
category = gIODefaultMatchCategoryKey;
if( getClientWithCategory( category )) {
#if IOMATCHDEBUG
if( debugFlags & kIOLogMatch)
LOG("%s: match category %s exists\n", getName(),
category->getCStringNoCopy());
#endif
nextMatch->release();
nextMatch = 0;
continue;
}
props = OSDictionary::withDictionary( match, match->getCount());
if( 0 == props)
continue;
props->setCapacityIncrement(1);
if( false == passiveMatch( props, true ))
continue;
needReloc = (false == gIOCatalogue->isModuleLoaded( match ));
if( needReloc) {
#if IOMATCHDEBUG
if( debugFlags & kIOLogCatalogue)
LOG("%s: stalling for module\n", getName());
#endif
continue;
}
if( 0 == familyMatches)
familyMatches = OSOrderedSet::withCapacity( 1,
IOServiceOrdering, (void *) gIOProbeScoreKey );
if( familyMatches)
familyMatches->setObject( props );
} while( false );
if (nextMatch) {
nextMatch->release();
nextMatch = 0;
}
if( props)
props->release();
}
matches->release();
matches = 0;
if( familyMatches) {
while( !needReloc
&& (props = (OSDictionary *) familyMatches->getFirstObject())) {
props->retain();
familyMatches->removeObject( props );
inst = 0;
newInst = 0;
#if IOMATCHDEBUG
debugFlags = getDebugFlags( props );
#endif
do {
symbol = OSDynamicCast( OSSymbol,
props->getObject( gIOClassKey));
if( !symbol)
continue;
inst = (IOService *) OSMetaClass::allocClassWithName( symbol);
if( !inst) {
IOLog("Couldn't alloc class \"%s\"\n",
symbol->getCStringNoCopy());
continue;
}
if( !(inst->init( props ))) {
#if IOMATCHDEBUG
if( debugFlags & kIOLogStart)
IOLog("%s::init fails\n", symbol->getCStringNoCopy());
#endif
continue;
}
if( __state[1] & kIOServiceSynchronousState)
inst->__state[1] |= kIOServiceSynchronousState;
category = OSDynamicCast( OSSymbol,
props->getObject( gIOMatchCategoryKey ));
if( 0 == category)
category = gIODefaultMatchCategoryKey;
inst->setProperty( gIOMatchCategoryKey, (OSObject *) category );
#if CONFIG_MACF_KEXT
isSandbox = OSDynamicCast(OSBoolean,
props->getObject("IOKitForceMatch"));
#endif
if( !(inst->attach( this )))
continue;
score = familyMatches->orderObject( props );
#if IOMATCHDEBUG
if( debugFlags & kIOLogProbe)
LOG("%s::probe(%s)\n",
inst->getMetaClass()->getClassName(), getName());
#endif
newInst = inst->probe( this, &score );
inst->detach( this );
#if CONFIG_MACF_KEXT
if (isSandbox && isSandbox->isTrue() && newInst != 0) {
if (startDict != 0) {
startDict->flushCollection();
startDict->release();
startDict = 0;
}
useSandbox = true;
}
#endif
if( 0 == newInst) {
#if IOMATCHDEBUG
if( debugFlags & kIOLogProbe)
IOLog("%s::probe fails\n", symbol->getCStringNoCopy());
#endif
continue;
}
newPri = OSNumber::withNumber( score, 32 );
if( newPri) {
newInst->setProperty( gIOProbeScoreKey, newPri );
newPri->release();
}
if( 0 == startDict)
startDict = OSDictionary::withCapacity( 1 );
assert( startDict );
startList = (OSOrderedSet *)
startDict->getObject( category );
if( 0 == startList) {
startList = OSOrderedSet::withCapacity( 1,
IOServiceOrdering, (void *) gIOProbeScoreKey );
if( startDict && startList) {
startDict->setObject( category, startList );
startList->release();
}
}
assert( startList );
if( startList)
startList->setObject( newInst );
} while( false );
props->release();
if( inst)
inst->release();
#if CONFIG_MACF_KEXT
if (isSandbox && isSandbox->isTrue() && useSandbox)
break;
#endif
}
familyMatches->release();
familyMatches = 0;
}
iter = OSCollectionIterator::withCollection( startDict );
if( iter) {
while( (category = (const OSSymbol *) iter->getNextObject())) {
startList = (OSOrderedSet *) startDict->getObject( category );
assert( startList );
if( !startList)
continue;
started = false;
while( true && (inst = (IOService *)startList->getFirstObject())) {
inst->retain();
startList->removeObject(inst);
#if IOMATCHDEBUG
debugFlags = getDebugFlags( inst->getPropertyTable() );
if( debugFlags & kIOLogStart) {
if( started)
LOG( "match category exists, skipping " );
LOG( "%s::start(%s) <%d>\n", inst->getName(),
getName(), inst->getRetainCount());
}
#endif
if( false == started)
started = startCandidate( inst );
#if IOMATCHDEBUG
if( (debugFlags & kIOLogStart) && (false == started))
LOG( "%s::start(%s) <%d> failed\n", inst->getName(), getName(),
inst->getRetainCount());
#endif
inst->release();
}
}
iter->release();
}
lockForArbitration();
SInt32 adjBusy = 0;
if( needReloc) {
adjBusy = (__state[1] & kIOServiceModuleStallState) ? 0 : 1;
if( adjBusy)
__state[1] |= kIOServiceModuleStallState;
} else if( __state[1] & kIOServiceModuleStallState) {
__state[1] &= ~kIOServiceModuleStallState;
adjBusy = -1;
}
if( adjBusy)
_adjustBusy( adjBusy );
unlockForArbitration();
if( startDict)
startDict->release();
}
bool IOService::startCandidate( IOService * service )
{
bool ok;
ok = service->attach( this );
if( ok)
{
if (this != gIOResources)
{
checkResources();
service->checkResources();
}
AbsoluteTime startTime;
AbsoluteTime endTime;
UInt64 nano;
if (kIOLogStart & gIOKitDebug)
clock_get_uptime(&startTime);
ok = service->start(this);
if (kIOLogStart & gIOKitDebug)
{
clock_get_uptime(&endTime);
if (CMP_ABSOLUTETIME(&endTime, &startTime) > 0)
{
SUB_ABSOLUTETIME(&endTime, &startTime);
absolutetime_to_nanoseconds(endTime, &nano);
if (nano > 500000000ULL)
IOLog("%s::start took %ld ms\n", service->getName(), (UInt32)(nano / 1000000ULL));
}
}
if( !ok)
service->detach( this );
}
return( ok );
}
IOService * IOService::resources( void )
{
return( gIOResources );
}
void IOService::publishResource( const char * key, OSObject * value )
{
const OSSymbol * sym;
if( (sym = OSSymbol::withCString( key))) {
publishResource( sym, value);
sym->release();
}
}
void IOService::publishResource( const OSSymbol * key, OSObject * value )
{
if( 0 == value)
value = (OSObject *) gIOServiceKey;
gIOResources->setProperty( key, value);
if( IORecursiveLockHaveLock( gNotificationLock))
return;
gIOResourceGenerationCount++;
gIOResources->registerService();
}
bool IOService::addNeededResource( const char * key )
{
OSObject * resourcesProp;
OSSet * set;
OSString * newKey;
bool ret;
resourcesProp = getProperty( gIOResourceMatchKey );
newKey = OSString::withCString( key );
if( (0 == resourcesProp) || (0 == newKey))
return( false);
set = OSDynamicCast( OSSet, resourcesProp );
if( !set) {
set = OSSet::withCapacity( 1 );
if( set)
set->setObject( resourcesProp );
}
else
set->retain();
set->setObject( newKey );
newKey->release();
ret = setProperty( gIOResourceMatchKey, set );
set->release();
return( ret );
}
bool IOService::checkResource( OSObject * matching )
{
OSString * str;
OSDictionary * table;
if( (str = OSDynamicCast( OSString, matching ))) {
if( gIOResources->getProperty( str ))
return( true );
}
if( str)
table = resourceMatching( str );
else if( (table = OSDynamicCast( OSDictionary, matching )))
table->retain();
else {
IOLog("%s: Can't match using: %s\n", getName(),
matching->getMetaClass()->getClassName());
return( true );
}
if( gIOKitDebug & kIOLogConfig)
LOG("config(%x): stalling %s\n", (int) IOThreadSelf(), getName());
waitForService( table );
if( gIOKitDebug & kIOLogConfig)
LOG("config(%x): waking\n", (int) IOThreadSelf() );
return( true );
}
bool IOService::checkResources( void )
{
OSObject * resourcesProp;
OSSet * set;
OSIterator * iter;
bool ok;
resourcesProp = getProperty( gIOResourceMatchKey );
if( 0 == resourcesProp)
return( true );
if( (set = OSDynamicCast( OSSet, resourcesProp ))) {
iter = OSCollectionIterator::withCollection( set );
ok = (0 != iter);
while( ok && (resourcesProp = iter->getNextObject()) )
ok = checkResource( resourcesProp );
if( iter)
iter->release();
} else
ok = checkResource( resourcesProp );
return( ok );
}
void _IOConfigThread::configThread( void )
{
_IOConfigThread * inst;
do {
if( !(inst = new _IOConfigThread))
continue;
if( !inst->init())
continue;
if( !(IOCreateThread((IOThreadFunc) &_IOConfigThread::main, inst )))
continue;
return;
} while( false);
if( inst)
inst->release();
return;
}
void _IOConfigThread::free( void )
{
OSObject::free();
}
void IOService::doServiceMatch( IOOptionBits options )
{
_IOServiceNotifier * notify;
OSIterator * iter;
OSOrderedSet * matches;
SInt32 catalogGeneration;
bool keepGuessing = true;
bool reRegistered = true;
while( keepGuessing ) {
matches = gIOCatalogue->findDrivers( this, &catalogGeneration );
if( matches) {
lockForArbitration();
if( 0 == (__state[0] & kIOServiceFirstPublishState))
deliverNotification( gIOFirstPublishNotification,
kIOServiceFirstPublishState, 0xffffffff );
LOCKREADNOTIFY();
__state[1] &= ~kIOServiceNeedConfigState;
__state[1] |= kIOServiceConfigState;
__state[0] |= kIOServiceRegisteredState;
if( reRegistered && (0 == (__state[0] & kIOServiceInactiveState))) {
iter = OSCollectionIterator::withCollection( (OSOrderedSet *)
gNotifications->getObject( gIOPublishNotification ) );
if( iter) {
while((notify = (_IOServiceNotifier *)
iter->getNextObject())) {
if( passiveMatch( notify->matching )
&& (kIOServiceNotifyEnable & notify->state))
matches->setObject( notify );
}
iter->release();
}
}
UNLOCKNOTIFY();
unlockForArbitration();
if( matches->getCount() && (kIOReturnSuccess == getResources()))
probeCandidates( matches );
else
matches->release();
}
lockForArbitration();
reRegistered = (0 != (__state[1] & kIOServiceNeedConfigState));
keepGuessing =
(reRegistered || (catalogGeneration !=
gIOCatalogue->getGenerationCount()))
&& (0 == (__state[0] & kIOServiceInactiveState));
if( keepGuessing)
unlockForArbitration();
}
if( (0 == (__state[0] & kIOServiceInactiveState))
&& (0 == (__state[1] & kIOServiceModuleStallState)) ) {
deliverNotification( gIOMatchedNotification,
kIOServiceMatchedState, 0xffffffff );
if( 0 == (__state[0] & kIOServiceFirstMatchState))
deliverNotification( gIOFirstMatchNotification,
kIOServiceFirstMatchState, 0xffffffff );
}
__state[1] &= ~kIOServiceConfigState;
if( __state[0] & kIOServiceInactiveState)
scheduleTerminatePhase2();
_adjustBusy( -1 );
unlockForArbitration();
}
UInt32 IOService::_adjustBusy( SInt32 delta )
{
IOService * next;
UInt32 count;
UInt32 result;
bool wasQuiet, nowQuiet, needWake;
next = this;
result = __state[1] & kIOServiceBusyStateMask;
if( delta) do {
if( next != this)
next->lockForArbitration();
count = next->__state[1] & kIOServiceBusyStateMask;
assert( count < kIOServiceBusyMax);
wasQuiet = (0 == count);
assert( (!wasQuiet) || (delta > 0));
next->__state[1] += delta;
nowQuiet = (0 == (next->__state[1] & kIOServiceBusyStateMask));
needWake = (0 != (kIOServiceBusyWaiterState & next->__state[1]));
if( needWake) {
next->__state[1] &= ~kIOServiceBusyWaiterState;
IOLockLock( gIOServiceBusyLock );
thread_wakeup( (event_t) next);
IOLockUnlock( gIOServiceBusyLock );
}
if( next != this)
next->unlockForArbitration();
if( (wasQuiet || nowQuiet) ) {
MessageClientsContext context;
context.service = next;
context.type = kIOMessageServiceBusyStateChange;
context.argument = (void *) wasQuiet; context.argSize = 0;
applyToInterestNotifiers( next, gIOBusyInterest,
&messageClientsApplier, &context );
#if !NO_KEXTD
if( nowQuiet && (next == gIOServiceRoot))
OSMetaClass::considerUnloads();
#endif
}
delta = nowQuiet ? -1 : +1;
} while( (wasQuiet || nowQuiet) && (next = next->getProvider()));
return( result );
}
void IOService::adjustBusy( SInt32 delta )
{
lockForArbitration();
_adjustBusy( delta );
unlockForArbitration();
}
UInt32 IOService::getBusyState( void )
{
return( __state[1] & kIOServiceBusyStateMask );
}
IOReturn IOService::waitForState( UInt32 mask, UInt32 value,
mach_timespec_t * timeout )
{
bool wait;
int waitResult = THREAD_AWAKENED;
bool computeDeadline = true;
AbsoluteTime abstime;
do {
lockForArbitration();
IOLockLock( gIOServiceBusyLock );
wait = (value != (__state[1] & mask));
if( wait) {
__state[1] |= kIOServiceBusyWaiterState;
unlockForArbitration();
if( timeout ) {
if( computeDeadline ) {
AbsoluteTime nsinterval;
clock_interval_to_absolutetime_interval(
timeout->tv_sec, kSecondScale, &abstime );
clock_interval_to_absolutetime_interval(
timeout->tv_nsec, kNanosecondScale, &nsinterval );
ADD_ABSOLUTETIME( &abstime, &nsinterval );
clock_absolutetime_interval_to_deadline(
abstime, &abstime );
computeDeadline = false;
}
assert_wait_deadline((event_t)this, THREAD_UNINT, __OSAbsoluteTime(abstime));
}
else
assert_wait((event_t)this, THREAD_UNINT );
} else
unlockForArbitration();
IOLockUnlock( gIOServiceBusyLock );
if( wait)
waitResult = thread_block(THREAD_CONTINUE_NULL);
} while( wait && (waitResult != THREAD_TIMED_OUT));
if( waitResult == THREAD_TIMED_OUT)
return( kIOReturnTimeout );
else
return( kIOReturnSuccess );
}
IOReturn IOService::waitQuiet( mach_timespec_t * timeout )
{
return( waitForState( kIOServiceBusyStateMask, 0, timeout ));
}
bool IOService::serializeProperties( OSSerialize * s ) const
{
#if 0
((IOService *)this)->setProperty( ((IOService *)this)->__state,
sizeof( __state), "__state");
#endif
return( super::serializeProperties(s) );
}
void _IOConfigThread::main( _IOConfigThread * self )
{
_IOServiceJob * job;
IOService * nub;
bool alive = true;
kern_return_t kr;
thread_precedence_policy_data_t precedence = { -1 };
kr = thread_policy_set(current_thread(),
THREAD_PRECEDENCE_POLICY,
(thread_policy_t) &precedence,
THREAD_PRECEDENCE_POLICY_COUNT);
if (KERN_SUCCESS != kr)
IOLog("thread_policy_set(%d)\n", kr);
do {
semaphore_wait( gJobsSemaphore );
IOTakeLock( gJobsLock );
job = (_IOServiceJob *) gJobs->getFirstObject();
job->retain();
gJobs->removeObject(job);
if( job) {
gOutstandingJobs--;
gNumWaitingThreads--; }
IOUnlock( gJobsLock );
if( job) {
nub = job->nub;
if( gIOKitDebug & kIOLogConfig)
LOG("config(%x): starting on %s, %d\n",
(int) IOThreadSelf(), job->nub->getName(), job->type);
switch( job->type) {
case kMatchNubJob:
nub->doServiceMatch( job->options );
break;
default:
LOG("config(%x): strange type (%d)\n",
(int) IOThreadSelf(), job->type );
break;
}
nub->release();
job->release();
IOTakeLock( gJobsLock );
alive = (gOutstandingJobs > gNumWaitingThreads);
if( alive)
gNumWaitingThreads++; else {
if( 0 == --gNumConfigThreads) {
IOLockWakeup( gJobsLock, (event_t) &gNumConfigThreads, false );
}
}
IOUnlock( gJobsLock );
}
} while( alive );
if( gIOKitDebug & kIOLogConfig)
LOG("config(%x): terminating\n", (int) IOThreadSelf() );
self->release();
}
IOReturn IOService::waitMatchIdle( UInt32 msToWait )
{
bool wait;
int waitResult = THREAD_AWAKENED;
bool computeDeadline = true;
AbsoluteTime abstime;
IOLockLock( gJobsLock );
do {
wait = (0 != gNumConfigThreads);
if( wait) {
if( msToWait) {
if( computeDeadline ) {
clock_interval_to_absolutetime_interval(
msToWait, kMillisecondScale, &abstime );
clock_absolutetime_interval_to_deadline(
abstime, &abstime );
computeDeadline = false;
}
waitResult = IOLockSleepDeadline( gJobsLock, &gNumConfigThreads,
abstime, THREAD_UNINT );
} else {
waitResult = IOLockSleep( gJobsLock, &gNumConfigThreads,
THREAD_UNINT );
}
}
} while( wait && (waitResult != THREAD_TIMED_OUT));
IOLockUnlock( gJobsLock );
if( waitResult == THREAD_TIMED_OUT)
return( kIOReturnTimeout );
else
return( kIOReturnSuccess );
}
void _IOServiceJob::pingConfig( _IOServiceJob * job )
{
int count;
bool create;
assert( job );
IOTakeLock( gJobsLock );
gOutstandingJobs++;
gJobs->setLastObject( job );
count = gNumWaitingThreads;
create = ( (gOutstandingJobs > count)
&& (gNumConfigThreads < kMaxConfigThreads) );
if( create) {
gNumConfigThreads++;
gNumWaitingThreads++;
}
IOUnlock( gJobsLock );
job->release();
if( create) {
if( gIOKitDebug & kIOLogConfig)
LOG("config(%d): creating\n", gNumConfigThreads - 1);
_IOConfigThread::configThread();
}
semaphore_signal( gJobsSemaphore );
}
OSObject * IOService::getExistingServices( OSDictionary * matching,
IOOptionBits inState, IOOptionBits options )
{
OSObject * current = 0;
OSIterator * iter;
IOService * service;
OSObject * obj;
if( !matching)
return( 0 );
if(true
&& (obj = matching->getObject(gIOProviderClassKey))
&& gIOResourcesKey
&& gIOResourcesKey->isEqualTo(obj)
&& (service = gIOResources))
{
if( (inState == (service->__state[0] & inState))
&& (0 == (service->__state[0] & kIOServiceInactiveState))
&& service->passiveMatch( matching ))
{
if( options & kIONotifyOnce)
current = service;
else
current = OSSet::withObjects(
(const OSObject **) &service, 1, 1 );
}
}
else
{
iter = IORegistryIterator::iterateOver( gIOServicePlane,
kIORegistryIterateRecursively );
if( iter) {
do {
iter->reset();
while( (service = (IOService *) iter->getNextObject())) {
if( (inState == (service->__state[0] & inState))
&& (0 == (service->__state[0] & kIOServiceInactiveState))
&& service->passiveMatch( matching )) {
if( options & kIONotifyOnce) {
current = service;
break;
}
if( current)
((OSSet *)current)->setObject( service );
else
current = OSSet::withObjects(
(const OSObject **) &service, 1, 1 );
}
}
} while( !service && !iter->isValid());
iter->release();
}
}
if( current && (0 == (options & (kIONotifyOnce | kIOServiceExistingSet)))) {
iter = OSCollectionIterator::withCollection( (OSSet *)current );
current->release();
current = iter;
}
return( current );
}
OSIterator * IOService::getMatchingServices( OSDictionary * matching )
{
OSIterator * iter;
LOCKWRITENOTIFY();
iter = (OSIterator *) getExistingServices( matching,
kIOServiceMatchedState );
UNLOCKNOTIFY();
return( iter );
}
IONotifier * IOService::setNotification(
const OSSymbol * type, OSDictionary * matching,
IOServiceNotificationHandler handler, void * target, void * ref,
SInt32 priority )
{
_IOServiceNotifier * notify = 0;
OSOrderedSet * set;
if( !matching)
return( 0 );
notify = new _IOServiceNotifier;
if( notify && !notify->init()) {
notify->release();
notify = 0;
}
if( notify) {
notify->matching = matching;
notify->handler = handler;
notify->target = target;
notify->ref = ref;
notify->priority = priority;
notify->state = kIOServiceNotifyEnable;
queue_init( ¬ify->handlerInvocations );
if( 0 == (set = (OSOrderedSet *) gNotifications->getObject( type ))) {
set = OSOrderedSet::withCapacity( 1,
IONotifyOrdering, 0 );
if( set) {
gNotifications->setObject( type, set );
set->release();
}
}
notify->whence = set;
if( set)
set->setObject( notify );
}
return( notify );
}
IONotifier * IOService::doInstallNotification(
const OSSymbol * type, OSDictionary * matching,
IOServiceNotificationHandler handler,
void * target, void * ref,
SInt32 priority, OSIterator ** existing )
{
OSIterator * exist;
IONotifier * notify;
IOOptionBits inState;
if( !matching)
return( 0 );
if( type == gIOPublishNotification)
inState = kIOServiceRegisteredState;
else if( type == gIOFirstPublishNotification)
inState = kIOServiceFirstPublishState;
else if( (type == gIOMatchedNotification)
|| (type == gIOFirstMatchNotification))
inState = kIOServiceMatchedState;
else if( type == gIOTerminatedNotification)
inState = 0;
else
return( 0 );
notify = setNotification( type, matching, handler, target, ref, priority );
if( inState)
exist = (OSIterator *) getExistingServices( matching, inState );
else
exist = 0;
*existing = exist;
return( notify );
}
IONotifier * IOService::installNotification(
const OSSymbol * type, OSDictionary * matching,
IOServiceNotificationHandler handler,
void * target, void * ref,
SInt32 priority, OSIterator ** existing )
{
IONotifier * notify;
LOCKWRITENOTIFY();
notify = doInstallNotification( type, matching, handler, target, ref,
priority, existing );
UNLOCKNOTIFY();
return( notify );
}
IONotifier * IOService::addNotification(
const OSSymbol * type, OSDictionary * matching,
IOServiceNotificationHandler handler,
void * target, void * ref,
SInt32 priority )
{
OSIterator * existing = NULL;
_IOServiceNotifier * notify;
IOService * next;
notify = (_IOServiceNotifier *) installNotification( type, matching,
handler, target, ref, priority, &existing );
if( existing) {
notify->retain(); while( (next = (IOService *) existing->getNextObject())) {
next->lockForArbitration();
if( 0 == (next->__state[0] & kIOServiceInactiveState))
next->invokeNotifer( notify );
next->unlockForArbitration();
}
notify->release();
existing->release();
}
return( notify );
}
struct SyncNotifyVars {
semaphore_port_t waitHere;
IOService * result;
};
bool IOService::syncNotificationHandler(
void * , void * ref,
IOService * newService )
{
((SyncNotifyVars *) ref)->result = newService;
semaphore_signal( ((SyncNotifyVars *) ref)->waitHere );
return( false );
}
IOService * IOService::waitForService( OSDictionary * matching,
mach_timespec_t * timeout )
{
IONotifier * notify = 0;
SInt32 priority = 0;
SyncNotifyVars state;
kern_return_t err = kIOReturnBadArgument;
if( !matching)
return( 0 );
state.waitHere = 0;
state.result = 0;
LOCKWRITENOTIFY();
do {
state.result = (IOService *) getExistingServices( matching,
kIOServiceMatchedState, kIONotifyOnce );
if( state.result)
continue;
err = semaphore_create( kernel_task, &state.waitHere,
SYNC_POLICY_FIFO, 0 );
if( KERN_SUCCESS != err)
continue;
notify = IOService::setNotification( gIOMatchedNotification, matching,
&IOService::syncNotificationHandler, (void *) 0,
(void *) &state, priority );
} while( false );
UNLOCKNOTIFY();
if( notify) {
if( timeout)
err = semaphore_timedwait( state.waitHere, *timeout );
else
err = semaphore_wait( state.waitHere );
}
if( notify)
notify->remove(); else
matching->release();
if( state.waitHere)
semaphore_destroy( kernel_task, state.waitHere );
return( state.result );
}
void IOService::deliverNotification( const OSSymbol * type,
IOOptionBits orNewState, IOOptionBits andNewState )
{
_IOServiceNotifier * notify;
OSIterator * iter;
OSArray * willSend = 0;
lockForArbitration();
if( (0 == (__state[0] & kIOServiceInactiveState))
|| (type == gIOTerminatedNotification)) {
LOCKREADNOTIFY();
iter = OSCollectionIterator::withCollection( (OSOrderedSet *)
gNotifications->getObject( type ) );
if( iter) {
while( (notify = (_IOServiceNotifier *) iter->getNextObject())) {
if( passiveMatch( notify->matching)
&& (kIOServiceNotifyEnable & notify->state)) {
if( 0 == willSend)
willSend = OSArray::withCapacity(8);
if( willSend)
willSend->setObject( notify );
}
}
iter->release();
}
__state[0] = (__state[0] | orNewState) & andNewState;
UNLOCKNOTIFY();
}
if( willSend) {
for( unsigned int idx = 0;
(notify = (_IOServiceNotifier *) willSend->getObject(idx));
idx++) {
invokeNotifer( notify );
}
willSend->release();
}
unlockForArbitration();
}
IOOptionBits IOService::getState( void ) const
{
return( __state[0] );
}
OSDictionary * IOService::serviceMatching( const OSString * name,
OSDictionary * table )
{
if( !table)
table = OSDictionary::withCapacity( 2 );
if( table)
table->setObject(gIOProviderClassKey, (OSObject *)name );
return( table );
}
OSDictionary * IOService::serviceMatching( const char * name,
OSDictionary * table )
{
const OSString * str;
str = OSSymbol::withCString( name );
if( !str)
return( 0 );
table = serviceMatching( str, table );
str->release();
return( table );
}
OSDictionary * IOService::nameMatching( const OSString * name,
OSDictionary * table )
{
if( !table)
table = OSDictionary::withCapacity( 2 );
if( table)
table->setObject( gIONameMatchKey, (OSObject *)name );
return( table );
}
OSDictionary * IOService::nameMatching( const char * name,
OSDictionary * table )
{
const OSString * str;
str = OSSymbol::withCString( name );
if( !str)
return( 0 );
table = nameMatching( str, table );
str->release();
return( table );
}
OSDictionary * IOService::resourceMatching( const OSString * str,
OSDictionary * table )
{
table = serviceMatching( gIOResourcesKey, table );
if( table)
table->setObject( gIOResourceMatchKey, (OSObject *) str );
return( table );
}
OSDictionary * IOService::resourceMatching( const char * name,
OSDictionary * table )
{
const OSSymbol * str;
str = OSSymbol::withCString( name );
if( !str)
return( 0 );
table = resourceMatching( str, table );
str->release();
return( table );
}
OSDictionary * IOService::propertyMatching( const OSSymbol * key, const OSObject * value,
OSDictionary * table )
{
OSDictionary * properties;
properties = OSDictionary::withCapacity( 2 );
if( !properties)
return( 0 );
properties->setObject( key, value );
if( !table)
table = OSDictionary::withCapacity( 2 );
if( table)
table->setObject( gIOPropertyMatchKey, properties );
properties->release();
return( table );
}
void _IOServiceNotifier::wait()
{
_IOServiceNotifierInvocation * next;
bool doWait;
do {
doWait = false;
queue_iterate( &handlerInvocations, next,
_IOServiceNotifierInvocation *, link) {
if( next->thread != current_thread() ) {
doWait = true;
break;
}
}
if( doWait) {
state |= kIOServiceNotifyWaiter;
SLEEPNOTIFY(this);
}
} while( doWait );
}
void _IOServiceNotifier::free()
{
assert( queue_empty( &handlerInvocations ));
OSObject::free();
}
void _IOServiceNotifier::remove()
{
LOCKWRITENOTIFY();
if( whence) {
whence->removeObject( (OSObject *) this );
whence = 0;
}
if( matching) {
matching->release();
matching = 0;
}
state &= ~kIOServiceNotifyEnable;
wait();
UNLOCKNOTIFY();
release();
}
bool _IOServiceNotifier::disable()
{
bool ret;
LOCKWRITENOTIFY();
ret = (0 != (kIOServiceNotifyEnable & state));
state &= ~kIOServiceNotifyEnable;
if( ret)
wait();
UNLOCKNOTIFY();
return( ret );
}
void _IOServiceNotifier::enable( bool was )
{
LOCKWRITENOTIFY();
if( was)
state |= kIOServiceNotifyEnable;
else
state &= ~kIOServiceNotifyEnable;
UNLOCKNOTIFY();
}
IOService * IOResources::resources( void )
{
IOResources * inst;
inst = new IOResources;
if( inst && !inst->init()) {
inst->release();
inst = 0;
}
return( inst );
}
IOWorkLoop * IOResources::getWorkLoop() const
{
if (this == (IOResources *) gIOResources)
return getPlatform()->getWorkLoop();
else
return IOService::getWorkLoop();
}
bool IOResources::matchPropertyTable( OSDictionary * table )
{
OSObject * prop;
OSString * str;
OSSet * set;
OSIterator * iter;
bool ok = false;
prop = table->getObject( gIOResourceMatchKey );
str = OSDynamicCast( OSString, prop );
if( str)
ok = (0 != getProperty( str ));
else if( (set = OSDynamicCast( OSSet, prop))) {
iter = OSCollectionIterator::withCollection( set );
ok = (iter != 0);
while( ok && (str = OSDynamicCast( OSString, iter->getNextObject()) ))
ok = (0 != getProperty( str ));
if( iter)
iter->release();
}
return( ok );
}
IOReturn IOResources::setProperties( OSObject * properties )
{
IOReturn err;
const OSSymbol * key;
OSDictionary * dict;
OSCollectionIterator * iter;
err = IOUserClient::clientHasPrivilege(current_task(), kIOClientPrivilegeAdministrator);
if ( kIOReturnSuccess != err)
return( err );
dict = OSDynamicCast(OSDictionary, properties);
if( 0 == dict)
return( kIOReturnBadArgument);
iter = OSCollectionIterator::withCollection( dict);
if( 0 == iter)
return( kIOReturnBadArgument);
while( (key = OSDynamicCast(OSSymbol, iter->getNextObject()))) {
if (gIOConsoleUsersKey == key)
{
IORegistryEntry::getRegistryRoot()->setProperty(key, dict->getObject(key));
OSIncrementAtomic( &gIOConsoleUsersSeed );
publishResource( gIOConsoleUsersSeedKey, gIOConsoleUsersSeedValue );
continue;
}
publishResource( key, dict->getObject(key) );
}
iter->release();
return( kIOReturnSuccess );
}
bool IOService::compareProperty( OSDictionary * matching,
const char * key )
{
OSObject * value;
bool ok;
value = matching->getObject( key );
if( value)
ok = value->isEqualTo( getProperty( key ));
else
ok = true;
return( ok );
}
bool IOService::compareProperty( OSDictionary * matching,
const OSString * key )
{
OSObject * value;
bool ok;
value = matching->getObject( key );
if( value)
ok = value->isEqualTo( getProperty( key ));
else
ok = true;
return( ok );
}
bool IOService::compareProperties( OSDictionary * matching,
OSCollection * keys )
{
OSCollectionIterator * iter;
const OSString * key;
bool ok = true;
if( !matching || !keys)
return( false );
iter = OSCollectionIterator::withCollection( keys );
if( iter) {
while( ok && (key = OSDynamicCast( OSString, iter->getNextObject())))
ok = compareProperty( matching, key );
iter->release();
}
keys->release();
return( ok );
}
OSDictionary * IOService::addLocation( OSDictionary * table )
{
OSDictionary * dict;
if( !table)
return( 0 );
dict = OSDictionary::withCapacity( 1 );
if( dict) {
table->setObject( gIOLocationMatchKey, dict );
dict->release();
}
return( dict );
}
IOService * IOService::matchLocation( IOService * )
{
IOService * parent;
parent = getProvider();
if( parent)
parent = parent->matchLocation( this );
return( parent );
}
bool IOService::passiveMatch( OSDictionary * table, bool changesOK )
{
IOService * where;
OSString * matched;
OSObject * obj;
OSString * str;
IORegistryEntry * entry;
OSNumber * num;
SInt32 score;
OSNumber * newPri;
bool match = true;
bool matchParent = false;
UInt32 done;
assert( table );
where = this;
do {
do {
done = 0;
str = OSDynamicCast( OSString, table->getObject( gIOProviderClassKey));
if( str) {
done++;
match = (0 != where->metaCast( str ));
if( !match)
break;
}
obj = table->getObject( gIONameMatchKey );
if( obj) {
done++;
match = where->compareNames( obj, changesOK ? &matched : 0 );
if( !match)
break;
if( changesOK && matched) {
table->setObject( gIONameMatchedKey, matched );
matched->release();
}
}
str = OSDynamicCast( OSString, table->getObject( gIOLocationMatchKey ));
if( str) {
const OSSymbol * sym;
done++;
match = false;
sym = where->copyLocation();
if( sym) {
match = sym->isEqualTo( str );
sym->release();
}
if( !match)
break;
}
obj = table->getObject( gIOPropertyMatchKey );
if( obj) {
OSDictionary * dict;
OSDictionary * nextDict;
OSIterator * iter;
done++;
match = false;
dict = where->dictionaryWithProperties();
if( dict) {
nextDict = OSDynamicCast( OSDictionary, obj);
if( nextDict)
iter = 0;
else
iter = OSCollectionIterator::withCollection(
OSDynamicCast(OSCollection, obj));
while( nextDict
|| (iter && (0 != (nextDict = OSDynamicCast(OSDictionary,
iter->getNextObject()))))) {
match = dict->isEqualTo( nextDict, nextDict);
if( match)
break;
nextDict = 0;
}
dict->release();
if( iter)
iter->release();
}
if( !match)
break;
}
str = OSDynamicCast( OSString, table->getObject( gIOPathMatchKey ));
if( str) {
done++;
entry = IORegistryEntry::fromPath( str->getCStringNoCopy() );
match = (where == entry);
if( entry)
entry->release();
if( !match)
break;
}
num = OSDynamicCast( OSNumber, table->getObject( gIOMatchedServiceCountKey ));
if( num) {
OSIterator * iter;
IOService * service = 0;
UInt32 serviceCount = 0;
done++;
iter = where->getClientIterator();
if( iter) {
while( (service = (IOService *) iter->getNextObject())) {
if( kIOServiceInactiveState & service->__state[0])
continue;
if( 0 == service->getProperty( gIOMatchCategoryKey ))
continue;
++serviceCount;
}
iter->release();
}
match = (serviceCount == num->unsigned32BitValue());
if( !match)
break;
}
if( done == table->getCount()) {
matchParent = false;
break;
}
score = IOServiceObjectOrder( table, (void *) gIOProbeScoreKey);
match = where->matchPropertyTable( table, &score );
if( !match) {
#if IOMATCHDEBUG
if( kIOLogMatch & getDebugFlags( table ))
LOG("%s: family specific matching fails\n", where->getName());
#endif
break;
}
if( changesOK) {
newPri = OSNumber::withNumber( score, 32 );
if( newPri) {
table->setObject( gIOProbeScoreKey, newPri );
newPri->release();
}
}
if( !(match = where->compareProperty( table, kIOBSDNameKey )))
break;
if( !(match = where->compareProperty( table, kIOBSDMajorKey )))
break;
if( !(match = where->compareProperty( table, kIOBSDMinorKey )))
break;
if( !(match = where->compareProperty( table, kIOBSDUnitKey )))
break;
matchParent = false;
obj = OSDynamicCast( OSDictionary,
table->getObject( gIOParentMatchKey ));
if( obj) {
match = false;
matchParent = true;
table = (OSDictionary *) obj;
break;
}
table = OSDynamicCast( OSDictionary,
table->getObject( gIOLocationMatchKey ));
if( table) {
match = false;
where = where->getProvider();
if( where)
where = where->matchLocation( where );
}
} while( table && where );
} while( matchParent && (where = where->getProvider()) );
if( kIOLogMatch & gIOKitDebug)
if( where != this)
LOG("match parent @ %s = %d\n",
where->getName(), match );
return( match );
}
IOReturn IOService::newUserClient( task_t owningTask, void * securityID,
UInt32 type, OSDictionary * properties,
IOUserClient ** handler )
{
const OSSymbol *userClientClass = 0;
IOUserClient *client;
OSObject *temp;
if (kIOReturnSuccess == newUserClient( owningTask, securityID, type, handler ))
return kIOReturnSuccess;
temp = getProperty(gIOUserClientClassKey);
if (temp) {
if (OSDynamicCast(OSSymbol, temp))
userClientClass = (const OSSymbol *) temp;
else if (OSDynamicCast(OSString, temp)) {
userClientClass = OSSymbol::withString((OSString *) temp);
if (userClientClass)
setProperty(kIOUserClientClassKey,
(OSObject *) userClientClass);
}
}
if (!userClientClass)
return kIOReturnUnsupported;
temp = OSMetaClass::allocClassWithName(userClientClass);
if (!temp)
return kIOReturnNoMemory;
if (OSDynamicCast(IOUserClient, temp))
client = (IOUserClient *) temp;
else {
temp->release();
return kIOReturnUnsupported;
}
if ( !client->initWithTask(owningTask, securityID, type, properties) ) {
client->release();
return kIOReturnBadArgument;
}
if ( !client->attach(this) ) {
client->release();
return kIOReturnUnsupported;
}
if ( !client->start(this) ) {
client->detach(this);
client->release();
return kIOReturnUnsupported;
}
*handler = client;
return kIOReturnSuccess;
}
IOReturn IOService::newUserClient( task_t owningTask, void * securityID,
UInt32 type, IOUserClient ** handler )
{
return( kIOReturnUnsupported );
}
IOReturn IOService::requestProbe( IOOptionBits options )
{
return( kIOReturnUnsupported);
}
const char * IOService::stringFromReturn( IOReturn rtn )
{
static const IONamedValue IOReturn_values[] = {
{kIOReturnSuccess, "success" },
{kIOReturnError, "general error" },
{kIOReturnNoMemory, "memory allocation error" },
{kIOReturnNoResources, "resource shortage" },
{kIOReturnIPCError, "Mach IPC failure" },
{kIOReturnNoDevice, "no such device" },
{kIOReturnNotPrivileged, "privilege violation" },
{kIOReturnBadArgument, "invalid argument" },
{kIOReturnLockedRead, "device is read locked" },
{kIOReturnLockedWrite, "device is write locked" },
{kIOReturnExclusiveAccess, "device is exclusive access" },
{kIOReturnBadMessageID, "bad IPC message ID" },
{kIOReturnUnsupported, "unsupported function" },
{kIOReturnVMError, "virtual memory error" },
{kIOReturnInternalError, "internal driver error" },
{kIOReturnIOError, "I/O error" },
{kIOReturnCannotLock, "cannot acquire lock" },
{kIOReturnNotOpen, "device is not open" },
{kIOReturnNotReadable, "device is not readable" },
{kIOReturnNotWritable, "device is not writeable" },
{kIOReturnNotAligned, "alignment error" },
{kIOReturnBadMedia, "media error" },
{kIOReturnStillOpen, "device is still open" },
{kIOReturnRLDError, "rld failure" },
{kIOReturnDMAError, "DMA failure" },
{kIOReturnBusy, "device is busy" },
{kIOReturnTimeout, "I/O timeout" },
{kIOReturnOffline, "device is offline" },
{kIOReturnNotReady, "device is not ready" },
{kIOReturnNotAttached, "device/channel is not attached" },
{kIOReturnNoChannels, "no DMA channels available" },
{kIOReturnNoSpace, "no space for data" },
{kIOReturnPortExists, "device port already exists" },
{kIOReturnCannotWire, "cannot wire physical memory" },
{kIOReturnNoInterrupt, "no interrupt attached" },
{kIOReturnNoFrames, "no DMA frames enqueued" },
{kIOReturnMessageTooLarge, "message is too large" },
{kIOReturnNotPermitted, "operation is not permitted" },
{kIOReturnNoPower, "device is without power" },
{kIOReturnNoMedia, "media is not present" },
{kIOReturnUnformattedMedia, "media is not formatted" },
{kIOReturnUnsupportedMode, "unsupported mode" },
{kIOReturnUnderrun, "data underrun" },
{kIOReturnOverrun, "data overrun" },
{kIOReturnDeviceError, "device error" },
{kIOReturnNoCompletion, "no completion routine" },
{kIOReturnAborted, "operation was aborted" },
{kIOReturnNoBandwidth, "bus bandwidth would be exceeded" },
{kIOReturnNotResponding, "device is not responding" },
{kIOReturnInvalid, "unanticipated driver error" },
{0, NULL }
};
return IOFindNameForValue(rtn, IOReturn_values);
}
int IOService::errnoFromReturn( IOReturn rtn )
{
switch(rtn) {
case kIOReturnSuccess:
return(0);
case kIOReturnNoMemory:
return(ENOMEM);
case kIOReturnNoDevice:
return(ENXIO);
case kIOReturnVMError:
return(EFAULT);
case kIOReturnNotPermitted:
return(EPERM);
case kIOReturnNotPrivileged:
return(EACCES);
case kIOReturnIOError:
return(EIO);
case kIOReturnNotWritable:
return(EROFS);
case kIOReturnBadArgument:
return(EINVAL);
case kIOReturnUnsupported:
return(ENOTSUP);
case kIOReturnBusy:
return(EBUSY);
case kIOReturnNoPower:
return(EPWROFF);
case kIOReturnDeviceError:
return(EDEVERR);
case kIOReturnTimeout:
return(ETIMEDOUT);
case kIOReturnMessageTooLarge:
return(EMSGSIZE);
case kIOReturnNoSpace:
return(ENOSPC);
case kIOReturnCannotLock:
return(ENOLCK);
case kIOReturnBadMessageID:
case kIOReturnNoCompletion:
case kIOReturnNotAligned:
return(EINVAL);
case kIOReturnNotReady:
return(EBUSY);
case kIOReturnRLDError:
return(EBADMACHO);
case kIOReturnPortExists:
case kIOReturnStillOpen:
return(EEXIST);
case kIOReturnExclusiveAccess:
case kIOReturnLockedRead:
case kIOReturnLockedWrite:
case kIOReturnNotAttached:
case kIOReturnNotOpen:
case kIOReturnNotReadable:
return(EACCES);
case kIOReturnCannotWire:
case kIOReturnNoResources:
return(ENOMEM);
case kIOReturnAborted:
case kIOReturnOffline:
case kIOReturnNotResponding:
return(EBUSY);
case kIOReturnBadMedia:
case kIOReturnNoMedia:
case kIOReturnUnformattedMedia:
return(ENXIO); case kIOReturnDMAError:
case kIOReturnOverrun:
case kIOReturnUnderrun:
return(EIO); case kIOReturnNoBandwidth:
case kIOReturnNoChannels:
case kIOReturnNoFrames:
case kIOReturnNoInterrupt:
return(EIO); case kIOReturnError:
case kIOReturnInternalError:
case kIOReturnInvalid:
return(EIO); case kIOReturnIPCError:
return(EIO); default:
return(EIO); }
}
IOReturn IOService::message( UInt32 type, IOService * provider,
void * argument )
{
return kIOReturnUnsupported;
}
IOItemCount IOService::getDeviceMemoryCount( void )
{
OSArray * array;
IOItemCount count;
array = OSDynamicCast( OSArray, getProperty( gIODeviceMemoryKey));
if( array)
count = array->getCount();
else
count = 0;
return( count);
}
IODeviceMemory * IOService::getDeviceMemoryWithIndex( unsigned int index )
{
OSArray * array;
IODeviceMemory * range;
array = OSDynamicCast( OSArray, getProperty( gIODeviceMemoryKey));
if( array)
range = (IODeviceMemory *) array->getObject( index );
else
range = 0;
return( range);
}
IOMemoryMap * IOService::mapDeviceMemoryWithIndex( unsigned int index,
IOOptionBits options )
{
IODeviceMemory * range;
IOMemoryMap * map;
range = getDeviceMemoryWithIndex( index );
if( range)
map = range->map( options );
else
map = 0;
return( map );
}
OSArray * IOService::getDeviceMemory( void )
{
return( OSDynamicCast( OSArray, getProperty( gIODeviceMemoryKey)));
}
void IOService::setDeviceMemory( OSArray * array )
{
setProperty( gIODeviceMemoryKey, array);
}
void IOService::
setCPUSnoopDelay(UInt32 __unused ns)
{
#if defined(__i386__)
ml_set_maxsnoop(ns);
#endif
}
UInt32 IOService::
getCPUSnoopDelay()
{
#if defined(__i386__)
return ml_get_maxsnoop();
#else
return 0;
#endif
}
#if defined(__i386__)
static void
requireMaxCpuDelay(IOService * service, UInt32 ns, UInt32 delayType)
{
static const UInt kNoReplace = -1U; UInt replace = kNoReplace;
bool setCpuDelay = false;
IORecursiveLockLock(sCpuDelayLock);
UInt count = sCpuDelayData->getLength() / sizeof(CpuDelayEntry);
CpuDelayEntry *entries = (CpuDelayEntry *) sCpuDelayData->getBytesNoCopy();
IOService * holder = NULL;
if (ns) {
const CpuDelayEntry ne = {service, ns, delayType};
holder = service;
for (UInt i = 0; i < count; i++) {
IOService *thisService = entries[i].fService;
bool sameType = (delayType == entries[i].fDelayType);
if ((service == thisService) && sameType)
replace = i;
else if (!thisService) {
if (kNoReplace == replace)
replace = i;
}
else if (sameType) {
const UInt32 thisMax = entries[i].fMaxDelay;
if (thisMax < ns)
{
ns = thisMax;
holder = thisService;
}
}
}
setCpuDelay = true;
if (kNoReplace == replace)
sCpuDelayData->appendBytes(&ne, sizeof(ne));
else
entries[replace] = ne;
}
else {
ns = -1U;
for (UInt i = 0; i < count; i++) {
IOService *thisService = entries[i].fService;
if (thisService && (delayType == entries[i].fDelayType)) {
UInt32 thisMax = entries[i].fMaxDelay;
if (service == thisService)
replace = i;
else if (thisMax < ns) {
ns = thisMax;
holder = thisService;
}
}
}
if (kNoReplace != replace) {
entries[replace].fService = 0; setCpuDelay = true;
}
}
if (setCpuDelay)
{
if (delayType == kCpuDelayBusStall)
{
ml_set_maxbusdelay(ns);
}
else if (delayType == kCpuDelayInterrupt)
{
ml_set_maxintdelay(ns);
}
OSArray * handlers = sCpuLatencyHandlers[delayType];
IOService * target;
if (handlers) for (unsigned int idx = 0;
(target = (IOService *) handlers->getObject(idx));
idx++)
{
target->callPlatformFunction(sCPULatencyFunctionName[delayType], false,
(void *) (uintptr_t) ns, holder,
NULL, NULL);
}
}
IORecursiveLockUnlock(sCpuDelayLock);
}
static IOReturn
setLatencyHandler(UInt32 delayType, IOService * target, bool enable)
{
IOReturn result = kIOReturnNotFound;
OSArray * array;
unsigned int idx;
IORecursiveLockLock(sCpuDelayLock);
do
{
if (enable && !sCpuLatencyHandlers[delayType])
sCpuLatencyHandlers[delayType] = OSArray::withCapacity(4);
array = sCpuLatencyHandlers[delayType];
if (!array)
break;
idx = array->getNextIndexOfObject(target, 0);
if (!enable)
{
if (-1U != idx)
{
array->removeObject(idx);
result = kIOReturnSuccess;
}
}
else
{
if (-1U != idx) {
result = kIOReturnExclusiveAccess;
break;
}
array->setObject(target);
UInt count = sCpuDelayData->getLength() / sizeof(CpuDelayEntry);
CpuDelayEntry *entries = (CpuDelayEntry *) sCpuDelayData->getBytesNoCopy();
UInt32 ns = -1U; IOService * holder = NULL;
for (UInt i = 0; i < count; i++) {
if (entries[i].fService
&& (delayType == entries[i].fDelayType)
&& (entries[i].fMaxDelay < ns)) {
ns = entries[i].fMaxDelay;
holder = entries[i].fService;
}
}
target->callPlatformFunction(sCPULatencyFunctionName[delayType], false,
(void *) (uintptr_t) ns, holder,
NULL, NULL);
result = kIOReturnSuccess;
}
}
while (false);
IORecursiveLockUnlock(sCpuDelayLock);
return (result);
}
#endif
void IOService::
requireMaxBusStall(UInt32 __unused ns)
{
#if defined(__i386__)
requireMaxCpuDelay(this, ns, kCpuDelayBusStall);
#endif
}
IOReturn IOService::resolveInterrupt(IOService *nub, int source)
{
IOInterruptController *interruptController;
OSArray *array;
OSData *data;
OSSymbol *interruptControllerName;
long numSources;
IOInterruptSource *interruptSources;
array = OSDynamicCast(OSArray, nub->getProperty(gIOInterruptControllersKey));
if (array == 0) return kIOReturnNoResources;
if (nub->_interruptSources == 0) {
numSources = array->getCount();
interruptSources = (IOInterruptSource *)IOMalloc(numSources * sizeof(IOInterruptSource));
if (interruptSources == 0) return kIOReturnNoMemory;
bzero(interruptSources, numSources * sizeof(IOInterruptSource));
nub->_numInterruptSources = numSources;
nub->_interruptSources = interruptSources;
return kIOReturnSuccess;
}
interruptControllerName = OSDynamicCast(OSSymbol,array->getObject(source));
if (interruptControllerName == 0) return kIOReturnNoResources;
interruptController = getPlatform()->lookUpInterruptController(interruptControllerName);
if (interruptController == 0) return kIOReturnNoResources;
array = OSDynamicCast(OSArray, nub->getProperty(gIOInterruptSpecifiersKey));
if (array == 0) return kIOReturnNoResources;
data = OSDynamicCast(OSData, array->getObject(source));
if (data == 0) return kIOReturnNoResources;
interruptSources = nub->_interruptSources;
interruptSources[source].interruptController = interruptController;
interruptSources[source].vectorData = data;
return kIOReturnSuccess;
}
IOReturn IOService::lookupInterrupt(int source, bool resolve, IOInterruptController **interruptController)
{
IOReturn ret;
if (_interruptSources == 0) {
ret = resolveInterrupt(this, source);
if (ret != kIOReturnSuccess) return ret;
}
if ((source < 0) || (source >= _numInterruptSources))
return kIOReturnNoInterrupt;
*interruptController = _interruptSources[source].interruptController;
if (*interruptController == NULL) {
if (!resolve) return kIOReturnNoInterrupt;
ret = resolveInterrupt(this, source);
if (ret != kIOReturnSuccess) return ret;
*interruptController = _interruptSources[source].interruptController;
}
return kIOReturnSuccess;
}
IOReturn IOService::registerInterrupt(int source, OSObject *target,
IOInterruptAction handler,
void *refCon)
{
IOInterruptController *interruptController;
IOReturn ret;
ret = lookupInterrupt(source, true, &interruptController);
if (ret != kIOReturnSuccess) return ret;
return interruptController->registerInterrupt(this, source, target,
(IOInterruptHandler)handler,
refCon);
}
IOReturn IOService::unregisterInterrupt(int source)
{
IOInterruptController *interruptController;
IOReturn ret;
ret = lookupInterrupt(source, false, &interruptController);
if (ret != kIOReturnSuccess) return ret;
return interruptController->unregisterInterrupt(this, source);
}
IOReturn IOService::getInterruptType(int source, int *interruptType)
{
IOInterruptController *interruptController;
IOReturn ret;
ret = lookupInterrupt(source, true, &interruptController);
if (ret != kIOReturnSuccess) return ret;
return interruptController->getInterruptType(this, source, interruptType);
}
IOReturn IOService::enableInterrupt(int source)
{
IOInterruptController *interruptController;
IOReturn ret;
ret = lookupInterrupt(source, false, &interruptController);
if (ret != kIOReturnSuccess) return ret;
return interruptController->enableInterrupt(this, source);
}
IOReturn IOService::disableInterrupt(int source)
{
IOInterruptController *interruptController;
IOReturn ret;
ret = lookupInterrupt(source, false, &interruptController);
if (ret != kIOReturnSuccess) return ret;
return interruptController->disableInterrupt(this, source);
}
IOReturn IOService::causeInterrupt(int source)
{
IOInterruptController *interruptController;
IOReturn ret;
ret = lookupInterrupt(source, false, &interruptController);
if (ret != kIOReturnSuccess) return ret;
return interruptController->causeInterrupt(this, source);
}
OSMetaClassDefineReservedUsed(IOService, 0);
OSMetaClassDefineReservedUsed(IOService, 1);
OSMetaClassDefineReservedUsed(IOService, 2);
OSMetaClassDefineReservedUsed(IOService, 3);
OSMetaClassDefineReservedUsed(IOService, 4);
OSMetaClassDefineReservedUnused(IOService, 5);
OSMetaClassDefineReservedUnused(IOService, 6);
OSMetaClassDefineReservedUnused(IOService, 7);
OSMetaClassDefineReservedUnused(IOService, 8);
OSMetaClassDefineReservedUnused(IOService, 9);
OSMetaClassDefineReservedUnused(IOService, 10);
OSMetaClassDefineReservedUnused(IOService, 11);
OSMetaClassDefineReservedUnused(IOService, 12);
OSMetaClassDefineReservedUnused(IOService, 13);
OSMetaClassDefineReservedUnused(IOService, 14);
OSMetaClassDefineReservedUnused(IOService, 15);
OSMetaClassDefineReservedUnused(IOService, 16);
OSMetaClassDefineReservedUnused(IOService, 17);
OSMetaClassDefineReservedUnused(IOService, 18);
OSMetaClassDefineReservedUnused(IOService, 19);
OSMetaClassDefineReservedUnused(IOService, 20);
OSMetaClassDefineReservedUnused(IOService, 21);
OSMetaClassDefineReservedUnused(IOService, 22);
OSMetaClassDefineReservedUnused(IOService, 23);
OSMetaClassDefineReservedUnused(IOService, 24);
OSMetaClassDefineReservedUnused(IOService, 25);
OSMetaClassDefineReservedUnused(IOService, 26);
OSMetaClassDefineReservedUnused(IOService, 27);
OSMetaClassDefineReservedUnused(IOService, 28);
OSMetaClassDefineReservedUnused(IOService, 29);
OSMetaClassDefineReservedUnused(IOService, 30);
OSMetaClassDefineReservedUnused(IOService, 31);
OSMetaClassDefineReservedUnused(IOService, 32);
OSMetaClassDefineReservedUnused(IOService, 33);
OSMetaClassDefineReservedUnused(IOService, 34);
OSMetaClassDefineReservedUnused(IOService, 35);
OSMetaClassDefineReservedUnused(IOService, 36);
OSMetaClassDefineReservedUnused(IOService, 37);
OSMetaClassDefineReservedUnused(IOService, 38);
OSMetaClassDefineReservedUnused(IOService, 39);
OSMetaClassDefineReservedUnused(IOService, 40);
OSMetaClassDefineReservedUnused(IOService, 41);
OSMetaClassDefineReservedUnused(IOService, 42);
OSMetaClassDefineReservedUnused(IOService, 43);
OSMetaClassDefineReservedUnused(IOService, 44);
OSMetaClassDefineReservedUnused(IOService, 45);
OSMetaClassDefineReservedUnused(IOService, 46);
OSMetaClassDefineReservedUnused(IOService, 47);
#ifdef __ppc__
OSMetaClassDefineReservedUnused(IOService, 48);
OSMetaClassDefineReservedUnused(IOService, 49);
OSMetaClassDefineReservedUnused(IOService, 50);
OSMetaClassDefineReservedUnused(IOService, 51);
OSMetaClassDefineReservedUnused(IOService, 52);
OSMetaClassDefineReservedUnused(IOService, 53);
OSMetaClassDefineReservedUnused(IOService, 54);
OSMetaClassDefineReservedUnused(IOService, 55);
OSMetaClassDefineReservedUnused(IOService, 56);
OSMetaClassDefineReservedUnused(IOService, 57);
OSMetaClassDefineReservedUnused(IOService, 58);
OSMetaClassDefineReservedUnused(IOService, 59);
OSMetaClassDefineReservedUnused(IOService, 60);
OSMetaClassDefineReservedUnused(IOService, 61);
OSMetaClassDefineReservedUnused(IOService, 62);
OSMetaClassDefineReservedUnused(IOService, 63);
#endif