// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// e32\nkernsmp\dfcs.cpp
// DFCs
// 
//

// NThreadBase member data
#define __INCLUDE_NTHREADBASE_DEFINES__

// TDfc member data
#define __INCLUDE_TDFC_DEFINES__

#include "nk_priv.h"

extern "C" void send_self_resched_ipi();

/** Construct an IDFC

	@param aFunction = function to call
	@param aPtr = parameter to be passed to function
 */
EXPORT_C TDfc::TDfc(TDfcFn aFunction, TAny* aPtr)
	{
	iPtr = aPtr;
	iFn = aFunction;
	iTied = 0;
	iHType = EEventHandlerIDFC;
	i8888.iHState0 = 0;
	i8888.iHState1 = 0;
	i8888.iHState2 = 0;
	iTiedLink.iNext = 0;
	}


/** Construct an IDFC tied to a thread or group

	@param aTied = pointer to thread or group to which IDFC should be tied
	@param aFunction = function to call
	@param aPtr = parameter to be passed to function

	@pre Call in thread context, interrupts enabled
 */
EXPORT_C TDfc::TDfc(NSchedulable* aTied, TDfcFn aFunction, TAny* aPtr)
	{
	iPtr = aPtr;
	iFn = aFunction;
	iTied = 0;
	iHType = EEventHandlerIDFC;
	i8888.iHState0 = 0;
	i8888.iHState1 = 0;
	i8888.iHState2 = 0;
	iTiedLink.iNext = 0;
	if (aTied)
		{
		SetTied(aTied);
		}
	}


/** Construct a DFC without specifying a DFC queue.
	The DFC queue must be set before the DFC may be queued.

	@param aFunction = function to call
	@param aPtr = parameter to be passed to function
	@param aPriority = priority of DFC within the queue (0 to 7, where 7 is highest)
 */
EXPORT_C TDfc::TDfc(TDfcFn aFunction, TAny* aPtr, TInt aPriority)
	{
	__NK_ASSERT_DEBUG((TUint)aPriority<(TUint)KNumDfcPriorities);
	iPtr = aPtr;
	iFn = aFunction;
	iTied = 0;
	iHType = TUint8(aPriority);
	i8888.iHState0 = 0;
	i8888.iHState1 = 0;
	i8888.iHState2 = 0;
	iTiedLink.iNext = 0;
	}


/** Construct a DFC specifying a DFC queue.

	@param aFunction = function to call
	@param aPtr = parameter to be passed to function
	@param aDfcQ = pointer to DFC queue which this DFC should use
	@param aPriority = priority of DFC within the queue (0-7)
 */
EXPORT_C TDfc::TDfc(TDfcFn aFunction, TAny* aPtr, TDfcQue* aDfcQ, TInt aPriority)
	{
	__NK_ASSERT_DEBUG((TUint)aPriority<(TUint)KNumDfcPriorities);
	iPtr = aPtr;
	iFn = aFunction;
	iDfcQ = aDfcQ;
	iHType = TUint8(aPriority);
	i8888.iHState0 = 0;
	i8888.iHState1 = 0;
	i8888.iHState2 = 0;
	iTiedLink.iNext = 0;
	}


/** Tie an IDFC to a thread or group

	@param	aTied = pointer to thread or group to which IDFC should be tied
	@return	KErrNone if successful
	@return	KErrDied if thread has exited or group has been destroyed.

	@pre Call in thread context, interrupts enabled
	@pre Must be IDFC not DFC
	@pre IDFC must not be queued or running
	@pre IDFC must not already be tied
 */
EXPORT_C TInt TDfc::SetTied(NSchedulable* aTied)
	{
	__NK_ASSERT_ALWAYS(IsIDFC() && i8816.iHState16==0);
	__NK_ASSERT_ALWAYS(aTied && !iTied);
	NKern::Lock();
	TInt r = aTied->AddTiedEvent(this);
	__NK_ASSERT_ALWAYS(r==KErrNone || r==KErrDied);
	NKern::Unlock();
	return r;
	}


