{
fWatchdogTimer = thread_call_allocate(
&IOService::watchdog_timer_expired, (thread_call_param_t)this);
+ fWatchdogLock = IOLockAlloc();
+
+ fBlockedArray = OSArray::withCapacity(4);
}
fAckTimer = thread_call_allocate(
fWatchdogTimer = NULL;
}
+ if (fWatchdogLock) {
+ IOLockFree(fWatchdogLock);
+ fWatchdogLock = NULL;
+ }
+
+ if (fBlockedArray) {
+ fBlockedArray->release();
+ fBlockedArray = NULL;
+ }
+
if ( fSettleTimer ) {
thread_call_cancel(fSettleTimer);
thread_call_free(fSettleTimer);
if ( fHeadNotePendingAcks == 0 )
{
stop_ack_timer();
+ getPMRootDomain()->reset_watchdog_timer(this, 0);
// This parent may have a request in the work queue that is
// blocked on fHeadNotePendingAcks=0. And removePowerChild()
stop_ack_timer();
// and now we can continue
all_acked = true;
+ getPMRootDomain()->reset_watchdog_timer(this, 0);
}
} else {
OUR_PMLog(kPMLogAcknowledgeErr3, 0, 0); // not expecting anybody to ack
IOItemCount count;
DriverCallParam * param;
IOReturn result;
+ int maxTimeout = 0;
PM_ASSERT_IN_GATE();
assert( fDriverCallBusy == false );
result = kMinAckTimeoutTicks;
informee->timer = (result / (ACK_TIMER_PERIOD / ns_per_us)) + 1;
+ if (result > maxTimeout) {
+ maxTimeout = result;
+ }
}
// else, child has already acked or driver has removed interest,
// and head_note_pendingAcks decremented.
{
OUR_PMLog(kPMLogStartAckTimer, 0, 0);
start_ack_timer();
+ getPMRootDomain()->reset_watchdog_timer(this, maxTimeout/USEC_PER_SEC+1);
}
}
param = (DriverCallParam *) fDriverCallParamPtr;
powerState = fHeadNotePowerState;
+ callEntry.callMethod = OSMemberFunctionCast(const void *, fControllingDriver, &IOService::setPowerState);
if (assertPMDriverCall(&callEntry))
{
OUR_PMLogFuncStart(kPMLogProgramHardware, (uintptr_t) this, powerState);
informee = (IOPMinformee *) param->Target;
driver = informee->whatObject;
+ if (fDriverCallReason == kDriverCallInformPreChange) {
+ callEntry.callMethod = OSMemberFunctionCast(const void *, driver, &IOService::powerStateWillChangeTo);
+ }
+ else {
+ callEntry.callMethod = OSMemberFunctionCast(const void *, driver, &IOService::powerStateDidChangeTo);
+ }
if (assertPMDriverCall(&callEntry, 0, informee))
{
if (fDriverCallReason == kDriverCallInformPreChange)
{
OUR_PMLog(kPMLogStartAckTimer, 0, 0);
start_ack_timer();
+ getPMRootDomain()->reset_watchdog_timer(this, result/USEC_PER_SEC+1);
}
}
done = true;
}
#endif
+ getPMRootDomain()->reset_watchdog_timer(this, 0);
} else {
// still waiting, set timer again
start_ack_timer();
//*********************************************************************************
void IOService::start_watchdog_timer( void )
{
- AbsoluteTime deadline;
- boolean_t pending;
- static int timeout = -1;
+ int timeout;
+ uint64_t deadline;
if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug))
return;
- if (thread_call_isactive(fWatchdogTimer)) return;
- if (timeout == -1) {
- PE_parse_boot_argn("swd_timeout", &timeout, sizeof(timeout));
- }
- if (timeout < 60) {
- timeout = WATCHDOG_TIMER_PERIOD;
- }
+ IOLockLock(fWatchdogLock);
+ timeout = getPMRootDomain()->getWatchdogTimeout();
clock_interval_to_deadline(timeout, kSecondScale, &deadline);
+ fWatchdogDeadline = deadline;
+ start_watchdog_timer(deadline);
+ IOLockUnlock(fWatchdogLock);
+}
- retain();
- pending = thread_call_enter_delayed(fWatchdogTimer, deadline);
- if (pending) release();
+void IOService::start_watchdog_timer(uint64_t deadline)
+{
+
+ IOLockAssert(fWatchdogLock, kIOLockAssertOwned);
+
+ if (!thread_call_isactive(fWatchdogTimer)) {
+ thread_call_enter_delayed(fWatchdogTimer, deadline);
+ }
}
//*********************************************************************************
// [private] stop_watchdog_timer
-// Returns true if watchdog was enabled and stopped now
//*********************************************************************************
-bool IOService::stop_watchdog_timer( void )
+void IOService::stop_watchdog_timer( void )
{
- boolean_t pending;
-
if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug))
- return false;
+ return;
- pending = thread_call_cancel(fWatchdogTimer);
- if (pending) release();
+ IOLockLock(fWatchdogLock);
+
+ thread_call_cancel(fWatchdogTimer);
+ fWatchdogDeadline = 0;
+
+ while (fBlockedArray->getCount()) {
+ IOService *obj = OSDynamicCast(IOService, fBlockedArray->getObject(0));
+ if (obj) {
+ PM_ERROR("WDOG:Object %s unexpected in blocked array\n", obj->fName);
+ fBlockedArray->removeObject(0);
+ }
+ }
- return pending;
+ IOLockUnlock(fWatchdogLock);
}
//*********************************************************************************
// reset_watchdog_timer
//*********************************************************************************
-void IOService::reset_watchdog_timer( void )
+void IOService::reset_watchdog_timer(IOService *blockedObject, int pendingResponseTimeout)
{
- if (stop_watchdog_timer())
- start_watchdog_timer();
+ unsigned int i;
+ uint64_t deadline;
+ IOService *obj;
+
+ if (!fWatchdogTimer || (kIOSleepWakeWdogOff & gIOKitDebug))
+ return;
+
+
+ IOLockLock(fWatchdogLock);
+ if (!fWatchdogDeadline) {
+ goto exit;
+ }
+
+ i = fBlockedArray->getNextIndexOfObject(blockedObject, 0);
+ if (pendingResponseTimeout == 0) {
+ blockedObject->fPendingResponseDeadline = 0;
+ if (i == (unsigned int)-1) {
+ goto exit;
+ }
+ fBlockedArray->removeObject(i);
+ }
+ else {
+ // Set deadline 2secs after the expected response timeout to allow
+ // ack timer to handle the timeout.
+ clock_interval_to_deadline(pendingResponseTimeout+2, kSecondScale, &deadline);
+
+ if (i != (unsigned int)-1) {
+ PM_ERROR("WDOG:Object %s is already blocked for responses. Ignoring timeout %d\n",
+ fName, pendingResponseTimeout);
+ goto exit;
+ }
+
+
+ for (i = 0; i < fBlockedArray->getCount(); i++) {
+ obj = OSDynamicCast(IOService, fBlockedArray->getObject(i));
+ if (obj && (obj->fPendingResponseDeadline < deadline)) {
+ blockedObject->fPendingResponseDeadline = deadline;
+ fBlockedArray->setObject(i, blockedObject);
+ break;
+ }
+ }
+ if (i == fBlockedArray->getCount()) {
+ blockedObject->fPendingResponseDeadline = deadline;
+ fBlockedArray->setObject(blockedObject);
+ }
+ }
+
+ obj = OSDynamicCast(IOService, fBlockedArray->getObject(0));
+ if (!obj) {
+ int timeout = getPMRootDomain()->getWatchdogTimeout();
+ clock_interval_to_deadline(timeout, kSecondScale, &deadline);
+ }
+ else {
+ deadline = obj->fPendingResponseDeadline;
+ }
+
+ thread_call_cancel(fWatchdogTimer);
+ start_watchdog_timer(deadline);
+
+exit:
+ IOLockUnlock(fWatchdogLock);
}
pending = thread_call_enter_delayed(fAckTimer, deadline);
if (pending) release();
- // Stop watchdog if ack is delayed by more than a sec
- if (interval * scale > kSecondScale) {
- stop_watchdog_timer();
- }
}
//*********************************************************************************
pending = thread_call_cancel(fAckTimer);
if (pending) release();
-
- start_watchdog_timer();
}
//*********************************************************************************
if (done && gIOPMWorkQueue)
{
gIOPMWorkQueue->signalWorkAvailable();
- me->start_watchdog_timer();
}
return kIOReturnSuccess;
}
}
+ if (IS_ROOT_DOMAIN) {
+ getPMRootDomain()->reset_watchdog_timer(this, 0);
+ }
if (fResponseArray)
{
fResponseArray->release();
}
}
context.maxTimeRequested = maxTimeOut;
+ context.enableTracing = isRootDomain;
applyToInterested( gIOGeneralInterest,
pmTellClientWithResponse, (void *) &context );
OUR_PMLog(kPMLogStartAckTimer, context.maxTimeRequested, 0);
if (context.enableTracing) {
getPMRootDomain()->traceDetail(context.messageType, 0, context.maxTimeRequested / 1000);
+ getPMRootDomain()->reset_watchdog_timer(this, context.maxTimeRequested/USEC_PER_SEC+1);
}
start_ack_timer( context.maxTimeRequested / 1000, kMillisecondScale );
return false;
if (context->enableTracing && (notifier != 0))
{
- getPMRootDomain()->traceDetail(notifier);
+ getPMRootDomain()->traceDetail(notifier, true);
}
clock_get_uptime(&start);
retCode = context->us->messageClient(msgType, object, (void *) ¬ify, sizeof(notify));
clock_get_uptime(&end);
+ if (context->enableTracing && (notifier != NULL))
+ {
+ getPMRootDomain()->traceDetail(notifier, false);
+ }
+
+
if (kIOReturnSuccess == retCode)
{
if (0 == notify.returnValue) {
if (context->enableTracing && (notifier != 0))
{
- getPMRootDomain()->traceDetail(notifier);
+ getPMRootDomain()->traceDetail(notifier, true);
}
clock_get_uptime(&start);
retCode = context->us->messageClient(
msgType, object, (void *) &msgArg, sizeof(msgArg));
clock_get_uptime(&end);
+ if (context->enableTracing && (notifier != NULL))
+ {
+ getPMRootDomain()->traceDetail(notifier, false);
+ }
if ( kIOReturnSuccess == retCode )
{
context.stateNumber = fHeadNotePowerState;
context.stateFlags = fHeadNotePowerArrayEntry->capabilityFlags;
context.changeFlags = fHeadNoteChangeFlags;
+ context.enableTracing = IS_ROOT_DOMAIN;
context.messageFilter = (IS_ROOT_DOMAIN) ?
OSMemberFunctionCast(
IOPMMessageFilter,
notify.stateNumber = context->stateNumber;
notify.stateFlags = context->stateFlags;
+ if (context->enableTracing && object)
+ {
+ IOService::getPMRootDomain()->traceDetail(object, true);
+ }
context->us->messageClient(context->messageType, object, ¬ify, sizeof(notify));
+ if (context->enableTracing && object)
+ {
+ IOService::getPMRootDomain()->traceDetail(object, false);
+ }
+
+
if ((kIOLogDebugPower & gIOKitDebug) &&
(OSDynamicCast(_IOServiceInterestNotifier, object)))
// expected ack, stop the timer
stop_ack_timer();
+ getPMRootDomain()->reset_watchdog_timer(this, 0);
uint64_t nsec = computeTimeDeltaNS(&fDriverCallStartTime);
if (nsec > LOG_SETPOWER_TIMES) {
PM_LOCK_WAKEUP(&fPMDriverCallQueue);
}
+bool IOService::getBlockingDriverCall(thread_t *thread, const void **callMethod)
+{
+ const IOPMDriverCallEntry * entry = NULL;
+ bool blocked = false;
+
+ if (!initialized) {
+ return false;
+ }
+
+ if (current_thread() != gIOPMWatchDogThread) {
+ // Meant to be accessed only from watchdog thread
+ return false;
+ }
+
+ PM_LOCK();
+ entry = qe_queue_first(&fPMDriverCallQueue, IOPMDriverCallEntry, link);
+ if (entry) {
+ *thread = entry->thread;
+ *callMethod = entry->callMethod;
+ blocked = true;
+ }
+ PM_UNLOCK();
+
+ return blocked;
+}
+
+
void IOService::waitForPMDriverCall( IOService * target )
{
const IOPMDriverCallEntry * entry;
projects / apple / xnu.git / blobdiff