MCL/sf/os/kernelhwsrv: comparison kernel/eka/nkernsmp/nkern.cpp

equal deleted inserted replaced

--1:000000000000
+:a41df078684a
+// Copyright (c) 2005-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\nkern.cpp
+//
+//
+// NThreadBase member data
+#define __INCLUDE_NTHREADBASE_DEFINES__
+#include "nk_priv.h"
+/******************************************************************************
+* Fast mutex
+******************************************************************************/
+/** Acquires the fast mutex.
+This will block until the mutex is available, and causes
+	the thread to enter an implicit critical section until the mutex is released.
+	Generally threads would use NKern::FMWait() which manipulates the kernel lock
+	for you.
+	@pre Kernel must be locked, with lock count 1.
+	@pre The calling thread holds no fast mutexes.
+	@post Kernel is locked, with lock count 1.
+	@post The calling thread holds the mutex.
+	@see NFastMutex::Signal()
+	@see NKern::FMWait()
+*/
+EXPORT_C void NFastMutex::Wait()
+	{
+	NThreadBase* pC = NCurrentThreadL();
+	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED_ONCE|MASK_NO_FAST_MUTEX,"NFastMutex::Wait");
+	pC->iHeldFastMutex = this;		// to handle kill/suspend between here and setting iHeldFastMutex
+	DoWaitL();
+	}
+void NFastMutex::DoWaitL()
+	{
+	NThreadBase* pC = NCurrentThreadL();
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T FMWait %M",pC,this));
+	TBool waited = FALSE;				// set if we actually had to wait
+	iMutexLock.LockOnly();			// acquire mutex spin lock
+	__e32_atomic_ior_rlx_ptr(&iHoldingThread, 1);		// set contention flag to make sure any other thread must acquire the mutex spin lock
+	pC->AcqSLock();
+	FOREVER
+		{
+		if (pC->iFastMutexDefer == 1)
+			--pC->iParent->iFreezeCpu;
+		pC->iFastMutexDefer = 0;
+		NThreadBase* pH = (NThreadBase*)(TLinAddr(iHoldingThread) &~ 1);
+		if (!pH)
+			{
+			// mutex is free
+			TInt wp = iWaitQ.HighestPriority();		// -1 if no other thread wants the mutex
+			// don't grab mutex if we have been suspended/killed/migrated by the previous holding thread
+			if (!pC->iSuspended && pC->iCsFunction!=NThreadBase::ECSDivertPending && (!pC->iParent->iCpuChange || pC->iParent->iFreezeCpu))
+				{
+				TInt p = pC->iPriority;
+				if (p>wp || (p==wp && waited))
+					{
+					// if we are highest priority waiting thread or equal and we have waited then grab the mutex
+					// don't just grab it if we are equal priority and someone else was already waiting
+					// set contention flag if other threads waiting or if current thread has a round robin outstanding
+					pC->iMutexPri = (TUint8)(wp>=0 ? wp : 0);	// pC's actual priority doesn't change since p>=wp
+					iHoldingThread = (wp>=0 || TUint32(pC->iTime)==0x80000000u) ? (NThreadBase*)(TLinAddr(pC)|1) : pC;
+					__KTRACE_OPT(KNKERN,DEBUGPRINT("%T got mutex %M CF=%d WP=%d",TLinAddr(iHoldingThread)&~1,this,TLinAddr(iHoldingThread)&1,wp));
+					pC->RelSLock();
+					iMutexLock.UnlockOnly();
+#ifdef BTRACE_FAST_MUTEX
+					BTraceContext4(BTrace::EFastMutex, BTrace::EFastMutexWait, this);
+#endif
+					return;
+					}
+				}
+			}
+		pC->iFastMutexDefer = 2;	// signal to scheduler to allow ctxsw without incrementing iParent->iFreezeCpu
+		if (!pC->iSuspended && pC->iCsFunction!=NThreadBase::ECSDivertPending && (!pC->iParent->iCpuChange || pC->iParent->iFreezeCpu))
+			{
+			// this forces priority changes to wait for the mutex lock
+			pC->iLinkedObjType = NThreadBase::EWaitFastMutex;
+			pC->iLinkedObj = this;
+			pC->iWaitState.SetUpWait(NThreadBase::EWaitFastMutex, NThreadWaitState::EWtStObstructed, this);
+			pC->iWaitLink.iPriority = pC->iPriority;
+			iWaitQ.Add(&pC->iWaitLink);
+			pC->RelSLock();
+			if (pH)
+				pH->SetMutexPriority(this);
+do_pause:
+			iMutexLock.UnlockOnly();
+			RescheduleNeeded();
+#ifdef BTRACE_FAST_MUTEX
+			BTraceContext4(BTrace::EFastMutex, BTrace::EFastMutexBlock, this);
+#endif
+			NKern::PreemptionPoint();	// we block here until the mutex is released and we are 'nominated' for it or we are suspended/killed
+			iMutexLock.LockOnly();
+			pC->AcqSLock();
+			if (pC->iPauseCount || pC->iSuspended || pC->iCsFunction==NThreadBase::ECSDivertPending || (pC->iParent->iCpuChange && !pC->iParent->iFreezeCpu))
+				{
+				pC->RelSLock();
+				goto do_pause;			// let pause/suspend/kill take effect
+				}
+			// if thread was suspended it will have been removed from the wait queue
+			if (!pC->iLinkedObj)
+				goto thread_suspended;
+			iWaitQ.Remove(&pC->iWaitLink);	// take ourselves off the wait/contend queue while we try to grab the mutex
+			pC->iWaitLink.iNext = 0;
+			pC->iLinkedObj = 0;
+			pC->iLinkedObjType = NThreadBase::EWaitNone;
+			waited = TRUE;
+			// if we are suspended or killed, we loop round again and do the 'else' clause next time
+			}
+		else
+			{
+			pC->RelSLock();
+			if (pC->iSuspended || pC->iCsFunction==NThreadBase::ECSDivertPending)
+				{
+				// wake up next thread to take this one's place
+				if (!pH && !iWaitQ.IsEmpty())
+					{
+					NThreadBase* pT = _LOFF(iWaitQ.First(), NThreadBase, iWaitLink);
+					pT->AcqSLock();
+					// if thread is still blocked on this fast mutex, release it but leave it on the wait queue
+					// NOTE: it can't be suspended
+					pT->iWaitState.UnBlockT(NThreadBase::EWaitFastMutex, this, KErrNone);
+					pT->RelSLock();
+					}
+				}
+			iMutexLock.UnlockOnly();
+			NKern::PreemptionPoint();	// thread suspends/dies/migrates here
+			iMutexLock.LockOnly();
+			pC->AcqSLock();
+thread_suspended:
+			waited = FALSE;
+			// set contention flag to make sure any other thread must acquire the mutex spin lock
+			// need to do it again since mutex may have been released while thread was suspended
+			__e32_atomic_ior_rlx_ptr(&iHoldingThread, 1);
+			}
+		}
+	}
+#ifndef __FAST_MUTEX_MACHINE_CODED__
+/** Releases a previously acquired fast mutex.
+	Generally, threads would use NKern::FMSignal() which manipulates the kernel lock
+	for you.
+	@pre The calling thread holds the mutex.
+	@pre Kernel must be locked.
+	@post Kernel is locked.
+	@see NFastMutex::Wait()
+	@see NKern::FMSignal()
+*/
+EXPORT_C void NFastMutex::Signal()
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED,"NFastMutex::Signal");
+#ifdef BTRACE_FAST_MUTEX
+	BTraceContext4(BTrace::EFastMutex, BTrace::EFastMutexSignal, this);
+#endif
+	NThreadBase* pC = NCurrentThreadL();
+	((volatile TUint32&)pC->iHeldFastMutex) |= 1;	// flag to indicate about to release mutex
+	if (__e32_atomic_cas_rel_ptr(&iHoldingThread, &pC, 0))
+		{
+		// tricky if suspend/kill here
+		// suspend/kill should check flag set above and aMutex->iHoldingThread
+		// if bit 0 of iHeldFastMutex set and iHoldingThread==pC then set iHeldFastMutex=0 and proceed
+		// no-one else was waiting for the mutex - simple
+		pC->iHeldFastMutex = 0;
+		return;
+		}
+	// there was contention so do it the hard way
+	DoSignalL();
+	}
+#endif
+void NFastMutex::DoSignalL()
+	{
+	NThreadBase* pC = NCurrentThreadL();
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T FMSignal %M",pC,this));
+	__ASSERT_WITH_MESSAGE_DEBUG(HeldByCurrentThread(),"The calling thread holds the mutex","NFastMutex::Signal");
+	iMutexLock.LockOnly();
+	if (!iWaitQ.IsEmpty())
+		{
+		NThreadBase* pT = _LOFF(iWaitQ.First(), NThreadBase, iWaitLink);
+		pT->AcqSLock();
+		// if thread is still blocked on this fast mutex, release it but leave it on the wait queue
+		// NOTE: it can't be suspended
+		pT->iWaitState.UnBlockT(NThreadBase::EWaitFastMutex, this, KErrNone);
+		pT->RelSLock();
+		iHoldingThread = (NThreadBase*)1;	// mark mutex as released but contended
+		}
+	else
+		iHoldingThread = 0;	// mark mutex as released and uncontended
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("SiHT=%d",iHoldingThread));
+	pC->AcqSLock();
+	pC->iHeldFastMutex = 0;
+	iMutexLock.UnlockOnly();
+	pC->iMutexPri = 0;
+	if (pC->iPriority != pC->iBasePri)
+		{
+		// lose any inherited priority
+		pC->LoseInheritedPriorityT();
+		}
+	if (TUint32(pC->iTime)==0x80000000u)
+		{
+		pC->iTime = 0;
+		RescheduleNeeded();	// handle deferred timeslicing
+		__KTRACE_OPT(KNKERN,DEBUGPRINT("DTS %T",pC));
+		}
+	if (pC->iFastMutexDefer)
+		{
+		pC->iFastMutexDefer = 0;
+		--pC->iParent->iFreezeCpu;
+		}
+	if (pC->iParent->iCpuChange && !pC->iParent->iFreezeCpu)
+		RescheduleNeeded();	// need to migrate to another CPU
+	if (!pC->iCsCount && pC->iCsFunction)
+		pC->DoCsFunctionT();
+	pC->RelSLock();
+	}
+/** Checks if the current thread holds this fast mutex
+	@return TRUE if the current thread holds this fast mutex
+	@return FALSE if not
+	@pre	Call in thread context.
+*/
+EXPORT_C TBool NFastMutex::HeldByCurrentThread()
+	{
+	return (TLinAddr(iHoldingThread)&~1) == (TLinAddr)NKern::CurrentThread();
+	}
+/** Returns the fast mutex held by the calling thread, if any.
+	@return	If the calling thread currently holds a fast mutex, this function
+			returns a pointer to it; otherwise it returns NULL.
+	@pre	Call in thread context.
+*/
+EXPORT_C NFastMutex* NKern::HeldFastMutex()
+	{
+	NThreadBase* t = NKern::CurrentThread();
+	NFastMutex* m = (NFastMutex*)(TLinAddr(t->iHeldFastMutex)&~3);
+	return (m && m->HeldByCurrentThread()) ? m : 0;
+	}
+#ifndef __FAST_MUTEX_MACHINE_CODED__
+/** Acquires a fast mutex.
+This will block until the mutex is available, and causes
+	the thread to enter an implicit critical section until the mutex is released.
+	@param aMutex The fast mutex to acquire.
+	@post The calling thread holds the mutex.
+	@see NFastMutex::Wait()
+	@see NKern::FMSignal()
+	@pre No fast mutex can be held.
+	@pre Call in a thread context.
+	@pre Kernel must be unlocked
+	@pre interrupts enabled
+*/
+EXPORT_C void NKern::FMWait(NFastMutex* aMutex)
+	{
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("NFMW %M", aMutex));
+	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"NKern::FMWait");
+	NThreadBase* pC = NKern::CurrentThread();
+	// If the reschedule IPI from an external suspend or kill occurs after this
+	// point the initiating CPU must observe the write to iHeldFastMutex before
+	// the cas operation.
+	pC->iHeldFastMutex = aMutex;	// kill/suspend after this point should set mutex contention flag
+	NThreadBase* expect = 0;
+	if (__e32_atomic_cas_acq_ptr(&aMutex->iHoldingThread, &expect, pC))
+		{
+		// mutex was free and we have just claimed it - simple
+#ifdef BTRACE_FAST_MUTEX
+		BTraceContext4(BTrace::EFastMutex, BTrace::EFastMutexWait, aMutex);
+#endif
+		return;
+		}
+	// care required if suspend/kill here
+	// there is contention so do it the hard way
+	NKern::Lock();
+	aMutex->DoWaitL();
+	NKern::Unlock();
+	}
+/** Releases a previously acquired fast mutex.
+	@param aMutex The fast mutex to release.
+	@pre The calling thread holds the mutex.
+	@see NFastMutex::Signal()
+	@see NKern::FMWait()
+*/
+EXPORT_C void NKern::FMSignal(NFastMutex* aMutex)
+	{
+	NThreadBase* pC = NKern::CurrentThread();
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("NFMS %M", aMutex));
+#ifdef BTRACE_FAST_MUTEX
+	BTraceContext4(BTrace::EFastMutex, BTrace::EFastMutexSignal, aMutex);
+#endif
+	((volatile TUint32&)pC->iHeldFastMutex) |= 1;	// flag to indicate about to release mutex
+	if (__e32_atomic_cas_rel_ptr(&aMutex->iHoldingThread, &pC, 0))
+		{
+		// no-one else was waiting for the mutex and we have just released it
+		// tricky if suspend/kill here
+		// suspend/kill should check flag set above and aMutex->iHoldingThread
+		// if bit 0 of iHeldFastMutex set and iHoldingThread==pC then set iHeldFastMutex=0 and proceed
+		// If the reschedule IPI from an external suspend or kill occurs after this
+		// point the initiating CPU must observe the write to iHeldFastMutex after
+		// the cas operation.
+		pC->iHeldFastMutex = 0;
+		return;
+		}
+	// there was contention so do it the hard way
+	NKern::Lock();
+	aMutex->DoSignalL();
+	NKern::Unlock();
+	}
+/** Acquires the System Lock.
+This will block until the mutex is available, and causes
+	the thread to enter an implicit critical section until the mutex is released.
+	@post System lock is held.
+	@see NKern::UnlockSystem()
+	@see NKern::FMWait()
+	@pre No fast mutex can be held.
+	@pre Call in a thread context.
+	@pre Kernel must be unlocked
+	@pre interrupts enabled
+*/
+EXPORT_C void NKern::LockSystem()
+	{
+	NKern::FMWait(&TheScheduler.iLock);
+	}
+/** Releases the System Lock.
+	@pre System lock must be held.
+	@see NKern::LockSystem()
+	@see NKern::FMSignal()
+*/
+EXPORT_C void NKern::UnlockSystem()
+	{
+	NKern::FMSignal(&TheScheduler.iLock);
+	}
+/** Temporarily releases a fast mutex if there is contention.
+If there is another thread attempting to acquire the mutex, the calling
+	thread releases the mutex and then acquires it again.
+	This is more efficient than the equivalent code:
+	@code
+	NKern::FMSignal();
+	NKern::FMWait();
+	@endcode
+	@return	TRUE if the mutex was relinquished, FALSE if not.
+	@pre	The mutex must be held.
+	@post	The mutex is held.
+*/
+EXPORT_C TBool NKern::FMFlash(NFastMutex* aM)
+	{
+	NThreadBase* pC = NKern::CurrentThread();
+	__ASSERT_WITH_MESSAGE_DEBUG(aM->HeldByCurrentThread(),"The calling thread holds the mutex","NKern::FMFlash");
+	TBool w = (pC->iMutexPri >= pC->iBasePri);	// a thread of greater or equal priority is waiting
+	if (w)
+		{
+		NKern::Lock();
+		aM->Signal();
+		NKern::PreemptionPoint();
+		aM->Wait();
+		NKern::Unlock();
+		}
+#ifdef BTRACE_FAST_MUTEX
+	else
+		{
+		BTraceContext4(BTrace::EFastMutex, BTrace::EFastMutexFlash, aM);
+		}
+#endif
+	return w;
+	}
+/** Temporarily releases the System Lock if there is contention.
+If there
+	is another thread attempting to acquire the System lock, the calling
+	thread releases the mutex and then acquires it again.
+	This is more efficient than the equivalent code:
+	@code
+	NKern::UnlockSystem();
+	NKern::LockSystem();
+	@endcode
+	Note that this can only allow higher priority threads to use the System
+	lock as lower priority cannot cause contention on a fast mutex.
+	@return	TRUE if the system lock was relinquished, FALSE if not.
+	@pre	System lock must be held.
+	@post	System lock is held.
+	@see NKern::LockSystem()
+	@see NKern::UnlockSystem()
+*/
+EXPORT_C TBool NKern::FlashSystem()
+	{
+	CHECK_PRECONDITIONS(MASK_SYSTEM_LOCKED,"NKern::FlashSystem");
+	return NKern::FMFlash(&TheScheduler.iLock);
+	}
+#endif
+/******************************************************************************
+* Fast semaphore
+******************************************************************************/
+/** Sets the owner of a fast semaphore.
+	@param aThread The thread to own this semaphore. If aThread==0, then the
+					owner is set to the current thread.
+	@pre Kernel must be locked.
+	@pre If changing ownership form one thread to another, the there must be no
+		 pending signals or waits.
+	@pre Call either in a thread or an IDFC context.
+	@post Kernel is locked.
+*/
+EXPORT_C void NFastSemaphore::SetOwner(NThreadBase* aThread)
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NFastSemaphore::SetOwner");
+	if (!aThread)
+		aThread = NCurrentThreadL();
+	if (iOwningThread && iOwningThread!=aThread)
+		{
+		__NK_ASSERT_ALWAYS(!iCount);	// Can't change owner if iCount!=0
+		}
+	iOwningThread = aThread;
+	}
+#ifndef __FAST_SEM_MACHINE_CODED__
+/** Waits on a fast semaphore.
+Decrements the signal count for the semaphore and
+	removes the calling thread from the ready-list if the semaphore becomes
+	unsignalled. Only the thread that owns a fast semaphore can wait on it.
+	Note that this function does not block, it merely updates the NThread state,
+	rescheduling will only occur when the kernel is unlocked. Generally threads
+	would use NKern::FSWait() which manipulates the kernel lock for you.
+	@pre The calling thread must own the semaphore.
+	@pre No fast mutex can be held.
+	@pre Kernel must be locked.
+	@post Kernel is locked.
+	@see NFastSemaphore::Signal()
+	@see NKern::FSWait()
+	@see NKern::Unlock()
+*/
+EXPORT_C void NFastSemaphore::Wait()
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NO_FAST_MUTEX,"NFastSemaphore::Wait");
+	NThreadBase* pC = NCurrentThreadL();
+	__ASSERT_WITH_MESSAGE_ALWAYS(pC==iOwningThread,"The calling thread must own the semaphore","NFastSemaphore::Wait");
+	pC->iWaitState.SetUpWait(NThreadBase::EWaitFastSemaphore, 0, this);
+	if (Dec(pC))						// full barrier
+		pC->iWaitState.CancelWait();	// don't have to wait
+	else
+		RescheduleNeeded();				// have to wait
+	}
+/** Signals a fast semaphore.
+Increments the signal count of a fast semaphore by
+	one and releases any waiting thread if the semphore becomes signalled.
+	Note that a reschedule will not occur before this function returns, this will
+	only take place when the kernel is unlocked. Generally threads
+	would use NKern::FSSignal() which manipulates the kernel lock for you.
+	@pre Kernel must be locked.
+	@pre Call either in a thread or an IDFC context.
+	@post Kernel is locked.
+	@see NFastSemaphore::Wait()
+	@see NKern::FSSignal()
+	@see NKern::Unlock()
+*/
+EXPORT_C void NFastSemaphore::Signal()
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NFastSemaphore::Signal");
+	NThreadBase* t = Inc(1);	// release semantics
+	if (t)
+		{
+		t->AcqSLock();
+		t->iWaitState.UnBlockT(NThreadBase::EWaitFastSemaphore, this, KErrNone);
+		t->RelSLock();
+		}
+	}
+/** Signals a fast semaphore multiple times.
+	@pre Kernel must be locked.
+	@pre Call either in a thread or an IDFC context.
+	@post Kernel is locked.
+	@internalComponent
+*/
+EXPORT_C void NFastSemaphore::SignalN(TInt aCount)
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NFastSemaphore::SignalN");
+	__NK_ASSERT_DEBUG(aCount>=0);
+	if (aCount > 0)
+		{
+		NThreadBase* t = Inc(aCount);
+		if (t)
+			{
+			t->AcqSLock();
+			t->iWaitState.UnBlockT(NThreadBase::EWaitFastSemaphore, this, KErrNone);
+			t->RelSLock();
+			}
+		}
+	}
+/** Cancels a wait on a fast semaphore.
+	@pre Kernel must be locked.
+	@pre Call either in a thread or an IDFC context.
+	@post Kernel is locked.
+	@internalComponent
+*/
+void NFastSemaphore::WaitCancel()
+	{
+	Inc(1);
+	}
+/** Waits for a signal on the current thread's I/O semaphore.
+	@pre No fast mutex can be held.
+	@pre Call in a thread context.
+	@pre Kernel must be unlocked
+	@pre interrupts enabled
+*/
+EXPORT_C void NKern::WaitForAnyRequest()
+	{
+	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"NKern::WaitForAnyRequest");
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("WfAR"));
+	NThreadBase* t = NKern::LockC();
+	NFastSemaphore* s = &t->iRequestSemaphore;
+	t->iWaitState.SetUpWait(NThreadBase::EWaitFastSemaphore, 0, s);
+	if (s->Dec(t))					// fully ordered semantics
+		t->iWaitState.CancelWait();	// don't have to wait
+	else
+		RescheduleNeeded();			// have to wait
+	NKern::Unlock();
+	}
+#endif
+/** Resets a fast semaphore.
+	@pre Kernel must be locked.
+	@pre Call either in a thread or an IDFC context.
+	@post Kernel is locked.
+	@internalComponent
+*/
+EXPORT_C void NFastSemaphore::Reset()
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NFastSemaphore::Reset");
+	NThreadBase* t = DoReset();
+	if (t)
+		{
+		t->AcqSLock();
+		t->iWaitState.UnBlockT(NThreadBase::EWaitFastSemaphore, this, KErrNone);
+		t->RelSLock();
+		}
+	}
+/** Sets the owner of a fast semaphore.
+	@param aSem The semaphore to change ownership off.
+	@param aThread The thread to own this semaphore. If aThread==0, then the
+					owner is set to the current thread.
+	@pre If changing ownership form one thread to another, the there must be no
+		 pending signals or waits.
+*/
+EXPORT_C void NKern::FSSetOwner(NFastSemaphore* aSem,NThreadBase* aThread)
+	{
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("NKern::FSSetOwner %m %T",aSem,aThread));
+	NKern::Lock();
+	aSem->SetOwner(aThread);
+	NKern::Unlock();
+	}
+#ifndef __FAST_SEM_MACHINE_CODED__
+/** Waits on a fast semaphore.
+Decrements the signal count for the semaphore
+	and waits for a signal if the semaphore becomes unsignalled. Only the
+	thread that owns a fast	semaphore can wait on it.
+	@param aSem The semaphore to wait on.
+	@pre The calling thread must own the semaphore.
+	@pre No fast mutex can be held.
+	@see NFastSemaphore::Wait()
+*/
+EXPORT_C void NKern::FSWait(NFastSemaphore* aSem)
+	{
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("NFSW %m",aSem));
+	NKern::Lock();
+	aSem->Wait();
+	NKern::Unlock();
+	}
+/** Signals a fast semaphore.
+Increments the signal count of a fast semaphore
+	by one and releases any	waiting thread if the semaphore becomes signalled.
+	@param aSem The semaphore to signal.
+	@see NKern::FSWait()
+	@pre Interrupts must be enabled.
+	@pre Do not call from an ISR
+*/
+EXPORT_C void NKern::FSSignal(NFastSemaphore* aSem)
+	{
+	CHECK_PRECONDITIONS(MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR,"NKern::FSSignal(NFastSemaphore*)");
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("NFSS %m",aSem));
+	NKern::Lock();
+	aSem->Signal();
+	NKern::Unlock();
+	}
+/** Signals a fast semaphore multiple times.
+Increments the signal count of a
+	fast semaphore by aCount and releases any waiting thread if the semphore
+	becomes signalled.
+	@param aSem The semaphore to signal.
+	@param aCount The number of times to signal the semaphore.
+	@see NKern::FSWait()
+	@pre Interrupts must be enabled.
+	@pre Do not call from an ISR
+*/
+EXPORT_C void NKern::FSSignalN(NFastSemaphore* aSem, TInt aCount)
+	{
+	CHECK_PRECONDITIONS(MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR,"NKern::FSSignalN(NFastSemaphore*, TInt)");
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("NFSSN %m %d",aSem,aCount));
+	__NK_ASSERT_DEBUG(aCount>=0);
+	if (aCount == 0)
+		return;
+	NKern::Lock();
+	aSem->SignalN(aCount);
+	NKern::Unlock();
+	}
+/** Signals the request semaphore of a nanothread.
+	This function is intended to be used by the EPOC layer and personality
+	layers.  Device drivers should use Kern::RequestComplete instead.
+	@param aThread Nanothread to signal. Must be non NULL.
+	@see Kern::RequestComplete()
+	@pre Interrupts must be enabled.
+	@pre Do not call from an ISR
+*/
+EXPORT_C void NKern::ThreadRequestSignal(NThread* aThread)
+	{
+	NKern::FSSignal(&aThread->iRequestSemaphore);
+	}
+/** Signals the request semaphore of a nanothread several times.
+	This function is intended to be used by the EPOC layer and personality
+	layers.  Device drivers should use Kern::RequestComplete instead.
+	@param aThread Nanothread to signal.  If NULL, the current thread is signaled.
+	@param aCount Number of times the request semaphore must be signaled.
+	@pre aCount >= 0
+	@see Kern::RequestComplete()
+*/
+EXPORT_C void NKern::ThreadRequestSignal(NThread* aThread, TInt aCount)
+	{
+	__ASSERT_WITH_MESSAGE_DEBUG(aCount >= 0,"aCount >= 0","NKern::ThreadRequestSignal");
+	if (!aThread)
+		aThread = (NThread*)NKern::CurrentThread();
+	NKern::FSSignalN(&aThread->iRequestSemaphore, aCount);
+	}
+#endif
+/** Atomically signals a fast semaphore and releases a fast mutex.
+	Rescheduling only occurs after both synchronisation operations are complete.
+	@param aSem The semaphore to signal.
+	@param aMutex The mutex to release. If NULL, the System Lock is released
+	@pre The calling thread must hold the mutex.
+	@see NKern::FMSignal()
+*/
+EXPORT_C void NKern::FSSignal(NFastSemaphore* aSem, NFastMutex* aMutex)
+	{
+	if (!aMutex)
+		aMutex=&TheScheduler.iLock;
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("NFSS %m +FM %M",aSem,aMutex));
+	NKern::Lock();
+	aSem->Signal();
+	aMutex->Signal();
+	NKern::Unlock();
+	}
+/** Atomically signals a fast semaphore multiple times and releases a fast mutex.
+	Rescheduling only occurs after both synchronisation operations are complete.
+	@param aSem The semaphore to signal.
+	@param aCount The number of times to signal the semaphore.
+	@param aMutex The mutex to release. If NULL, the System Lock is released.
+	@pre The calling thread must hold the mutex.
+	@see NKern::FMSignal()
+*/
+EXPORT_C void NKern::FSSignalN(NFastSemaphore* aSem, TInt aCount, NFastMutex* aMutex)
+	{
+	if (!aMutex)
+		aMutex=&TheScheduler.iLock;
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("NFSSN %m %d + FM %M",aSem,aCount,aMutex));
+	NKern::Lock();
+	aSem->SignalN(aCount);
+	aMutex->Signal();
+	NKern::Unlock();
+	}
+/******************************************************************************
+* Thread
+******************************************************************************/
+void NThreadBase::DoCsFunctionT()
+	{
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nDoCsFuncT %d",this,iCsFunction));
+	TInt f=iCsFunction;
+	if (f==0)
+		return;
+	if (f>0)
+		{
+		// suspend this thread f times
+		iCsFunction = 0;
+		iSuspendCount += f;
+		iSuspended = 1;
+		RescheduleNeeded();
+		return;
+		}
+	if (f==ECSExitPending || f==ECSDivertPending)
+		{
+		// We need to exit now
+		RelSLock();
+		Exit();	// this won't return
+		}
+//	UnknownState(ELeaveCS,f);	// call into RTOS personality
+	__NK_ASSERT_ALWAYS(0);
+	}
+TBool NThreadBase::DoSuspendOrKillT(TInt aCount, TSubScheduler* aS)
+	{
+	TBool result = TRUE;
+	if (aCount>=0)
+		{
+		if (iSuspended)
+			result = FALSE;
+		iSuspendCount+=aCount;
+		iSuspended = 1;
+		if (!iCurrent)
+			{
+			if (aS)
+				UnReadyT();
+			else if (iReady)
+				{
+				NThreadGroup* g = (NThreadGroup*)iParent;
+				g->iNThreadList.Remove(this);
+				}
+			}
+		if (this == NCurrentThreadL())
+			RescheduleNeeded();
+		if (aS)
+			aS->iReadyListLock.UnlockOnly();
+		}
+	else
+		{
+		iCsFunction = ECSDivertPending;
+		iSuspendCount = 0;
+		iSuspended = 0;
+		if (aS)
+			aS->iReadyListLock.UnlockOnly();
+		DoReleaseT(KErrDied,0);
+		if (!iReady && !iPauseCount)
+			ReadyT(0);
+		}
+	return result;
+	}
+// If aCount>=0 suspend the thread aCount times
+// If aCount<0 kill the thread
+TBool NThreadBase::SuspendOrKill(TInt aCount)
+	{
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nSuspendOrKill %d", this, aCount));
+	if (aCount==0)
+		return FALSE;
+	TBool result = FALSE;
+	TBool concurrent = FALSE;
+	TSubScheduler* ss = 0;
+	AcqSLock();
+	NFastMutex* wfm = 0;
+	if (iLinkedObj && iLinkedObjType==EWaitFastMutex)
+		wfm = (NFastMutex*)iLinkedObj;
+	if (iCsFunction<0)
+		goto done2;	// if already exiting ignore suspend or kill
+	if (wfm)
+		{
+		// if thread is waiting on a fast mutex, need to acquire mutex lock
+		++iPauseCount;
+		RelSLock();
+		wfm->iMutexLock.LockOnly();
+		AcqSLock();
+		UnPauseT();
+		}
+	if (iReady && iParent->iReady)
+		{
+		ss = TheSubSchedulers + (iParent->iReady & EReadyCpuMask);
+		ss->iReadyListLock.LockOnly();
+		}
+	concurrent = (iCurrent && this!=NCurrentThreadL());
+	if (iWaitState.ThreadIsDead())				// already dead so suspension/kill is a no-op
+		goto done;
+	if (concurrent)
+		{
+		// thread is actually running on another CPU
+		// interrupt that CPU and wait for it to enter interrupt mode
+		// this allows a snapshot of the thread state to be observed
+		// in this state, the thread cannot enter or leave a critical section
+		send_resched_ipi_and_wait(iLastCpu);
+		}
+	if (iCsCount)
+		{
+suspend_or_kill_in_cs:
+		__KTRACE_OPT(KNKERN,DEBUGPRINT("n Suspend %T (CSF %d) %d",this,iCsFunction,aCount));
+		if (aCount>0)				// -ve means thread is about to exit
+			iCsFunction+=aCount;	// so thread will suspend itself when it leaves the critical section
+		else
+			iCsFunction = ECSExitPending;
+		goto done;
+		}
+	// iCsCount==0 and it can't become nonzero until we release the thread spin lock
+	// (since threads may not set iCsCount to a nonzero value with the kernel lock held)
+	// Make sure the thread isn't actually about to exit by itself
+	if (iCsFunction<0)
+		goto done;	// if already exiting ignore suspend or kill
+	if (wfm)
+		{
+		wfm->iWaitQ.Remove(&iWaitLink);	// take thread off the wait/contend queue
+		iWaitLink.iNext = 0;
+		iLinkedObj = 0;
+		iLinkedObjType = EWaitNone;
+		result = DoSuspendOrKillT(aCount, ss);
+		if (aCount>0)
+			DoReleaseT(KErrGeneral, 0);	// thread isn't blocked any more, just suspended
+		RelSLock();
+		// May need to adjust holding thread's inherited priority.
+		// May need to wake up next thread to take this one's place.
+		NThreadBase* pH = (NThreadBase*)(TLinAddr(wfm->iHoldingThread) &~ 1);
+		if (pH)
+			pH->SetMutexPriority(wfm);
+		else if (!pH && !wfm->iWaitQ.IsEmpty())
+			{
+			NThreadBase* pT = _LOFF(wfm->iWaitQ.First(), NThreadBase, iWaitLink);
+			pT->AcqSLock();
+			pT->iWaitState.UnBlockT(NThreadBase::EWaitFastMutex, wfm, KErrNone);
+			pT->RelSLock();
+			}
+		wfm->iMutexLock.UnlockOnly();
+		return result;
+		}
+	if (CheckFastMutexDefer())
+		goto suspend_or_kill_in_cs;
+	// thread not in critical section, so suspend it
+	result = DoSuspendOrKillT(aCount, ss);
+	goto done2;
+done:
+	if (wfm)
+		wfm->iMutexLock.UnlockOnly();
+	if (ss)
+		ss->iReadyListLock.UnlockOnly();
+done2:
+	RelSLock();
+	return result;
+	}
+/** Suspends a nanothread the specified number of times.
+	For use by RTOS personality layers.
+	Do not use this function directly on a Symbian OS thread.
+	Since the kernel is locked on entry, any reschedule will be deferred until
+	it is unlocked.
+	The suspension will be deferred if the target thread is currently in a
+	critical section; in this case the suspension will take effect when it exits
+	the critical section.
+	The thread's unknown state handler will be invoked with function ESuspend and
+	parameter aCount if the current NState is not recognised and it is not in a
+	critical section.
+	@param	aCount = the number of times to suspend.
+	@return	TRUE, if the suspension has taken immediate effect;
+			FALSE, if the thread is in a critical section or is already suspended.
+	@pre	Kernel must be locked.
+	@pre	Call in a thread context.
+	@post	Kernel is locked.
+*/
+EXPORT_C TBool NThreadBase::Suspend(TInt aCount)
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR|MASK_NOT_IDFC,"NThreadBase::Suspend");
+	__NK_ASSERT_ALWAYS(aCount>=0);
+	// If thread is executing a critical section, we must defer the suspend
+	return SuspendOrKill(aCount);
+	}
+TBool NThreadBase::Resume(TBool aForce)
+	{
+	TBool result = FALSE;
+	AcqSLock();
+	if (iWaitState.ThreadIsDead() || iCsFunction<0)		// already dead or dying so resume is a no-op
+		goto done;
+	if (iCsFunction>0)
+		{
+		if (aForce)
+			iCsFunction = 0;
+		else
+			--iCsFunction;
+		}
+	else if (iSuspendCount)
+		{
+		if (aForce)
+			iSuspendCount = 0;
+		else
+			--iSuspendCount;
+		if (!iSuspendCount)
+			{
+			result = TRUE;
+			iSuspended = 0;
+			if (!iPauseCount && !iReady && !iWaitState.iWtC.iWtStFlags)
+				ReadyT(0);
+			}
+		}
+done:
+	RelSLock();
+	return result;
+	}
+/** Resumes a nanothread, cancelling one suspension.
+	For use by RTOS personality layers.
+	Do not use this function directly on a Symbian OS thread.
+	Since the kernel is locked on entry, any reschedule will be deferred until
+	it is unlocked.
+	If the target thread is currently in a critical section this will simply
+	cancel one deferred suspension.
+	The thread's unknown state handler will be invoked with function EResume if
+	the current NState is not recognised and it is not in a	critical section.
+	@return	TRUE, if the resumption has taken immediate effect;
+			FALSE, if the thread is in a critical section or is still suspended.
+	@pre	Kernel must be locked.
+	@pre	Call either in a thread or an IDFC context.
+	@post	Kernel must be locked.
+*/
+EXPORT_C TBool NThreadBase::Resume()
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR|MASK_NOT_IDFC,"NThreadBase::Resume");
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nRsm",this));
+	return Resume(FALSE);
+	}
+/** Resumes a nanothread, cancelling all outstanding suspensions.
+	For use by RTOS personality layers.
+	Do not use this function directly on a Symbian OS thread.
+	Since the kernel is locked on entry, any reschedule will be deferred until
+	it is unlocked.
+	If the target thread is currently in a critical section this will simply
+	cancel all deferred suspensions.
+	The thread's unknown state handler will be invoked with function EForceResume
+	if the current NState is not recognised and it is not in a	critical section.
+	@return	TRUE, if the resumption has taken immediate effect;
+			FALSE, if the thread is in a critical section.
+	@pre	Kernel must be locked.
+	@pre	Call either in a thread or an IDFC context.
+	@post	Kernel is locked.
+*/
+EXPORT_C TBool NThreadBase::ForceResume()
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NThreadBase::ForceResume");
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nFRsm",this));
+	return Resume(TRUE);
+	}
+void NThreadBase::DoReleaseT(TInt aReturnCode, TUint aMode)
+	{
+	TAny* wobj = 0;
+	TUint32 b = iWaitState.ReleaseT(wobj, aReturnCode);	// cancels timer if necessary
+	// if wait pending or no wait, done
+	// if wait in effect and nothing else stopping it, make thread ready
+	// cancel any outstanding wait on fast semaphore if abnormal release
+	// FIXME: Potential problems with abnormal release of generic wait objects
+	if (aReturnCode<0 && ((b>>8)&0xff)==NThreadBase::EWaitFastSemaphore && wobj)
+		((NFastSemaphore*)wobj)->WaitCancel();
+	if ((b & NThreadWaitState::EWtStWaitActive) && !iPauseCount && !iSuspended)
+		ReadyT(aMode);
+	}
+/** Releases a waiting nanokernel thread.
+	For use by RTOS personality layers.
+	Do not use this function directly on a Symbian OS thread.
+	This function should make the thread ready (provided it is not explicitly
+	suspended) and cancel any wait timeout. It should also remove it from any
+	wait queues.
+	If aReturnCode is nonnegative it indicates normal completion of the wait.
+	If aReturnCode is negative it indicates early/abnormal completion of the
+	wait and so any wait object should be reverted as if the wait had never
+	occurred (eg semaphore count should be incremented as this thread has not
+	actually acquired the semaphore).
+	The thread's unknown state handler will be invoked with function ERelease
+	and parameter aReturnCode if the current NState is not recognised.
+	@param aReturnCode	The reason code for release.
+	@pre	Kernel must be locked.
+	@pre	Call either in a thread or an IDFC context.
+	@post	Kernel is locked.
+*/
+EXPORT_C void NThreadBase::Release(TInt aReturnCode, TUint aMode)
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NThreadBase::Release");
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nRel %d",this,aReturnCode));
+	AcqSLock();
+	DoReleaseT(aReturnCode, aMode);
+	RelSLock();
+	}
+/** Signals a nanokernel thread's request semaphore.
+	This can also be used on Symbian OS threads.
+	@pre	Kernel must be locked.
+	@pre	Call either in a thread or an IDFC context.
+	@post	Kernel is locked.
+*/
+EXPORT_C void NThreadBase::RequestSignal()
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NThreadBase::RequestSignal");
+	iRequestSemaphore.Signal();
+	}
+void exit_sync_fn(TAny* aDfc)
+	{
+	((TDfc*)aDfc)->Enque();
+	}
+void NThreadBase::Exit()
+	{
+	// The current thread is exiting
+	// Enter with kernel locked, don't return
+	__NK_ASSERT_DEBUG(this==NCurrentThreadL());
+	OnExit();
+	TInt threadCS = iCsCount;
+	TInt kernCS = SubScheduler().iKernLockCount;
+	iCsCount = 1;
+	AcqSLock();
+	iCsFunction = ECSExitInProgress;
+	NFastMutex* m = NKern::HeldFastMutex();
+	iHeldFastMutex = 0;
+	RelSLock();
+	NKern::Unlock();
+	__KTRACE_OPT(KSCHED,DEBUGPRINT("Exit %T %u",this,NTickCount()));
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nExit, CSC %d HeldFM %M KernCS %d",this,threadCS,iHeldFastMutex,kernCS));
+	if (kernCS!=1)
+		FAULT();
+	if (m)
+		FAULT();
+	if (threadCS)
+		FAULT();
+	TDfc* pD = NULL;
+	NThreadExitHandler xh = iHandlers->iExitHandler;
+	if (xh)
+		pD = (*xh)((NThread*)this);		// call exit handler
+	// detach any tied events
+	DetachTiedEvents();
+	NKern::LeaveGroup();	// detach from group if exit handler didn't do it
+	NKern::Lock();
+#ifdef BTRACE_THREAD_IDENTIFICATION
+	BTrace4(BTrace::EThreadIdentification,BTrace::ENanoThreadDestroy,this);
+#endif
+	__NK_ASSERT_ALWAYS(iCsFunction == ECSExitInProgress);
+	iWaitState.SetDead(pD);	// doesn't return
+	FAULT();
+	}
+/** Kills a nanokernel thread.
+	For use by RTOS personality layers.
+	Do not use this function directly on a Symbian OS thread.
+	When acting on the calling thread, causes the calling thread to exit.
+	When acting on another thread, causes that thread to exit unless it is
+	currently in a critical section. In this case the thread is marked as
+	"exit pending" and will exit as soon as it leaves the critical section.
+	In either case the exiting thread first invokes its exit handler (if it
+	exists). The handler runs with preemption enabled and with the thread in a
+	critical section so that it may not be suspended or killed again. The
+	handler may return a pointer to a TDfc, which will be enqueued just before
+	the thread finally terminates (after the kernel has been relocked). This DFC
+	will therefore execute once the NThread has been safely removed from the
+	scheduler and is intended to be used to cleanup the NThread object and any
+	associated personality layer resources.
+	@pre	Kernel must be locked.
+	@pre	Call in a thread context.
+	@pre	If acting on calling thread, calling thread must not be in a
+			critical section; if it is the kernel will fault. Also, the kernel
+			must be locked exactly once (iKernCSLocked = 1).
+	@post	Kernel is locked, if not acting on calling thread.
+	@post	Does not return if it acts on the calling thread.
+*/
+EXPORT_C void NThreadBase::Kill()
+	{
+	// Kill a thread
+	// Enter with kernel locked
+	// Exit with kernel locked if not current thread, otherwise does not return
+	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED_ONCE|MASK_NOT_IDFC|MASK_NOT_ISR,"NThreadBase::Kill");
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nKill",this));
+	OnKill(); // platform-specific hook
+	NThreadBase* pC = NCurrentThreadL();
+	if (this==pC)
+		{
+		if (iCsFunction==ECSExitInProgress)
+			FAULT();
+		Exit();				// this will not return
+		}
+	SuspendOrKill(-1);
+	}
+/** Change the CPU affinity of a thread
+	@pre	Kernel must be locked.
+	@pre	Call in a thread context.
+	@param	The number of the CPU to which this thread should be locked, or
+			KCpuAny if it should be able to run on any CPU.
+	@return The previous affinity mask.
+*/
+TUint32 NThreadBase::SetCpuAffinity(TUint32 aAffinity)
+	{
+	// check aAffinity is valid
+	AcqSLock();
+	TUint32 old_aff = iParent->iCpuAffinity;
+	TBool migrate = FALSE;
+	TBool make_ready = FALSE;
+	TSubScheduler* ss0 = &SubScheduler();
+	TSubScheduler* ss = 0;
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nSetCpu %08x->%08x, F:%d R:%02x PR:%02x",this,iParent->iCpuAffinity,aAffinity,iParent->iFreezeCpu,iReady,iParent->iReady));
+	if (i_NThread_Initial)
+		goto done;	// can't change affinity of initial thread
+	iParent->iCpuAffinity = aAffinity;		// set new affinity, might not take effect yet
+	if (!iParent->iReady)
+		goto done;	// thread/group not currently on a ready list so can just change affinity
+	migrate = !CheckCpuAgainstAffinity(iParent->iReady & EReadyCpuMask, aAffinity);	// TRUE if thread's current CPU is incompatible with the new affinity
+	if (!migrate)
+		goto done;	// don't need to move thread, so just change affinity
+	ss = TheSubSchedulers + (iParent->iReady & EReadyCpuMask);
+	ss->iReadyListLock.LockOnly();
+	if (iParent->iCurrent)
+		{
+		iParent->iCpuChange = TRUE;			// mark CPU change pending
+		if (ss == ss0)
+			RescheduleNeeded();
+		else
+			// kick other CPU now so migration happens before acquisition of fast mutex
+			send_resched_ipi_and_wait(iParent->iReady & EReadyCpuMask);
+		}
+	else
+		{
+		// Note: Need to know here if any thread in group would return TRUE from CheckFastMutexDefer()
+		// This is handled by the scheduler - when a thread belonging to a group is context switched
+		// out while holding a fast mutex its iFastMutexDefer is set to 1 and the group's iFreezeCpu
+		// is incremented.
+		if (iParent->iFreezeCpu || (iParent==this && CheckFastMutexDefer()))
+			iParent->iCpuChange = TRUE;	// CPU frozen or fast mutex held so just mark deferred CPU migration
+		else
+			{
+			ss->Remove(iParent);
+			iParent->iReady = 0;
+			make_ready = TRUE;
+			}
+		}
+	ss->iReadyListLock.UnlockOnly();
+	if (make_ready)
+		iParent->ReadyT(0);
+done:
+	RelSLock();
+	return old_aff;
+	}
+/******************************************************************************
+* Thread wait state
+******************************************************************************/
+#ifndef __NTHREAD_WAITSTATE_MACHINE_CODED__
+void NThreadWaitState::SetUpWait(TUint aType, TUint aFlags, TAny* aWaitObj)
+	{
+	SetUpWait(aType, aFlags, aWaitObj, 0);
+	}
+void NThreadWaitState::SetUpWait(TUint aType, TUint aFlags, TAny* aWaitObj, TUint32 aTimeout)
+	{
+	aFlags &= EWtStObstructed;
+	aFlags |= EWtStWaitPending;
+	aType &= 0xff;
+	TUint64 ws64 = (TUint32)aWaitObj;
+	ws64 <<= 32;
+	ws64 |= ((aType<<8)|aFlags);
+	TUint64 oldws64 = __e32_atomic_swp_rlx64(&iWtSt64, ws64);
+	if (I64LOW(oldws64)!=0)
+		__crash();	// ??we were already waiting for something else??
+	iTimer.iTriggerTime = aTimeout;
+	}
+void NThreadWaitState::CancelWait()
+	{
+	TUint64 oldws64 = __e32_atomic_swp_rlx64(&iWtSt64, 0);
+	if (oldws64 & (EWtStDead|EWtStWaitActive))
+		__crash();
+	}
+TInt NThreadWaitState::DoWait()
+	{
+	TUint64 oldws64 = iWtSt64;
+	TUint64 ws64;
+	TUint32 timeout = iTimer.iTriggerTime;
+	TUint32 set = timeout ? (EWtStWaitActive|EWtStTimeout) : EWtStWaitActive;
+	do	{
+		TUint32 ws32 = I64LOW(oldws64);
+		if (ws32 & EWtStDead)
+			return KErrDied;
+		if (!(ws32 & EWtStWaitPending))
+			return KErrGeneral;
+		ws64 = oldws64;
+		ws64 &= ~TUint64(EWtStWaitPending);
+		ws64 |= TUint64(set);
+		} while(!__e32_atomic_cas_rlx64(&iWtSt64, &oldws64, ws64));
+	if (timeout)
+		{
+		if (iTimer.OneShot(timeout, TRUE)!=KErrNone)
+			__crash();
+		++iTimer.iNTimerSpare1;
+		}
+	return TUint32(oldws64)>>8;
+	}
+TInt NThreadWaitState::UnBlockT(TUint aType, TAny* aWaitObj, TInt aReturnValue)
+	{
+	TUint64 exp = TUint32(aWaitObj);
+	exp <<= 32;
+	exp |= (aType<<8);
+	TUint64 oldws64 = iWtSt64;
+	TUint64 ws64;
+	do	{
+		if ((oldws64 ^ exp) < TUint64(EWtStDead))
+			ws64 = TUint64(TUint32(aReturnValue))<<32;
+		else
+			ws64 = oldws64;
+		} while(!__e32_atomic_cas_rel64(&iWtSt64, &oldws64, ws64));
+	if ((oldws64 ^ exp) >= TUint64(EWtStDead))
+		return KErrGeneral;	// not unblocked - no matching wait
+	if (oldws64 & EWtStTimeout)
+		CancelTimerT();
+	if (oldws64 & EWtStWaitActive)
+		{
+		NThreadBase* t = Thread();
+		if (!t->iPauseCount && !t->iSuspended)
+			t->ReadyT(0);
+		}
+	return KErrNone;
+	}
+TUint32 NThreadWaitState::ReleaseT(TAny*& aWaitObj, TInt aReturnValue)
+	{
+	TUint64 leave = EWtStDead;
+	TUint64 set = TUint64(TUint32(aReturnValue))<<32;
+	TUint64 ws64 = __e32_atomic_axo_ord64(&iWtSt64, leave, set);
+	aWaitObj = (TAny*)I64HIGH(ws64);
+	TUint32 ws32 = I64LOW(ws64);
+	if (ws32 & EWtStTimeout)
+		CancelTimerT();
+	return ws32;
+	}
+#endif
+void NThreadWaitState::SetDead(TDfc* aKillDfc)
+	{
+	TDfc syncDfc(&exit_sync_fn, aKillDfc, TheTimerQ.iDfc.iDfcQ, 0);
+	NThreadBase* t = Thread();
+	t->AcqSLock();
+	iWtC.iWtStFlags = NThreadWaitState::EWtStDead;
+	iWtC.iWtObjType = NThreadBase::EWaitNone;
+	CancelTimerT();
+	if (aKillDfc && iTimer.iNTimerSpare1)
+		{
+		// There is an outstanding timer expiry handler still running
+		// so we must synchronise with DfcThread1.
+		// Add a priority 0 DFC to DfcThread1 so this thread's exit DFC can
+		// only run after the timer expiry handler has completed.
+		aKillDfc = &syncDfc;
+		}
+	iWtC.iKillDfc = aKillDfc;
+	RescheduleNeeded();
+	t->RelSLock();
+	NKern::Unlock();	// this won't return
+	}
+void NThreadWaitState::CancelTimerT()
+	{
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nCancelTimerT ",Thread()));
+	if (iTimer.Cancel())
+		--iTimer.iNTimerSpare1;
+	else
+		{
+		// Potential race condition - timer must have completed but expiry
+		// handler has not yet run. Signal to the handler that it should do
+		// nothing by flipping the bottom bit of iTimer.iPtr
+		// This condition cannot possibly recur until the expiry handler has
+		// run since all expiry handlers run in DfcThread1.
+		volatile TLinAddr& x = *(volatile TLinAddr*)&iTimer.iPtr;
+		x ^= 1;
+		}
+	}
+// Timeout handler, called in DfcThread1
+// NOTE: aPtr is sampled with the timer queue locked, so if Cancel() on the timer fails
+// and iTimer.iPtr is then changed, aPtr here will differ from iTimer.iPtr.
+// This fact is used here to detect expiry of cancelled timers.
+void NThreadWaitState::TimerExpired(TAny* aPtr)
+	{
+	TLinAddr cookie = (TLinAddr)aPtr;
+	NThreadWaitState* pW = (NThreadWaitState*)(cookie &~ 3);
+	NThread* pT = (NThread*)pW->Thread();
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nTmExp",pT));
+	NThreadTimeoutHandler th = pT->iHandlers->iTimeoutHandler;
+	pT->LAcqSLock();
+	TUint flags = pW->iWtSt32[0];
+	if (!(flags & EWtStWaitActive) || ((flags>>8)&0xff)!=NThreadBase::EWaitBlocked)
+		th = 0;
+	if (th)
+		{
+		// Use higher level timeout handler
+		pT->RelSLockU();
+		(*th)(pT, NThreadBase::ETimeoutPreamble);
+		TInt param = NThreadBase::ETimeoutPostamble;
+		pT->LAcqSLock();
+		TLinAddr current_cookie = *(volatile TLinAddr*)&pW->iTimer.iPtr;
+		if ((cookie ^ current_cookie) & 1)
+			{
+			// The timer was cancelled just after expiring but before this function
+			// managed to acquire the thread spin lock, so it's spurious
+			param = NThreadBase::ETimeoutSpurious;
+			}
+		pT->RelSLockU();
+		(*th)(pT, param);
+		pT->LAcqSLock();
+		--pW->iTimer.iNTimerSpare1;	// note timer has expired
+		pT->RelSLockU();
+		return;
+		}
+	TLinAddr current_cookie = *(volatile TLinAddr*)&pW->iTimer.iPtr;
+	if ((cookie ^ current_cookie) & 1)
+		// The timer was cancelled just after expiring but before this function
+		// managed to acquire the thread spin lock, so just return without doing anything.
+		goto done;
+	pT->DoReleaseT(KErrTimedOut,0);
+done:
+	pT->RelSLockU();
+	}
+/******************************************************************************
+* NKern:: static functions
+******************************************************************************/
+/** Suspends the execution of a thread.
+	This function is intended to be used by the EPOC layer and personality layers.
+	Do not use this function directly on a Symbian OS thread - use Kern::ThreadSuspend().
+If the thread is in a critical section or holds a fast mutex, the suspension will
+be deferred until the thread leaves the critical section or signals the fast mutex.
+Otherwise the thread will be suspended with immediate effect. If the thread it's
+running, the execution of the thread will be suspended and a reschedule will occur.
+@param aThread Thread to be suspended.
+@param aCount  Number of times to suspend this thread.
+@return TRUE, if the thread had changed the state from non-suspended to suspended;
+	        FALSE, otherwise.
+	@see Kern::ThreadSuspend()
+*/
+EXPORT_C TBool NKern::ThreadSuspend(NThread* aThread, TInt aCount)
+	{
+	NKern::Lock();
+	TBool r=aThread->Suspend(aCount);
+	NKern::Unlock();
+	return r;
+	}
+/** Resumes the execution of a thread.
+	This function is intended to be used by the EPOC layer and personality layers.
+	Do not use this function directly on a Symbian OS thread - use Kern::ThreadResume().
+This function resumes the thread once. If the thread was suspended more than once
+the thread will remain suspended.
+If the thread is in a critical section, this function will decrease the number of
+deferred suspensions.
+@param aThread Thread to be resumed.
+@return TRUE, if the thread had changed the state from suspended to non-suspended;
+FALSE, otherwise.
+	@see Kern::ThreadResume()
+*/
+EXPORT_C TBool NKern::ThreadResume(NThread* aThread)
+	{
+	NKern::Lock();
+	TBool r=aThread->Resume();
+	NKern::Unlock();
+	return r;
+	}
+/** Resumes the execution of a thread and signals a mutex.
+	This function is intended to be used by the EPOC layer and personality layers.
+	Do not use this function directly on a Symbian OS thread - use Kern::ThreadResume().
+This function resumes the thread once. If the thread was suspended more than once
+the thread will remain suspended.
+If the thread is in a critical section, this function will decrease the number of
+deferred suspensions.
+@param aThread Thread to be resumed.
+@param aMutex Mutex to be signalled. If NULL, the scheduler's mutex will be signalled.
+@return TRUE, if the thread had changed the state from suspended to non-suspended;
+FALSE, otherwise.
+	@see Kern::ThreadResume()
+*/
+EXPORT_C TBool NKern::ThreadResume(NThread* aThread, NFastMutex* aMutex)
+	{
+	if (!aMutex)
+		aMutex=&TheScheduler.iLock;
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T NRsm + FM %M",aThread,aMutex));
+	NKern::Lock();
+	TBool r=aThread->Resume();
+	aMutex->Signal();
+	NKern::Unlock();
+	return r;
+	}
+/** Forces the execution of a thread to be resumed.
+	This function is intended to be used by the EPOC layer and personality layers.
+	Do not use this function directly on a Symbian OS thread - use Kern::ThreadResume().
+This function cancels all suspensions on a thread.
+@param aThread Thread to be resumed.
+@return TRUE, if the thread had changed the state from suspended to non-suspended;
+FALSE, otherwise.
+	@see Kern::ThreadResume()
+*/
+EXPORT_C TBool NKern::ThreadForceResume(NThread* aThread)
+	{
+	NKern::Lock();
+	TBool r=aThread->ForceResume();
+	NKern::Unlock();
+	return r;
+	}
+/** Forces the execution of a thread to be resumed and signals a mutex.
+	This function is intended to be used by the EPOC layer and personality layers.
+	Do not use this function directly on a Symbian OS thread - use Kern::ThreadResume().
+This function cancels all suspensions on a thread.
+@param aThread Thread to be resumed.
+@param aMutex Mutex to be signalled. If NULL, the scheduler's mutex will be signalled.
+@return TRUE, if the thread had changed the state from suspended to non-suspended;
+FALSE, otherwise.
+@see Kern::ThreadResume()
+*/
+EXPORT_C TBool NKern::ThreadForceResume(NThread* aThread, NFastMutex* aMutex)
+	{
+	if (!aMutex)
+		aMutex=&TheScheduler.iLock;
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T NFRsm + FM %M",aThread,aMutex));
+	NKern::Lock();
+	TBool r=aThread->ForceResume();
+	aMutex->Signal();
+	NKern::Unlock();
+	return r;
+	}
+/** Awakens a nanothread.
+	This function is used to implement synchronisation primitives in the EPOC
+	kernel (e.g. DMutex and DSemaphore) and in personality layers.  It is not
+	intended to be used directly by device drivers.
+	If the nanothread is waiting on a fast semaphore, waiting for a DFC, or is
+	blocked in a call to NKern::Block, it is awakened and put back on the ready
+	list.  Otherwise, the thread state is unchanged.  In particular, nothing
+	happens if the nanothread has been explicitly suspended.
+	@param aThread Thread to release.
+	@param aReturnValue Value returned by NKern::Block if the thread was blocked.
+	@see NKern::Block()
+	@pre Interrupts must be enabled.
+	@pre Do not call from an ISR
+*/
+EXPORT_C void NKern::ThreadRelease(NThread* aThread, TInt aReturnValue)
+	{
+	CHECK_PRECONDITIONS(MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR,"NKern::ThreadRelease(NThread*, TInt)");
+	NKern::Lock();
+	aThread->Release(aReturnValue,0);
+	NKern::Unlock();
+	}
+/** Atomically awakens a nanothread and signals a fast mutex.
+	This function is used to implement synchronisation primitives in the EPOC
+	kernel (e.g. DMutex and DSemaphore) and in personality layers.  It is not
+	intended to be used directly by device drivers.
+	@param aThread Thread to release.
+	@param aReturnValue Value returned by NKern::Block if the thread was blocked.
+	@param aMutex Fast mutex to signal. If NULL, the system lock is signalled.
+	@see NKern::ThreadRelease(NThread*, TInt)
+	@see NKern::Block()
+	@pre	Call in a thread context.
+	@pre	Interrupts must be enabled.
+	@pre	Kernel must be unlocked.
+	@pre	Specified mutex must be held
+*/
+EXPORT_C void NKern::ThreadRelease(NThread* aThread, TInt aReturnValue, NFastMutex* aMutex)
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED|MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR|MASK_NOT_IDFC,"NKern::ThreadRelease(NThread*,TInt,NFastMutex*)");
+	if (!aMutex)
+		aMutex=&TheScheduler.iLock;
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T NRel ret %d + FM %M",aThread,aReturnValue,aMutex));
+	NKern::Lock();
+	aThread->Release(aReturnValue,0);
+	aMutex->Signal();
+	NKern::Unlock();
+	}
+/** Changes the priority of a thread.
+	This function is intended to be used by the EPOC layer and personality layers.
+	Do not use this function directly on a Symbian OS thread - use Kern::ThreadSetPriority().
+@param aThread Thread to receive the new priority.
+@param aPriority New priority for aThread.
+	@see Kern::SetThreadPriority()
+*/
+EXPORT_C void NKern::ThreadSetPriority(NThread* aThread, TInt aPriority)
+	{
+	NKern::Lock();
+	aThread->SetPriority(aPriority);
+	NKern::Unlock();
+	}
+/** Changes the priority of a thread and signals a mutex.
+	This function is intended to be used by the EPOC layer and personality layers.
+	Do not use this function directly on a Symbian OS thread - use Kern::ThreadSetPriority().
+@param aThread Thread to receive the new priority.
+@param aPriority New priority for aThread.
+@param aMutex Mutex to be signalled. If NULL, the scheduler's mutex will be signalled.
+	@see Kern::SetThreadPriority()
+*/
+EXPORT_C void NKern::ThreadSetPriority(NThread* aThread, TInt aPriority, NFastMutex* aMutex)
+	{
+	if (!aMutex)
+		aMutex=&TheScheduler.iLock;
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T NSPri->%d + FM %M",aThread,aPriority,aMutex));
+	NKern::Lock();
+	aThread->SetPriority(aPriority);
+	aMutex->Signal();
+	NKern::Unlock();
+	}
+/** Atomically signals the request semaphore of a nanothread and a fast mutex.
+	This function is intended to be used by the EPOC layer and personality
+	layers.  Device drivers should use Kern::RequestComplete instead.
+	@param aThread Nanothread to signal.  Must be non NULL.
+	@param aMutex Fast mutex to signal.  If NULL, the system lock is signaled.
+	@see Kern::RequestComplete()
+	@pre	Call in a thread context.
+	@pre	Interrupts must be enabled.
+	@pre	Kernel must be unlocked.
+	@pre	Specified mutex must be held
+*/
+EXPORT_C void NKern::ThreadRequestSignal(NThread* aThread, NFastMutex* aMutex)
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED|MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR|MASK_NOT_IDFC,"NKern::ThreadRequestSignal(NThread*,NFastMutex*)");
+	if (!aMutex)
+		aMutex = &TheScheduler.iLock;
+	NKern::Lock();
+	aThread->iRequestSemaphore.Signal();
+	aMutex->Signal();
+	NKern::Unlock();
+	}
+/**	Kills a nanothread.
+	This function is intended to be used by the EPOC layer and personality layers.
+	Do not use this function directly on a Symbian OS thread - use Kern::ThreadKill().
+	This function does not return if the current thread is killed.
+	This function is asynchronous (i.e. the thread to kill may still be alive when the call returns).
+	@param aThread Thread to kill.  Must be non NULL.
+	@pre If acting on calling thread, calling thread must not be in a
+			critical section
+	@pre Thread must not already be exiting.
+	@see Kern::ThreadKill()
+*/
+EXPORT_C void NKern::ThreadKill(NThread* aThread)
+	{
+	NKern::Lock();
+	aThread->Kill();
+	NKern::Unlock();
+	}
+/**	Atomically kills a nanothread and signals a fast mutex.
+	This function is intended to be used by the EPOC layer and personality layers.
+	Do not use this function directly on a Symbian OS thread - use Kern::ThreadKill().
+	@param aThread Thread to kill.  Must be non NULL.
+	@param aMutex Fast mutex to signal.  If NULL, the system lock is signalled.
+	@pre	If acting on calling thread, calling thread must not be in a
+			critical section
+	@pre Thread must not already be exiting.
+	@see NKern::ThreadKill(NThread*)
+*/
+EXPORT_C void NKern::ThreadKill(NThread* aThread, NFastMutex* aMutex)
+	{
+	if (!aMutex)
+		aMutex = &TheScheduler.iLock;
+	NThreadBase* pC = NKern::LockC();
+	if (aThread==pC)
+		{
+		__NK_ASSERT_DEBUG(pC->iCsCount==0);	// Make sure thread isn't in critical section
+		__NK_ASSERT_ALWAYS(aMutex->HeldByCurrentThread());
+		pC->AcqSLock();
+		aThread->iCsFunction = NThreadBase::ECSExitPending;
+		pC->RelSLock();
+		aMutex->iHoldingThread = (NThreadBase*)(TLinAddr(aThread) | 1);
+		aMutex->Signal();	// this will make us exit
+		FAULT();			// should never get here
+		}
+	else
+		{
+		aThread->Kill();
+		aMutex->Signal();
+		}
+	NKern::Unlock();
+	}
+/** Enters thread critical section.
+	This function can safely be used in device drivers.
+The current thread will enter its critical section. While in critical section
+the thread cannot be suspended or killed. Any suspension or kill will be deferred
+until the thread leaves the critical section.
+Some API explicitly require threads to be in critical section before calling that
+API.
+Only User threads need to call this function as the concept of thread critical
+section applies to User threads only.
+	@pre	Call in a thread context.
+	@pre	Kernel must be unlocked.
+*/
+EXPORT_C void NKern::ThreadEnterCS()
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED|MASK_NOT_ISR|MASK_NOT_IDFC,"NKern::ThreadEnterCS");
+	NThreadBase* pC = NKern::CurrentThread();
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T NEntCS",pC));
+	__NK_ASSERT_DEBUG(pC->iCsCount>=0);
+	++pC->iCsCount;
+	}
+NThread* NKern::_ThreadEnterCS()
+	{
+	NThreadBase* pC = NKern::CurrentThread();
+	__NK_ASSERT_DEBUG(pC->iCsCount>=0);
+	++pC->iCsCount;
+	return (NThread*)pC;
+	}
+/** Leaves thread critical section.
+	This function can safely be used in device drivers.
+The current thread will leave its critical section. If the thread was suspended/killed
+while in critical section, the thread will be suspended/killed after leaving the
+critical section by calling this function.
+Only User threads need to call this function as the concept of thread critical
+section applies to User threads only.
+	@pre	Call in a thread context.
+	@pre	Kernel must be unlocked.
+*/
+EXPORT_C void NKern::ThreadLeaveCS()
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED|MASK_NOT_ISR|MASK_NOT_IDFC,"NKern::ThreadLeaveCS");
+	NThreadBase* pC = NKern::LockC();
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T NLvCS",pC));
+	pC->AcqSLock();
+	__NK_ASSERT_DEBUG(pC->iCsCount>0);
+	if (--pC->iCsCount==0 && pC->iCsFunction!=0)
+		{
+		NFastMutex* m = HeldFastMutex();
+		if (m)
+			m->iHoldingThread = (NThreadBase*)(TLinAddr(pC) | 1);
+		else
+			pC->DoCsFunctionT();
+		}
+	pC->RelSLock();
+	NKern::Unlock();
+	}
+void NKern::_ThreadLeaveCS()
+	{
+	NThreadBase* pC = NKern::LockC();
+	pC->AcqSLock();
+	__NK_ASSERT_DEBUG(pC->iCsCount>0);
+	if (--pC->iCsCount==0 && pC->iCsFunction!=0)
+		{
+		NFastMutex* m = HeldFastMutex();
+		if (m)
+			m->iHoldingThread = (NThreadBase*)(TLinAddr(pC) | 1);
+		else
+			pC->DoCsFunctionT();
+		}
+	pC->RelSLock();
+	NKern::Unlock();
+	}
+/** Freeze the CPU of the current thread
+	After this the current thread will not migrate to another processor
+	@return	A cookie to be passed to NKern::EndFreezeCpu() to allow nesting
+*/
+EXPORT_C TInt NKern::FreezeCpu()
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED|MASK_NOT_ISR|MASK_NOT_IDFC,"NKern::FreezeCpu");
+	NKern::Lock();
+	TSubScheduler& ss = SubScheduler();
+	NThreadBase* pC = ss.iCurrentThread;
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T NFrzCpu",pC));
+	if (pC->iFreezeCpu)
+		{
+		NKern::Unlock();
+		return 1;
+		}
+	pC->iFreezeCpu = 1;
+	if (pC->iParent != pC)
+		{
+		pC->AcqSLock();
+		++pC->iParent->iFreezeCpu;
+		pC->RelSLock();
+		}
+	NKern::Unlock();
+	return 0;
+	}
+/** Unfreeze the current thread's CPU
+	After this the current thread will again be eligible to migrate to another processor
+	@param	aCookie the value returned by NKern::FreezeCpu()
+*/
+EXPORT_C void NKern::EndFreezeCpu(TInt aCookie)
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED|MASK_NOT_ISR|MASK_NOT_IDFC,"NKern::EndFreezeCpu");
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T NEndFrz %d",NKern::CurrentThread(),aCookie));
+	if (aCookie)
+		return;
+	NKern::Lock();
+	TSubScheduler& ss = SubScheduler();
+	NThreadBase* pC = ss.iCurrentThread;
+	if (pC->iFreezeCpu)
+		{
+		pC->iFreezeCpu = 0;
+		mb();
+		if (pC->iParent != pC)
+			{
+			pC->AcqSLock();
+			if (!--pC->iParent->iFreezeCpu && pC->iParent->iCpuChange)
+				RescheduleNeeded();
+			pC->RelSLock();
+			}
+		else if (pC->iCpuChange)		// deferred CPU change?
+			RescheduleNeeded();
+		}
+	NKern::Unlock();
+	}
+/** Change the CPU affinity of a thread
+	@pre	Call in a thread context.
+	@param	The new CPU affinity mask
+	@return The old affinity mask
+*/
+EXPORT_C TUint32 NKern::ThreadSetCpuAffinity(NThread* aThread, TUint32 aAffinity)
+	{
+	NKern::Lock();
+	TUint32 r = aThread->SetCpuAffinity(aAffinity);
+	NKern::Unlock();
+	return r;
+	}
+/** Modify a thread's timeslice
+	@pre	Call in a thread context.
+	@param	aTimeslice	The new timeslice value
+*/
+EXPORT_C void NKern::ThreadSetTimeslice(NThread* aThread, TInt aTimeslice)
+	{
+	NKern::Lock();
+	aThread->AcqSLock();
+	if (aThread->iTimeslice == aThread->iTime || aTimeslice<0)
+		aThread->iTime = aTimeslice;
+	aThread->iTimeslice = aTimeslice;
+	aThread->RelSLock();
+	NKern::Unlock();
+	}
+/** Blocks current nanothread.
+	This function is used to implement synchronisation primitives in the EPOC
+	layer and in personality layers.  It is not intended to be used directly by
+	device drivers.
+	@param aTimeout If greater than 0, the nanothread will be blocked for at most
+					aTimeout microseconds.
+	@param aMode	Bitmask whose possible values are documented in TBlockMode.
+	@param aMutex	Fast mutex to operate on.  If NULL, the system lock is used.
+	@see NKern::ThreadRelease()
+	@see TBlockMode
+	@pre	Call in a thread context.
+	@pre	Interrupts must be enabled.
+	@pre	Kernel must be unlocked.
+	@pre	Specified mutex must be held
+*/
+EXPORT_C TInt NKern::Block(TUint32 aTimeout, TUint aMode, NFastMutex* aMutex)
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED|MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR|MASK_NOT_IDFC,"NKern::Block(TUint32,TUint,NFastMutex*)");
+	if (!aMutex)
+		aMutex = &TheScheduler.iLock;
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("NKern::Block time %d mode %d FM %M",aTimeout,aMode,aMutex));
+	if (aMode & EEnterCS)
+		NKern::_ThreadEnterCS();	// NOTE: MUST DO THIS BEFORE CALLING NKern::Lock()
+	NThreadBase* pC = NKern::LockC();
+	TUint flags = (aMode & NKern::EObstruct) ? NThreadWaitState::EWtStObstructed : 0;
+	pC->iWaitState.SetUpWait(NThreadBase::EWaitBlocked, flags, 0, aTimeout);
+	if (aMode & ERelease)
+		aMutex->Signal();
+	RescheduleNeeded();
+	NKern::Unlock();	// thread blocks here
+	TInt r = pC->iWaitState.iWtC.iRetVal;	// sample here since it will be overwritten if we block on the fast mutex
+	if (aMode & EClaim)
+		FMWait(aMutex);
+	return r;
+	}
+/**
+@pre	Call in a thread context.
+@pre	Interrupts must be enabled.
+@pre	Kernel must be unlocked.
+@pre	No fast mutex can be held
+*/
+/** @see NKern::Block(TUint32, TUint, NFastMutex*) */
+EXPORT_C TInt NKern::Block(TUint32 aTimeout, TUint aMode)
+	{
+	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"NKern::Block(TUint32,TUint)");
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("NKern::Block time %d mode %d",aTimeout,aMode));
+	if (aMode & EEnterCS)
+		NKern::_ThreadEnterCS();	// NOTE: MUST DO THIS BEFORE CALLING NKern::Lock()
+	NThreadBase* pC = NKern::LockC();
+	TUint flags = (aMode & NKern::EObstruct) ? NThreadWaitState::EWtStObstructed : 0;
+	pC->iWaitState.SetUpWait(NThreadBase::EWaitBlocked, flags, 0, aTimeout);
+	RescheduleNeeded();
+	NKern::Unlock();	// thread blocks here
+	return pC->iWaitState.iWtC.iRetVal;
+	}
+/**
+Places the current nanothread into a wait state on an externally
+defined wait object.
+For use by RTOS personality layers.
+Do not use this function directly on a Symbian OS thread.
+Since the kernel is locked on entry, any reschedule will be deferred until
+it is unlocked. The thread should be added to any necessary wait queue after
+a call to this function, since this function removes it from the ready list.
+The thread's wait timer is started if aTimeout is nonzero.
+The thread's NState and wait object are updated.
+Call NThreadBase::Release() when the wait condition is resolved.
+@param aTimeout The maximum time for which the thread should block, in nanokernel timer ticks.
+A zero value means wait forever.
+If the thread is still blocked when the timeout expires,
+then the timeout state handler will be called.
+@param aState   The nanokernel thread state (N-State) value to be set.
+This state corresponds to the externally defined wait object.
+This value will be written into the member NThreadBase::iNState.
+@param aWaitObj A pointer to an externally defined wait object.
+This value will be written into the member NThreadBase::iWaitObj.
+@pre	Kernel must be locked.
+@pre	Call in a thread context.
+@post	Kernel is locked.
+@see	NThreadBase::Release()
+*/
+EXPORT_C void NKern::NanoBlock(TUint32 aTimeout, TUint aState, TAny* aWaitObj)
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR|MASK_NOT_IDFC,"NKern::NanoBlock");
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("NanoBlock time %d state %d obj %08x", aTimeout, aState, aWaitObj));
+	NThreadBase* pC = NCurrentThreadL();
+	pC->iWaitState.SetUpWait(aState, aState>>8, aWaitObj, aTimeout);
+	RescheduleNeeded();
+	}
+EXPORT_C void NKern::Sleep(TUint32 aTime)
+/**
+Puts the current nanothread to sleep for the specified duration.
+It can be called from Symbian OS threads.
+@param	aTime sleep time in nanokernel timer ticks.
+@pre    No fast mutex can be held.
+@pre    Kernel must be unlocked.
+@pre	Call in a thread context.
+@pre	Interrupts must be enabled.
+*/
+	{
+	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"NKern::Sleep");
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("NSlp %d",aTime));
+	NThreadBase* pC = NKern::LockC();
+	pC->iWaitState.SetUpWait(NThreadBase::EWaitSleep, 0, 0, aTime);
+	RescheduleNeeded();
+	NKern::Unlock();
+	}
+/**	Terminates the current nanothread.
+	Calls to this function never return.
+	For use by RTOS personality layers.
+	Do not use this function directly on a Symbian OS thread.
+	@pre	Call in a thread context.
+	@pre	Interrupts must be enabled.
+	@pre	Kernel must be unlocked.
+*/
+EXPORT_C void NKern::Exit()
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED|MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR|MASK_NOT_IDFC,"NKern::Exit");
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("NExit"));
+	NKern::LockC()->Exit();		// this won't return
+	FAULT();
+	}
+/**	Terminates the current nanothread at the next possible point.
+	If the calling thread is not currently in a critical section and does not
+	currently hold a fast mutex, it exits immediately and this function does
+	not return. On the other hand if the thread is in a critical section or
+	holds a fast mutex the thread continues executing but it will exit as soon
+	as it leaves the critical section and/or releases the fast mutex.
+	@pre	Call in a thread context.
+	@pre	Interrupts must be enabled.
+	@pre	Kernel must be unlocked.
+*/
+EXPORT_C void NKern::DeferredExit()
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED|MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR|MASK_NOT_IDFC,"NKern::DeferredExit");
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("NDefExit"));
+	NFastMutex* m = HeldFastMutex();
+	NThreadBase* pC = NKern::LockC();
+	if (!m && !pC->iCsCount)
+		pC->Exit();			// this won't return
+	pC->AcqSLock();
+	if (pC->iCsFunction >= 0)	// don't touch it if we are already exiting
+		pC->iCsFunction = NThreadBase::ECSExitPending;
+	pC->RelSLock();
+	if (m && !pC->iCsCount)
+		m->iHoldingThread = (NThreadBase*)(TLinAddr(pC) | 1);
+	NKern::Unlock();
+	}
+/** Prematurely terminates the current thread's timeslice
+	@pre	Kernel must be unlocked.
+	@pre	Call in a thread context.
+	@post	Kernel is unlocked.
+*/
+EXPORT_C void NKern::YieldTimeslice()
+	{
+	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED|MASK_NOT_ISR|MASK_NOT_IDFC,"NKern::YieldTimeslice");
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("NKern::YieldTimeslice"));
+	NThreadBase* t = NKern::LockC();
+	t->iTime = 0;
+	mb();
+	if (t->iNext!=t || t->iParent->iNext!=t->iParent)
+		RescheduleNeeded();
+	NKern::Unlock();
+	}
+/** Returns the number of CPUs available to Symbian OS
+	@return the number of CPUs
+	@pre Call in any context.
+*/
+EXPORT_C TInt NKern::NumberOfCpus()
+	{
+	return TheScheduler.iNumCpus;
+	}
+/** Rotates the specified CPU ready list for threads at the specified priority.
+	For use by RTOS personality layers to allow external control of round-robin
+	scheduling. Not intended for direct use by device drivers.
+	@param	aPriority = priority at which threads should be rotated.
+						-1 means use calling thread's priority.
+	@param	aCpu		CPU to act on
+	@pre	Kernel must be unlocked.
+	@pre	Call in a thread context.
+	@post	Kernel is unlocked.
+*/
+EXPORT_C void NKern::RotateReadyList(TInt aPriority, TInt aCpu)
+	{
+//	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED|MASK_NOT_ISR|MASK_NOT_IDFC,"NKern::RotateReadyList");
+//	__KTRACE_OPT(KNKERN,DEBUGPRINT("NKern::RotateReadyList %d",aPriority));
+//	if (aPriority<0 || aPriority>=KNumPriorities)
+//		aPriority=NKern::CurrentThread()->iPriority;
+//	NKern::Lock();
+//	TheScheduler.RotateReadyList(aPriority);
+//	NKern::Unlock();
+	}
+/** Rotates the ready list for threads at the specified priority.
+	For use by RTOS personality layers to allow external control of round-robin
+	scheduling. Not intended for direct use by device drivers.
+	@param	aPriority = priority at which threads should be rotated.
+						-1 means use calling thread's priority.
+	@pre	Kernel must be unlocked.
+	@pre	Call in a thread context.
+	@post	Kernel is unlocked.
+*/
+EXPORT_C void NKern::RotateReadyList(TInt aPriority)
+	{
+	RotateReadyList(aPriority, -1);
+	}
+/** Returns a pointer to the thread group to which the current thread belongs,
+	if any.	Returns NULL if current thread is a standalone thread.
+	@pre	Call in a thread context.
+*/
+EXPORT_C NThreadGroup* NKern::CurrentGroup()
+	{
+	NThreadBase* pC = NKern::CurrentThread();
+	return (pC->iParent == pC) ? (NThreadGroup*)0 : (NThreadGroup*)pC->iParent;
+	}
+/** Detaches the current thread from the group to which it currently belongs,
+	if any.	Returns a pointer to the group (NULL if none).
+	@pre	Call in a thread context.
+	@pre	Interrupts enabled
+	@pre	Kernel unlocked
+*/
+EXPORT_C NThreadGroup* NKern::LeaveGroup()
+	{
+	CHECK_PRECONDITIONS(MASK_NOT_ISR|MASK_NOT_IDFC|MASK_INTERRUPTS_ENABLED|MASK_KERNEL_UNLOCKED, "NKern::LeaveGroup");
+	NKern::Lock();
+	TSubScheduler& ss = SubScheduler();
+	NThreadBase* pC = ss.iCurrentThread;
+	pC->iNewParent = 0;	// cancel any pending Join
+	NThreadGroup* g = (pC->iParent == pC) ? (NThreadGroup*)0 : (NThreadGroup*)pC->iParent;
+	TBool make_group_ready = FALSE;
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("NLeaveGroup %T (%G)",pC,g));
+	if (g)
+		{
+		while (!pC->TiedEventLeaveInterlock())
+			{
+			TInt irq = NKern::DisableAllInterrupts();
+			ss.QueueDfcs();
+			NKern::RestoreInterrupts(irq);
+			}
+		pC->AcqSLock();
+		ss.iReadyListLock.LockOnly();
+		pC->UnReadyT();
+		pC->iParent = pC;
+		g->iCurrent = 0;	// since current thread is no longer in g
+		ss.AddHead(pC);
+		pC->iReady = TUint8(ss.iCpuNum | NSchedulable::EReadyOffset);
+		pC->iCpuAffinity = g->iCpuAffinity;	// keep same CPU affinity
+		// if we're frozen, the group's freeze count was incremented
+		if (pC->iFreezeCpu)
+			--g->iFreezeCpu;
+		// if we've been marked as deferring, the group's freeze count was incremented
+		if (pC->iFastMutexDefer == 1)
+			{
+			--g->iFreezeCpu;
+			pC->iFastMutexDefer = 0;
+			}
+		// if the group was waiting to change cpu then this thread needs to change still
+		if (g->iCpuChange)
+			{
+			pC->iCpuChange = g->iCpuChange;
+			RescheduleNeeded();
+			if (!g->iFreezeCpu)
+				{
+				// we were the last thread in the group stopping it from moving
+				// but there may be no other threads left after UnReadyT'ing this one
+				g->iCpuChange = FALSE;
+				if (g->iReady)
+					{
+					ss.Remove(g);
+					g->iReady = 0;
+					make_group_ready = TRUE;
+					}
+				}
+			}
+		ss.iReadyListLock.UnlockOnly();
+		--g->iThreadCount;
+		if (make_group_ready)
+			g->ReadyT(0);
+		g->RelSLock();		// since pC is no longer attached to g
+		pC->RelSLock();
+		}
+	NKern::Unlock();
+	return g;
+	}
+/** Adds the current thread to the specified group.
+	@param	aGroup = pointer to group to join
+	@pre	Call in a thread context, not in one of the idle threads.
+	@pre	Interrupts enabled
+	@pre	Kernel unlocked
+	@pre	Thread does not hold a fast mutex
+	@pre	Thread does not have a freeze on CPU migration
+	@pre	Current thread is not already in a group
+*/
+EXPORT_C void NKern::JoinGroup(NThreadGroup* aGroup)
+	{
+	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD, "NKern::JoinGroup");
+	NKern::Lock();
+	TSubScheduler& ss = SubScheduler();
+	NThreadBase* pC = ss.iCurrentThread;
+	__ASSERT_WITH_MESSAGE_DEBUG(pC->iParent==pC, "Thread not already in a group", "NKern::JoinGroup");
+	__ASSERT_WITH_MESSAGE_DEBUG(!pC->iFreezeCpu, "No interdiction on CPU migration", "NKern::JoinGroup");
+	__ASSERT_WITH_MESSAGE_DEBUG(!pC->i_NThread_Initial, "Not idle thread", "NKern::JoinGroup");
+	__NK_ASSERT_ALWAYS(pC->iParent==pC && !pC->iFreezeCpu);
+	__KTRACE_OPT(KNKERN,DEBUGPRINT("NJoinGroup %T->%G",pC,aGroup));
+	pC->AcqSLock();
+	aGroup->AcqSLock();
+	TBool migrate = !CheckCpuAgainstAffinity(ss.iCpuNum, aGroup->iCpuAffinity);	// TRUE if thread's current CPU is incompatible with the group's affinity
+	if (!aGroup->iReady || aGroup->iReady==pC->iReady)
+		{
+		// group not ready or ready on this CPU
+		if (!migrate)
+			{
+			ss.iReadyListLock.LockOnly();
+			pC->UnReadyT();
+			pC->iParent = aGroup;
+			aGroup->iNThreadList.AddHead(pC);
+			if (!aGroup->iReady)
+				{
+				aGroup->iPriority = pC->iPriority;
+				ss.AddHead(aGroup);
+				aGroup->iReady = TUint8(ss.iCpuNum | NSchedulable::EReadyOffset);
+				}
+			else if (pC->iPriority > aGroup->iPriority)
+				{
+				ss.ChangePriority(aGroup, pC->iPriority);
+				}
+			pC->iReady = NSchedulable::EReadyGroup;
+			aGroup->iCurrent = aGroup->iReady;
+			ss.iReadyListLock.UnlockOnly();
+			++aGroup->iThreadCount;
+			goto done;
+			}
+		}
+	// this thread needs to migrate to another CPU
+	pC->iNewParent = aGroup;
+	RescheduleNeeded();
+	// the following reschedule definitely joins the group even if the
+	// thread's CPU affinity is incompatible with that of the group
+	// (the thread's CPU affinity is subsequently determined by that of
+	// the group)
+done:
+	if (pC->iParent != aGroup)
+		aGroup->RelSLock();
+	pC->RelSLock();
+	while (!pC->TiedEventJoinInterlock())
+		{
+		TInt irq = NKern::DisableAllInterrupts();
+		ss.QueueDfcs();
+		NKern::RestoreInterrupts(irq);
+		}
+	NKern::Unlock();
+	}
+/******************************************************************************
+* Priority Lists
+******************************************************************************/
+#ifndef __PRI_LIST_MACHINE_CODED__
+/** Returns the priority of the highest priority item present on a priority list.
+	@return	The highest priority present or -1 if the list is empty.
+*/
+EXPORT_C TInt TPriListBase::HighestPriority()
+	{
+//	TUint64 present = MAKE_TUINT64(iPresent[1], iPresent[0]);
+//	return __e32_find_ms1_64(present);
+	return __e32_find_ms1_64(iPresent64);
+	}
+/** Finds the highest priority item present on a priority list.
+	If multiple items at the same priority are present, return the first to be
+	added in chronological order.
+	@return	A pointer to the item or NULL if the list is empty.
+*/
+EXPORT_C TPriListLink* TPriListBase::First()
+	{
+	TInt p = HighestPriority();
+	return p >=0 ? static_cast<TPriListLink*>(iQueue[p]) : NULL;
+	}
+/** Adds an item to a priority list at the tail of the queue for its priority.
+	@param aLink A pointer to the item - must not be NULL.
+*/
+EXPORT_C void TPriListBase::Add(TPriListLink* aLink)
+	{
+	TInt p = aLink->iPriority;
+	SDblQueLink* head = iQueue[p];
+	if (head)
+		{
+		// already some at this priority
+		aLink->InsertBefore(head);
+		}
+	else
+		{
+		// 'create' new list
+		iQueue[p] = aLink;
+		aLink->iNext = aLink->iPrev = aLink;
+		iPresent[p>>5] |= 1u << (p & 0x1f);
+		}
+	}
+/** Removes an item from a priority list.
+	@param aLink A pointer to the item - must not be NULL.
+*/
+EXPORT_C void TPriListBase::Remove(TPriListLink* aLink)
+	{
+	if (!aLink->Alone())
+		{
+		// not the last on this list
+		TInt p = aLink->iPriority;
+		if (iQueue[p] == aLink)
+			iQueue[p] = aLink->iNext;
+		aLink->Deque();
+		}
+	else
+		{
+		TInt p = aLink->iPriority;
+		iQueue[p] = 0;
+		iPresent[p>>5] &= ~(1u << (p & 0x1f));
+		KILL_LINK(aLink);
+		}
+	}
+/** Changes the priority of an item on a priority list.
+	@param	aLink A pointer to the item to act on - must not be NULL.
+	@param	aNewPriority A new priority for the item.
+*/
+EXPORT_C void TPriListBase::ChangePriority(TPriListLink* aLink, TInt aNewPriority)
+	{
+	if (aLink->iPriority!=aNewPriority)
+		{
+		Remove(aLink);
+		aLink->iPriority=TUint8(aNewPriority);
+		Add(aLink);
+		}
+	}
+#endif
+/** Adds an item to a priority list at the head of the queue for its priority.
+	@param aLink A pointer to the item - must not be NULL.
+*/
+EXPORT_C void TPriListBase::AddHead(TPriListLink* aLink)
+	{
+	TInt p = aLink->iPriority;
+	SDblQueLink* head = iQueue[p];
+	iQueue[p] = aLink;
+	if (head)
+		{
+		// already some at this priority
+		aLink->InsertBefore(head);
+		}
+	else
+		{
+		// 'create' new list
+		aLink->iNext = aLink->iPrev = aLink;
+		iPresent[p>>5] |= 1u << (p & 0x1f);
+		}
+	}
+/******************************************************************************
+* Generic IPIs
+******************************************************************************/
+TGenIPIList::TGenIPIList()
+	:	iGenIPILock(TSpinLock::EOrderGenericIPIList)
+	{
+	}
+TGenIPIList GenIPIList;
+extern "C" {
+extern void send_generic_ipis(TUint32);
+void generic_ipi_isr(TSubScheduler* aS)
+	{
+	TGenericIPI* ipi = aS->iNextIPI;
+	if (!ipi)
+		return;
+	TUint32 m = aS->iCpuMask;
+	SDblQueLink* anchor = &GenIPIList.iA;
+	while (ipi != anchor)
+		{
+		__e32_atomic_and_acq32(&ipi->iCpusIn, ~m);
+		(*ipi->iFunc)(ipi);
+		TInt irq = GenIPIList.iGenIPILock.LockIrqSave();
+		TGenericIPI* n = (TGenericIPI*)ipi->iNext;
+		ipi->iCpusOut &= ~m;
+		if (ipi->iCpusOut == 0)
+			{
+			ipi->Deque();
+			mb();
+			ipi->iNext = 0;
+			}
+		ipi = n;
+		while (ipi!=anchor && !(ipi->iCpusIn & m))
+			ipi = (TGenericIPI*)ipi->iNext;
+		if (ipi == anchor)
+			aS->iNextIPI = 0;
+		GenIPIList.iGenIPILock.UnlockIrqRestore(irq);
+		}
+	}
+}
+void TGenericIPI::Queue(TGenericIPIFn aFunc, TUint32 aCpuMask)
+	{
+	__KTRACE_OPT(KSCHED2,DEBUGPRINT("GenIPI F=%08x M=%08x", aFunc, aCpuMask));
+	iFunc = aFunc;
+	TScheduler& s = TheScheduler;
+	TInt i;
+	TUint32 ipis = 0;
+	TInt irq = GenIPIList.iGenIPILock.LockIrqSave();
+	if (aCpuMask & 0x80000000u)
+		{
+		if (aCpuMask==0xffffffffu)
+			aCpuMask = s.iActiveCpus2;
+		else if (aCpuMask==0xfffffffeu)
+			aCpuMask = s.iActiveCpus2 &~ SubScheduler().iCpuMask;
+		else
+			aCpuMask = 0;
+		}
+	iCpusIn = aCpuMask;
+	iCpusOut = aCpuMask;
+	if (!aCpuMask)
+		{
+		GenIPIList.iGenIPILock.UnlockIrqRestore(irq);
+		iNext = 0;
+		return;
+		}
+	GenIPIList.Add(this);
+	for (i=0; i<s.iNumCpus; ++i)
+		{
+		if (!(aCpuMask & (1<<i)))
+			continue;
+		TSubScheduler& ss = *s.iSub[i];
+		if (!ss.iNextIPI)
+			{
+			ss.iNextIPI = this;
+			ipis |= (1<<i);
+			}
+		}
+	send_generic_ipis(ipis);
+	GenIPIList.iGenIPILock.UnlockIrqRestore(irq);
+	__KTRACE_OPT(KSCHED2,DEBUGPRINT("GenIPI ipis=%08x", ipis));
+	}
+void TGenericIPI::QueueAll(TGenericIPIFn aFunc)
+	{
+	Queue(aFunc, 0xffffffffu);
+	}
+void TGenericIPI::QueueAllOther(TGenericIPIFn aFunc)
+	{
+	Queue(aFunc, 0xfffffffeu);
+	}
+// Call from thread or IDFC with interrupts enabled
+void TGenericIPI::WaitEntry()
+	{
+	CHECK_PRECONDITIONS(MASK_NOT_ISR|MASK_INTERRUPTS_ENABLED,"TGenericIPI::WaitEntry");
+	while (iCpusIn)
+		{
+		__chill();
+		}
+	mb();
+	}
+// Call from thread or IDFC with interrupts enabled
+void TGenericIPI::WaitCompletion()
+	{
+	CHECK_PRECONDITIONS(MASK_NOT_ISR|MASK_INTERRUPTS_ENABLED,"TGenericIPI::WaitCompletion");
+	volatile TInt* p = (volatile TInt*)&iNext;
+	while (*p)
+		{
+		__chill();
+		}
+	mb();
+	}
+/**	Stop all other CPUs
+	Call with kernel locked
+*/
+void TStopIPI::StopCPUs()
+	{
+	iFlag = 0;
+	QueueAllOther(&Isr);	// send IPIs to all other CPUs
+	WaitEntry();			// wait for other CPUs to reach the ISR
+	}
+void TStopIPI::ReleaseCPUs()
+	{
+	iFlag = 1;				// allow other CPUs to proceed
+	WaitCompletion();		// wait for them to finish with this IPI
+	}
+void TStopIPI::Isr(TGenericIPI* a)
+	{
+	TStopIPI* s = (TStopIPI*)a;
+	while (!s->iFlag)
+		{
+		__chill();
+		}
+	}

changeset 0	a41df078684a
child 43	c1f20ce4abcf