/** Destroy a DFC or IDFC

	@pre Call from thread context with interrupts and preemption enabled
	@pre Calling thread holds no fast mutex
	@pre Calling thread in critical section
 */
EXPORT_C TDfc::~TDfc()
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"TDfc::~TDfc");
	NKern::Lock();
	NEventHandler::TiedLock.LockOnly();
	NSchedulable* tied = iTied;
	if (IsDFC() || (IsIDFC() && !tied))
		{
		Cancel();
		iHType = (TUint8)EEventHandlerDummy;
		}
	if (IsIDFC())
		{
		__NK_ASSERT_ALWAYS(tied!=0);
		tied->AcqSLock();
		if (iTiedLink.iNext)
			{
			iTiedLink.Deque();
			iTiedLink.iNext = 0;
			}
		tied->RelSLock();
		Cancel();
		iHType = (TUint8)EEventHandlerDummy;
		iTied = 0;
		}
	NEventHandler::TiedLock.UnlockOnly();
	NKern::Unlock();
	}


/** Construct a DFC queue
	Kern::DfcQInit() should be called on the new DFC queue before it can be used.
 */
EXPORT_C TDfcQue::TDfcQue()
	: iThread(NULL)
	{}



/** Queue an IDFC or a DFC from an ISR

	This function is the only way to queue an IDFC and is the only way to queue
	a DFC from an ISR. To queue a DFC from an IDFC or a thread either Enque()
	or DoEnque() should be used.

	This function does nothing if the IDFC/DFC is already queued.

	@pre Call only from ISR, IDFC or thread with preemption disabled.
	@pre Do not call from thread with preemption enabled.
	@return	TRUE if DFC was actually queued by this call
			FALSE if DFC was already queued on entry so this call did nothing

	@see TDfc::DoEnque()
	@see TDfc::Enque()
 */
EXPORT_C TBool TDfc::Add()
	{
	__ASSERT_DEBUG(NKern::CurrentContext()!=NKern::EThread || NKern::KernelLocked(), *(int*)0xdfcadd01=0);
	__ASSERT_DEBUG(IsIDFC() || (IsDFC() && iDfcQ), *(int*)0xdfcadd03=0);
//	__ASSERT_WITH_MESSAGE_DEBUG(  NKern::CurrentContext()!=NKern::EThread  ||  NKern::KernelLocked(),"Do not call from thread with preemption enabled","TDfc::Add");
//	__ASSERT_WITH_MESSAGE_DEBUG(  IsIDFC() || (IsDFC() && iDfcQ), "DFC queue not set", "TDfc::Add");
#ifdef __WINS__
	__NK_ASSERT_ALWAYS(Interrupt.InInterrupt() || NKern::KernelLocked());
#endif
	TInt irq = NKern::DisableAllInterrupts();
	TSubScheduler& ss = SubScheduler();
	TUint32 orig = 0xFF00;

	// Transition the state to 'on normal IDFC queue'
	// 0000->008n
	// 00Cn->00En
	// All other states unchanged
	// Return original state
	if (IsValid())	// don't add if tied and tied thread/group is being/has been destroyed
		orig = AddStateChange();
	if (orig==0)
		{
		// wasn't already queued
		i8888.iHState0 = 0;	// BeginTiedEvent() not done
		ss.iDfcs.Add(this);
		ss.iDfcPendingFlag = 1;
#ifdef _DEBUG
		TUint32 st8 = DFC_STATE(this) & 0xFF;
		if (st8 != (0x80|ss.iCpuNum))
			__crash();
#endif
		}
	NKern::RestoreInterrupts(irq);
	return (orig==0 || (orig&0xFFE0)==0x00C0);
	}


/** Queue an IDFC or a DFC from any context

	This function is identical to TDfc::Add() but no checks are performed for correct usage,
	and it contains no instrumentation code.

	@return	TRUE if DFC was actually queued by this call
			FALSE if DFC was already queued on entry so this call did nothing

	@see TDfc::DoEnque()
	@see TDfc::Enque()
	@see TDfc::Add()
 */
