/*
- * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 1998-2007 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
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 __i386__
+#if defined(__i386__)
// Only used by the intel implementation of
-// IOService::requireMaxBusStall(UInt32 __unused ns)
-struct BusStallEntry
+// IOService::requireMaxBusStall(UInt32 ns)
+// IOService::requireMaxInterruptDelay(uint32_t ns)
+struct CpuDelayEntry
{
- const IOService *fService;
- UInt32 fMaxDelay;
+ IOService * fService;
+ UInt32 fMaxDelay;
+ UInt32 fDelayType;
};
-static OSData *sBusStall = OSData::withCapacity(8 * sizeof(BusStallEntry));
-static IOLock *sBusStallLock = IOLockAlloc();
-#endif /* __i386__ */
+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__) */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
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
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);
}
OSObjectApplierFunction applier,
void * context )
{
- applyToClients( (IOServiceApplierFunction) applier, context );
+ if (gIOGeneralInterest == typeOfInterest)
+ applyToClients( (IOServiceApplierFunction) applier, context );
applyToInterestNotifiers(this, typeOfInterest, applier, context);
}
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;
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;
void IOService::
setCPUSnoopDelay(UInt32 __unused ns)
{
-#if __i386__
+#if defined(__i386__)
ml_set_maxsnoop(ns);
-#endif /* __i386__ */
+#endif /* defined(__i386__) */
}
UInt32 IOService::
getCPUSnoopDelay()
{
-#if __i386__
+#if defined(__i386__)
return ml_get_maxsnoop();
#else
return 0;
-#endif /* __i386__ */
+#endif /* defined(__i386__) */
}
-void IOService::
-requireMaxBusStall(UInt32 __unused ns)
+#if defined(__i386__)
+static void
+requireMaxCpuDelay(IOService * service, UInt32 ns, UInt32 delayType)
{
-#if __i386__
static const UInt kNoReplace = -1U; // Must be an illegal index
UInt replace = kNoReplace;
+ bool setCpuDelay = false;
- IOLockLock(sBusStallLock);
+ IORecursiveLockLock(sCpuDelayLock);
- UInt count = sBusStall->getLength() / sizeof(BusStallEntry);
- BusStallEntry *entries = (BusStallEntry *) sBusStall->getBytesNoCopy();
+ UInt count = sCpuDelayData->getLength() / sizeof(CpuDelayEntry);
+ CpuDelayEntry *entries = (CpuDelayEntry *) sCpuDelayData->getBytesNoCopy();
+ IOService * holder = NULL;
if (ns) {
- const BusStallEntry ne = {this, ns};
-
- // Set Maximum bus delay.
- for (UInt i = 0; i < count; i++) {
- const IOService *thisService = entries[i].fService;
- if (this == thisService)
- replace = i;
- else if (!thisService) {
- if (kNoReplace == replace)
- replace = i;
- }
- else {
- const UInt32 thisMax = entries[i].fMaxDelay;
- if (thisMax < ns)
- ns = thisMax;
- }
- }
-
- // Must be safe to call from locked context
- ml_set_maxbusdelay(ns);
-
- if (kNoReplace == replace)
- sBusStall->appendBytes(&ne, sizeof(ne));
- else
- entries[replace] = ne;
+ 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 bus delay.
- const IOService *thisService = entries[i].fService;
- UInt32 thisMax = entries[i].fMaxDelay;
- if (this == thisService)
- replace = i;
- else if (thisService && thisMax < ns)
- ns = thisMax;
+ 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);
}
+ }
- // Check if entry found
- if (kNoReplace != replace) {
- entries[replace].fService = 0; // Null the entry
- ml_set_maxbusdelay(ns);
+ 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);
+}
- IOLockUnlock(sBusStallLock);
-#endif /* __i386__ */
+#endif /* defined(__i386__) */
+
+void IOService::
+requireMaxBusStall(UInt32 __unused ns)
+{
+#if defined(__i386__)
+ requireMaxCpuDelay(this, ns, kCpuDelayBusStall);
+#endif
}
/*
OSMetaClassDefineReservedUsed(IOService, 1);
OSMetaClassDefineReservedUsed(IOService, 2);
OSMetaClassDefineReservedUsed(IOService, 3);
+OSMetaClassDefineReservedUsed(IOService, 4);
-OSMetaClassDefineReservedUnused(IOService, 4);
OSMetaClassDefineReservedUnused(IOService, 5);
OSMetaClassDefineReservedUnused(IOService, 6);
OSMetaClassDefineReservedUnused(IOService, 7);
projects / apple / xnu.git / blobdiff