FCL/sf/os/kernelhwsrv: comparison kernel/eka/nkern/win32/ncsched.cpp

equal deleted inserted replaced

-:dc268b18d709
+:6a75fa55495f
 //
 // 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"
+#include <emulator.h>
-#ifdef __EMI_SUPPORT__
+#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.
+// This should be essentially the same as the EPOC32 version!
 //
 	{
 	NThreadBase* t = static_cast<NThreadBase*>(aS.First());
+#ifdef	_DEBUG
 	__NK_ASSERT_DEBUG(t);
-#ifdef _DEBUG
 	if (t->iHeldFastMutex)
 		{
-		__KTRACE_OPT(KSCHED2,DEBUGPRINT("Resched init->%T, Holding %M",t,t->iHeldFastMutex));
+		__KTRACE_OPT(KSCHED2, DEBUGPRINT("Resched init->%T, Holding %M", t, t->iHeldFastMutex));
 		}
 	else
 		{
-		__KTRACE_OPT(KSCHED2,DEBUGPRINT("Resched init->%T",t));
+		__KTRACE_OPT(KSCHED2, DEBUGPRINT("Resched init->%T", t));
 		}
-#endif
+#endif	// _DEBUG
 	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
 			{
 			// 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));
+		__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));
+		__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));
+			__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()
+// From here on it's all emulator (i.e. Win32) specific; there isn't any EPOC32 equivalent for most of it.
 //
-// Wake up the thread. What to do depends on whether we were preempted or voluntarily
+// The emulator uses one Win32 thread for each Symbian thread; these are the ones scheduled by the Symbian
-// rescheduled.
+// nanokernel in the algorithm above. Only one such thread will be running at a time; the others will be
-//
+// waiting on their individual scheduler locks, thus simulating a single-threaded architecture.
-// 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.
+// In addition, there are some more Win32 threads used to handle timers, interrupts and the like. These
-//
+// are not under control of the Symbian scheduler. They are given higher priority than the Symbian threads,
-// NB. kernel is locked
+// so they can run preemptively under control of the Win32 scheduler. However, they must call functions
-//
+// from the Win32Interrupt class before using any Symbian OS calls, so that the current Symbian thread can
-	{
+// be suspended during the 'virtual interrupt'.
-	switch (iWakeup)
-		{
+static DWORD TlsIndex = TLS_OUT_OF_INDEXES;
-	default:
-		FAULT();
+void SchedulerInit(NThread& aInit)
-	case EIdle:
+//
-		__NK_ASSERT_ALWAYS(TheScheduler.iCurrentThread == this);
+// Initialise the win32 nKern scheduler
-		__NK_ASSERT_ALWAYS(SetEvent(iScheduleLock));
+//
-		break;
+	{
-	case ERelease:
+	DWORD procaffin, sysaffin;
-		TheScheduler.iCurrentThread = this;
+	if (GetProcessAffinityMask(GetCurrentProcess(), &procaffin, &sysaffin))
-		__NK_ASSERT_ALWAYS(SetEvent(iScheduleLock));
+		{
-		break;
+		DWORD cpu;
-	case EResumeLocked:
+		switch (Win32SingleCpu)
-		// The thread is Win32 suspended and must be resumed.
+			{
-		//
+		default:
-		// A newly created thread does not need the kernel unlocked so we can
+			// bind the emulator to a nominated CPU on the host PC
-		// just resume the suspended thread
+			cpu = (1 << Win32SingleCpu);
-		//
+			if (!(sysaffin & cpu))
-		__KTRACE_OPT(KSCHED,DEBUGPRINT("Win32Resume->%T",this));
+				cpu = procaffin;	// CPU selection invalid
-		iWakeup = ERelease;
+			break;
-		TheScheduler.iCurrentThread = this;
-		if (TheScheduler.iProcessHandler)
+		case NThread::ECpuSingle:
-			(*ProcessHandler(TheScheduler.iProcessHandler))(iAddressSpace); // new thread will need to have its static data updated
+			// bind the emulator to a single CPU on the host PC, pick one
-		__NK_ASSERT_ALWAYS(TInt(ResumeThread(iWinThread)) > 0);	// check thread was previously suspended
+			cpu = procaffin ^ (procaffin & (procaffin - 1));
-		break;
+			break;
-	case EResumeDiverted:
-		// The thread is Win32 suspended and must be resumed.
+		case NThread::ECpuAll:
-		//
+			// run the emulator on all CPUs on the host PC
-		// The thread needs to be diverted, and does not need the kernel
+			cpu = sysaffin;
-		// unlocked.
+			break;
-		//
+			}
-		// It's safe the divert the thread here because we called
-		// IsSafeToPreempt() when we suspended it - otherwise the diversion
+		SetProcessAffinityMask(GetCurrentProcess(), cpu);
-		// could get lost.
+		}
-		//
-		__KTRACE_OPT(KSCHED,DEBUGPRINT("Win32Resume->%T (Resuming diverted thread)",this));
+	// identify whether we can use the atomic SignalObjectAndWait API in Win32 for rescheduling
-		iWakeup = ERelease;
+	Win32AtomicSOAW = (SignalObjectAndWait(aInit.iScheduleLock, aInit.iScheduleLock, INFINITE, FALSE) == WAIT_OBJECT_0);
-		ApplyDiversion();
-		TheScheduler.iCurrentThread = this;
+	// allocate the TLS used for thread identification, and set it for the init thread
-		__NK_ASSERT_ALWAYS(TInt(ResumeThread(iWinThread)) == 1);
+	TlsIndex = TlsAlloc();
-		break;
+	__NK_ASSERT_ALWAYS(TlsIndex != TLS_OUT_OF_INDEXES);
-	case EResume:
+	SchedulerRegister(aInit);
-		// The thread is Win32 suspended and must be resumed.
-		//
+	Win32FindNonPreemptibleFunctions();
-		// the complication here is that we have to unlock the kernel on behalf of the
+	Interrupt.Init();
-		// 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.
+void SchedulerRegister(NThread& aSelf)
-		//
+	{
-		// If so, we go back around the loop in this thread context
+	TlsSetValue(TlsIndex, &aSelf);
-		//
+	}
-		// 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
+inline NThread* RunningThread()
-		// is resumed, it is the new thread that is pre-empted, not the running thread, so we are guaranteed
+// Returns the NThread actually running
-		// 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
+	if (TlsIndex == TLS_OUT_OF_INDEXES)
-		// have been re-suspended by Win32: so all is well.
+		return NULL;				// not yet initialised
-		//
+	else
-		{
+		return static_cast<NThread*>(TlsGetValue(TlsIndex));
-		__KTRACE_OPT(KSCHED,DEBUGPRINT("Win32Resume->%T",this));
+	}
-		TInt irq = NKern::DisableAllInterrupts();
-		if (TheScheduler.iDfcPendingFlag || TheScheduler.iRescheduleNeededFlag)
+inline TBool IsScheduledThread()
-			{
+// True if the NThread actually running is the scheduled one (not an interrupt thread or similar)
-			// we were interrrupted... back to the top
+	{
-			TheScheduler.iRescheduleNeededFlag = TRUE;	// ensure we do the reschedule
+	return RunningThread() == TheScheduler.iCurrentThread;
-			return TRUE;
+	}
-			}
-		iWakeup = ERelease;
+inline NThread& CheckedCurrentThread()
-		TheScheduler.iCurrentThread = this;
+// Returns the NThread actually running, checking that it's the scheduled one (not an interrupt thread or similar)
-		if (TheScheduler.iProcessHandler)
+	{
-			(*ProcessHandler(TheScheduler.iProcessHandler))(iAddressSpace); // threads resumed after interrupt or locks need to have static data updated
+	NThread* t = RunningThread();
+	__NK_ASSERT_ALWAYS(t == TheScheduler.iCurrentThread);
-		if (iInKernel == 0 && iUserModeCallbacks != NULL)
+	return *t;
-			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
+// Return without terminating if we need to immediately reschedule again
-// we had to unlock the kernel but there are DFCs pending.
+// 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;
 	CloseHandle(sl);
 	CloseHandle(th);
 	ExitThread(0);		// does not return
 	}
-#ifdef MONITOR_THREAD_CPU_TIME
+#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
+#endif	// MONITOR_THREAD_CPU_TIME
 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
 //
 	{
+	__NK_ASSERT_ALWAYS(InterruptsStatus(ETrue));
 	UpdateThreadCpuTime(aCurrent, aNext);
 	if (aCurrent.iNState == NThread::EDead)
+		{
 		ThreadExit(aCurrent, aNext);
-	else if (Win32AtomicSOAW && aNext.iWakeup==NThread::ERelease)
+		// Yes, this is reachable!
-		{
+		}
-		// special case optimization for normally blocked threads using atomic Win32 primitive
+	else if (Win32AtomicSOAW && aNext.iWakeup == NThread::ERelease)
+		{
+		// special case optimization for normally scheduled threads using atomic Win32 primitive
 		TheScheduler.iCurrentThread = &aNext;
-		DWORD result=SignalObjectAndWait(aNext.iScheduleLock,aCurrent.iScheduleLock, INFINITE, FALSE);
+		CheckedSignalObjectAndWait(aNext.iScheduleLock, aCurrent.iScheduleLock);
-		if (result != WAIT_OBJECT_0)
+		}
-			{
+	else if (aNext.WakeUp())
-			__NK_ASSERT_ALWAYS(result == 0xFFFFFFFF);
+		{
-			KPrintf("SignalObjectAndWait() failed with %d (%T->%T)",GetLastError(),&aCurrent,&aNext);
+		// We didn't wake the target thread; instead we need to re-reschedule in this thread
-			FAULT();
+		__NK_ASSERT_ALWAYS(InterruptsStatus(EFalse));
-			}
+		return;
 		}
 	else
 		{
-		if (aNext.WakeUp())
+		// Target thread woken, now wait to be rescheduled
-			return;			// need to re-reschedule in this thread
+		CheckedWaitForSingleObject(aCurrent.iScheduleLock);
-		__NK_ASSERT_ALWAYS(WaitForSingleObject(aCurrent.iScheduleLock, INFINITE) == WAIT_OBJECT_0);
+		}
-		}
-	}
+	__NK_ASSERT_ALWAYS(InterruptsStatus(ETrue));
-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();
+		// Exit from this loop when further rescheduling is no longer needed
 		if (!TheScheduler.iRescheduleNeededFlag)
 			break;
+		// Choose the next thread to run, using the Symbian scheduler
+		TheScheduler.iRescheduleNeededFlag = FALSE;
 		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]));
