X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/378393581903b274cb7a4d18e0d978071a6b592d..cc8bc92ae4a8e9f1a1ab61bf83d34ad8150b3405:/iokit/Kernel/IOTimerEventSource.cpp diff --git a/iokit/Kernel/IOTimerEventSource.cpp b/iokit/Kernel/IOTimerEventSource.cpp index b81757f38..bb7acea43 100644 --- a/iokit/Kernel/IOTimerEventSource.cpp +++ b/iokit/Kernel/IOTimerEventSource.cpp @@ -1,34 +1,29 @@ /* - * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved. + * Copyright (c) 1998-2000, 2009-2010 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@ - */ -/* - * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. - * - * IOTimerEventSource.cpp - * - * HISTORY - * 2-Feb-1999 Joe Liu (jliu) created. - * 1999-10-14 Godfrey van der Linden(gvdl) - * Revamped to use thread_call APIs - * + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ #include @@ -45,32 +40,89 @@ __END_DECLS #include #include +#include +#if CONFIG_DTRACE +#include +#endif #define super IOEventSource OSDefineMetaClassAndStructors(IOTimerEventSource, IOEventSource) -OSMetaClassDefineReservedUnused(IOTimerEventSource, 0); -OSMetaClassDefineReservedUnused(IOTimerEventSource, 1); -OSMetaClassDefineReservedUnused(IOTimerEventSource, 2); +OSMetaClassDefineReservedUsed(IOTimerEventSource, 0); +OSMetaClassDefineReservedUsed(IOTimerEventSource, 1); +OSMetaClassDefineReservedUsed(IOTimerEventSource, 2); OSMetaClassDefineReservedUnused(IOTimerEventSource, 3); OSMetaClassDefineReservedUnused(IOTimerEventSource, 4); OSMetaClassDefineReservedUnused(IOTimerEventSource, 5); OSMetaClassDefineReservedUnused(IOTimerEventSource, 6); OSMetaClassDefineReservedUnused(IOTimerEventSource, 7); +#if IOKITSTATS + +#define IOStatisticsInitializeCounter() \ +do { \ + IOStatistics::setCounterType(IOEventSource::reserved->counter, kIOStatisticsTimerEventSourceCounter); \ +} while (0) + +#define IOStatisticsOpenGate() \ +do { \ + IOStatistics::countOpenGate(me->IOEventSource::reserved->counter); \ +} while (0) + +#define IOStatisticsCloseGate() \ +do { \ + IOStatistics::countCloseGate(me->IOEventSource::reserved->counter); \ +} while (0) + +#define IOStatisticsTimeout() \ +do { \ + IOStatistics::countTimerTimeout(me->IOEventSource::reserved->counter); \ +} while (0) + +#else + +#define IOStatisticsInitializeCounter() +#define IOStatisticsOpenGate() +#define IOStatisticsCloseGate() +#define IOStatisticsTimeout() + +#endif /* IOKITSTATS */ + // // reserved != 0 means IOTimerEventSource::timeoutAndRelease is being used, // not a subclassed implementation. // -bool IOTimerEventSource::checkForWork() { return false; } - // Timeout handler function. This function is called by the kernel when // the timeout interval expires. // + +static __inline__ void +InvokeAction(IOTimerEventSource::Action action, IOTimerEventSource * ts, + OSObject * owner, IOWorkLoop * workLoop) +{ + bool trace = (gIOKitTrace & kIOTraceTimers) ? true : false; + + if (trace) + IOTimeStampStartConstant(IODBG_TIMES(IOTIMES_ACTION), + VM_KERNEL_ADDRHIDE(action), VM_KERNEL_ADDRHIDE(owner)); + + (*action)(owner, ts); + +#if CONFIG_DTRACE + DTRACE_TMR3(iotescallout__expire, Action, action, OSObject, owner, void, workLoop); +#endif + + if (trace) + IOTimeStampEndConstant(IODBG_TIMES(IOTIMES_ACTION), + VM_KERNEL_UNSLIDE(action), VM_KERNEL_ADDRHIDE(owner)); +} + void IOTimerEventSource::timeout(void *self) { IOTimerEventSource *me = (IOTimerEventSource *) self; + IOStatisticsTimeout(); + if (me->enabled && me->action) { IOWorkLoop * @@ -79,22 +131,27 @@ void IOTimerEventSource::timeout(void *self) { Action doit; wl->closeGate(); + IOStatisticsCloseGate(); doit = (Action) me->action; if (doit && me->enabled && AbsoluteTime_to_scalar(&me->abstime)) { - IOTimeStampConstant(IODBG_TIMES(IOTIMES_ACTION), - (unsigned int) doit, (unsigned int) me->owner); - (*doit)(me->owner, me); + InvokeAction(doit, me, me->owner, me->workLoop); } + IOStatisticsOpenGate(); wl->openGate(); } } } -void IOTimerEventSource::timeoutAndRelease(void * self, void * count) +void IOTimerEventSource::timeoutAndRelease(void * self, void * c) { IOTimerEventSource *me = (IOTimerEventSource *) self; + /* The second parameter (a pointer) gets abused to carry an SInt32, so on LP64, "count" + must be cast to "long" before, in order to tell GCC we're not truncating a pointer. */ + SInt32 count = (SInt32) (long) c; + IOStatisticsTimeout(); + if (me->enabled && me->action) { IOWorkLoop * @@ -103,13 +160,13 @@ void IOTimerEventSource::timeoutAndRelease(void * self, void * count) { Action doit; wl->closeGate(); + IOStatisticsCloseGate(); doit = (Action) me->action; - if (doit && (me->reserved->calloutGeneration == (SInt32) count)) + if (doit && (me->reserved->calloutGeneration == count)) { - IOTimeStampConstant(IODBG_TIMES(IOTIMES_ACTION), - (unsigned int) doit, (unsigned int) me->owner); - (*doit)(me->owner, me); + InvokeAction(doit, me, me->owner, me->workLoop); } + IOStatisticsOpenGate(); wl->openGate(); } } @@ -118,13 +175,99 @@ void IOTimerEventSource::timeoutAndRelease(void * self, void * count) me->release(); } +// -- work loop delivery + +bool IOTimerEventSource::checkForWork() +{ + Action doit; + + if (reserved + && (reserved->calloutGenerationSignaled == reserved->calloutGeneration) + && enabled && (doit = (Action) action)) + { + reserved->calloutGenerationSignaled = ~reserved->calloutGeneration; + InvokeAction(doit, this, owner, workLoop); + } + + return false; +} + +void IOTimerEventSource::timeoutSignaled(void * self, void * c) +{ + IOTimerEventSource *me = (IOTimerEventSource *) self; + + me->reserved->calloutGenerationSignaled = (SInt32)(long) c; + if (me->enabled) me->signalWorkAvailable(); +} + +// -- + void IOTimerEventSource::setTimeoutFunc() { + thread_call_priority_t pri; + uint32_t options; + + if (reserved) panic("setTimeoutFunc already %p, %p", this, reserved); + // reserved != 0 means IOTimerEventSource::timeoutAndRelease is being used, // not a subclassed implementation reserved = IONew(ExpansionData, 1); - calloutEntry = (void *) thread_call_allocate((thread_call_func_t) &IOTimerEventSource::timeoutAndRelease, - (thread_call_param_t) this); + reserved->calloutGenerationSignaled = ~reserved->calloutGeneration; + options = abstime; + abstime = 0; + + thread_call_options_t tcoptions = 0; + thread_call_func_t func = NULL; + + switch (kIOTimerEventSourceOptionsPriorityMask & options) + { + case kIOTimerEventSourceOptionsPriorityHigh: + pri = THREAD_CALL_PRIORITY_HIGH; + func = &IOTimerEventSource::timeoutAndRelease; + break; + + case kIOTimerEventSourceOptionsPriorityKernel: + pri = THREAD_CALL_PRIORITY_KERNEL; + func = &IOTimerEventSource::timeoutAndRelease; + break; + + case kIOTimerEventSourceOptionsPriorityKernelHigh: + pri = THREAD_CALL_PRIORITY_KERNEL_HIGH; + func = &IOTimerEventSource::timeoutAndRelease; + break; + + case kIOTimerEventSourceOptionsPriorityUser: + pri = THREAD_CALL_PRIORITY_USER; + func = &IOTimerEventSource::timeoutAndRelease; + break; + + case kIOTimerEventSourceOptionsPriorityLow: + pri = THREAD_CALL_PRIORITY_LOW; + func = &IOTimerEventSource::timeoutAndRelease; + break; + + case kIOTimerEventSourceOptionsPriorityWorkLoop: + pri = THREAD_CALL_PRIORITY_KERNEL; + tcoptions |= THREAD_CALL_OPTIONS_SIGNAL; + if (kIOTimerEventSourceOptionsAllowReenter & options) break; + func = &IOTimerEventSource::timeoutSignaled; + break; + + default: + break; + } + + assertf(func, "IOTimerEventSource options 0x%x", options); + if (!func) return; // init will fail + + if (THREAD_CALL_OPTIONS_SIGNAL & tcoptions) flags |= kActive; + else flags |= kPassive; + + if (!(kIOTimerEventSourceOptionsAllowReenter & options)) tcoptions |= THREAD_CALL_OPTIONS_ONCE; + + calloutEntry = (void *) thread_call_allocate_with_options(func, + (thread_call_param_t) this, pri, tcoptions); + assert(calloutEntry); } bool IOTimerEventSource::init(OSObject *inOwner, Action inAction) @@ -136,15 +279,23 @@ bool IOTimerEventSource::init(OSObject *inOwner, Action inAction) if (!calloutEntry) return false; + IOStatisticsInitializeCounter(); + return true; } +bool IOTimerEventSource::init(uint32_t options, OSObject *inOwner, Action inAction) +{ + abstime = options; + return (init(inOwner, inAction)); +} + IOTimerEventSource * -IOTimerEventSource::timerEventSource(OSObject *inOwner, Action inAction) +IOTimerEventSource::timerEventSource(uint32_t inOptions, OSObject *inOwner, Action inAction) { IOTimerEventSource *me = new IOTimerEventSource; - if (me && !me->init(inOwner, inAction)) { + if (me && !me->init(inOptions, inOwner, inAction)) { me->release(); return 0; } @@ -152,11 +303,25 @@ IOTimerEventSource::timerEventSource(OSObject *inOwner, Action inAction) return me; } +#define _thread_call_cancel(tc) ((kActive & flags) ? thread_call_cancel_wait((tc)) : thread_call_cancel((tc))) + +IOTimerEventSource * +IOTimerEventSource::timerEventSource(OSObject *inOwner, Action inAction) +{ + return (IOTimerEventSource::timerEventSource( + kIOTimerEventSourceOptionsPriorityKernelHigh, + inOwner, inAction)); +} + void IOTimerEventSource::free() { if (calloutEntry) { + __assert_only bool freed; + cancelTimeout(); - thread_call_free((thread_call_t) calloutEntry); + + freed = thread_call_free((thread_call_t) calloutEntry); + assert(freed); } if (reserved) @@ -169,9 +334,9 @@ void IOTimerEventSource::cancelTimeout() { if (reserved) reserved->calloutGeneration++; - bool active = thread_call_cancel((thread_call_t) calloutEntry); + bool active = _thread_call_cancel((thread_call_t) calloutEntry); AbsoluteTime_to_scalar(&abstime) = 0; - if (active && reserved) + if (active && reserved && (kPassive & flags)) { release(); workLoop->release(); @@ -189,9 +354,9 @@ void IOTimerEventSource::disable() { if (reserved) reserved->calloutGeneration++; - bool active = thread_call_cancel((thread_call_t) calloutEntry); + bool active = _thread_call_cancel((thread_call_t) calloutEntry); super::disable(); - if (active && reserved) + if (active && reserved && (kPassive & flags)) { release(); workLoop->release(); @@ -216,11 +381,12 @@ IOReturn IOTimerEventSource::setTimeoutUS(UInt32 us) IOReturn IOTimerEventSource::setTimeout(UInt32 interval, UInt32 scale_factor) { AbsoluteTime end; - + clock_interval_to_deadline(interval, scale_factor, &end); return wakeAtTime(end); } +#if !defined(__LP64__) IOReturn IOTimerEventSource::setTimeout(mach_timespec_t interval) { AbsoluteTime end, nsecs; @@ -233,15 +399,22 @@ IOReturn IOTimerEventSource::setTimeout(mach_timespec_t interval) return wakeAtTime(end); } +#endif IOReturn IOTimerEventSource::setTimeout(AbsoluteTime interval) { AbsoluteTime end; + clock_absolutetime_interval_to_deadline(interval, &end); + return wakeAtTime(end); +} - clock_get_uptime(&end); - ADD_ABSOLUTETIME(&end, &interval); +IOReturn IOTimerEventSource::setTimeout(uint32_t options, + AbsoluteTime abstime, AbsoluteTime leeway) +{ + AbsoluteTime end; + clock_continuoustime_interval_to_deadline(abstime, &end); + return wakeAtTime(options, end, leeway); - return wakeAtTime(end); } IOReturn IOTimerEventSource::wakeAtTimeTicks(UInt32 ticks) @@ -267,6 +440,7 @@ IOReturn IOTimerEventSource::wakeAtTime(UInt32 inAbstime, UInt32 scale_factor) return wakeAtTime(end); } +#if !defined(__LP64__) IOReturn IOTimerEventSource::wakeAtTime(mach_timespec_t inAbstime) { AbsoluteTime end, nsecs; @@ -279,6 +453,7 @@ IOReturn IOTimerEventSource::wakeAtTime(mach_timespec_t inAbstime) return wakeAtTime(end); } +#endif void IOTimerEventSource::setWorkLoop(IOWorkLoop *inWorkLoop) { @@ -288,28 +463,45 @@ void IOTimerEventSource::setWorkLoop(IOWorkLoop *inWorkLoop) } IOReturn IOTimerEventSource::wakeAtTime(AbsoluteTime inAbstime) +{ + return wakeAtTime(0, inAbstime, 0); +} + +IOReturn IOTimerEventSource::wakeAtTime(uint32_t options, AbsoluteTime inAbstime, AbsoluteTime leeway) { if (!action) return kIOReturnNoResources; abstime = inAbstime; - if ( enabled && AbsoluteTime_to_scalar(&abstime) && workLoop ) + if ( enabled && AbsoluteTime_to_scalar(&inAbstime) && AbsoluteTime_to_scalar(&abstime) && workLoop ) { + uint32_t tcoptions = 0; + + if (kIOTimeOptionsWithLeeway & options) tcoptions |= THREAD_CALL_DELAY_LEEWAY; + if (kIOTimeOptionsContinuous & options) tcoptions |= THREAD_CALL_CONTINUOUS; + if (reserved) { - retain(); - workLoop->retain(); + if (kPassive & flags) + { + retain(); + workLoop->retain(); + } reserved->workLoop = workLoop; reserved->calloutGeneration++; - if (thread_call_enter1_delayed((thread_call_t) calloutEntry, - (void *) reserved->calloutGeneration, abstime)) + if (thread_call_enter_delayed_with_leeway((thread_call_t) calloutEntry, + (void *)(uintptr_t) reserved->calloutGeneration, inAbstime, leeway, tcoptions) + && (kPassive & flags)) { release(); workLoop->release(); } } else - thread_call_enter_delayed((thread_call_t) calloutEntry, abstime); + { + thread_call_enter_delayed_with_leeway((thread_call_t) calloutEntry, + NULL, inAbstime, leeway, tcoptions); + } } return kIOReturnSuccess;