// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32\nkern\nkern.cpp

// 

//

// NThreadBase member data

#define __INCLUDE_NTHREADBASE_DEFINES__

#include "nk_priv.h"

/******************************************************************************

 * Fast mutex

 ******************************************************************************/

/** Checks if the current thread holds this fast mutex

	@return TRUE if the current thread holds this fast mutex

	@return FALSE if not

*/

EXPORT_C TBool NFastMutex::HeldByCurrentThread()

	{

	return iHoldingThread == NCurrentThread();

	}

/** Find the fast mutex held by the current thread

	@return a pointer to the fast mutex held by the current thread

	@return NULL if the current thread does not hold a fast mutex

*/

EXPORT_C NFastMutex* NKern::HeldFastMutex()

	{

	return TheScheduler.iCurrentThread->iHeldFastMutex;

	}

#ifndef __FAST_MUTEX_MACHINE_CODED__

/** 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()

	{

	__KTRACE_OPT(KNKERN,DEBUGPRINT("FMWait %M",this));

	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED_ONCE|MASK_NO_FAST_MUTEX,"NFastMutex::Wait");			

	NThreadBase* pC=TheScheduler.iCurrentThread;

	if (iHoldingThread)

		{

		iWaiting=1;

		pC->iWaitFastMutex=this;

		__KTRACE_OPT(KNKERN,DEBUGPRINT("FMWait: YieldTo %T",iHoldingThread));

		TheScheduler.YieldTo(iHoldingThread);	// returns with kernel unlocked, interrupts disabled

		TheScheduler.iKernCSLocked = 1;	// relock kernel

		NKern::EnableAllInterrupts();

		pC->iWaitFastMutex=NULL;

		}

	pC->iHeldFastMutex=this;		// automatically puts thread into critical section

#ifdef BTRACE_FAST_MUTEX

	BTraceContext4(BTrace::EFastMutex,BTrace::EFastMutexWait,this);

#endif

	iHoldingThread=pC;

	}

/** 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()

	{

	__KTRACE_OPT(KNKERN,DEBUGPRINT("FMSignal %M",this));

	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED,"NFastMutex::Signal");			

	NThreadBase* pC=TheScheduler.iCurrentThread;

	__ASSERT_WITH_MESSAGE_DEBUG(pC->iHeldFastMutex==this,"The calling thread holds the mutex","NFastMutex::Signal");

#ifdef BTRACE_FAST_MUTEX

	BTraceContext4(BTrace::EFastMutex,BTrace::EFastMutexSignal,this);

#endif

	iHoldingThread=NULL;

	pC->iHeldFastMutex=NULL;

	TBool w=iWaiting;

	iWaiting=0;

	if (w)

		{

		RescheduleNeeded();

		if (pC->iCsFunction && !pC->iCsCount)

			pC->DoCsFunction();

		}

	}

/** 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)

	{

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"NKern::FMWait");

	NKern::Lock();

	aMutex->Wait();

	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)

	{

	NKern::Lock();

	aMutex->Signal();

	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()

	{

	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"NKern::LockSystem");

	NKern::Lock();

	TheScheduler.iLock.Wait();

	NKern::Unlock();

	}

/** Releases the System Lock.

	@pre System lock must be held.

	@see NKern::LockSystem()

	@see NKern::FMSignal()

*/

EXPORT_C void NKern::UnlockSystem()

	{

	NKern::Lock();

	TheScheduler.iLock.Signal();

	NKern::Unlock();

	}

/** 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)

	{

	__ASSERT_WITH_MESSAGE_DEBUG(aM->HeldByCurrentThread(),"The calling thread holds the mutex","NKern::FMFlash");

	TBool w = aM->iWaiting;

	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()

	{

	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 = TheScheduler.iCurrentThread;

	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 sempahore 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=TheScheduler.iCurrentThread;

	__ASSERT_WITH_MESSAGE_ALWAYS(pC==iOwningThread,"The calling thread must own the semaphore","NFastSemaphore::Wait");

	if (--iCount<0)

		{

		pC->iNState=NThread::EWaitFastSemaphore;

		pC->iWaitObj=this;

		TheScheduler.Remove(pC);

		RescheduleNeeded();

		}

	}

/** 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");			

	if (++iCount<=0)

		{

		iOwningThread->iWaitObj=NULL;

		iOwningThread->CheckSuspendThenReady();

		}

	}

/** 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 && iCount<0)

		{

		iOwningThread->iWaitObj=NULL;

		iOwningThread->CheckSuspendThenReady();

		}

	iCount+=aCount;

	}

/** 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");			

	if (iCount<0)

		{

		iOwningThread->iWaitObj=NULL;

		iOwningThread->CheckSuspendThenReady();

		}

	iCount=0;

	}

/** 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()

	{

	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NFastSemaphore::WaitCancel");			

	iCount=0;

	iOwningThread->iWaitObj=NULL;

	iOwningThread->CheckSuspendThenReady();

	}

/** 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* pC=TheScheduler.iCurrentThread;

	NKern::Lock();

	pC->iRequestSemaphore.Wait();

	NKern::Unlock();

	}

#endif

/** 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();

	}

/** Waits on a fast semaphore.

    Decrements the signal count for the semaphore

	and waits for a signal if the sempahore 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("NKern::FSWait %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 semphore 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("NKern::FSSignal %m",aSem));

	NKern::Lock();

	aSem->Signal();

	NKern::Unlock();

	}

/** 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("NKern::FSSignal %m +FM %M",aSem,aMutex));

	NKern::Lock();

	aSem->Signal();

	aMutex->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("NKern::FSSignalN %m %d",aSem,aCount));

	NKern::Lock();

	aSem->SignalN(aCount);

	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("NKern::FSSignalN %m %d + FM %M",aSem,aCount,aMutex));

	NKern::Lock();

	aSem->SignalN(aCount);

	aMutex->Signal();

	NKern::Unlock();

	}

/******************************************************************************

 * Thread

 ******************************************************************************/