EXPORT_C TBool TDfc::RawAdd()
	{
	TInt irq = NKern::DisableAllInterrupts();
	TSubScheduler& ss = SubScheduler();
	TUint32 orig = 0xFF00;
	if (IsValid())	// don't add if tied and tied thread/group is being/has been destroyed
		orig = AddStateChange();
	if (orig==0)
		{
		// wasn't already queued
		i8888.iHState0 = 0;	// BeginTiedEvent() not done
		ss.iDfcs.Add(this);
		ss.iDfcPendingFlag = 1;
		send_self_resched_ipi();	// ensure current CPU runs the DFC
#ifdef _DEBUG
		TUint32 st8 = DFC_STATE(this) & 0xFF;
		if (st8 != (0x80|ss.iCpuNum))
			__crash();
#endif
		// FIXME: Need to wait to ensure IRQ is active before reenabling interrupts
		}
	NKern::RestoreInterrupts(irq);
	return (orig==0 || (orig&0xFFE0)==0x00C0);
	}


/** Queue a DFC (not an IDFC) from an IDFC or thread with preemption disabled.

	This function is the preferred way to queue a DFC from an IDFC. It should not
	be used to queue an IDFC - use TDfc::Add() for this.

	This function does nothing if the DFC is already queued.

	@pre Call only from IDFC or thread with preemption disabled.
	@pre Do not call from ISR or thread with preemption enabled.
	@return	TRUE if DFC was actually queued by this call
			FALSE if DFC was already queued on entry so this call did nothing

	@see TDfc::Add()
	@see TDfc::Enque()
 */
EXPORT_C TBool TDfc::DoEnque()
	{
	__ASSERT_WITH_MESSAGE_DEBUG(  (NKern::CurrentContext()==NKern::EIDFC )||( NKern::CurrentContext()==NKern::EThread && NKern::KernelLocked()),"Do not call from ISR or thread with preemption enabled","TDfc::DoEnque");
	__NK_ASSERT_DEBUG(IsDFC());
	__ASSERT_WITH_MESSAGE_DEBUG(iDfcQ, "DFC queue not set", "TDfc::DoEnque");

	// Check not already queued and then mark queued to prevent ISRs touching this DFC
	TDfcQue* q = iDfcQ;
	NThreadBase* t = q->iThread;
	t->AcqSLock();	// also protects DFC queue
	TUint16 expect = 0;
	TBool ok = __e32_atomic_cas_acq16(&iDfcState, &expect, 1);
	if (ok)
		{
		// wasn't already queued, now marked as on final queue, which means
		// attempts to cancel will block on the thread spin lock
		TUint present = q->iPresent[0];
		q->Add((TPriListLink*)this);
		if (!present)
			t->iWaitState.UnBlockT(NThreadBase::EWaitDfc, q, KErrNone);
		}
	t->RelSLock();	// also protects DFC queue
	return ok;
	}

void TDfcQue::ThreadFunction(TAny* aDfcQ)
	{
	TDfcQue& q = *(TDfcQue*)aDfcQ;
	NThreadBase* t = NKern::CurrentThread();
	FOREVER
		{
		NKern::Lock();
		t->AcqSLock();	// also protects DFC queue
		if (q.IsEmpty())
			{
			t->iWaitState.SetUpWait(NThreadBase::EWaitDfc, 0, &q);
			RescheduleNeeded();
			t->RelSLock();	// also protects DFC queue
			NKern::Unlock();
			}
		else
			{
			TDfc* d = q.First();
			q.Remove((TPriListLink*)d);
			TDfcFn f = d->iFn;
			TAny* p = d->iPtr;
			d->ResetState();
			t->RelSLock();	// also protects DFC queue
			NKern::Unlock();
			(*f)(p);
			}
		}
	}



void TCancelIPI::Send(TDfc* aDfc, TInt aCpu)
	{
	iDfc = aDfc;
	Queue(&Isr, 1u<<aCpu);
	}

