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

	}