#ifndef __SCHEDULER_MACHINE_CODED__

/** Makes a nanothread ready provided that it is not explicitly suspended.

	For use by RTOS personality layers.

	@pre	Kernel must be locked.

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

	@post	Kernel is locked.

 */

EXPORT_C void NThreadBase::CheckSuspendThenReady()

	{

	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NThreadBase::CheckSuspendThenReady");	

	if (iSuspendCount==0)

		Ready();

	else

		iNState=ESuspended;

	}

/** Makes a nanothread ready.

	For use by RTOS personality layers.

	@pre	Kernel must be locked.

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

	@pre	The thread being made ready must not be explicitly suspended

	@post	Kernel is locked.

 */

EXPORT_C void NThreadBase::Ready()

	{

#ifdef _DEBUG

	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NThreadBase::Ready");	

	__ASSERT_WITH_MESSAGE_DEBUG(iSuspendCount==0,"The thread being made ready must not be explicitly suspended","NThreadBase::Ready");

	if (DEBUGNUM(KCRAZYSCHEDDELAY) && iPriority && TheTimerQ.iMsCount)

		{

		// Delay this thread, unless it's already on the delayed queue

		if ((i_ThrdAttr & KThreadAttDelayed) == 0)

			{

			i_ThrdAttr |= KThreadAttDelayed;

			TheScheduler.iDelayedQ.Add(this);

			}

		}

	else

		{

		// Delayed scheduler off

		// or idle thread, or the tick hasn't started yet

		DoReady();

		}

#else

	DoReady();

#endif

	}

void NThreadBase::DoReady()

	{

	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NThreadBase::DoReady");	

	__ASSERT_WITH_MESSAGE_DEBUG(iSuspendCount==0,"The thread being made ready must not be explicitly suspended","NThreadBase::DoReady");

	TScheduler& s=TheScheduler;

	TInt p=iPriority;

//	__KTRACE_OPT(KSCHED,Kern::Printf("Ready(%O), priority %d status %d",this,p,iStatus));

	if (iNState==EDead)

		return;

	s.Add(this);

	iNState=EReady;

	if (!(s>p))	// s>p <=> highest ready priority > our priority so no preemption

		{

		// if no other thread at this priority or first thread at this priority has used its timeslice, reschedule

		// note iNext points to first thread at this priority since we got added to the end

		if (iNext==this || ((NThreadBase*)iNext)->iTime==0)

			RescheduleNeeded();

		}

	}

#endif

void NThreadBase::DoCsFunction()

	{

	__KTRACE_OPT(KNKERN,DEBUGPRINT("NThreadBase::DoCsFunction %T %d",this,iCsFunction));

	TInt f=iCsFunction;

	iCsFunction=0;

	if (f>0)

		{

		// suspend this thread f times

		Suspend(f);

		return;

		}

	if (f==ECSExitPending)

		{

		// We need to exit now

		Exit();	// this won't return

		}

	UnknownState(ELeaveCS,f);	// call into RTOS personality

	}