void TCancelIPI::Isr(TGenericIPI* aIPI)
	{
	TCancelIPI* p = (TCancelIPI*)aIPI;
	TDfc* d = p->iDfc;
	if (d->iNext)
		{
		// QueueDfcs() hasn't dequeued it yet
		// just dequeue it here and reset the state - QueueDfcs() will never see it
		// Note that this means we have to release the tied thread/group if necessary
		// BeginTiedEvent() has occurred if iHState0 is set and it's actually an IDFC not an NTimer
		NSchedulable* tied = (d->iHType==NEventHandler::EEventHandlerIDFC && d->i8888.iHState0) ? d->iTied : 0;
		d->Deque();
		d->ResetState();
		if (tied)
			tied->EndTiedEvent();
		}
	else
		{
		// QueueDfcs() has already dequeued it
		// state transition:
		//		XXYY->XX00
		//		XX00->0000
		// QueueDfcs() will take care of the tied thread/group
		d->CancelFinalStateChange();
		}
	}


/** Cancels an IDFC or DFC.

	This function does nothing if the IDFC or DFC is not queued.

	For any DFC or IDFC the following identity holds:
			Number of times Add() is called and returns TRUE
		+	Number of times DoEnque() is called and returns TRUE
		+	Number of times Enque() is called and returns TRUE
		+	Number of times QueueOnIdle() is called and returns TRUE
		=	Number of times Cancel() is called and returns TRUE
		+	Number of times the DFC/IDFC function executes

	@pre IDFC or thread context. Do not call from ISRs.

	@pre If the DFC function accesses the DFC object itself, the user must ensure that
	     Cancel() cannot be called while the DFC function is running.

	@return	TRUE	if the DFC was actually dequeued by this call - i.e. an
					instance of the DFC's execution has been prevented. It
					is still possible that a previous execution is still in
					progress.
			FALSE	if the DFC was not queued on entry to the call, or was in
					the process of being executed or cancelled. In this case
					it is possible that the DFC executes after this call
					returns.

	@post	However in either case it is safe to delete the DFC object on
			return from this call provided only that the DFC function does not
			refer to the DFC object itself.
 */