+		__KTRACE_OPT(KSCHED, DEBUGPRINT("Reschedule->%T (%08x%08x)", t, TheScheduler.iPresent[1], TheScheduler.iPresent[0]));
-#ifdef __EMI_SUPPORT__
-		EMI_AddTaskSwitchEvent(&me,t);
+#ifdef	__EMI_SUPPORT__
+		EMI_AddTaskSwitchEvent(&me, t);
 		EMI_CheckDfcTag(t);
 #endif
-#ifdef BTRACE_CPU_USAGE
+#ifdef	BTRACE_CPU_USAGE
-		if(TheScheduler.iCpuUsageFilter)
+		if (TheScheduler.iCpuUsageFilter)
-			TheScheduler.iBTraceHandler(BTRACE_HEADER_C(4,BTrace::ECpuUsage,BTrace::ENewThreadContext),0,(TUint32)t,0,0,0,0,0);
+			TheScheduler.iBTraceHandler(BTRACE_HEADER_C(4, BTrace::ECpuUsage, BTrace::ENewThreadContext), 0, (TUint32)t, 0, 0, 0, 0, 0);
 #endif
+		// SwitchThreads() can return immediately, if it turns out that another reschedule is
+		// necessary; otherwise, this thread will be descheduled in favour of the one selected
+		// above, and SwitchThreads() will only return when this thread is next selected
 		SwitchThreads(me, *t);
-		// we have just been scheduled to run... check for diversion/new Dfcs
+		// When we start again, we should check for being forced to exit; otherwise go round the
-		NThread::TDivert divert = me.iDivert;
+		// loop again to see whether another reschedule is called for (e.g. if there are new DFCs).
-		if (divert)
+		NThread::TDivert divertToExit = me.iDivertFn;
-			{
+		me.iDivertFn = NULL;
-			// diversion (e.g. force exit)
+		if (divertToExit)
-			me.iDivert = NULL;
+			divertToExit();
-			divert();						// does not return
+		}
-			}
-		}
+	// interrupts are disabled, the kernel is still locked
 	if (TheScheduler.iProcessHandler)
