// Copyright (c) 1998-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\nkern\win32\ncsched.cpp

 // 

 //

 // NThreadBase member data

 #define __INCLUDE_NTHREADBASE_DEFINES__

 #include <e32cmn.h>

 #include <e32cmn_private.h>

 #include "nk_priv.h"

 #ifdef __EMI_SUPPORT__

 extern void EMI_AddTaskSwitchEvent(TAny* aPrevious, TAny* aNext);

 extern void EMI_CheckDfcTag(TAny* aNext);

 #endif

 typedef void (*ProcessHandler)(TAny* aAddressSpace);

 static DWORD TlsIndex = TLS_OUT_OF_INDEXES;

 static NThreadBase* SelectThread(TScheduler& aS)

 //

 // Select the next thread to run.

 // This is the heart of the rescheduling algorithm.

 //

 	{

 	NThreadBase* t = static_cast<NThreadBase*>(aS.First());

 	__NK_ASSERT_DEBUG(t);

 #ifdef _DEBUG

 	if (t->iHeldFastMutex)

 		{

 		__KTRACE_OPT(KSCHED2,DEBUGPRINT("Resched init->%T, Holding %M",t,t->iHeldFastMutex));

 		}

 	else

 		{

 		__KTRACE_OPT(KSCHED2,DEBUGPRINT("Resched init->%T",t));

 		}

 #endif

 	if (t->iTime == 0 && !t->Alone())

 		{

 		// round robin

 		// get here if thread's timeslice has expired and there is another

 		// thread ready at the same priority

 		if (t->iHeldFastMutex)

 			{

 			// round-robin deferred due to fast mutex held

 			t->iHeldFastMutex->iWaiting = 1;

 			return t;

 			}

 		t->iTime = t->iTimeslice;		// reset old thread time slice

 		t = static_cast<NThreadBase*>(t->iNext);					// next thread

 		aS.iQueue[t->iPriority] = t;		// make it first in list

 		__KTRACE_OPT(KSCHED2,DEBUGPRINT("RoundRobin->%T",t));

 		}

 	if (t->iHeldFastMutex)

 		{

 		if (t->iHeldFastMutex == &aS.iLock)

 			{

 			// thread holds system lock: use it

 			return t;

 			}

 		if ((t->i_ThrdAttr & KThreadAttImplicitSystemLock) != 0 && aS.iLock.iHoldingThread)

 			t->iHeldFastMutex->iWaiting = 1;

 		__NK_ASSERT_DEBUG((t->i_ThrdAttr & KThreadAttAddressSpace) == 0);

 /*

 		Check for an address space change. Not implemented for Win32, but useful as

 		documentaiton of the algorithm.

 		if ((t->i_ThrdAttr & KThreadAttAddressSpace) != 0 && t->iAddressSpace != aS.iAddressSpace)

 			t->iHeldFastMutex->iWaiting = 1;

 */

 		}

 	else if (t->iWaitFastMutex && t->iWaitFastMutex->iHoldingThread)

 		{

 		__KTRACE_OPT(KSCHED2,DEBUGPRINT("Resched inter->%T, Blocked on %M",t->iWaitFastMutex->iHoldingThread,t->iWaitFastMutex));

 		t = t->iWaitFastMutex->iHoldingThread;

 		}

 	else if (t->i_ThrdAttr & KThreadAttImplicitSystemLock)

 		{

 		// implicit system lock required

 		if (aS.iLock.iHoldingThread)

 			{

 			// system lock held, switch to that thread

 			t = aS.iLock.iHoldingThread;

 			__KTRACE_OPT(KSCHED2,DEBUGPRINT("Resched inter->%T (IMP SYS)",t));

 			t->iHeldFastMutex->iWaiting = 1;	// aS.iLock.iWaiting = 1;

 			return t;

 			}

 		__NK_ASSERT_DEBUG((t->i_ThrdAttr & KThreadAttAddressSpace) == 0);

 /*

 		Check for an address space change. Not implemented for Win32, but useful as

 		documentaiton of the algorithm.

 		if ((t->i_ThrdAttr & KThreadAttAddressSpace) != 0 || t->iAddressSpace != aS.iAddressSpace)

 			{

 			// what do we do now?

 			__NK_ASSERT_DEBUG(FALSE);

 			}

 */

 		}

 	return t;

 	}

 // from NThread

 #undef i_ThrdAttr

 TBool NThread::WakeUp()

 //

 // Wake up the thread. What to do depends on whether we were preempted or voluntarily

 // rescheduled.

 //

 // Return TRUE if we need to immediately reschedule again because we had to unlock

 // the kernel but there are DFCs pending. In this case, the thread does not wake up.

 //

 // NB. kernel is locked

 //

 	{

 	switch (iWakeup)

 		{

 	default:

 		FAULT();

 	case EIdle:

 		__NK_ASSERT_ALWAYS(TheScheduler.iCurrentThread == this);

 		__NK_ASSERT_ALWAYS(SetEvent(iScheduleLock));

 		break;

 	case ERelease:

 		TheScheduler.iCurrentThread = this;

 		__NK_ASSERT_ALWAYS(SetEvent(iScheduleLock));

 		break;

 	case EResumeLocked:

 		// The thread is Win32 suspended and must be resumed.

 		//

 		// A newly created thread does not need the kernel unlocked so we can

 		// just resume the suspended thread

 		//

 		__KTRACE_OPT(KSCHED,DEBUGPRINT("Win32Resume->%T",this));

 		iWakeup = ERelease;

 		TheScheduler.iCurrentThread = this;

 		if (TheScheduler.iProcessHandler)

 			(*ProcessHandler(TheScheduler.iProcessHandler))(iAddressSpace); // new thread will need to have its static data updated

 		__NK_ASSERT_ALWAYS(TInt(ResumeThread(iWinThread)) > 0);	// check thread was previously suspended

 		break;

 	case EResumeDiverted:

 		// The thread is Win32 suspended and must be resumed.

 		//

 		// The thread needs to be diverted, and does not need the kernel

 		// unlocked.

 		//

 		// It's safe the divert the thread here because we called

 		// IsSafeToPreempt() when we suspended it - otherwise the diversion

 		// could get lost.

 		//

 		__KTRACE_OPT(KSCHED,DEBUGPRINT("Win32Resume->%T (Resuming diverted thread)",this));

 		iWakeup = ERelease;

 		ApplyDiversion();

 		TheScheduler.iCurrentThread = this;

 		__NK_ASSERT_ALWAYS(TInt(ResumeThread(iWinThread)) == 1);

 		break;

 	case EResume:

 		// The thread is Win32 suspended and must be resumed.

 		//

 		// the complication here is that we have to unlock the kernel on behalf of the

 		// pre-empted thread. This means that we have to check to see if there are more DFCs

 		// pending or a reschedule required, as we unlock the kernel. That check is

 		// carried out with interrupts disabled.

 		//

 		// If so, we go back around the loop in this thread context

 		//

 		// Otherwise, we unlock the kernel (having marked us as not-preempted),

 		// enable interrupts and then resume the thread. If pre-emption occurs before the thread

 		// is resumed, it is the new thread that is pre-empted, not the running thread, so we are guaranteed

 		// to be able to call ResumeThread. If pre-emption occurs, and we are rescheduled to run before

 		// that occurs, we will once again be running with the kernel locked and the other thread will

 		// have been re-suspended by Win32: so all is well.

 		//		

 		{

 		__KTRACE_OPT(KSCHED,DEBUGPRINT("Win32Resume->%T",this));

 		TInt irq = NKern::DisableAllInterrupts();

 		if (TheScheduler.iDfcPendingFlag || TheScheduler.iRescheduleNeededFlag)

 			{

 			// we were interrrupted... back to the top

 			TheScheduler.iRescheduleNeededFlag = TRUE;	// ensure we do the reschedule

 			return TRUE;

 			}

 		iWakeup = ERelease;

 		TheScheduler.iCurrentThread = this;

 		if (TheScheduler.iProcessHandler)

 			(*ProcessHandler(TheScheduler.iProcessHandler))(iAddressSpace); // threads resumed after interrupt or locks need to have static data updated

 		if (iInKernel == 0 && iUserModeCallbacks != NULL)

 			ApplyDiversion();

 		else 

 			TheScheduler.iKernCSLocked = 0;		// have to unlock the kernel on behalf of the new thread

 		TheScheduler.iCurrentThread = this;

 		NKern::RestoreInterrupts(irq);

 		__NK_ASSERT_ALWAYS(TInt(ResumeThread(iWinThread)) > 0);	// check thread was previously suspended

 		}

 		break;

 		}

 	return FALSE;

 	}

 static void ThreadExit(NThread& aCurrent, NThread& aNext)

 //

 // The final context switch of a thread.

 // Wake up the next thread and then destroy this one's Win32 resources.

 //

 // Return without terminating if we need to immediately reschedule again because

 // we had to unlock the kernel but there are DFCs pending.

 //

 	{

 	// the thread is dead

 	// extract win32 handles from dying NThread object before rescheduling

 	HANDLE sl = aCurrent.iScheduleLock;

 	HANDLE th = aCurrent.iWinThread;

 	// wake up the next thread

 	if (aNext.WakeUp())

 		return;			// need to re-reschedule in this thread

 	// we are now a vanilla win32 thread, nKern no longer knows about us

 	// release resources and exit cleanly

 	CloseHandle(sl);

 	CloseHandle(th);

 	ExitThread(0);		// does not return

 	}

 #ifdef MONITOR_THREAD_CPU_TIME

 static inline void UpdateThreadCpuTime(NThread& aCurrent, NThread& aNext)

 	{	

 	TUint32 timestamp = NKern::FastCounter();

 	if (aCurrent.iLastStartTime)

 		aCurrent.iTotalCpuTime += timestamp - aCurrent.iLastStartTime;

 	aNext.iLastStartTime = timestamp;

 	}

 #else

 static inline void UpdateThreadCpuTime(NThread& /*aCurrent*/, NThread& /*aNext*/)

 	{	

 	}

 #endif

 static void SwitchThreads(NThread& aCurrent, NThread& aNext)

 //

 // The fundamental context switch - wake up the next thread and wait for reschedule

 // trivially is aNext.WakeUp(), Wait(aCurrent.iScheduleLock), but we may be able to

 // optimise the signal-and-wait

 //

 	{

 	UpdateThreadCpuTime(aCurrent, aNext);

 	if (aCurrent.iNState == NThread::EDead)

 		ThreadExit(aCurrent, aNext);

 	else if (Win32AtomicSOAW && aNext.iWakeup==NThread::ERelease)

 		{

 		// special case optimization for normally blocked threads using atomic Win32 primitive

 		TheScheduler.iCurrentThread = &aNext;

 		DWORD result=SignalObjectAndWait(aNext.iScheduleLock,aCurrent.iScheduleLock, INFINITE, FALSE);

 		if (result != WAIT_OBJECT_0)

 			{

 			__NK_ASSERT_ALWAYS(result == 0xFFFFFFFF);

 			KPrintf("SignalObjectAndWait() failed with %d (%T->%T)",GetLastError(),&aCurrent,&aNext);

 			FAULT();

 			}

 		}

 	else

 		{

 		if (aNext.WakeUp())

 			return;			// need to re-reschedule in this thread

 		__NK_ASSERT_ALWAYS(WaitForSingleObject(aCurrent.iScheduleLock, INFINITE) == WAIT_OBJECT_0);

 		}

 	}

 void TScheduler::YieldTo(NThreadBase*)

 //

 // Directed context switch to the nominated thread.

 // Enter with kernel locked, exit with kernel unlocked but interrupts disabled.

 //

 	{

 	RescheduleNeeded();

 	TScheduler::Reschedule();

 	}

 void TScheduler::Reschedule()

 //

 // Enter with kernel locked, exit with kernel unlocked, interrupts disabled.

 // If the thread is dead do not return, but terminate the thread.

 //

 	{

 	__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked == 1);

 	NThread& me = *static_cast<NThread*>(TheScheduler.iCurrentThread);

 	for (;;)

 		{

 		NKern::DisableAllInterrupts();

 		if (TheScheduler.iDfcPendingFlag)

 			TheScheduler.QueueDfcs();

 		if (!TheScheduler.iRescheduleNeededFlag)

 			break;

 		NKern::EnableAllInterrupts();

 		TheScheduler.iRescheduleNeededFlag = FALSE;

 		NThread* t = static_cast<NThread*>(SelectThread(TheScheduler));

 		__KTRACE_OPT(KSCHED,DEBUGPRINT("Reschedule->%T (%08x%08x)",t,TheScheduler.iPresent[1],TheScheduler.iPresent[0]));

 #ifdef __EMI_SUPPORT__

 		EMI_AddTaskSwitchEvent(&me,t);

 		EMI_CheckDfcTag(t);

 #endif

 #ifdef BTRACE_CPU_USAGE

 		if(TheScheduler.iCpuUsageFilter)

 			TheScheduler.iBTraceHandler(BTRACE_HEADER_C(4,BTrace::ECpuUsage,BTrace::ENewThreadContext),0,(TUint32)t,0,0,0,0,0);

 #endif

 		SwitchThreads(me, *t);

 		// we have just been scheduled to run... check for diversion/new Dfcs

 		NThread::TDivert divert = me.iDivert;

 		if (divert)

 			{

 			// diversion (e.g. force exit)

 			me.iDivert = NULL;

 			divert();						// does not return

 			}

 		}

 	if (TheScheduler.iProcessHandler)

 		(*ProcessHandler(TheScheduler.iProcessHandler))(me.iAddressSpace);

 	// interrrupts are disabled, the kernel is still locked

 	TheScheduler.iKernCSLocked = 0;

 	}

 /**	Put the emulator into 'idle'.

 	This is called by the idle thread when there is nothing else to do.

 	@internalTechnology

  */

 EXPORT_C void NThread::Idle()

 //

 // Rather than spin, we go to sleep on the schedule lock. Preemption detects

 // this state (Win32Idling) and pokes the event rather than diverting the thread.

 //

 // enter and exit with kernel locked

 //

 	{

 	NThread& me = *static_cast<NThread*>(TheScheduler.iCurrentThread);

 	me.iWakeup = EIdle;

 	__NK_ASSERT_ALWAYS(WaitForSingleObject(me.iScheduleLock, INFINITE) == WAIT_OBJECT_0);

 	// something happened, and we've been prodded by an interrupt

 	// the kernel was locked by the interrupt, and now reschedule

 	me.iWakeup = ERelease;

 	TScheduler::Reschedule();

 	NKern::EnableAllInterrupts();

 	}

 void SchedulerInit(NThread& aInit)

 //

 // Initialise the win32 nKern scheduler

 //

 	{

 	DWORD procaffin,sysaffin;

 	if (GetProcessAffinityMask(GetCurrentProcess(),&procaffin,&sysaffin))

 		{

 		DWORD cpu;

 		switch (Win32SingleCpu)

 			{

 		default:

 			// bind the emulator to a nominated CPU on the host PC

 			cpu = (1<<Win32SingleCpu);

 			if (!(sysaffin & cpu))

 				cpu = procaffin;	// CPU selection invalid

 			break;

 		case NThread::ECpuSingle:

 			// bind the emulator to a single CPU on the host PC, pick one

 			cpu = procaffin ^ (procaffin & (procaffin-1));

 			break;

 		case NThread::ECpuAll:

 			// run the emulator on all CPUs on the host PC

 			cpu=sysaffin;

 			break;

 			}

 		SetProcessAffinityMask(GetCurrentProcess(), cpu);

 		}

 	// identify if we can use the atomic SignalObjectAndWait API in Win32 for rescheduling

 	Win32AtomicSOAW = (SignalObjectAndWait(aInit.iScheduleLock, aInit.iScheduleLock, INFINITE, FALSE) == WAIT_OBJECT_0);

 	//

 	// allocate the TLS used for thread identification, and set it for the init thread

 	TlsIndex = TlsAlloc();

 	__NK_ASSERT_ALWAYS(TlsIndex != TLS_OUT_OF_INDEXES);

 	SchedulerRegister(aInit);

 	//

 	Interrupt.Init();

 	Win32FindNonPreemptibleFunctions();

 	}

 void SchedulerRegister(NThread& aSelf)

 	{

 	TlsSetValue(TlsIndex,&aSelf);

 	}

 NThread* SchedulerThread()

 	{

 	if (TlsIndex != TLS_OUT_OF_INDEXES)

 		return static_cast<NThread*>(TlsGetValue(TlsIndex));

 	else

 		return NULL;  // not yet initialised

 	}

 inline TBool IsScheduledThread()

 	{

 	return SchedulerThread() == TheScheduler.iCurrentThread;

 	}

 NThread& CheckedCurrentThread()

 	{

 	NThread* t = SchedulerThread();

 	__NK_ASSERT_ALWAYS(t == TheScheduler.iCurrentThread);

 	return *t;

 	}

 /**	Disable normal 'interrupts'.

 	@param	aLevel Ignored

 	@return	Cookie to be passed into RestoreInterrupts()

  */

 EXPORT_C TInt NKern::DisableInterrupts(TInt /*aLevel*/)

 	{

 	return Interrupt.Mask();

 	}

 /**	Disable all maskable 'interrupts'.

 	@return	Cookie to be passed into RestoreInterrupts()

  */

 EXPORT_C TInt NKern::DisableAllInterrupts()

 	{

 	return Interrupt.Mask();

 	}

 /**	Enable all maskable 'interrupts'

 	@internalComponent

  */

 EXPORT_C void NKern::EnableAllInterrupts()

 	{

 	Interrupt.Restore(0);

 	}

 /** Restore interrupt mask to state preceding a DisableInterrupts() call

 	@param	aLevel Cookie returned by Disable(All)Interrupts()

  */

 EXPORT_C void NKern::RestoreInterrupts(TInt aLevel)

 	{

 	Interrupt.Restore(aLevel);

 	}

 /**	Unlocks the kernel.

 	Decrements iKernCSLocked; if it becomes zero and IDFCs or a reschedule are

 	pending, calls the scheduler to process them.

     @pre    Call either in a thread or an IDFC context.

     @pre    Do not call from an ISR.

 	@pre	Do not call from bare Win32 threads.

  */

 EXPORT_C void NKern::Unlock()

 //

 // using this coding sequence it is possible to call Reschedule unnecessarily

 // if we are preempted after testing the flags (lock is zero at this point).

 // However, in the common case this is much faster because 'disabling interrupts'

 // can be very expensive.

 //

 	{

 	CHECK_PRECONDITIONS(MASK_NOT_ISR,"NKern::Unlock");	

 	__ASSERT_WITH_MESSAGE_DEBUG(IsScheduledThread(),"Do not call from bare Win32 threads","NKern::Unlock");	// check that we are a scheduled thread

 	__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked > 0);	// Can't unlock if it isn't locked!

 	if (--TheScheduler.iKernCSLocked == 0)

 		{

 		if (TheScheduler.iRescheduleNeededFlag || TheScheduler.iDfcPendingFlag)

 			{

 			TheScheduler.iKernCSLocked = 1;

 			TScheduler::Reschedule();

 			NKern::EnableAllInterrupts();

 			}

 		}

 	}

 /**	Locks the kernel.

 	Increments iKernCSLocked, thereby deferring IDFCs and preemption.

     @pre    Call either in a thread or an IDFC context.

     @pre    Do not call from an ISR.

 	@pre	Do not call from bare Win32 threads.

  */

 EXPORT_C void NKern::Lock()

 	{

 	CHECK_PRECONDITIONS(MASK_NOT_ISR,"NKern::Lock");		

 	__ASSERT_WITH_MESSAGE_ALWAYS(IsScheduledThread(),"Do not call from bare Win32 threads","NKern::Lock");	// check that we are a scheduled thread

 	++TheScheduler.iKernCSLocked;

 	}

 /**	Locks the kernel and returns a pointer to the current thread

 	Increments iKernCSLocked, thereby deferring IDFCs and preemption.

     @pre    Call either in a thread or an IDFC context.

     @pre    Do not call from an ISR.

 	@pre	Do not call from bare Win32 threads.

  */

 EXPORT_C NThread* NKern::LockC()

 	{

 	CHECK_PRECONDITIONS(MASK_NOT_ISR,"NKern::Lock");		

 	__ASSERT_WITH_MESSAGE_ALWAYS(IsScheduledThread(),"Do not call from bare Win32 threads","NKern::Lock");	// check that we are a scheduled thread

 	++TheScheduler.iKernCSLocked;

 	return (NThread*)TheScheduler.iCurrentThread;

 	}

 /**	Allows IDFCs and rescheduling if they are pending.

 	If IDFCs or a reschedule are pending and iKernCSLocked is exactly equal to 1

 	calls the scheduler to process the IDFCs and possibly reschedule.

 	@return	Nonzero if a reschedule actually occurred, zero if not.

     @pre    Call either in a thread or an IDFC context.

     @pre    Do not call from an ISR.

 	@pre	Do not call from bare Win32 threads.

  */

 EXPORT_C TInt NKern::PreemptionPoint()

 	{

 	CHECK_PRECONDITIONS(MASK_NOT_ISR,"NKern::PreemptionPoint");		

 	__ASSERT_WITH_MESSAGE_DEBUG(IsScheduledThread(),"Do not call from bare Win32 threads","NKern::PreemptionPoint");	// check that we are a scheduled thread

 	if (TheScheduler.iKernCSLocked == 1 && 

 		(TheScheduler.iRescheduleNeededFlag || TheScheduler.iDfcPendingFlag))

 		{

 		TScheduler::Reschedule();

 		TheScheduler.iKernCSLocked = 1;

 		NKern::EnableAllInterrupts();

 		return TRUE;

 		}

 	return FALSE;

 	}

 /**	Mark the start of an 'interrupt' in the Win32 emulator.

 	This must be called in interrupt threads before using any other kernel APIs,

 	and should be paired with a call to EndOfInterrupt().

 	@pre	Win32 'interrupt' thread context

  */

 EXPORT_C void StartOfInterrupt()

 	{

 	__ASSERT_WITH_MESSAGE_DEBUG(!IsScheduledThread(),"Win32 'interrupt' thread context","StartOfInterrupt");	// check that we are a scheduled thread

 	Interrupt.Begin();

 	}

 /**	Mark the end of an 'interrupt' in the Win32 emulator.

 	This checks to see if we need to reschedule.

 	@pre	Win32 'interrupt' thread context

  */

 EXPORT_C void EndOfInterrupt()

 	{

 	__ASSERT_WITH_MESSAGE_DEBUG(!IsScheduledThread(),"Win32 'interrupt' thread context","EndOfInterrupt");	// check that we are a scheduled thread

 	Interrupt.End();

 	}

 void Win32Interrupt::Init()

 	{

 	iQ=CreateSemaphoreA(NULL, 0, KMaxTInt, NULL);

 	__NK_ASSERT_ALWAYS(iQ);

 	//

 	// create the NThread which exists solely to service reschedules for interrupts

 	// this makes the End() much simpler as it merely needs to kick this thread

 	SNThreadCreateInfo ni;

 	memclr(&ni, sizeof(ni));

 	ni.iFunction=&Reschedule;

 	ni.iTimeslice=-1;

 	ni.iPriority=1;

 	NKern::ThreadCreate(&iScheduler, ni);

 	NKern::Lock();

 	TScheduler::YieldTo(&iScheduler);

 	Restore(0);

 	}

 TInt Win32Interrupt::Mask()

 	{

 	if (!iQ)

 		return 0;				// interrupt scheme not enabled yet

 	DWORD id=GetCurrentThreadId();

 	if (__e32_atomic_add_ord32(&iLock, 1))

 		{

 		if (id==iOwner)

 			return iLevel++;

 		__NK_ASSERT_ALWAYS(WaitForSingleObject(iQ,INFINITE) == WAIT_OBJECT_0);

 		iRescheduleOnExit=IsScheduledThread() &&

 				(TheScheduler.iRescheduleNeededFlag || TheScheduler.iDfcPendingFlag);

 		}

 	else

 		iRescheduleOnExit=FALSE;

 	__NK_ASSERT_ALWAYS(iOwner==0 && iLevel==0);

 	iOwner=id;

 	iLevel=1;

 	return 0;

 	}

 void Win32Interrupt::Restore(TInt aLevel)

 	{

 	if (!iQ)

 		return;				// interrupt scheme not enabled yet

 	DWORD id=GetCurrentThreadId();

 	for (;;)

 		{

 		__NK_ASSERT_ALWAYS(id == iOwner);

 		TInt count = iLevel - aLevel;

 		if (count <= 0)

 			return;						// alredy restored to that level

 		TBool reschedule = FALSE;

 		iLevel = aLevel;		// update this value before releasing the lock

 		if (aLevel == 0)

 			{

 			// we release the lock

 			iOwner = 0;

 			if (iRescheduleOnExit && TheScheduler.iKernCSLocked == 0)

 				reschedule = TRUE;		// need to trigger reschedule on full release

 			}

 		// now release the lock

 		if (__e32_atomic_add_ord32(&iLock, TUint32(-count)) == (TUint32)count)

 			{	// fully released, check for reschedule

 			if (!reschedule)

 				return;

 			}

 		else

 			{	// not fully released

 			if (aLevel == 0)

 				__NK_ASSERT_ALWAYS(ReleaseSemaphore(iQ,1,NULL));

 			return;

 			}

 		// unlocked everything but a reschedule may be required

 		TheScheduler.iKernCSLocked = 1;

 		TScheduler::Reschedule();

 		// return with the kernel unlocked, but interrupts disabled

 		// instead of going recursive with a call to EnableAllInterrupts() we iterate

 		aLevel=0;

 		}

 	}

 void Win32Interrupt::Begin()

 	{

 	Mask();

 	__NK_ASSERT_ALWAYS(iInterrupted==0);	// check we haven't done this already

 	__NK_ASSERT_ALWAYS(!IsScheduledThread());	// check that we aren't a scheduled thread

 	NThread* pC;

 	for (;;)

 		{

 		pC=static_cast<NThread*>(TheScheduler.iCurrentThread);

 		DWORD r=SuspendThread(pC->iWinThread);

 		if (pC == TheScheduler.iCurrentThread)

 			{

 			// there was no race while suspending the thread, so we can carry on

 			__NK_ASSERT_ALWAYS(r != 0xffffffff);

 			break;

 			}

 		// We suspended the thread while doing a context switch, resume it and try again

 		if (r != 0xffffffff)

 			__NK_ASSERT_ALWAYS(TInt(ResumeThread(pC->iWinThread)) > 0);	// check thread was previously suspended

 		}

 #ifdef BTRACE_CPU_USAGE

 	BTrace0(BTrace::ECpuUsage,BTrace::EIrqStart);

 #endif

 	iInterrupted = pC;

 	}

 void Win32Interrupt::End()

 	{

 	__NK_ASSERT_ALWAYS(iOwner == GetCurrentThreadId());	// check we are the interrupting thread

 	NThread* pC = iInterrupted;

 	__NK_ASSERT_ALWAYS(pC==TheScheduler.iCurrentThread);

 	iInterrupted = 0;

 	if (iLock == 1 && TheScheduler.iKernCSLocked == 0 &&

 		(TheScheduler.iRescheduleNeededFlag || TheScheduler.iDfcPendingFlag) &&

 		pC->IsSafeToPreempt())

 		{

 		TheScheduler.iKernCSLocked = 1;		// prevent further pre-emption

 		if (pC->iWakeup == NThread::EIdle)

 			{

 			// wake up the NULL thread, it will always reschedule immediately

 			pC->WakeUp();

 			}

 		else

 			{

 			// pre-empt the current thread and poke the 'scheduler' thread

 			__NK_ASSERT_ALWAYS(pC->iWakeup == NThread::ERelease);

 			pC->iWakeup = NThread::EResume;

 			UpdateThreadCpuTime(*pC, iScheduler);

 			RescheduleNeeded();

 			NKern::EnableAllInterrupts();

 			iScheduler.WakeUp();

 			return;

 			}

 		}

 	else

 		{

 		// no thread reschedle, so emit trace...

 #ifdef BTRACE_CPU_USAGE

 		BTrace0(BTrace::ECpuUsage,BTrace::EIrqEnd);

 #endif

 		}

 	if (((NThread*)pC)->iInKernel == 0 &&		// thread is running in user mode

 		pC->iUserModeCallbacks != NULL && 		// and has callbacks queued

 		TheScheduler.iKernCSLocked == 0 &&		// and is not currently processing a diversion

 		pC->IsSafeToPreempt())					// and can be safely prempted at this point

 		{

 		TheScheduler.iKernCSLocked = 1;

 		pC->ApplyDiversion();

 		}

 	NKern::EnableAllInterrupts();

 	__NK_ASSERT_ALWAYS(TInt(ResumeThread(pC->iWinThread)) > 0);	// check thread was previously suspended

 	}

 void Win32Interrupt::Reschedule(TAny*)

 //

 // The entry-point for the interrupt-rescheduler thread.

 //

 // This spends its whole life going around the TScheduler::Reschedule() loop

 // selecting another thread to run.

 //

 	{

 	TheScheduler.iKernCSLocked = 1;

 	RescheduleNeeded();

 	TScheduler::Reschedule();

 	FAULT();

 	}

 void Win32Interrupt::ForceReschedule()

 	{

 	RescheduleNeeded();

 	iScheduler.WakeUp();

 	}

 void SchedulerEscape()

 	{

 	NThread& me=CheckedCurrentThread();

 	EnterKernel();

 	__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked==0);	// Can't call Escape() with the Emulator/kernel already locked

 	NKern::ThreadEnterCS();

 	NKern::Lock();

 	me.iNState=NThreadBase::EBlocked;

 	TheScheduler.Remove(&me);

 	me.iWakeup=NThread::EEscaped;

 	SetThreadPriority(me.iWinThread,THREAD_PRIORITY_ABOVE_NORMAL);

 	Interrupt.ForceReschedule();	// schedules some other thread so we can carry on outside the scheduler domain

 	// this will change the value of iCurrentThread to ensure the 'escaped' invariants are set

 	}

 void ReenterDfc(TAny* aPtr)

 	{

 	NThread& me = *static_cast<NThread*>(aPtr);

 	me.iWakeup = NThread::ERelease;

 	me.CheckSuspendThenReady();

 	}

 void SchedulerReenter()

 	{

 	NThread* me=SchedulerThread();

 	__NK_ASSERT_ALWAYS(me);

 	__NK_ASSERT_ALWAYS(me->iWakeup == NThread::EEscaped);

 	TDfc idfc(&ReenterDfc, me);

 	StartOfInterrupt();

 	idfc.Add();

 	EndOfInterrupt();

 	SetThreadPriority(me->iWinThread,THREAD_PRIORITY_NORMAL);

 	__NK_ASSERT_ALWAYS(WaitForSingleObject(me->iScheduleLock, INFINITE) == WAIT_OBJECT_0);

 	// when released, the kernel is locked and handed over to us

 	// need to complete the reschedule protocol in this thread now

 	TScheduler::Reschedule();

 	NKern::EnableAllInterrupts();

 	NKern::ThreadLeaveCS();

 	LeaveKernel();

 	}

 /**	Return the current processor context type

 	(thread, IDFC, interrupt or escaped thread)

 	@return	A value from NKern::TContext enumeration (including EEscaped)

 	@pre	Any context

 	@see	NKern::TContext

  */

 EXPORT_C TInt NKern::CurrentContext()

 	{

 	NThread* t = SchedulerThread();

 	if (!t)

 		return NKern::EInterrupt;

 	if (TheScheduler.iInIDFC)

 		return NKern::EIDFC;

 	if (t->iWakeup == NThread::EEscaped)

 		return NKern::EEscaped;

 	__NK_ASSERT_ALWAYS(NKern::Crashed() || t == TheScheduler.iCurrentThread);

 	return NKern::EThread;

 	}

 //

 // We use SuspendThread and ResumeThread to preempt threads.  This can cause

 // deadlock if the thread is using windows synchronisation primitives (eg

 // critical sections).  This isn't too much of a problem most of the time,

 // because threads generally use the symbian environment rather than the native

 // windows APIs.  However exceptions are an issue - they can happen at any time,

 // and cause execution of native windows code over which we have no control.

 //

 // To work around this we examine the call stack to see if the thread is inside

 // one of the windows exception handling functions.  If so, preemption is

 // deferred.

 //

 #include <winnt.h>

 const TInt KWin32NonPreemptibleFunctionCount = 2;

 struct TWin32FunctionInfo

 	{

 	TUint iStartAddr;

 	TUint iLength;

 	};

 static TWin32FunctionInfo Win32NonPreemptibleFunctions[KWin32NonPreemptibleFunctionCount];

 TWin32FunctionInfo Win32FindExportedFunction(const char* aModuleName, const char* aFunctionName)

 	{

 	HMODULE library = GetModuleHandleA(aModuleName);

 	__NK_ASSERT_ALWAYS(library != NULL);

 	// Find the start address of the function

 	TUint start = (TUint)GetProcAddress(library, aFunctionName);

 	__NK_ASSERT_ALWAYS(start);

 	// Now have to check all other exports to find the end of the function

 	TUint end = 0xffffffff;

 	TInt i = 1;

 	for (;;)

 		{

 		TUint addr = (TUint)GetProcAddress(library, MAKEINTRESOURCEA(i));

 		if (!addr)

 			break;

 		if (addr > start && addr < end)

 			end = addr;

 		++i;

 		}

 	__NK_ASSERT_ALWAYS(end != 0xffffffff);

 	TWin32FunctionInfo result = { start, end - start };

 	return result;

 	}

 void Win32FindNonPreemptibleFunctions()

 	{

 	Win32NonPreemptibleFunctions[0] = Win32FindExportedFunction("kernel32.dll", "RaiseException");

 	Win32NonPreemptibleFunctions[1] = Win32FindExportedFunction("ntdll.dll", "KiUserExceptionDispatcher");

 	}

 TBool Win32IsThreadInNonPreemptibleFunction(HANDLE aWinThread, TLinAddr aStackTop)

 	{

 	const TInt KMaxSearchDepth = 16;		 // 12 max observed while handling exceptions

 	const TInt KMaxStackSize = 1024 * 1024;  // Default reserved stack size on windows

 	const TInt KMaxFrameSize = 4096;

 	CONTEXT c;

  	c.ContextFlags=CONTEXT_FULL;

 	GetThreadContext(aWinThread, &c);

 	TUint eip = c.Eip;

 	TUint ebp = c.Ebp;

 	TUint lastEbp = c.Esp;

 	// Walk the call stack

 	for (TInt i = 0 ; i < KMaxSearchDepth ; ++i)

 		{

 		for (TInt j = 0 ; j < KWin32NonPreemptibleFunctionCount ; ++j)

 			{

 			const TWin32FunctionInfo& info = Win32NonPreemptibleFunctions[j];

 			if (TUint(eip - info.iStartAddr) < info.iLength)

 				{

 				__KTRACE_OPT(KSCHED, DEBUGPRINT("Thread is in non-preemptible function %d at frame %d: eip == %08x", j, i, eip));

 				return TRUE;

 				}

 			}

 		// Check frame pointer is valid before dereferencing it

 		if (TUint(aStackTop - ebp) > KMaxStackSize || TUint(ebp - lastEbp) > KMaxFrameSize || ebp & 3)

 			break;

 		TUint* frame = (TUint*)ebp;

 		lastEbp = ebp;

 		ebp = frame[0];

 		eip = frame[1];

 		}

 	return FALSE;

 	}

 TBool NThread::IsSafeToPreempt()

 	{

 	return !Win32IsThreadInNonPreemptibleFunction(iWinThread, iUserStackBase);

 	}

 void LeaveKernel()

 	{

 	TInt& k=CheckedCurrentThread().iInKernel;

 	__NK_ASSERT_DEBUG(k>0);

 	if (k==1)  // just about to leave kernel

 		{

 		NThread& t = CheckedCurrentThread();

 		__NK_ASSERT_ALWAYS(t.iCsCount==0);

 		__NK_ASSERT_ALWAYS(t.iHeldFastMutex==0);

 		__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked==0);

 		NKern::DisableAllInterrupts();

 		t.CallUserModeCallbacks();

 		NKern::EnableAllInterrupts();

 		}

 	--k;

 	}