EXPORT_C TBool TDfc::Cancel()
	{
	enum TAction { EDeque=1, EReset=2, EIdleUnlock=4, ESendIPI=8, EWait=16 };

	CHECK_PRECONDITIONS(MASK_NOT_ISR|MASK_INTERRUPTS_ENABLED,"TDfc::Cancel");
	if (!iDfcState)
		return FALSE;
	TUint action = EIdleUnlock;
	TBool ret = FALSE;
	TInt cpu = -1;
	NSchedulable* tied = 0;
	TDfcQue* q = 0;
	NThreadBase* t = 0;
	NKern::Lock();
	TSubScheduler& ss0 = SubScheduler();
	if (IsDFC())
		q = iDfcQ, t = q->iThread, t->AcqSLock();
	TInt irq = NKern::DisableAllInterrupts();
	TheScheduler.iIdleSpinLock.LockOnly();

	// 0000->0000, XX00->ZZ00, xxYY->zzYY
	TUint state = CancelInitialStateChange();
	TUint stt = state >> 5;
	if (state & 0xFF00)
		{
		// someone else cancelling at the same time - just wait for them to finish
		action = EWait|EIdleUnlock;
		goto end;
		}
	if (state == 0)	// DFC not active
		goto end;

	// possible states here are 0001, 002g, 006m, 008m, 00Am, 00Cm, 00Em
	ret = (stt!=6);	// if running but not pending, Cancel() will not have prevented an execution
	if (state == TUint(TheScheduler.iIdleGeneration | 0x20))
		{
		// was on idle queue, BeginTiedEvent() isn't called until QueueDfcs() runs
		action = EDeque|EReset|EIdleUnlock;
		goto end;
		}
	if (state == 1)
		{
		// was on final queue, must be DFC not IDFC
		q->Remove((TPriListLink*)this);
		action = EReset|EIdleUnlock;
		goto end;
		}

	// possible states here are 002g (spilled), 006m, 008m, 00Am, 00Cm, 00Em
	// i.e. either on IDFC queue, ExIDFC queue or running
	// For IDFCs, tied thread/group is now in play.
	cpu = state & 0x1f;	// CPU it's on for states 006m, 008m, 00Am, 00Cm, 00Em
	if (stt==3 || stt==6 || stt==7)
		{
		// It's actually running - must be IDFC. A re-queue may also be pending.
		TheScheduler.iIdleSpinLock.UnlockOnly();
		TSubScheduler* ss = TheSubSchedulers + cpu;
		TDfc* expect = this;
		TBool done = __e32_atomic_cas_acq_ptr(&ss->iCurrentIDFC, &expect, 0);
		if (done)
			{
			// We cleared iCurrentIDFC so QueueDfcs() won't touch this again - we reset the state and finish up
			// We must also release the tied thread/group
			tied = iTied;
			action = EReset;
			goto end;
			}
		// QueueDfcs() got to iCurrentIDFC before we did, so we interlock with it
		// and we can leave the EndTiedEvent to it as well
		// State transition:
		//		XXAm->XX00, wait
		//		XX00->0000, don't wait
		TUint32 orig = CancelFinalStateChange() & 0xFF;
		__NK_ASSERT_ALWAYS(orig==0 || orig==state);
		action = orig ? EWait : 0;
		goto end;
		}

	// possible states here 002g (propagated), 008m, 00Am so it's either on the endogenous or exogenous IDFC queue
	if (stt==5)
		{
		// it's on the exogenous IDFC queue
		TheScheduler.iIdleSpinLock.UnlockOnly();
		TSubScheduler* ss = TheSubSchedulers + cpu;
		ss->iExIDfcLock.LockOnly();
		if (iNext)
			{
			// we got to it before QueueDfcs() on the other CPU so we can finish up here
			// QueueDfcs() will never see it again so we must release tied thread/group
			Deque();
			tied = iTied;
			ss->iExIDfcLock.UnlockOnly();
			action = EReset;
			goto end;
			}
		// QueueDfcs() on other CPU has already dequeued it - we must now interlock with RunIDFCStateChange()
		ss->iExIDfcLock.UnlockOnly();
		// State transition:
		//		XXAm->XX00, wait
		//		XX00->0000, don't wait
		// QueueDfcs() will take care of tied thread/group
		TUint32 orig = CancelFinalStateChange() & 0xFF;
		__NK_ASSERT_ALWAYS(orig==0 || orig==state);
		action = orig ? EWait : 0;
		goto end;
		}

	// possible states here 002g (propagated idle) or 008m (IDFC or DFC on endogenous DFC queue)
	if (stt==1)	// propagated idle
		cpu = TheScheduler.iIdleSpillCpu;

	// if it's on this CPU's IDFC queue we can just remove it and reset the state here
	// otherwise we send a cancel IPI to the CPU it's on
	// We are guaranteed to dequeue the DFC before it executes since the
	// QueueDfcs() on the target CPU will notice that a cancel is in progress and
	// so will not run the DFC even if it dequeues it.
	// QueueDfcs() takes care of the tied thread/group if it sees the DFC/IDFC again, otherwise
	// we must do it here.
	if (TUint(cpu) == ss0.iCpuNum)
		{
		if (IsIDFC())
			tied = iTied;
		action = EDeque|EReset|EIdleUnlock;
		}
	else
		action = EIdleUnlock|ESendIPI|EWait;

end:
	// Common exit point
	if (action & EDeque)
		Deque();
	if (action & EReset)
		{
		ResetState();
		}
	if (action & EIdleUnlock)
		TheScheduler.iIdleSpinLock.UnlockOnly();
	NKern::RestoreInterrupts(irq);
	if (t)
		t->RelSLock();

	// on another CPU's IDFC queue so send IPI to remove it
	if (action & ESendIPI)
		{
		TCancelIPI ipi;
		ipi.Send(this, cpu);
		ipi.WaitCompletion();
		tied = 0;
		}

	// wait for cancel to complete
	if (action & EWait)
		{
		TUint n = 0x01000000;
		while ((iDfcState>>8) & ss0.iCpuMask)
			{
			__chill();
			if (!--n)
				__crash();
			}
		}

	// release tied thread/group if waiting for IDFC to complete
	if (tied)
		tied->EndTiedEvent();
	NKern::Unlock();
	return ret;
	}