-		(*ProcessHandler(TheScheduler.iProcessHandler))(me.iAddressSpace);
+		(*ProcessHandler(TheScheduler.iProcessHandler))(me.iAddressSpace);		// thread will need to have its static data updated
-	// interrrupts are disabled, the kernel is still locked
+	__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked == 1);
 	TheScheduler.iKernCSLocked = 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();
+	}
+TBool NThread::WakeUp()
+//
+// Wake up the thread. What to do depends on whether it was preempted or voluntarily
+// rescheduled.
+//
+// On entry, the kernel is locked, and interrupts may be enabled or disabled.
+//
+// The return value is TRUE if the caller should immediately reschedule again because we
+// needed to unlock the kernel in order to resume the thread but there were DFCs pending.
+// In this case, the thread is not woken, the kernel remains locked, and the return is
+// made with interrupts disabled (whether or not they were on entry).
+//
+// Otherise, the target thread is woken up (in any of several different ways), and the
+// the return value is FALSE. In that case the interrupt status is unchanged; and the
+// kernel may or not still be locked.
+//
+	{
+	__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked > 0);
+	__NK_ASSERT_ALWAYS(RunningThread() != this);		// Can't wake self!
+	switch (iWakeup)
+		{
+	default:
+		FAULT();
+	case EIdle:
+		// The thread is waiting on its scheduler lock, in Idle()
+		__NK_ASSERT_ALWAYS(TheScheduler.iCurrentThread == this);
+		CheckedSetEvent(iScheduleLock);
+		break;
+	case ERelease:
+		// The thread is waiting on its scheduler lock
+		TheScheduler.iCurrentThread = this;
+		CheckedSetEvent(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 it; OTOH it will need to have its static data updated ...
+		//
+		__KTRACE_OPT(KSCHED, DEBUGPRINT("Win32ResumeLocked->%T", this));
+		iWakeup = ERelease;
+		TheScheduler.iCurrentThread = this;
+		if (TheScheduler.iProcessHandler)
+			(*ProcessHandler(TheScheduler.iProcessHandler))(iAddressSpace);
+		CheckedResumeThread(iWinThread);
+		break;
+	case EResumeDiverted:
+		// The thread is Win32 suspended and must be resumed.
+		//
+		// It does not need the kernel unlocked, but does have a diversion pending. We
+		// know it's safe to 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;
+		TheScheduler.iCurrentThread = this;
+		ApplyDiversion();
+		CheckedResumeThread(iWinThread, ETrue);
+		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. Before doing so, we have to check whether there are DFCs
+		// or a reschedule pending; if so, we don't unlock the kernel or wake the target
+		// thread, but instead return TRUE, so that our caller (usually SwitchThreads()
+		// above) knows to return and go round the TScheduler::Reschedule() loop again.
+		//
+		TInt irq = NKern::DisableAllInterrupts();
+		if (TheScheduler.iRescheduleNeededFlag || TheScheduler.iDfcPendingFlag)
+			{
+			__KTRACE_OPT(KSCHED, DEBUGPRINT("Win32Resume->%T preempted", this));
+			TheScheduler.iRescheduleNeededFlag = TRUE;	// ensure we do the reschedule
+			return TRUE;
+			}
+		// Otherwise we mark the thread as not-preempted, unlock the kernel, restore
+		// interrupts, and resume the thread.
+		__KTRACE_OPT(KSCHED, DEBUGPRINT("Win32Resume->%T", this));
+		iWakeup = ERelease;
+		TheScheduler.iCurrentThread = this;
+		if (TheScheduler.iProcessHandler)
+			(*ProcessHandler(TheScheduler.iProcessHandler))(iAddressSpace); // threads resumed after interrupt or locks need to have static data updated
+		TheScheduler.iKernCSLocked = 0;
+		// If there are callbacks waiting, and the thread is in user mode, divert it to
+		// pick up its callbacks (we know this is safe because we called IsSafeToPreempt()
+		// when we suspended it - otherwise the diversion could get lost.
+		if (iUserModeCallbacks != NULL && !iInKernel)
+			{
+			TheScheduler.iKernCSLocked = 1;					// prevent further pre-emption
+			ApplyDiversion();
+			}
+		// 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.
+		//
+		NKern::RestoreInterrupts(irq);
+		CheckedResumeThread(iWinThread);
+		break;
+		}
+	return FALSE;
+	}
 /**	Put the emulator into 'idle'.
 	This is called by the idle thread when there is nothing else to do.
 	@internalTechnology
 // 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);
+	CheckedWaitForSingleObject(me.iScheduleLock);
 	// 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)
-//
+void EnterKernel(TBool aDiversion)
-// Initialise the win32 nKern scheduler
+	{
-//
+	NThread& t = CheckedCurrentThread();
-	{
+	volatile TInt& inKernel = t.iInKernel;
-	DWORD procaffin,sysaffin;
+	__NK_ASSERT_DEBUG(inKernel >= 0);
-	if (GetProcessAffinityMask(GetCurrentProcess(),&procaffin,&sysaffin))
-		{
+	// This code has to be re-entrant, because a thread that's in the process
-		DWORD cpu;
+	// of entering the kernel may be preempted; then if it isn't yet marked
-		switch (Win32SingleCpu)
+	// as 'in the kernel' it can be diverted through EnterKernel()/LeaveKernel()
-			{
+	// in order to execute user-mode callbacks.  However this is all in the
-		default:
+	// same thread context, so it doesn't need any special synchronisation.
-			// bind the emulator to a nominated CPU on the host PC
+	// The moment of 'entering' the kernel is deemed to occur when the new value
-			cpu = (1<<Win32SingleCpu);
+	// of iInKernel is written back to the NThread object.
-			if (!(sysaffin & cpu))
+	if (inKernel++ == 0)
-				cpu = procaffin;	// CPU selection invalid
+		{
-			break;
+		// preamble when coming from userspace
-		case NThread::ECpuSingle:
+		__NK_ASSERT_ALWAYS(InterruptsStatus(ETrue));
-			// bind the emulator to a single CPU on the host PC, pick one
+		__NK_ASSERT_ALWAYS(t.iHeldFastMutex == 0);
-			cpu = procaffin ^ (procaffin & (procaffin-1));
+		if (aDiversion)
-			break;
+			{
-		case NThread::ECpuAll:
+			// Forced entry, to make thread exit or run user-mode callbacks
-			// run the emulator on all CPUs on the host PC
+			// If exiting, iCsCount will have been set to 1 to prevent preemption
-			cpu=sysaffin;
+			// Otherwise it must be 0, as in the non-diversion case
-			break;
+			__NK_ASSERT_ALWAYS(t.iCsCount <= 1);
-			}
+			__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked == 1);
-		SetProcessAffinityMask(GetCurrentProcess(), cpu);
+			}
-		}
+		else
-	// identify if we can use the atomic SignalObjectAndWait API in Win32 for rescheduling
+			{
-	Win32AtomicSOAW = (SignalObjectAndWait(aInit.iScheduleLock, aInit.iScheduleLock, INFINITE, FALSE) == WAIT_OBJECT_0);
+			__NK_ASSERT_ALWAYS(t.iCsCount == 0);
-	//
+			__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked == 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);
-	//
+void LeaveKernel()
-	Interrupt.Init();
+	{
+	NThread& t = CheckedCurrentThread();
-	Win32FindNonPreemptibleFunctions();
+	volatile TInt& inKernel = t.iInKernel;
-	}
+	__NK_ASSERT_DEBUG(inKernel > 0);
-void SchedulerRegister(NThread& aSelf)
+	// This code has to be re-entrant, because a thread that's in the process
-	{
+	// of leaving the kernel may be preempted; then if it isn't still marked
-	TlsSetValue(TlsIndex,&aSelf);
+	// as 'in the kernel' it can be diverted through EnterKernel()/LeaveKernel()
-	}
+	// in order to execute user-mode callbacks.  However this is all in the
+	// same thread context, so it doesn't need any special synchronisation.
-NThread* SchedulerThread()
+	// The moment of 'leaving' the kernel is deemed to occur when the new value
-	{
+	// of iInKernel is written back to the NThread object.
-	if (TlsIndex != TLS_OUT_OF_INDEXES)
+	if (inKernel == 1)
-		return static_cast<NThread*>(TlsGetValue(TlsIndex));
+		{
-	else
+		// postamble when about to return to userspace
-		return NULL;  // not yet initialised
+		__NK_ASSERT_ALWAYS(t.iCsCount == 0);
-	}
+		__NK_ASSERT_ALWAYS(t.iHeldFastMutex == 0);
+		__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked == 0);
-inline TBool IsScheduledThread()
+		NKern::DisableAllInterrupts();
-	{
+		t.CallUserModeCallbacks();
-	return SchedulerThread() == TheScheduler.iCurrentThread;
+		NKern::EnableAllInterrupts();
-	}
+		}
-NThread& CheckedCurrentThread()
+	inKernel -= 1;
-	{
+	}
-	NThread* t = SchedulerThread();
-	__NK_ASSERT_ALWAYS(t == TheScheduler.iCurrentThread);
+/**	Locks the kernel and returns a pointer to the current thread
-	return *t;
+	Increments iKernCSLocked, thereby deferring IDFCs and preemption.
-	}
+@pre    Call either in a thread or an IDFC context.
+@pre    Do not call from an ISR.
-/**	Disable normal 'interrupts'.
+	@pre	Do not call from bare Win32 threads.
-	@param	aLevel Ignored
-	@return	Cookie to be passed into RestoreInterrupts()
 */
