/*
- * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 1998-2007 Apple Inc. All rights reserved.
*
- * @APPLE_LICENSE_HEADER_START@
- *
- * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
- * compliance with the License. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* Please see the License for the specific language governing rights and
* limitations under the License.
*
- * @APPLE_LICENSE_HEADER_END@
- */
-/*
- * Copyright (c) 1991-1999 Apple Computer, Inc. All rights reserved.
- *
- * HISTORY
- *
- * 29-Jan-91 Portions from IODevice.m, Doug Mitchell at NeXT, Created.
- * 18-Jun-98 start IOKit objc
- * 10-Nov-98 start iokit cpp
- * 25-Feb-99 sdouglas, add threads and locks to ensure deadlock
- *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
*/
#include <IOKit/system.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/IOKitKeys.h>
+#include <IOKit/IOKitKeysPrivate.h>
#include <IOKit/IOBSD.h>
#include <IOKit/IOUserClient.h>
#include <IOKit/IOWorkLoop.h>
const OSSymbol * gIOCommandPoolSizeKey;
+const OSSymbol * gIOConsoleUsersKey;
+const OSSymbol * gIOConsoleSessionUIDKey;
+const OSSymbol * gIOConsoleUsersSeedKey;
+const OSSymbol * gIOConsoleSessionOnConsoleKey;
+const OSSymbol * gIOConsoleSessionSecureInputPIDKey;
+
static int gIOResourceGenerationCount;
const OSSymbol * gIOServiceKey;
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() \
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#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;
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#if defined(__i386__)
+
+// Only used by the intel implementation of
+// IOService::requireMaxBusStall(UInt32 ns)
+// IOService::requireMaxInterruptDelay(uint32_t ns)
+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 /* defined(__i386__) */
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
void IOService::initialize( void )
{
kern_return_t err;
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
&& gIOProviderClassKey && gIONameMatchKey && gIONameMatchedKey
&& gIOMatchCategoryKey && gIODefaultMatchCategoryKey
&& gIOPublishNotification && gIOMatchedNotification
- && gIOTerminatedNotification && gIOServiceKey );
+ && gIOTerminatedNotification && gIOServiceKey
+ && gIOConsoleUsersKey && gIOConsoleSessionUIDKey
+ && gIOConsoleSessionOnConsoleKey && gIOConsoleSessionSecureInputPIDKey
+ && gIOConsoleUsersSeedKey && gIOConsoleUsersSeedValue);
gJobsLock = IOLockAlloc();
gJobs = OSOrderedSet::withCapacity( 10 );
void IOService::free( void )
{
+ requireMaxBusStall(0);
if( getPropertyTable())
unregisterAllInterest();
PMfree();
* Register instance - publish it for matching
*/
-void IOService::registerService( IOOptionBits options = 0 )
+void IOService::registerService( IOOptionBits options )
{
char * pathBuf;
const char * path;
startMatching( options );
}
-void IOService::startMatching( IOOptionBits options = 0 )
+void IOService::startMatching( IOOptionBits options )
{
IOService * provider;
UInt32 prevBusy = 0;
|| ((provider = getProvider())
&& (provider->__state[1] & kIOServiceSynchronousState));
+ if ( options & kIOServiceAsynchronous )
+ sync = false;
needConfig = (0 == (__state[1] & (kIOServiceNeedConfigState | kIOServiceConfigState)))
&& (0 == (__state[0] & kIOServiceInactiveState));
lockForArbitration();
IOLockLock( gIOServiceBusyLock );
- waitAgain = (prevBusy != (__state[1] & kIOServiceBusyStateMask));
+ waitAgain = (prevBusy < (__state[1] & kIOServiceBusyStateMask));
if( waitAgain)
__state[1] |= kIOServiceSyncPubState | kIOServiceBusyWaiterState;
else
IOReturn IOService::catalogNewDrivers( OSOrderedSet * newTables )
{
OSDictionary * table;
- OSIterator * iter;
+ OSSet * set;
+ OSSet * allSet = 0;
IOService * service;
#if IOMATCHDEBUG
SInt32 count = 0;
while( (table = (OSDictionary *) newTables->getFirstObject())) {
LOCKWRITENOTIFY();
- iter = (OSIterator *) getExistingServices( table,
- kIOServiceRegisteredState );
+ set = (OSSet *) getExistingServices( table,
+ kIOServiceRegisteredState,
+ kIOServiceExistingSet);
UNLOCKNOTIFY();
- if( iter) {
- while( (service = (IOService *) iter->getNextObject())) {
- service->startMatching(kIOServiceAsynchronous);
+ if( set) {
+
#if IOMATCHDEBUG
- count++;
+ count += set->getCount();
#endif
+ if (allSet) {
+ allSet->merge((const OSSet *) set);
+ set->release();
}
- iter->release();
+ else
+ allSet = set;
}
+
#if IOMATCHDEBUG
if( getDebugFlags( table ) & kIOLogMatch)
LOG("Matching service count = %ld\n", count);
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 = 0 )
+ IOOptionBits options )
{
_IOServiceJob * job;
void *param3, void *param4 )
{
IOReturn result = kIOReturnUnsupported;
- IOService *provider = getProvider();
-
- if (provider != 0) {
+ 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 /* defined(__i386__) */
+ }
+
+ if ((kIOReturnUnsupported == result) && (provider = getProvider())) {
result = provider->callPlatformFunction(functionName, waitForFunction,
param1, param2, param3, param4);
}
* Stacking change
*/
-bool IOService::lockForArbitration( bool isSuccessRequired = true )
+bool IOService::lockForArbitration( bool isSuccessRequired )
{
bool found;
bool success;
// send a message to a client or interested party of this service
IOReturn IOService::messageClient( UInt32 type, OSObject * client,
- void * argument = 0, vm_size_t argSize = 0 )
+ void * argument, vm_size_t argSize )
{
IOReturn ret;
IOService * service;
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);
+
+ // iterate over queue, entry is set to each element in the list
+ 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 )
{
- OSArray * array;
- unsigned int index;
- OSObject * next;
- OSArray * copyArray;
-
- applyToClients( (IOServiceApplierFunction) applier, context );
-
- LOCKREADNOTIFY();
- array = OSDynamicCast( OSArray, getProperty( typeOfInterest ));
- if( array) {
- copyArray = OSArray::withArray( array );
- UNLOCKNOTIFY();
- if( copyArray) {
- for( index = 0;
- (next = array->getObject( index ));
- index++) {
- (*applier)(next, context);
- }
- copyArray->release();
- }
- } else
- UNLOCKNOTIFY();
+ if (gIOGeneralInterest == typeOfInterest)
+ applyToClients( (IOServiceApplierFunction) applier, context );
+ applyToInterestNotifiers(this, typeOfInterest, applier, context);
}
struct MessageClientsContext {
// send a message to all clients
IOReturn IOService::messageClients( UInt32 type,
- void * argument = 0, vm_size_t argSize = 0 )
+ void * argument, vm_size_t argSize )
{
MessageClientsContext context;
IOServiceInterestHandler handler, void * target, void * ref )
{
_IOServiceInterestNotifier * notify = 0;
- OSArray * set;
if( (typeOfInterest != gIOGeneralInterest)
&& (typeOfInterest != gIOBusyInterest)
////// queue
LOCKWRITENOTIFY();
- if( 0 == (set = (OSArray *) getProperty( typeOfInterest ))) {
- set = OSArray::withCapacity( 1 );
- if( set) {
- setProperty( typeOfInterest, set );
- set->release();
- }
- }
- notify->whence = set;
- if( set)
- set->setObject( notify );
+
+ // Get the head of the notifier linked list
+ 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(); // ref'ed while in list
+ }
+
UNLOCKNOTIFY();
}
}
return( notify );
}
-static void cleanInterestArray( OSObject * object )
+static void cleanInterestList( OSObject * head )
{
- OSArray * array;
- unsigned int index;
- _IOServiceInterestNotifier * next;
-
- if( (array = OSDynamicCast( OSArray, object))) {
- LOCKWRITENOTIFY();
- for( index = 0;
- (next = (_IOServiceInterestNotifier *)
- array->getObject( index ));
- index++) {
- next->whence = 0;
- }
- UNLOCKNOTIFY();
+ 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 )
{
- cleanInterestArray( getProperty( gIOGeneralInterest ));
- cleanInterestArray( getProperty( gIOBusyInterest ));
- cleanInterestArray( getProperty( gIOAppPowerStateInterest ));
- cleanInterestArray( getProperty( gIOPriorityPowerStateInterest ));
+ cleanInterestList( getProperty( gIOGeneralInterest ));
+ cleanInterestList( getProperty( gIOBusyInterest ));
+ cleanInterestList( getProperty( gIOAppPowerStateInterest ));
+ cleanInterestList( getProperty( gIOPriorityPowerStateInterest ));
}
/*
{
LOCKWRITENOTIFY();
- if( whence) {
- whence->removeObject(whence->getNextIndexOfObject(
- (OSObject *) this, 0 ));
- whence = 0;
+ if( queue_next( &chain )) {
+ remqueue( 0, &chain);
+ queue_next( &chain) = queue_prev( &chain) = 0;
+ release();
}
state &= ~kIOServiceNotifyEnable;
return( ok );
}
-bool IOService::terminatePhase1( IOOptionBits options = 0 )
+bool IOService::terminatePhase1( IOOptionBits options )
{
IOService * victim;
IOService * client;
victim->deliverNotification( gIOTerminatedNotification, 0, 0xffffffff );
IOUserClient::destroyUserReferences( victim );
- victim->unregisterAllInterest();
iter = victim->getClientIterator();
if( iter) {
return( true );
}
-void IOService::scheduleTerminatePhase2( IOOptionBits options = 0 )
+void IOService::scheduleTerminatePhase2( IOOptionBits options )
{
AbsoluteTime deadline;
- int waitResult;
+ int waitResult = THREAD_AWAKENED;
bool wait, haveDeadline = false;
options |= kIOServiceRequired;
gIOTerminateWork++;
do {
- terminateWorker( options );
+ while( gIOTerminateWork )
+ terminateWorker( options );
wait = (0 != (__state[1] & kIOServiceBusyStateMask));
if( wait) {
// wait for the victim to go non-busy
deadline, THREAD_UNINT );
if( waitResult == THREAD_TIMED_OUT) {
TLOG("%s::terminate(kIOServiceSynchronous) timeout", getName());
- } else
- thread_cancel_timer();
+ }
}
- } while( wait && (waitResult != THREAD_TIMED_OUT));
+ } while(gIOTerminateWork || (wait && (waitResult != THREAD_TIMED_OUT)));
- gIOTerminateThread = 0;
- IOLockWakeup( gJobsLock, (event_t) &gIOTerminateThread, /* one-thread */ false);
+ gIOTerminateThread = 0;
+ IOLockWakeup( gJobsLock, (event_t) &gIOTerminateThread, /* one-thread */ false);
} else {
// ! kIOServiceSynchronous
gIOTerminatePhase2List->setObject( this );
- if( 0 == gIOTerminateWork++)
- gIOTerminateThread = IOCreateThread( &terminateThread, (void *) options );
+ if( 0 == gIOTerminateWork++) {
+ if( !gIOTerminateThread)
+ gIOTerminateThread = IOCreateThread( &terminateThread, (void *) options );
+ else
+ IOLockWakeup(gJobsLock, (event_t) &gIOTerminateWork, /* one-thread */ false );
+ }
}
IOLockUnlock( gJobsLock );
{
IOLockLock( gJobsLock );
- terminateWorker( (IOOptionBits) arg );
+ while (gIOTerminateWork)
+ terminateWorker( (IOOptionBits) arg );
gIOTerminateThread = 0;
IOLockWakeup( gJobsLock, (event_t) &gIOTerminateThread, /* one-thread */ false);
return( true );
}
-#undef tailQ(o)
-#undef headQ(o)
+#undef tailQ
+#undef headQ
/*
* Terminate
return( ok );
}
-bool IOService::terminate( IOOptionBits options = 0 )
+bool IOService::terminate( IOOptionBits options )
{
options |= kIOServiceTerminate;
}
bool IOService::open( IOService * forClient,
- IOOptionBits options = 0,
- void * arg = 0 )
+ IOOptionBits options,
+ void * arg )
{
bool ok;
ServiceOpenMessageContext context;
}
void IOService::close( IOService * forClient,
- IOOptionBits options = 0 )
+ IOOptionBits options )
{
bool wasClosed;
bool last = false;
}
}
-bool IOService::isOpen( const IOService * forClient = 0 ) const
+bool IOService::isOpen( const IOService * forClient ) const
{
IOService * self = (IOService *) this;
bool ok;
OSObject * nextMatch = 0;
bool started;
bool needReloc = false;
+#if CONFIG_MACF_KEXT
+ OSBoolean * isSandbox = 0;
+ bool useSandbox = false;
+#endif
#if IOMATCHDEBUG
SInt64 debugFlags;
#endif
if( !symbol)
continue;
+ //IOLog("%s alloc (symbol %p props %p)\n", symbol->getCStringNoCopy(), symbol, props);
+
// alloc the driver instance
inst = (IOService *) OSMetaClass::allocClassWithName( symbol);
if( 0 == category)
category = gIODefaultMatchCategoryKey;
inst->setProperty( gIOMatchCategoryKey, (OSObject *) category );
-
+#if CONFIG_MACF_KEXT
+ isSandbox = OSDynamicCast(OSBoolean,
+ props->getObject("IOKitForceMatch"));
+#endif
// attach driver instance
if( !(inst->attach( this )))
continue;
newInst = inst->probe( this, &score );
inst->detach( this );
+#if CONFIG_MACF_KEXT
+ /*
+ * If this is the Sandbox driver and it matched, this is a
+ * disallowed device; toss any drivers that were already
+ * matched.
+ */
+ 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)
props->release();
if( inst)
inst->release();
+#if CONFIG_MACF_KEXT
+ /*
+ * If we're forcing the sandbox, drop out of the loop.
+ */
+ if (isSandbox && isSandbox->isTrue() && useSandbox)
+ break;
+#endif
}
familyMatches->release();
familyMatches = 0;
ok = service->attach( this );
- if( ok) {
- // stall for any nub resources
- checkResources();
- // stall for any driver resources
- service->checkResources();
+ if( ok)
+ {
+ if (this != gIOResources)
+ {
+ // stall for any nub resources
+ checkResources();
+ // stall for any driver resources
+ service->checkResources();
+ }
+
+ AbsoluteTime startTime;
+ AbsoluteTime endTime;
+ UInt64 nano;
+
+ if (kIOLogStart & gIOKitDebug)
+ clock_get_uptime(&startTime);
+ ok = service->start(this);
- 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( gIOResources );
}
-void IOService::publishResource( const char * key, OSObject * value = 0 )
+void IOService::publishResource( const char * key, OSObject * value )
{
const OSSymbol * sym;
}
}
-void IOService::publishResource( const OSSymbol * key, OSObject * value = 0 )
+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 * resources;
+ OSObject * resourcesProp;
OSSet * set;
OSString * newKey;
bool ret;
- resources = getProperty( gIOResourceMatchKey );
+ resourcesProp = getProperty( gIOResourceMatchKey );
newKey = OSString::withCString( key );
- if( (0 == resources) || (0 == newKey))
+ if( (0 == resourcesProp) || (0 == newKey))
return( false);
- set = OSDynamicCast( OSSet, resources );
+ set = OSDynamicCast( OSSet, resourcesProp );
if( !set) {
set = OSSet::withCapacity( 1 );
if( set)
- set->setObject( resources );
+ set->setObject( resourcesProp );
}
else
set->retain();
bool IOService::checkResources( void )
{
- OSObject * resources;
+ OSObject * resourcesProp;
OSSet * set;
OSIterator * iter;
bool ok;
- resources = getProperty( gIOResourceMatchKey );
- if( 0 == resources)
+ resourcesProp = getProperty( gIOResourceMatchKey );
+ if( 0 == resourcesProp)
return( true );
- if( (set = OSDynamicCast( OSSet, resources ))) {
+ if( (set = OSDynamicCast( OSSet, resourcesProp ))) {
iter = OSCollectionIterator::withCollection( set );
ok = (0 != iter);
- while( ok && (resources = iter->getNextObject()) )
- ok = checkResource( resources );
+ while( ok && (resourcesProp = iter->getNextObject()) )
+ ok = checkResource( resourcesProp );
if( iter)
iter->release();
} else
- ok = checkResource( resources );
+ ok = checkResource( resourcesProp );
return( ok );
}
-_IOConfigThread * _IOConfigThread::configThread( void )
+void _IOConfigThread::configThread( void )
{
_IOConfigThread * inst;
continue;
if( !inst->init())
continue;
- if( !(inst->thread = IOCreateThread
- ( (IOThreadFunc) &_IOConfigThread::main, inst )))
+ if( !(IOCreateThread((IOThreadFunc) &_IOConfigThread::main, inst )))
continue;
- return( inst );
+ return;
} while( false);
if( inst)
inst->release();
- return( 0 );
+ return;
}
void _IOConfigThread::free( void )
next->unlockForArbitration();
if( (wasQuiet || nowQuiet) ) {
- OSArray * array;
- unsigned int index;
- OSObject * interested;
-
- array = OSDynamicCast( OSArray, next->getProperty( gIOBusyInterest ));
- if( array) {
- LOCKREADNOTIFY();
- for( index = 0;
- (interested = array->getObject( index ));
- index++) {
- next->messageClient(kIOMessageServiceBusyStateChange,
- interested, (void *) wasQuiet /* busy now */);
- }
- UNLOCKNOTIFY();
- }
+ MessageClientsContext context;
+
+ context.service = next;
+ context.type = kIOMessageServiceBusyStateChange;
+ context.argument = (void *) wasQuiet; // busy now
+ context.argSize = 0;
+
+ applyToInterestNotifiers( next, gIOBusyInterest,
+ &messageClientsApplier, &context );
+#if !NO_KEXTD
if( nowQuiet && (next == gIOServiceRoot))
OSMetaClass::considerUnloads();
+#endif
}
delta = nowQuiet ? -1 : +1;
}
IOReturn IOService::waitForState( UInt32 mask, UInt32 value,
- mach_timespec_t * timeout = 0 )
+ mach_timespec_t * timeout )
{
bool wait;
int waitResult = THREAD_AWAKENED;
if( wait) {
__state[1] |= kIOServiceBusyWaiterState;
unlockForArbitration();
- assert_wait( (event_t) this, THREAD_UNINT );
if( timeout ) {
if( computeDeadline ) {
AbsoluteTime nsinterval;
abstime, &abstime );
computeDeadline = false;
}
- thread_set_timer_deadline( abstime );
+
+ assert_wait_deadline((event_t)this, THREAD_UNINT, __OSAbsoluteTime(abstime));
}
+ else
+ assert_wait((event_t)this, THREAD_UNINT );
} else
unlockForArbitration();
IOLockUnlock( gIOServiceBusyLock );
- if( wait) {
+ if( wait)
waitResult = thread_block(THREAD_CONTINUE_NULL);
- if( timeout && (waitResult != THREAD_TIMED_OUT))
- thread_cancel_timer();
- }
} while( wait && (waitResult != THREAD_TIMED_OUT));
return( kIOReturnSuccess );
}
-IOReturn IOService::waitQuiet( mach_timespec_t * timeout = 0 )
+IOReturn IOService::waitQuiet( mach_timespec_t * timeout )
{
return( waitForState( kIOServiceBusyStateMask, 0, timeout ));
}
void _IOConfigThread::main( _IOConfigThread * self )
{
- _IOServiceJob * job;
- IOService * nub;
- bool alive = true;
+ _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_signal( gJobsSemaphore );
}
-
// internal - call with gNotificationLock
OSObject * IOService::getExistingServices( OSDictionary * matching,
- IOOptionBits inState, IOOptionBits options = 0 )
+ IOOptionBits inState, IOOptionBits options )
{
OSObject * current = 0;
OSIterator * iter;
IOService * service;
+ OSObject * obj;
if( !matching)
return( 0 );
- 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(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))) {
+ if( current && (0 == (options & (kIONotifyOnce | kIOServiceExistingSet)))) {
iter = OSCollectionIterator::withCollection( (OSSet *)current );
current->release();
current = iter;
IONotifier * IOService::setNotification(
const OSSymbol * type, OSDictionary * matching,
IOServiceNotificationHandler handler, void * target, void * ref,
- SInt32 priority = 0 )
+ SInt32 priority )
{
_IOServiceNotifier * notify = 0;
OSOrderedSet * set;
IONotifier * IOService::addNotification(
const OSSymbol * type, OSDictionary * matching,
IOServiceNotificationHandler handler,
- void * target, void * ref = 0,
- SInt32 priority = 0 )
+ void * target, void * ref,
+ SInt32 priority )
{
- OSIterator * existing;
+ OSIterator * existing = NULL;
_IOServiceNotifier * notify;
IOService * next;
}
IOService * IOService::waitForService( OSDictionary * matching,
- mach_timespec_t * timeout = 0 )
+ mach_timespec_t * timeout )
{
IONotifier * notify = 0;
// priority doesn't help us much since we need a thread wakeup
*/
OSDictionary * IOService::serviceMatching( const OSString * name,
- OSDictionary * table = 0 )
+ OSDictionary * table )
{
if( !table)
table = OSDictionary::withCapacity( 2 );
}
OSDictionary * IOService::serviceMatching( const char * name,
- OSDictionary * table = 0 )
+ OSDictionary * table )
{
const OSString * str;
}
OSDictionary * IOService::nameMatching( const OSString * name,
- OSDictionary * table = 0 )
+ OSDictionary * table )
{
if( !table)
table = OSDictionary::withCapacity( 2 );
}
OSDictionary * IOService::nameMatching( const char * name,
- OSDictionary * table = 0 )
+ OSDictionary * table )
{
const OSString * str;
}
OSDictionary * IOService::resourceMatching( const OSString * str,
- OSDictionary * table = 0 )
+ OSDictionary * table )
{
table = serviceMatching( gIOResourcesKey, table );
if( table)
}
OSDictionary * IOService::resourceMatching( const char * name,
- OSDictionary * table = 0 )
+ OSDictionary * table )
{
const OSSymbol * str;
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 );
+}
+
/*
* _IOServiceNotifier
*/
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) );
}
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;
IOUserClient *client;
OSObject *temp;
+ if (kIOReturnSuccess == newUserClient( owningTask, securityID, type, handler ))
+ return kIOReturnSuccess;
+
// First try my own properties for a user client class name
temp = getProperty(gIOUserClientClassKey);
if (temp) {
if (!userClientClass)
return kIOReturnUnsupported;
+ // This reference is consumed by the IOServiceOpen call
temp = OSMetaClass::allocClassWithName(userClientClass);
if (!temp)
return kIOReturnNoMemory;
IOReturn IOService::newUserClient( task_t owningTask, void * securityID,
UInt32 type, IOUserClient ** handler )
{
- return( newUserClient( owningTask, securityID, type, 0, handler ));
+ return( kIOReturnUnsupported );
}
IOReturn IOService::requestProbe( IOOptionBits options )
case kIOReturnBadArgument:
return(EINVAL);
case kIOReturnUnsupported:
- return(EOPNOTSUPP);
+ return(ENOTSUP);
case kIOReturnBusy:
return(EBUSY);
case kIOReturnNoPower:
}
IOMemoryMap * IOService::mapDeviceMemoryWithIndex( unsigned int index,
- IOOptionBits options = 0 )
+ IOOptionBits options )
{
IODeviceMemory * range;
IOMemoryMap * map;
setProperty( gIODeviceMemoryKey, array);
}
+/*
+ * For machines where the transfers on an I/O bus can stall because
+ * the CPU is in an idle mode, These APIs allow a driver to specify
+ * the maximum bus stall that they can handle. 0 indicates no limit.
+ */
+void IOService::
+setCPUSnoopDelay(UInt32 __unused ns)
+{
+#if defined(__i386__)
+ ml_set_maxsnoop(ns);
+#endif /* defined(__i386__) */
+}
+
+UInt32 IOService::
+getCPUSnoopDelay()
+{
+#if defined(__i386__)
+ return ml_get_maxsnoop();
+#else
+ return 0;
+#endif /* defined(__i386__) */
+}
+
+#if defined(__i386__)
+static void
+requireMaxCpuDelay(IOService * service, UInt32 ns, UInt32 delayType)
+{
+ static const UInt kNoReplace = -1U; // Must be an illegal index
+ 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;
+ // Set maximum delay.
+ 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; // Set to max unsigned, i.e. no restriction
+
+ for (UInt i = 0; i < count; i++) {
+ // Clear a maximum delay.
+ 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;
+ }
+ }
+ }
+
+ // Check if entry found
+ if (kNoReplace != replace) {
+ entries[replace].fService = 0; // Null the entry
+ setCpuDelay = true;
+ }
+ }
+
+ if (setCpuDelay)
+ {
+ // Must be safe to call from locked context
+ 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; // Set to max unsigned, i.e. no restriction
+ 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 /* defined(__i386__) */
+
+void IOService::
+requireMaxBusStall(UInt32 __unused ns)
+{
+#if defined(__i386__)
+ requireMaxCpuDelay(this, ns, kCpuDelayBusStall);
+#endif
+}
+
/*
* Device interrupts
*/
OSMetaClassDefineReservedUsed(IOService, 0);
OSMetaClassDefineReservedUsed(IOService, 1);
OSMetaClassDefineReservedUsed(IOService, 2);
+OSMetaClassDefineReservedUsed(IOService, 3);
+OSMetaClassDefineReservedUsed(IOService, 4);
-OSMetaClassDefineReservedUnused(IOService, 3);
-OSMetaClassDefineReservedUnused(IOService, 4);
OSMetaClassDefineReservedUnused(IOService, 5);
OSMetaClassDefineReservedUnused(IOService, 6);
OSMetaClassDefineReservedUnused(IOService, 7);
OSMetaClassDefineReservedUnused(IOService, 45);
OSMetaClassDefineReservedUnused(IOService, 46);
OSMetaClassDefineReservedUnused(IOService, 47);
+
+#ifdef __ppc__
OSMetaClassDefineReservedUnused(IOService, 48);
OSMetaClassDefineReservedUnused(IOService, 49);
OSMetaClassDefineReservedUnused(IOService, 50);
OSMetaClassDefineReservedUnused(IOService, 61);
OSMetaClassDefineReservedUnused(IOService, 62);
OSMetaClassDefineReservedUnused(IOService, 63);
+#endif
projects / apple / xnu.git / blobdiff