/*
- * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 1998-2007 Apple Inc. All rights reserved.
*
- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License"). You may not use this file except in compliance with the
- * License. Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * 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. 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.
*
- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * 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
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
- * License for the specific language governing rights and limitations
- * under the License.
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
*
- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
*/
#include <IOKit/system.h>
const OSSymbol * gIOConsoleUsersKey;
const OSSymbol * gIOConsoleSessionUIDKey;
const OSSymbol * gIOConsoleUsersSeedKey;
+const OSSymbol * gIOConsoleSessionOnConsoleKey;
+const OSSymbol * gIOConsoleSessionSecureInputPIDKey;
static int gIOResourceGenerationCount;
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() \
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#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;
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
&& gIOPublishNotification && gIOMatchedNotification
&& gIOTerminatedNotification && gIOServiceKey
&& gIOConsoleUsersKey && gIOConsoleSessionUIDKey
+ && gIOConsoleSessionOnConsoleKey && gIOConsoleSessionSecureInputPIDKey
&& gIOConsoleUsersSeedKey && gIOConsoleUsersSeedValue);
gJobsLock = IOLockAlloc();
void IOService::free( void )
{
+ requireMaxBusStall(0);
if( getPropertyTable())
unregisterAllInterest();
PMfree();
|| ((provider = getProvider())
&& (provider->__state[1] & kIOServiceSynchronousState));
+ if ( options & kIOServiceAsynchronous )
+ sync = false;
needConfig = (0 == (__state[1] & (kIOServiceNeedConfigState | kIOServiceConfigState)))
&& (0 == (__state[0] & kIOServiceInactiveState));
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);
}
return( ret );
}
-void IOService::applyToInterested( const OSSymbol * typeOfInterest,
- OSObjectApplierFunction applier,
- void * context )
+static void
+applyToInterestNotifiers(const IORegistryEntry *target,
+ const OSSymbol * typeOfInterest,
+ OSObjectApplierFunction applier,
+ void * context )
{
OSArray * copyArray = 0;
- applyToClients( (IOServiceApplierFunction) applier, context );
-
LOCKREADNOTIFY();
IOCommand *notifyList =
- OSDynamicCast( IOCommand, getProperty( typeOfInterest ));
+ OSDynamicCast( IOCommand, target->getProperty( typeOfInterest ));
if( notifyList) {
copyArray = OSArray::withCapacity(1);
}
}
+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;
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;
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;
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 {
void * target, void * ref,
SInt32 priority )
{
- OSIterator * existing;
+ OSIterator * existing = NULL;
_IOServiceNotifier * notify;
IOService * next;
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
*/
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 )
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, 1);
OSMetaClassDefineReservedUsed(IOService, 2);
OSMetaClassDefineReservedUsed(IOService, 3);
+OSMetaClassDefineReservedUsed(IOService, 4);
-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