/** Queues a DFC (not an IDFC) from a thread.

	Does nothing if DFC is already queued.

    NOTE: Although this can be called in an IDFC context, it is more efficient to call
    DoEnque() in this case.
    
    @pre    Call either in a thread or an IDFC context.
	@pre	Do not call from an ISR.
	@return	TRUE if DFC was actually queued by this call
			FALSE if DFC was already queued on entry so this call did nothing
 */
EXPORT_C TBool TDfc::Enque()
	{
	CHECK_PRECONDITIONS(MASK_NOT_ISR,"TDfc::Enque()");		
	NKern::Lock();
	TBool ret = DoEnque();
	NKern::Unlock();
	return ret;
	}


/** Queue a DFC (not an IDFC) from a thread and also signals a fast mutex.

	The DFC is unaffected if it is already queued.

	The fast mutex is signalled before preemption is reenabled to avoid potential
	scheduler thrashing.

	@param	aMutex =	pointer to fast mutex to be signalled;
						NULL means system lock mutex.
	@return	TRUE if DFC was actually queued by this call
			FALSE if DFC was already queued on entry so this call did nothing
	@pre	Call in a thread context.
	@pre	Kernel must be unlocked.
	@pre	Do not call from an ISR.
	@pre    Do not call from an IDFC.
 */
EXPORT_C TBool TDfc::Enque(NFastMutex* aMutex)
	{
	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED|MASK_NOT_ISR|MASK_NOT_IDFC,"TDfc::Enque(NFastMutex* aMutex)");		
	if (!aMutex)
		aMutex=&TheScheduler.iLock;
	NKern::Lock();
	TBool ret = DoEnque();
	aMutex->Signal();
	NKern::Unlock();
	return ret;
	}


/** Returns a pointer to the thread on which a DFC runs

	@return	If this is a DFC and the DFC queue has been set, a pointer to the
			thread which will run the DFC.
			NULL if this is an IDFC or the DFC queue has not been set.
 */
EXPORT_C NThreadBase* TDfc::Thread()
	{
	if (!IsDFC())
		return 0;
	return iDfcQ ? iDfcQ->iThread : 0;
	}


/******************************************************************************
 * Idle notification
 ******************************************************************************/

/** Register an IDFC or a DFC to be called when the system goes idle

	This function does nothing if the IDFC/DFC is already queued.

	@return	TRUE if DFC was actually queued by this call
			FALSE if DFC was already queued on entry so this call did nothing
 */
EXPORT_C TBool TDfc::QueueOnIdle()
	{
	TInt irq = TheScheduler.iIdleSpinLock.LockIrqSave();
	TUint32 orig = 0xFF00;

	// Transition the state to 'on normal idle queue'
	// 0000->002g
	// 00Cn->006n
	// All other states unchanged
	// Return original state
	if (IsValid())	// don't add if tied and tied thread/group is being/has been destroyed
		orig = QueueOnIdleStateChange();
	if (orig==0)
		{
		i8888.iHState0 = 0;	// BeginTiedEvent() not done
		TheScheduler.iIdleDfcs.Add(this);
		}

	TheScheduler.iIdleSpinLock.UnlockIrqRestore(irq);
	return (orig==0 || (orig&0xFFE0)==0x00C0);
	}


/******************************************************************************
 * Scheduler IDFC/DFC Processing
 ******************************************************************************/