/** 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");		

	// If thread is executing a critical section, we must defer the suspend

	if (iNState==EDead)

		return FALSE;		// already dead so suspension is a no-op

	if (iCsCount || iHeldFastMutex)

		{

		__KTRACE_OPT(KNKERN,DEBUGPRINT("NThreadBase::Suspend %T (CSF %d) %d",this,iCsFunction,aCount));

		if (iCsFunction>=0)			// -ve means thread is about to exit

			{

			iCsFunction+=aCount;	// so thread will suspend itself when it leaves the critical section

			if (iHeldFastMutex && iCsCount==0)

				iHeldFastMutex->iWaiting=1;

			}

		return FALSE;

		}

	// thread not in critical section, so suspend it

	__KTRACE_OPT(KNKERN,DEBUGPRINT("NThreadBase::Suspend %T (NState %d) %d",this,iNState,aCount));

	switch (iNState)

		{

		case EReady:

			TheScheduler.Remove(this);

			RescheduleNeeded();

			iNState=ESuspended;

		case EWaitFastSemaphore:

		case EWaitDfc:

		case ESleep:

		case EBlocked:

		case ESuspended:

			break;

		default:

			UnknownState(ESuspend,aCount);

			break;

		}

	TInt old_suspend=iSuspendCount;

	iSuspendCount-=aCount;

	return (old_suspend==0);	// return TRUE if thread has changed from not-suspended to suspended.

	}

/** 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("NThreadBase::Resume %T, state %d CSC %d CSF %d",this,iNState,iCsCount,iCsFunction));

	if (iNState==EDead)

		return FALSE;

	// If thread is in critical section, just cancel deferred suspends

	if (iCsCount || iHeldFastMutex)

		{

		if (iCsFunction>0)

			--iCsFunction;	// one less deferred suspension

		return FALSE;

		}

	if (iSuspendCount<0 && ++iSuspendCount==0)

		{

		switch (iNState)

			{

			case ESuspended:

				Ready();

			case EReady:

			case EWaitFastSemaphore:

			case EWaitDfc:

			case ESleep:

			case EBlocked:

				break;

			default:

				UnknownState(EResume,0);

				break;

			}

		return TRUE;	// thread has changed from suspended to not-suspended

		}

	return FALSE;	// still suspended or not initially suspended so no higher level action required

	}

/** 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("NThreadBase::ForceResume %T, state %d CSC %d CSF %d",this,iNState,iCsCount,iCsFunction));

	if (iNState==EDead)

		return FALSE;

	// If thread is in critical section, just cancel deferred suspends

	if (iCsCount || iHeldFastMutex)

		{

		if (iCsFunction>0)

			iCsFunction=0;	// cancel all deferred suspensions

		return FALSE;

		}

	if (iSuspendCount<0)

		{

		iSuspendCount=0;

		switch (iNState)

			{

			case ESuspended:

				Ready();

			case EReady:

			case EWaitFastSemaphore:

			case EWaitDfc:

			case ESleep:

			case EBlocked:

			case EDead:

				break;

			default:

				UnknownState(EForceResume,0);

				break;

			}

		}

	return TRUE;

	}

/** 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)

	{

	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NThreadBase::Release");		

	__KTRACE_OPT(KNKERN,DEBUGPRINT("NThreadBase::Release %T, state %d retcode %d",this,iNState,aReturnCode));

	switch(iNState)

		{

		case EDead:

			return;

		case EReady:

		case ESuspended:

			// don't release explicit suspensions

			break;

		case EWaitFastSemaphore:

			if (aReturnCode<0 && iWaitObj)

				((NFastSemaphore*)iWaitObj)->WaitCancel();

			break;

		case ESleep:

		case EBlocked:

		case EWaitDfc:

			CheckSuspendThenReady();

			break;

		default:

			UnknownState(ERelease,aReturnCode);

			break;

		}

	if (iTimer.iUserFlags)

		{

		if (iTimer.iState == NTimer::EIdle)

			{

			// 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.

			TLinAddr& x = *(TLinAddr*)&iTimer.iPtr;

			x ^= 1;

			}

		iTimer.Cancel();

		iTimer.iUserFlags = FALSE;

		}

	iWaitObj=NULL;

	iReturnValue=aReturnCode;

	}

/** 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 NThreadBase::TimerExpired(TAny* aPtr)

	{

	TLinAddr cookie = (TLinAddr)aPtr;

	NThread* pT = (NThread*)(cookie &~ 3);

	__KTRACE_OPT(KNKERN,DEBUGPRINT("NThreadBase::TimerExpired %T, state %d",pT,pT->iNState));

	NThreadTimeoutHandler th = pT->iHandlers->iTimeoutHandler;

	NKern::Lock();

	if (pT->iNState<ENumNStates && pT->iNState!=EBlocked)

		th = NULL;

	if (th)

		{

		// Use higher level timeout handler

		NKern::Unlock();

		(*th)(pT, ETimeoutPreamble);

		TInt param = ETimeoutPostamble;

		NKern::Lock();

		TLinAddr current_cookie = (TLinAddr)pT->iTimer.iPtr;

		if ((cookie ^ current_cookie) & 1)

			{

			// The timer was cancelled just after expiring but before this function

			// managed to call NKern::Lock(), so it's spurious

			param = ETimeoutSpurious;

			}

		else

			pT->iTimer.iUserFlags = FALSE;

		NKern::Unlock();

		(*th)(pT, param);

		return;

		}

	TLinAddr current_cookie = (TLinAddr)pT->iTimer.iPtr;

	if ((cookie ^ current_cookie) & 1)

		{

		// The timer was cancelled just after expiring but before this function

		// managed to call NKern::Lock(), so just return without doing anything.

		NKern::Unlock();

		return;

		}

	pT->iTimer.iUserFlags = FALSE;

	switch(pT->iNState)

		{

		case EDead:

		case EReady:

		case ESuspended:

			NKern::Unlock();

			return;

		case EWaitFastSemaphore:

			((NFastSemaphore*)pT->iWaitObj)->WaitCancel();

			break;

		case EBlocked:

		case ESleep:

		case EWaitDfc:

			pT->CheckSuspendThenReady();