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