void TSubScheduler::QueueDfcs()
//
// Enter with interrupts off and kernel locked
// Leave with interrupts off and kernel locked
//
// In state descriptions:
//		XX=8 bits not all zero (bitmask representing cancelling CPUs)
//		xx=8 bits (bitmask representing cancelling CPUs)
//		YY=8 bits not all zero
//		ZZ=XX with an additional bit set corresponding to the current CPU
//		zz=xx with an additional bit set corresponding to the current CPU
//		n = current CPU number
//		m = another CPU number
//		g = idle generation number
	{
	__KTRACE_OPT(KSCHED2,DEBUGPRINT("^"));
	iInIDFC = TRUE;
	BTrace0(BTrace::ECpuUsage, BTrace::EIDFCStart);
	TDfc* d = 0;
	NSchedulable* tied = 0;
	FOREVER
		{
		NKern::DisableAllInterrupts();
		// remove from pending queue with interrupts disabled
		d = (TDfc*)iDfcs.GetFirst();
		if (d)
			{
			d->iNext = 0;
#ifdef _DEBUG
			TUint32 st8 = DFC_STATE(d) & 0xFF;
			if (st8 != TUint(0x80|iCpuNum) && st8 != TUint(0x21^TheScheduler.iIdleGeneration))
				__crash();
#endif
			if (d->IsDFC())	// also true for mutating NTimer
				{
				NKern::EnableAllInterrupts();
				TDfcQue* q = d->iDfcQ;
				NThreadBase* t = q->iThread;
				t->AcqSLock();	// also protects DFC queue

				// transition to 'final queue' state
				// 002g->0001, ok=TRUE
				// 008n->0001, ok=TRUE
				// XXYY->XX00, ok=FALSE
				// XX00->0000, ok=FALSE
				// other starting states invalid
				TUint32 orig = d->MoveToFinalQStateChange() >> 5;
				if (orig==1 || orig==4)
					{
					// wasn't being cancelled, now marked as on final queue, which means
					// attempts to cancel will block on the thread spin lock
					TUint present = q->iPresent[0];
					q->Add((TPriListLink*)d);
					if (!present)
						t->iWaitState.UnBlockT(NThreadBase::EWaitDfc, q, KErrNone);
					}
				t->RelSLock();	// also protects DFC queue
				continue;
				}
			// endogenous IDFC - could be tied in which case may need to be punted over to another CPU
			// can't be mutating NTimer since that would have gone into IsDFC() path
			tied = d->iTied;
			if (tied && !d->i8888.iHState0)	// if tied and BeginTiedEvent() not already done
				{
				d->i8888.iHState0 = 1;		// flag that BeginTiedEvent() done
				TInt cpu = tied->BeginTiedEvent();
				if (TUint(cpu) != iCpuNum)
					{
					// punt over to other CPU
					TBool kick = FALSE;
					TSubScheduler* ss = TheSubSchedulers + cpu;
					ss->iExIDfcLock.LockOnly();
					// transition state here to handle cancel
					// XXYY->XX00, ok=FALSE
					// XX00->0000, ok=FALSE
					// 008n->00Am, ok=TRUE
					// 002g->00Am, ok=TRUE
					// other starting states invalid
					TUint32 orig = d->TransferIDFCStateChange(cpu) >> 5;
					if (orig==1 || orig==4)
						{
						kick = !ss->iExIDfcPendingFlag;
						ss->iExIDfcPendingFlag = TRUE;
						ss->iExIDfcs.Add(d);
						}
					ss->iExIDfcLock.UnlockOnly();
					if (kick)
						send_resched_ipi(cpu);
					NKern::EnableAllInterrupts();	// let interrupts in
					if (orig >= 8)
						tied->EndTiedEvent();		// IDFC cancelled so release tied thread/group
					continue;
					}
				}
			}
		else
			{
			if (!iExIDfcPendingFlag)
				break;
			iExIDfcLock.LockOnly();
			d = (TDfc*)iExIDfcs.GetFirst();
			if (!d)
				{
				iExIDfcPendingFlag = 0;
				iExIDfcLock.UnlockOnly();
				break;
				}
			d->iNext = 0;
			tied = d->iTied;
			__NK_ASSERT_ALWAYS(d->IsIDFC() && tied);	// only tied IDFCs should get here
#ifdef _DEBUG
			TUint32 st8 = DFC_STATE(d) & 0xFF;
			if (st8 != (0xA0|iCpuNum))
				__crash();
#endif
			iExIDfcLock.UnlockOnly();
			}

		// endogenous or exogenous IDFC
		// if tied, we are on correct CPU
		TDfcFn f = d->iFn;
		TAny* p = d->iPtr;

		// If Cancel() finds the IDFC in the running state (00Cn or 00En) it will do the following
		// atomic { if (iCurrentIDFC==d) iCurrentIDFC=0; }
		// We must guarantee that the following access is observed before the state change in RunIDFCStateChange()
		// We assume the latter has full barrier semantics to guarantee this.
		iCurrentIDFC = d;

		// transition to running state
		// 002g->00Cn, ok=TRUE
		// 008n->00Cn, ok=TRUE
		// 00An->00Cn, ok=TRUE
		// XXYY->XX00, ok=FALSE
		// XX00->0000, ok=FALSE
		// other starting states invalid
		TUint32 orig = d->RunIDFCStateChange() >> 5;
		NKern::EnableAllInterrupts();
		if (orig==1 || orig==4 || orig==5)
			{
			(*f)(p);

			// transition to idle state or rerun if necessary
			// first swap iCurrentIDFC with 0 - if original value != d, don't touch d again, return 0xFFFFFFFF
			// 00Cn->0000
			// 00En->008n
			// 006n->006n
			// XXCn->XX00
			// XXEn->XX00
			// XX6n->XX00
			// other starting states invalid
			// return original state
			NKern::DisableAllInterrupts();
			TUint32 orig = d->EndIDFCStateChange(this);
			if ((orig>>5)==7)
				{
				iDfcs.Add(d);
#ifdef _DEBUG
				TUint32 st8 = DFC_STATE(d) & 0xFF;
				if (st8 != (0x80|iCpuNum))
					__crash();
#endif
				continue;
				}
			else if ((orig>>5)==3)
				{
				TheScheduler.iIdleSpinLock.LockOnly();
				// 006n->002g
				// XX6n->XX00
				orig = d->EndIDFCStateChange2();
				if ((orig>>5)==3)
					TheScheduler.iIdleDfcs.Add(d);
				TheScheduler.iIdleSpinLock.UnlockOnly();
				}
			NKern::EnableAllInterrupts();
			if (tied && orig<0x10000)
				tied->EndTiedEvent(); // if we set iCurrentIDFC back to 0, we release the tied thread/group
			}
		else
			{
			iCurrentIDFC = 0;
			if (tied)
				tied->EndTiedEvent();		// IDFC cancelled so release tied thread/group
			}
		}
	iDfcPendingFlag = 0;
	BTrace0(BTrace::ECpuUsage, BTrace::EIDFCEnd);
	iInIDFC = 0;
	__KTRACE_OPT(KSCHED2,DEBUGPRINT("~"));
	}