-EXPORT_C TInt NKern::DisableInterrupts(TInt /*aLevel*/)
+EXPORT_C NThread* NKern::LockC()
 	{
-	return Interrupt.Mask();
+	CHECK_PRECONDITIONS(MASK_NOT_ISR, "NKern::LockC");
-	}
+	__ASSERT_WITH_MESSAGE_ALWAYS(IsScheduledThread(), "Do not call from bare Win32 threads", "NKern::LockC");	// check that we are a scheduled thread
+	++TheScheduler.iKernCSLocked;
+	return (NThread*)TheScheduler.iCurrentThread;
-/**	Disable all maskable 'interrupts'.
+	}
-	@return	Cookie to be passed into RestoreInterrupts()
+/**	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 TInt NKern::DisableAllInterrupts()
+EXPORT_C void NKern::Lock()
 	{
-	return Interrupt.Mask();
+	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;
+	}
-/**	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
+	Decrements iKernCSLocked; if it would become 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
+	// check that the caller is the scheduled thread
-// if we are preempted after testing the flags (lock is zero at this point).
+	__ASSERT_WITH_MESSAGE_DEBUG(IsScheduledThread(), "Do not call from bare Win32 threads", "NKern::Unlock");
-// However, in the common case this is much faster because 'disabling interrupts'
+	CHECK_PRECONDITIONS(MASK_NOT_ISR, "NKern::Unlock");
-// 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)
-		{
+	// Rather than decrementing the lock before testing the flags, and then
-		if (TheScheduler.iRescheduleNeededFlag || TheScheduler.iDfcPendingFlag)
+	// re-incrementing it in order to call Reschedule() -- which would
-			{
+	// leave a window for preemption -- we can test the flags first, and then
-			TheScheduler.iKernCSLocked = 1;
+	// see whether the lock count is 1 ...
-			TScheduler::Reschedule();
+	if ((TheScheduler.iRescheduleNeededFlag || TheScheduler.iDfcPendingFlag) &&
-			NKern::EnableAllInterrupts();
+			TheScheduler.iKernCSLocked == 1)
-			}
+		{
-		}
+		// Reschedule() returns with the kernel unlocked, but interrupts disabled
-	}
+		TScheduler::Reschedule();
+		NKern::EnableAllInterrupts();
+		}
-/**	Locks the kernel.
+	else
+		{
-	Increments iKernCSLocked, thereby deferring IDFCs and preemption.
+		// All other cases - just decrement the lock count
+		TheScheduler.iKernCSLocked -= 1;
-@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");
+	// check that the caller is the scheduled thread
-	__ASSERT_WITH_MESSAGE_DEBUG(IsScheduledThread(),"Do not call from bare Win32 threads","NKern::PreemptionPoint");	// check that we are a scheduled thread
+	__ASSERT_WITH_MESSAGE_DEBUG(IsScheduledThread(), "Do not call from bare Win32 threads", "NKern::PreemptionPoint");
-	if (TheScheduler.iKernCSLocked == 1 &&
+	CHECK_PRECONDITIONS(MASK_NOT_ISR, "NKern::PreemptionPoint");
-		(TheScheduler.iRescheduleNeededFlag || TheScheduler.iDfcPendingFlag))
-		{
+	if ((TheScheduler.iRescheduleNeededFlag || TheScheduler.iDfcPendingFlag) &&
+			TheScheduler.iKernCSLocked == 1)
+		{
+		// Reschedule() returns with the kernel unlocked, but interrupts disabled
 		TScheduler::Reschedule();
 		TheScheduler.iKernCSLocked = 1;
 		NKern::EnableAllInterrupts();
 		return TRUE;
 		}
 	return FALSE;
 	}
+/**	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 = RunningThread();
+	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;
+	}
+/**	Disable normal 'interrupts'.
+	@param	aLevel Ignored
+@pre    Call in a Symbian (thread, IDFC, ISR) context.
+	@pre	Do not call from bare Win32 threads.
+	@return	Cookie to be passed into RestoreInterrupts()
+*/
+EXPORT_C TInt NKern::DisableInterrupts(TInt /*aLevel*/)
+	{
+	return Interrupt.MaskInterrupts(EFalse);
+	}
+/** Restore interrupt mask to state preceding a DisableInterrupts() call
+	@param	aLevel Cookie returned by Disable(All)Interrupts()
+@pre    Call in a Symbian (thread, IDFC, ISR) context.
+	@pre	Do not call from bare Win32 threads.
+*/
+EXPORT_C void NKern::RestoreInterrupts(TInt aLevel)
+	{
+	Interrupt.RestoreInterruptMask(aLevel);
+	}
+/**	Disable all maskable 'interrupts'.
+@pre    Call in a Symbian (thread, IDFC, ISR) context.
+	@pre	Do not call from bare Win32 threads.
+	@return	Cookie to be passed into RestoreInterrupts()
+*/
+EXPORT_C TInt NKern::DisableAllInterrupts()
+	{
+	return Interrupt.MaskInterrupts(EFalse);
+	}
+/**	Enable all maskable 'interrupts'
+	@internalComponent
+@pre    Call in a Symbian (thread, IDFC, ISR) context.
+	@pre	Do not call from bare Win32 threads.
+*/
+EXPORT_C void NKern::EnableAllInterrupts()
+	{
+	Interrupt.RestoreInterruptMask(0);
+	}
 /**	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
+	// check that the caller is not a scheduled thread
-	Interrupt.Begin();
+	__ASSERT_WITH_MESSAGE_DEBUG(!IsScheduledThread(), "Win32 'interrupt' thread context", "StartOfInterrupt");
-	}
+	Interrupt.BeginInterrupt();
+	}
 /**	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
+	// check that the caller is not a scheduled thread
-	Interrupt.End();
+	__ASSERT_WITH_MESSAGE_DEBUG(!IsScheduledThread(), "Win32 'interrupt' thread context", "EndOfInterrupt");
-	}
+	Interrupt.EndInterrupt();
+	}
+// The Win32Interrupt class manages virtual interrupts from Win32 event threads
 void Win32Interrupt::Init()
 	{
-	iQ=CreateSemaphoreA(NULL, 0, KMaxTInt, NULL);
+	InitializeCriticalSection(&iCS);
+	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.iFunction = &SchedulerThreadFunction;
-	ni.iTimeslice=-1;
+	ni.iTimeslice = -1;
-	ni.iPriority=1;
+	ni.iPriority = 1;
 	NKern::ThreadCreate(&iScheduler, ni);
 	NKern::Lock();
 	TScheduler::YieldTo(&iScheduler);
-	Restore(0);
+	RestoreInterruptMask(0);
 	}
-TInt Win32Interrupt::Mask()
+void Win32Interrupt::BeginInterrupt()
+	{
+	__NK_ASSERT_ALWAYS(!IsScheduledThread());				// check that we aren't a scheduled thread
+	MaskInterrupts(ETrue);									// suspend scheduled thread and set mask
+#ifdef	BTRACE_CPU_USAGE
+	BTrace0(BTrace::ECpuUsage, BTrace::EIrqStart);
+#endif
+	}
+void Win32Interrupt::EndInterrupt()
+	{
+	NThread* pC = iInterrupted;
+	iInterrupted = 0;
+	__NK_ASSERT_ALWAYS(pC == TheScheduler.iCurrentThread);	// unchanged since BeginInterrupt()
+	__NK_ASSERT_ALWAYS(!IsScheduledThread());				// check that we aren't a scheduled thread
+	__NK_ASSERT_ALWAYS(iOwner == GetCurrentThreadId());		// check we are the interrupting thread
+	__NK_ASSERT_ALWAYS(InterruptsStatus(EFalse));
+	__NK_ASSERT_ALWAYS(iLevel == 1);						// DSG: is this correct?
+	if (TheScheduler.iKernCSLocked)
+		{
+		// No rescheduling allowed; just resume the interrupted thread
+		NKern::EnableAllInterrupts();
+		CheckedResumeThread(pC->iWinThread);
+		return;
+		}
+	__NK_ASSERT_ALWAYS(iLevel == 1);						// DSG: is this correct?
+	__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked == 0);
+	TBool diversionUnsafe = EFalse;							// Optimistic assumption until checked
+	if (TheScheduler.iRescheduleNeededFlag || TheScheduler.iDfcPendingFlag)
+		{
+		switch (pC->iWakeup)
+			{
+		default:
+			FAULT();
+		case NThread::EIdle:
+			// wake up the Idle thread, it will always reschedule immediately
+			TheScheduler.iKernCSLocked = 1;					// prevent further pre-emption
+			if (pC->WakeUp())
+				FAULT();									// this can't happen
+			NKern::EnableAllInterrupts();
+			CheckedResumeThread(pC->iWinThread);
+			return;
+		case NThread::ERelease:
+			if (pC->IsSafeToPreempt())
+				{
+				// pre-empt the current thread and poke the 'scheduler' thread
+				UpdateThreadCpuTime(*pC, iScheduler);
+				pC->iWakeup = NThread::EResume;				// how to wake this thread later
+				TheScheduler.iKernCSLocked = 1;				// prevent further pre-emption
+				RescheduleNeeded();
+				NKern::EnableAllInterrupts();
+				if (iScheduler.WakeUp())
+					FAULT();								// this can't happen
+				return;
+				}
+			diversionUnsafe = ETrue;						// don't consider diverting
+			break;
+			}
+		}
+#ifdef	BTRACE_CPU_USAGE
+	// no thread reschedle, so emit trace...
+	BTrace0(BTrace::ECpuUsage, BTrace::EIrqEnd);
+#endif
+	// If there are callbacks waiting, and the thread is in user mode, and it's at a
+	// point where it can safely be preempted, then divert it to pick up its callbacks
+	if (pC->iUserModeCallbacks != NULL && !pC->iInKernel && !diversionUnsafe)
+		if (pC->IsSafeToPreempt())
+			{
+			TheScheduler.iKernCSLocked = 1;
+			pC->ApplyDiversion();
+			}
+	NKern::EnableAllInterrupts();
+	CheckedResumeThread(pC->iWinThread);
+	}
+TInt Win32Interrupt::MaskInterrupts(TBool aPreempt)
 	{
 	if (!iQ)
-		return 0;				// interrupt scheme not enabled yet
+		return 0;									// interrupt scheme not enabled yet
-	DWORD id=GetCurrentThreadId();
-	if (__e32_atomic_add_ord32(&iLock, 1))
+	EnterCriticalSection(&iCS); 					// Win32 critical section, not a Symbian one
-		{
-		if (id==iOwner)
+	DWORD id = GetCurrentThreadId();
-			return iLevel++;
+	if (iOwner == id)
-		__NK_ASSERT_ALWAYS(WaitForSingleObject(iQ,INFINITE) == WAIT_OBJECT_0);
+		{
-		iRescheduleOnExit=IsScheduledThread() &&
+		// The easiest case: we already own the mask, so just increment the level.
-				(TheScheduler.iRescheduleNeededFlag || TheScheduler.iDfcPendingFlag);
+		// The requirement for rescheduling on exit is unaffected.
-		}
+		__NK_ASSERT_ALWAYS(!aPreempt);
-	else
+		TInt r = iLevel++;
-		iRescheduleOnExit=FALSE;
+		LeaveCriticalSection(&iCS);
-	__NK_ASSERT_ALWAYS(iOwner==0 && iLevel==0);
+		return r;
-	iOwner=id;
+		}
-	iLevel=1;
-	return 0;
+	if (!iOwner && !aPreempt)
-	}
+		{
+		// Another easy case; we've been called from a Symbian thread, and there's
-void Win32Interrupt::Restore(TInt aLevel)
+		// no contention, so we can just take ownership of the interrupt mask. No
+		// rescheduling is required on exit (but this may change) ...
+		__NK_ASSERT_ALWAYS(iLevel == 0);
+		TInt r = iLevel++;
+		iOwner = id;
+		iRescheduleOnExit = EFalse;
+		LeaveCriticalSection(&iCS);
+		return r;
+		}
+	if (iOwner)
+		{
+		// Someone else owns it; if we've been called from an interrupt thread,
+		// this could be another interrupt thread or a Symbian thread. If we're
+		// being called from a Symbian thread, the owner must be another Symbian
+		// thread, because a Symbian thread can't preempt an interrupt thread.
+		//
+		// In either case, we can increment the count of waiters, then wait for the
+		// curent holder to release it. Note that another (interrupt) thread could
+		// also do this, and then the order in which they get to run is undefined.
+		iWaiting += 1;
+		do
+			{
+			__NK_ASSERT_ALWAYS(iWaiting > 0);
+			LeaveCriticalSection(&iCS);
+			CheckedWaitForSingleObject(iQ);
+			EnterCriticalSection(&iCS);
+			__NK_ASSERT_ALWAYS(iWaiting > 0);
+			}
+		while (iOwner);
+		iWaiting -= 1;
+		iRescheduleOnExit = IsScheduledThread() && (TheScheduler.iRescheduleNeededFlag || TheScheduler.iDfcPendingFlag);
+		}
+	// Nobody now controls the interrupt mask ...
+	__NK_ASSERT_ALWAYS(iOwner == 0 && iLevel == 0);
+	if (aPreempt)
+		{
+		// ... but in this case, we've been called from an interrupt thread and
+		// a Symbian thread may still be running -- yes, even though all emulator
+		// threads are normally bound to a single CPU!
+		//
+		// To ensure that such a thread doesn't see an inconsistent state, we
+		// have to suspend it before we actually take ownership, as it could
+		// examine the interrupt state at any time, without taking any locks.
+		__NK_ASSERT_ALWAYS(iInterrupted == 0);		// we haven't done this already
+		NThread* pC;
+		for (;;)
+			{
+			pC = static_cast<NThread*>(TheScheduler.iCurrentThread);
+			CheckedSuspendThread(pC->iWinThread);
+			if (pC == TheScheduler.iCurrentThread)
+				break;								// no change of thread, so ok to proceed
+			// We suspended the thread while doing a (Symbian) context switch!
+			// The scheduler state might be inconsistent if we left it like that,
+			// so instead we'll resume it, then try again ...
+			CheckedResumeThread(pC->iWinThread);
+			}
+		__NK_ASSERT_ALWAYS(iInterrupted == 0);
+		iInterrupted = pC;
+		}
+	// Now we can assert ownership of the interrupt mask.
+	__NK_ASSERT_ALWAYS(iOwner == 0 && iLevel == 0);
+	TInt r = iLevel++;
+	iOwner = id;
+	LeaveCriticalSection(&iCS);
+	return r;
+	}
+void Win32Interrupt::RestoreInterruptMask(TInt aLevel)
 	{
 	if (!iQ)
-		return;				// interrupt scheme not enabled yet
+		return;										// interrupt scheme not enabled yet
-	DWORD id=GetCurrentThreadId();
+	DWORD id = GetCurrentThreadId();
+	EnterCriticalSection(&iCS); 					// Win32 critical section, not a Symbian one
 	for (;;)
 		{
-		__NK_ASSERT_ALWAYS(id == iOwner);
+		__NK_ASSERT_ALWAYS(id == iOwner);			// only the current owner may do this
 		TInt count = iLevel - aLevel;
 		if (count <= 0)
-			return;						// alredy restored to that level
+			break;									// already restored to that level
-		TBool reschedule = FALSE;
-		iLevel = aLevel;		// update this value before releasing the lock
+		iLevel = aLevel;							// update the recursion level first
-		if (aLevel == 0)
+		if (aLevel > 0)
 			{
-			// we release the lock
+			// The easiest case: we're still holding ownership, so there's nothing to do
-			iOwner = 0;
+			break;
-			if (iRescheduleOnExit && TheScheduler.iKernCSLocked == 0)
+			}
-				reschedule = TRUE;		// need to trigger reschedule on full release
-			}
+		iOwner = 0;									// give up ownership
-		// now release the lock
+		if (iWaiting)
-		if (__e32_atomic_add_ord32(&iLock, TUint32(-count)) == (TUint32)count)
+			{
-			{	// fully released, check for reschedule
+			// Someone else is waiting for control of the interrupt mask.
-			if (!reschedule)
+			// They may preempt us as soon as we exit the critical section
-				return;
+			// (at the end of this function)
-			}
+			CheckedReleaseSemaphore(iQ);
-		else
+			break;
-			{	// not fully released
+			}
-			if (aLevel == 0)
-				__NK_ASSERT_ALWAYS(ReleaseSemaphore(iQ,1,NULL));
+		// Lock fully released, no-one waiting, so see whether we need to reschedule
-			return;
+		if (TheScheduler.iKernCSLocked || !iRescheduleOnExit)
-			}
+			break;
-		// unlocked everything but a reschedule may be required
+		// Interrupt mask fully unlocked, but reschedule required ...
 		TheScheduler.iKernCSLocked = 1;
+		LeaveCriticalSection(&iCS);
 		TScheduler::Reschedule();
-		// return with the kernel unlocked, but interrupts disabled
+		EnterCriticalSection(&iCS);
-		// instead of going recursive with a call to EnableAllInterrupts() we iterate
-		aLevel=0;
+		// Note: TScheduler::Reschedule() above calls MaskInterrupts() -- which changes
-		}
+		// the state of most of our member data. It returns with the kernel unlocked,
-	}
+		// but interrupts still disabled. Hence we will have reacquired ownership of the
+		// interrupt mask, and must release it again.  Instead of going recursive with a
-void Win32Interrupt::Begin()
+		// call to EnableAllInterrupts() we iterate; we'll get out of this loop eventually,
-	{
+		// because iRescheduleOnExit is updated by MaskInterrupts() ...
-	Mask();
+		aLevel = 0;
-	__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;
+	LeaveCriticalSection(&iCS);
-	for (;;)
+	}
-		{
-		pC=static_cast<NThread*>(TheScheduler.iCurrentThread);
+void Win32Interrupt::ForceReschedule()
-		DWORD r=SuspendThread(pC->iWinThread);
+	{
-		if (pC == TheScheduler.iCurrentThread)
+	RescheduleNeeded();
-			{
+	if (iScheduler.WakeUp())
-			// there was no race while suspending the thread, so we can carry on
+		FAULT();											// this can't happen
-			__NK_ASSERT_ALWAYS(r != 0xffffffff);
+	}
-			break;
-			}
+void Win32Interrupt::SchedulerThreadFunction(TAny*)
-		// 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.
 	RescheduleNeeded();
 	TScheduler::Reschedule();
 	FAULT();
 	}
-void Win32Interrupt::ForceReschedule()
-	{
+//
-	RescheduleNeeded();
+// We need a global lock in the emulator to avoid scheduling reentrancy problems with the host
-	iScheduler.WakeUp();
+// in particular, some host API calls acquire host mutexes, preempting such services results
-	}
+// in suspension of those threads which can cause deadlock if another thread requires that host
+// mutex.
+//
+// Because thread dreaction and code loading also require the same underlying mutex (used
+// by NT to protect DLL entrypoint calling), this would be rather complex with a fast mutex.
+// For now, keep it simple and use the preemption lock. Note that this means that the
+// MS timer DFC may be significantly delayed when loading large DLL trees, for example.
+//
+void SchedulerLock()
+//
+// Acquire the global lock. May be called before scheduler running, so handle that case
+//
+	{
+	if (TheScheduler.iCurrentThread)
+		{
+		EnterKernel();
+		NKern::Lock();
+		}
+	}
+void SchedulerUnlock()
+//
+// Release the global lock. May be called before scheduler running, so handle that case
+//
+	{
+	if (TheScheduler.iCurrentThread)
+		{
+		NKern::Unlock();
+		LeaveKernel();
+		}
+	}
+// This function allows a thread to escape from the Symbian scheduling domain to
+// become an ordinary Win32 thread for a while, in cases where it is necessary
+// to use Win32 APIs that are incompatible with the Symbian threading model.
+// AFAICS this is not currently used!
 void SchedulerEscape()
 	{
-	NThread& me=CheckedCurrentThread();
+	NThread& me = CheckedCurrentThread();
 	EnterKernel();
-	__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked==0);	// Can't call Escape() with the Emulator/kernel already locked
+	__NK_ASSERT_ALWAYS(TheScheduler.iKernCSLocked == 0);	// Can't call Escape() with the Emulator/kernel already locked
 	NKern::ThreadEnterCS();
 	NKern::Lock();
-	me.iNState=NThreadBase::EBlocked;
+	me.iNState = NThreadBase::EBlocked;
 	TheScheduler.Remove(&me);
-	me.iWakeup=NThread::EEscaped;
+	me.iWakeup = NThread::EEscaped;
-	SetThreadPriority(me.iWinThread,THREAD_PRIORITY_ABOVE_NORMAL);
+	SetThreadPriority(me.iWinThread, THREAD_PRIORITY_ABOVE_NORMAL);
-	Interrupt.ForceReschedule();	// schedules some other thread so we can carry on outside the scheduler domain
+	Interrupt.ForceReschedule();
-	// this will change the value of iCurrentThread to ensure the 'escaped' invariants are set
+	// This schedules some other thread so we can carry on outside the scheduler domain.
+	// It will change the value of iCurrentThread to ensure the 'escaped' invariants are set
 	}
 void ReenterDfc(TAny* aPtr)
 	{
 	NThread& me = *static_cast<NThread*>(aPtr);
 	me.CheckSuspendThenReady();
 	}
 void SchedulerReenter()
 	{
-	NThread* me=SchedulerThread();
+	NThread* me = RunningThread();
 	__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);
+	SetThreadPriority(me->iWinThread, THREAD_PRIORITY_NORMAL);
-	__NK_ASSERT_ALWAYS(WaitForSingleObject(me->iScheduleLock, INFINITE) == WAIT_OBJECT_0);
+	CheckedWaitForSingleObject(me->iScheduleLock);
 	// 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
 #include <winnt.h>
 // Uncomment the following line to turn on tracing when we examine the call stack
 // #define DUMP_STACK_BACKTRACE
-#ifdef DUMP_STACK_BACKTRACE
+#ifdef	DUMP_STACK_BACKTRACE
 #include <psapi.h>
 typedef BOOL (WINAPI GMIFunc)(HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb);
-typedef BOOL (WINAPI EPMFunc)(HANDLE hProcess, HMODULE *lphModule, DWORD cb, LPDWORD lpcbNeeded);
+typedef BOOL (WINAPI EPMFunc)(HANDLE hProcess, HMODULE* lphModule, DWORD cb, LPDWORD lpcbNeeded);
 typedef DWORD (WINAPI GMBNFunc)(HANDLE hProcess, HMODULE hModule, LPSTR lpBaseName, DWORD nSize);
 void PrintAllModuleInfo()
 	{
 	HMODULE psapiLibrary = LoadLibraryA("psapi.dll");
 	__NK_ASSERT_ALWAYS(psapiLibrary != NULL);
 	EPMFunc* epmFunc = (EPMFunc*)GetProcAddress(psapiLibrary, "EnumProcessModules");
 	__NK_ASSERT_ALWAYS(epmFunc != NULL);
 	GMIFunc* gmiFunc = (GMIFunc*)GetProcAddress(psapiLibrary, "GetModuleInformation");
 	__NK_ASSERT_ALWAYS(gmiFunc != NULL);
 	GMBNFunc* gmbnFunc = (GMBNFunc*)GetProcAddress(psapiLibrary, "GetModuleBaseNameA");
 	__NK_ASSERT_ALWAYS(gmbnFunc != NULL);
 	const TInt maxModules = 256;
 	HMODULE modules[maxModules];
 	DWORD spaceNeeded;
 	BOOL r = epmFunc(GetCurrentProcess(), modules, sizeof(HMODULE) * maxModules, &spaceNeeded);
 	__NK_ASSERT_ALWAYS(r);
 	__NK_ASSERT_ALWAYS(spaceNeeded <= sizeof(HMODULE) * maxModules);
 	for (TUint i = 0 ; i < spaceNeeded / sizeof(HMODULE) ; ++i)
 		{
 		HMODULE library = modules[i];
 		const TUint maxNameLen = 64;
 		char name[maxNameLen];
 		WORD len = gmbnFunc(GetCurrentProcess(), library, name, sizeof(name));
 		__NK_ASSERT_ALWAYS(len > 0 && len < maxNameLen);
 		MODULEINFO info;
 		r = gmiFunc(GetCurrentProcess(), library, &info, sizeof(info));
 		__NK_ASSERT_ALWAYS(r);
 		DEBUGPRINT("Module %s found at %08x to %08x", name, (TUint)info.lpBaseOfDll, (TUint)info.lpBaseOfDll + info.SizeOfImage);
 		}
 	r = FreeLibrary(psapiLibrary);
 	__NK_ASSERT_ALWAYS(r);
 	}
-#endif
+#endif	// DUMP_STACK_BACKTRACE
 const TInt KWin32NonPreemptibleFunctionCount = 2;
 struct TWin32FunctionInfo
 	{
 	return result ? result : GetModuleHandleA(aModuleName2);
 	}
 TWin32FunctionInfo Win32FindExportedFunction(const char* aFunctionName, ...)
 	{
-	const char *libname;
-	HMODULE library = NULL;
 	va_list arg;
 	va_start(arg, aFunctionName);
+	HMODULE library = NULL;
+	const char* libname;
 	// Loop through arguments until we find a library we can get a handle to.  List of library names
 	// is NULL-terminated.
-	while ((libname = va_arg(arg, const char *)) != NULL)
+	while ((libname = va_arg(arg, const char*)) != NULL)
 		{
 		library = GetModuleHandleA(libname);
 		if (library != NULL)
 			break;
 		}
 	va_end(arg);
 	// Make sure we did get a valid library
 	__NK_ASSERT_ALWAYS(library != NULL);
 	// Find the start address of the function
 	TUint start = (TUint)GetProcAddress(library, aFunctionName);
 	__NK_ASSERT_ALWAYS(start != 0);
 	// Now have to check all other exports to find the end of the function
-	TUint end = 0xffffffff;
+	TUint end = ~0u;
-	TInt i = 1;
+	for (TInt i = 1; ; ++i)
-	for (;;)
 		{
 		TUint addr = (TUint)GetProcAddress(library, MAKEINTRESOURCEA(i));
 		if (!addr)
 			break;
 		if (addr > start && addr < end)
 			end = addr;
-		++i;
+		}
-		}
+	__NK_ASSERT_ALWAYS(end != ~0u);
-	__NK_ASSERT_ALWAYS(end != 0xffffffff);
 	TWin32FunctionInfo result = { start, end - start };
-#ifdef DUMP_STACK_BACKTRACE
+#ifdef	DUMP_STACK_BACKTRACE
 	DEBUGPRINT("Function %s found at %08x to %08x", aFunctionName, start, end);
 #endif
 	return result;
 	}
 void Win32FindNonPreemptibleFunctions()
 	{
-#ifdef DUMP_STACK_BACKTRACE
+#ifdef	DUMP_STACK_BACKTRACE
 	PrintAllModuleInfo();
 #endif
 	TUint i = 0;
 	Win32NonPreemptibleFunctions[i++] = Win32FindExportedFunction("RaiseException", "kernelbase.dll", "kernel32.dll", NULL);
 	Win32NonPreemptibleFunctions[i++] = Win32FindExportedFunction("KiUserExceptionDispatcher", "ntdll.dll", NULL);
 	__NK_ASSERT_ALWAYS(i == KWin32NonPreemptibleFunctionCount);
 	}
 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;
+	c.ContextFlags = CONTEXT_CONTROL;
-	GetThreadContext(aWinThread, &c);
+	CheckedGetThreadContext(aWinThread, &c);
 	TUint eip = c.Eip;
 	TUint ebp = c.Ebp;
 	TUint lastEbp = c.Esp;
-	#ifdef DUMP_STACK_BACKTRACE
+#ifdef	DUMP_STACK_BACKTRACE
 	DEBUGPRINT("Stack backtrace for thread %x", aWinThread);
-	#endif
+#endif
 	// Walk the call stack
 	for (TInt i = 0 ; i < KMaxSearchDepth ; ++i)
 		{
-		#ifdef DUMP_STACK_BACKTRACE
+#ifdef	DUMP_STACK_BACKTRACE
 		DEBUGPRINT("  %08x", eip);
-		#endif
+#endif
 		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;
-	}

changeset 273	6a75fa55495f
parent 90	947f0dc9f7a8