/******************************************************************************
 * Kernel-side asynchronous request DFCs
 ******************************************************************************/

EXPORT_C TAsyncRequest::TAsyncRequest(TDfcFn aFunction, TDfcQue* aDfcQ, TInt aPriority)
	: TDfc(aFunction, this, aDfcQ, aPriority), iCompletionObject(0), iCancel(0), iResult(0)
	{
	}


EXPORT_C void TAsyncRequest::Send(TDfc* aCompletionDfc)
	{
	__NK_ASSERT_DEBUG(!iCompletionObject);
	iCancel = EFalse;
	iCompletionObject = (TAny*)((TLinAddr)aCompletionDfc|1);
	TDfc::Enque();
	}


EXPORT_C void TAsyncRequest::Send(NFastSemaphore* aCompletionSemaphore)
	{
	__NK_ASSERT_DEBUG(!iCompletionObject);
	iCancel = EFalse;
	iCompletionObject = aCompletionSemaphore;
	TDfc::Enque();
	}


EXPORT_C TInt TAsyncRequest::SendReceive()
	{
	NFastSemaphore signal;
	NKern::FSSetOwner(&signal, 0);
	Send(&signal);
	NKern::FSWait(&signal);
	return iResult;
	}


EXPORT_C void TAsyncRequest::Cancel()
	{
	iCancel = ETrue;
	if(TDfc::Cancel())
		Complete(KErrCancel);
	}


EXPORT_C void TAsyncRequest::Complete(TInt aResult)
	{
	TLinAddr signal = (TLinAddr)__e32_atomic_swp_ord_ptr(&iCompletionObject, 0);
	if(signal)
		{
		iResult = aResult;
		if(signal&1)
			((TDfc*)(signal&~1))->Enque();
		else
			NKern::FSSignal((NFastSemaphore*)signal);
		}
	}