// 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\sched.cpp

// 

//

// NThreadBase member data

#define __INCLUDE_NTHREADBASE_DEFINES__

// TDfc member data

#define __INCLUDE_TDFC_DEFINES__

#include "nk_priv.h"

#include <nk_irq.h>

TSpinLock	NEventHandler::TiedLock(TSpinLock::EOrderEventHandlerTied);

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

 * TScheduler

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

// TScheduler resides in .bss so other fields are zero-initialised

TScheduler::TScheduler()

	:	iActiveCpus1(1),	// only boot CPU for now

		iActiveCpus2(1),	// only boot CPU for now

		iIdleSpinLock(TSpinLock::EOrderIdleDFCList),

		iCpusNotIdle(1)		// only boot CPU for now

	{

	TInt i;

	for (i=0; i<KMaxCpus; ++i)

		{

		TSubScheduler* s = TheSubSchedulers + i;

		iSub[i] = s;

		s->iScheduler = this;

		s->iCpuNum = TUint32(i);

		s->iCpuMask = 1u<<i;

		}

	}

/** Return a pointer to the scheduler

	Intended for use by the crash debugger, not for general device driver use.

	@return	Pointer to the scheduler object

	@internalTechnology

 */

EXPORT_C TScheduler* TScheduler::Ptr()

	{

	return &TheScheduler;

	}

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

 * TSubScheduler

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

// TSubScheduler resides in .bss so other fields are zero-initialised

TSubScheduler::TSubScheduler()

	:	TPriListBase(KNumPriorities),

		iExIDfcLock(TSpinLock::EOrderExIDfcQ),

		iReadyListLock(TSpinLock::EOrderReadyList),

		iKernLockCount(1),

		iEventHandlerLock(TSpinLock::EOrderEventHandlerList)

	{

	}

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

 * NSchedulable

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

void NSchedulable::AcqSLock()

	{

	iSSpinLock.LockOnly();

	if (iParent!=this && iParent)

		iParent->AcqSLock();

	}

void NSchedulable::RelSLock()

	{

	if (iParent!=this && iParent)

		iParent->RelSLock();

	iSSpinLock.UnlockOnly();

	}

void NSchedulable::LAcqSLock()

	{

	NKern::Lock();

	AcqSLock();

	}

void NSchedulable::RelSLockU()

	{

	RelSLock();

	NKern::Unlock();

	}

void NSchedulable::UnPauseT()

	{

	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NSchedulable::UnPauseT");

	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nUnPauseT",this));

	__NK_ASSERT_DEBUG(iPauseCount);

	if (--iPauseCount || iReady || iSuspended || (iParent && ((NThread*)this)->iWaitState.ThreadIsBlocked()))

		return;

	ReadyT(EUnPause);

	}

void NSchedulable::DeferredReadyIDfcFn(TAny* aPtr)

	{

	NSchedulable* a = (NSchedulable*)aPtr;

	a->AcqSLock();

	TUint32 evs = __e32_atomic_and_acq32(&a->iEventState, ~EDeferredReady);

	if (evs & EDeferredReady)

		{

		if (a->iParent)

			{

			// thread

			a->UnPauseT();

			}

		else

			{

			// thread group

			NThreadGroup* g = (NThreadGroup*)a;

			__KTRACE_OPT(KNKERN,DEBUGPRINT("%G nDeferredReady",g));

			__NK_ASSERT_DEBUG(g->iPauseCount);

			if (--g->iPauseCount && g->iNThreadList.NonEmpty())

				g->ReadyT(EUnPause);

			}

		}

	a->RelSLock();

	}

TInt NSchedulable::AddTiedEvent(NEventHandler* aEvent)

	{

	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T AddEv %08x",this,aEvent));

	TInt r = KErrGeneral;

	NEventHandler::TiedLock.LockOnly();

	AcqSLock();

	if (iStopping)

		r = KErrDied;

	else if (!aEvent->iTied)

		{

		aEvent->iTied = this;

		iEvents.Add(&aEvent->iTiedLink);

		r = KErrNone;

		}

	RelSLock();

	NEventHandler::TiedLock.UnlockOnly();

	return r;

	}

void ipi_dummy(TGenericIPI*)

	{

	}

/** Detach and cancel any tied events attached to this thread/group

Call in a thread context with interrupts and preemption enabled.

Calling thread in critical section.

@internalComponent

*/

void NSchedulable::DetachTiedEvents()

	{

	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T DetTiedEv",this));

	NKern::Lock();

	NEventHandler::TiedLock.LockOnly();

	AcqSLock();

	iStopping = TRUE;

	if (!iParent)

		{

		// can't destroy a group until all threads have detached from it

		NThreadGroup* g = (NThreadGroup*)this;

		__NK_ASSERT_ALWAYS(g->iThreadCount==0 && g->iNThreadList.IsEmpty());

		}

	RelSLock();

	NEventHandler::TiedLock.UnlockOnly();

	// send IPI to all processors to synchronise

	// after this, any tied IDFCs can only proceed to completion

	// they can't be queued again

	TGenericIPI ipi;

	ipi.QueueAllOther(&ipi_dummy);

	NKern::Unlock();

	ipi.WaitCompletion();

	FOREVER

		{

		NKern::Lock();

		NEventHandler::TiedLock.LockOnly();

		AcqSLock();

		NEventHandler* h = 0;

		TInt type = -1;

		if (!iEvents.IsEmpty())

			{

			h = _LOFF(iEvents.First()->Deque(), NEventHandler, iTiedLink);

			h->iTiedLink.iNext = 0;

			type = h->iHType;

			}

		RelSLock();

		if (type == NEventHandler::EEventHandlerNTimer)

			{

			// everything's easy for a timer since we can just cancel it here

			NTimer* tmr = (NTimer*)h;

			tmr->DoCancel(NTimer::ECancelDestroy);

			tmr->iTied = 0;

			}

		else if (type == NEventHandler::EEventHandlerIDFC)

			{

			// can just cancel the IDFC with TiedLock held

			// EndTiedEvent() may be delayed, but we wait for that further down

			// iTied will have been captured before the IDFC state is reset

			// Cancel() waits for the state to be reset

			TDfc* d = (TDfc*)h;

			d->Cancel();

			d->iHType = (TUint8)NEventHandler::EEventHandlerDummy;

			d->iTied = 0;

			}

		NEventHandler::TiedLock.UnlockOnly();

		NKern::Unlock();

		if (!h)

			break;

		switch (type)

			{

			case NEventHandler::EEventHandlerIrq:

				{

				NIrqHandler* pH = (NIrqHandler*)h;

				// pH can't have been freed since we dequeued it but left iTied set

				pH->Unbind(pH->iHandle, this);

				break;

				}

			case NEventHandler::EEventHandlerNTimer:

			case NEventHandler::EEventHandlerIDFC:

			case NEventHandler::EEventHandlerDummy:

				// nothing left to do

				break;

			default:

				__NK_ASSERT_ALWAYS(0);

				break;

			}

		}

	// Wait for any remaining tied event handlers to complete

	while (iEventState & EEventCountMask)

		{

		__chill();

		}

	}

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

 * NThreadGroup

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

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

 * NThreadBase

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

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

 */

void NSchedulable::ReadyT(TUint aMode)

	{

	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_ISR,"NSchedulable::ReadyT");

	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nReadyT(%x)",this,aMode));

	NThreadBase* t = (NThreadBase*)this;

#ifdef _DEBUG

	if (!iParent)

		t = (NThreadBase*)0xface0fff;

#endif

	__NK_ASSERT_DEBUG(!iReady && (!iParent || (!t->iWaitState.iWtC.iWtStFlags && !t->iPauseCount && !t->iSuspended)));

	TSubScheduler& ss0 = SubScheduler();

	NSchedulable* g = this;

	if (iParent != this && iParent)

		{

		NThreadGroup* tg = (NThreadGroup*)iParent;

		iReady = EReadyGroup;

		if (tg->iReady)

			{

			// extra thread added to group - change priority if necessary

			tg->iNThreadList.Add(this);

			TInt gp = tg->iPriority;

			TSubScheduler& ss = TheSubSchedulers[tg->iReady & EReadyCpuMask];

			ss.iReadyListLock.LockOnly();

			TInt hp = ss.HighestPriority();

			if (iPriority>gp)

				ss.ChangePriority(tg, iPriority);

			if (iPriority>hp || (iPriority==hp && ss.iCurrentThread && ss.iCurrentThread->iTime==0))

				{

				if (&ss == &ss0)

					RescheduleNeeded();					// reschedule on this processor

				else

					ss0.iReschedIPIs |= ss.iCpuMask;	// will kick the other CPU when this CPU reenables preemption

				}

			if ((aMode & ENewTimeslice) && t->iTime==0 && (iNext!=this || ss.iQueue[iPriority]))

				t->iTime = t->iTimeslice;

			ss.iReadyListLock.UnlockOnly();

			return;

			}

		tg->iNThreadList.Add(this);

		tg->iPriority = iPriority;	// first in group

		g = tg;						// fall through to add group to subscheduler

		}

	TInt cpu = -1;

	if (aMode & EUnPause)

		{

		cpu = (g->iEventState & EThreadCpuMask)>>EThreadCpuShift;

		if (CheckCpuAgainstAffinity(cpu, g->iCpuAffinity))

			goto cpu_ok;

		}

	else if (g->iFreezeCpu)

		{

		cpu = g->iLastCpu;

		if (!CheckCpuAgainstAffinity(cpu, g->iCpuAffinity))

			g->iCpuChange = TRUE;

		}

	else if (!(g->iCpuAffinity & NTHREADBASE_CPU_AFFINITY_MASK))

		cpu = g->iCpuAffinity;

	else if ((aMode & EPreferSameCpu) && (g->iCpuAffinity & ss0.iCpuMask))

		cpu = ss0.iCpuNum;

	if (cpu < 0)

		{

		// pick a cpu

		TScheduler& s = TheScheduler;

		TUint32 m = g->iCpuAffinity & s.iActiveCpus1;

		TInt i;

		TInt lowest_p = KMaxTInt;

		for (i=0; i<s.iNumCpus; ++i)

			{

			TSubScheduler& ss = *s.iSub[i];

			if (!(m & ss.iCpuMask))

				continue;

			TInt hp = ss.HighestPriority();

			if (hp < lowest_p)

				{

				lowest_p = hp;

				cpu = i;

				continue;

				}

			if (hp > lowest_p)

				continue;

			if (cpu>=0 && g->iLastCpu!=i)

				continue;

			lowest_p = hp;

			cpu = i;

			}

		}

cpu_ok:

	__NK_ASSERT_ALWAYS(cpu>=0);

	if (g->TiedEventReadyInterlock(cpu))

		{

		__KTRACE_OPT(KSCHED2,DEBUGPRINT("ReadyT->CPU %dD",cpu));

		++g->iPauseCount;

//		((TDfc*)g->i_IDfcMem)->Add();

		return;

		}

	__KTRACE_OPT(KSCHED2,DEBUGPRINT("ReadyT->CPU %d",cpu));

	TSubScheduler& ss = TheSubSchedulers[cpu];

	ss.iReadyListLock.LockOnly();

	TInt hp = ss.HighestPriority();

	if (g->iPriority>hp || (g->iPriority==hp && ss.iCurrentThread && ss.iCurrentThread->iTime==0))

		{

		if (&ss == &ss0)

			RescheduleNeeded();					// reschedule on this processor

		else

			ss0.iReschedIPIs |= ss.iCpuMask;	// will kick the other CPU when this CPU reenables preemption

		}

	ss.Add(g);

	g->iReady = TUint8(cpu | EReadyOffset);

	if ((aMode & ENewTimeslice) && iParent && t->iTime==0 && g->iNext!=g)

		t->iTime = t->iTimeslice;

	ss.iReadyListLock.UnlockOnly();

	}

NThread* TSubScheduler::SelectNextThread()

	{

	NThread* ot = iCurrentThread;

	NThread* t = 0;

	TBool migrate = FALSE;

	TBool gmigrate = FALSE;

	TBool fmd_done = FALSE;

	TBool fmd_res = FALSE;

	if (!ot)

		{

		iReadyListLock.LockOnly();

		iRescheduleNeededFlag = FALSE;

		goto no_ot;

		}

	ot->AcqSLock();

	if (ot->iNewParent)

		ot->iNewParent->AcqSLock();

	SaveTimesliceTimer(ot);	// remember how much of current thread's timeslice remains

	if (ot->iCsFunction==NThreadBase::ECSDivertPending && ot->iWaitState.iWtC.iWtStFlags)

		{

		// thread about to exit so cancel outstanding wait

		ot->DoReleaseT(KErrDied,0);

		}

	if (ot->iWaitState.iWtC.iWtStFlags==0)

		{

		// ASSUMPTION: If iNewParent set, ot can't hold a fast mutex (assertion in JoinGroup)

		TBool pfmd = (ot->iParent!=ot && !ot->iFastMutexDefer);

		if (ot->iTime==0 || pfmd)

			{

			// ot's timeslice has expired

			fmd_res = ot->CheckFastMutexDefer();

			fmd_done = TRUE;

			if (fmd_res)

				{

				if (ot->iTime == 0)

					ot->iTime = 0x80000000;	// mark deferred timeslice expiry

				if (pfmd)

					{

					ot->iFastMutexDefer = 1;

					++ot->iParent->iFreezeCpu;

					}

				}

			}

		}

	iReadyListLock.LockOnly();

	iRescheduleNeededFlag = FALSE;

	//	process outstanding suspend/kill/CPU change on ot

	__NK_ASSERT_DEBUG(!(ot->iWaitState.iWtC.iWtStFlags & NThreadWaitState::EWtStWaitActive));

	if (ot->iWaitState.iWtC.iWtStFlags || ot->iPauseCount || ot->iSuspended)

		{

		// ot is no longer ready to run

		__KTRACE_OPT(KSCHED2,DEBUGPRINT("Rschd<-%T WS: %02x %02x (%08x) P:%02x S:%1x", ot, 

							ot->iWaitState.iWtC.iWtStFlags, ot->iWaitState.iWtC.iWtObjType, ot->iWaitState.iWtC.iWtObj, ot->iPauseCount, ot->iSuspended));

		TInt wtst = ot->iWaitState.DoWait();

		if (wtst>=0 && wtst!=NThread::EWaitFastMutex)

			ot->iTime = ot->iTimeslice;

		ot->UnReadyT();

		if (ot->iNewParent)

			{

			ot->iParent = ot->iNewParent, ++((NThreadGroup*)ot->iParent)->iThreadCount;

			wmb();	// must make sure iParent is updated before iNewParent is cleared

			ot->iNewParent = 0;

			}

		ot->iCpuChange = FALSE;

		}

	else if (ot->iNewParent)

		{

		__NK_ASSERT_ALWAYS(ot->iParent==ot && !ot->iHeldFastMutex && !ot->iFreezeCpu);

		ot->UnReadyT();

		migrate = TRUE;

		ot->iParent = ot->iNewParent;

		ot->iCpuChange = FALSE;

		++((NThreadGroup*)ot->iParent)->iThreadCount;

		wmb();	// must make sure iParent is updated before iNewParent is cleared

		ot->iNewParent = 0;

		}

	else if (ot->iParent->iCpuChange && !ot->iParent->iFreezeCpu)

		{

		if (!CheckCpuAgainstAffinity(iCpuNum, ot->iParent->iCpuAffinity))

			{

			if (ot->iParent==ot)

				{

				if (!fmd_done)

					fmd_res = ot->CheckFastMutexDefer(), fmd_done = TRUE;

				if (!fmd_res)

					{

					__KTRACE_OPT(KSCHED2,DEBUGPRINT("Rschd<-%T A:%08x",ot,ot->iParent->iCpuAffinity));

					ot->UnReadyT();

					migrate = TRUE;

					ot->iCpuChange = FALSE;

					}

				}

			else

				{

				__KTRACE_OPT(KSCHED2,DEBUGPRINT("Rschd<-%T GA:%08x",ot,ot->iParent->iCpuAffinity));

				Remove(ot->iParent);

				ot->iParent->iReady = 0;

				gmigrate = TRUE;

				ot->iCpuChange = FALSE;

				ot->iParent->iCpuChange = FALSE;

				}

			}

		else

			{

			ot->iCpuChange = FALSE;

			ot->iParent->iCpuChange = FALSE;

			}

		}

no_ot:

	NSchedulable* g = (NSchedulable*)First();

	TBool rrcg = FALSE;

	if (g && g->IsGroup())

		{

		t = (NThread*)((NThreadGroup*)g)->iNThreadList.First();

		if (g->iNext!=g)

			rrcg = TRUE;

		}

	else

		t = (NThread*)g;

	TBool rrct = (t && t->iNext!=t);

	if (t && t->iTime==0 && (rrcg || rrct))

		{

		// candidate thread's timeslice has expired and there is another at the same priority

		if (t==ot)

			{

			if (ot->iParent!=ot)

				{

				((NThreadGroup*)ot->iParent)->iNThreadList.iQueue[ot->iPriority] = ot->iNext;

				iQueue[ot->iParent->iPriority] = ot->iParent->iNext;

				}

			else

				iQueue[ot->iPriority] = ot->iNext;

			ot->iTime = ot->iTimeslice;

			NSchedulable* g2 = (NSchedulable*)First();

			if (g2->IsGroup())

				t = (NThread*)((NThreadGroup*)g2)->iNThreadList.First();

			else

				t = (NThread*)g2;

			if (t->iTime==0)

				{

				// loop again since we need to lock t before round robining it

				__KTRACE_OPT(KSCHED2,DEBUGPRINT("Rschd<-%T RRL",ot));

				iRescheduleNeededFlag = TRUE;

				}

			else

				{

				__KTRACE_OPT(KSCHED2,DEBUGPRINT("Rschd<-%T RR",ot));

				}

/*			if (ot->iCpuAffinity & NTHREADBASE_CPU_AFFINITY_MASK)

				{

				ot->UnReadyT();

				migrate = TRUE;

				}

			else

				ot->iTime = ot->iTimeslice;

*/

			}

		else	// loop again since we need to lock t before round robining it

			{

			__KTRACE_OPT(KSCHED2,DEBUGPRINT("Rschd<-%T LL",ot));

			iRescheduleNeededFlag = TRUE;

			}

		}

	if (t != ot)

		{

		if (ot)

			{

			ot->iCurrent = 0;

			ot->iParent->iCurrent = 0;

			ot->CompleteContextSave();

			}

		if (t)

			{

			t->iLastCpu = iCpuNum;

			t->iParent->iLastCpu = iCpuNum;

			t->iCurrent = TUint8(iCpuNum | NSchedulable::EReadyOffset);

			t->iParent->iCurrent = t->iCurrent;

			}

		iCurrentThread = t;

		}

	UpdateThreadTimes(ot,t);		// update ot's run time and set up the timeslice timer for t

	iReadyListLock.UnlockOnly();

	if (migrate)

		ot->ReadyT(NThreadBase::ENewTimeslice);	// new timeslice if it's queued behind another thread at same priority

	if (gmigrate)

		ot->iParent->ReadyT(0);	// new timeslice if it's queued behind another thread at same priority

	if (ot)

		{

		ot->RelSLock();

		// DFC to signal thread is now dead

		if (ot->iWaitState.ThreadIsDead() && ot->iWaitState.iWtC.iKillDfc)

			ot->iWaitState.iWtC.iKillDfc->DoEnque();

		}

	__KTRACE_OPT(KSCHED,DEBUGPRINT("Rschd->%T",t));

	__NK_ASSERT_ALWAYS(!t || t->iParent);	// must be a thread not a group

	return t;	// could return NULL

	}

void NThreadBase::UnReadyT()

	{

	if (iParent!=this)

		{

		NThreadGroup& g = *(NThreadGroup*)iParent;

		TPriListBase& l = g.iNThreadList;

		l.Remove(this);

		if (g.iReady)

			{

			TSubScheduler& ss = TheSubSchedulers[g.iReady & EReadyCpuMask];

			if (l.IsEmpty())

				{

//				__KTRACE_OPT(KNKERN,DEBUGPRINT("%T UnReadyT (G=%G-)",this,&g));

				ss.Remove(&g);

				g.iReady = 0;

				g.iPriority = 0;

				}

			else

				{

//				__KTRACE_OPT(KNKERN,DEBUGPRINT("%T UnReadyT (G=%G)",this,&g));

				ss.ChangePriority(&g, l.HighestPriority());

				}

			}

		}

	else

		{

//		__KTRACE_OPT(KNKERN,DEBUGPRINT("%T UnReadyT",this));

		TheSubSchedulers[iReady & EReadyCpuMask].Remove(this);

		}

	iReady = 0;

	}

void NThreadBase::ChangeReadyThreadPriority()

	{

	TInt newp = iMutexPri>iBasePri ? iMutexPri : iBasePri;

	TInt oldp = iPriority;

	TSubScheduler* ss0 = &SubScheduler();

	TSubScheduler* ss = 0;

	if (iParent->iReady)

		{

		ss = TheSubSchedulers + (iParent->iReady & EReadyCpuMask);

		ss->iReadyListLock.LockOnly();

		}

	TBool resched = FALSE;

	NSchedulable* g = iParent;

	if (g!=this)

		{

		NThreadGroup* tg = (NThreadGroup*)g;

		tg->iNThreadList.ChangePriority(this, newp);

		if (ss)

			{

			TInt ngp = tg->iNThreadList.HighestPriority();

			if (ngp!=tg->iPriority)

				ss->ChangePriority(tg, ngp);

			}

		}

	else

		ss->ChangePriority(this, newp);

	if (iCurrent)	// can't be current if parent not ready

		{

		TInt nhp = ss->HighestPriority();

		if (newp<oldp && (newp<nhp || (newp==nhp && iTime==0)))

			resched = TRUE;

		}

	else if (ss)

		{

		NThreadBase* ct = ss->iCurrentThread;

		TInt cp = ct ? ct->iPriority : -1;

		if (newp>cp || (newp==cp && ct->iTime==0))

			resched = TRUE;

		}

	if (resched)

		{

		if (ss == ss0)

			RescheduleNeeded();

		else

			ss0->iReschedIPIs |= ss->iCpuMask;	// will kick the other CPU when this CPU reenables preemption

		}

	if (ss)

		ss->iReadyListLock.UnlockOnly();

	}

/** Changes the priority of a nanokernel thread.

	For use by RTOS personality layers.

	Do not use this function directly on a Symbian OS thread.

	The thread's unknown state handler will be invoked with function EChangePriority

	and parameter newp if the current NState is not recognised and the new priority

	is not equal to the original priority.

	@param	newp  The new nanokernel priority (0 <= newp < KNumPriorities).

	@pre	Kernel must be locked.

	@pre	Call in a thread context.

	@post	Kernel is locked.

 */

EXPORT_C void NThreadBase::SetPriority(TInt newp)

	{

	CHECK_PRECONDITIONS(MASK_KERNEL_LOCKED|MASK_NOT_IDFC|MASK_NOT_ISR,"NThreadBase::SetPriority");

	AcqSLock();

	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nSetPri %d(%d)->%d(%d)",this,iPriority,iBasePri,newp,iMutexPri));

	iBasePri = TUint8(newp);

	if (iMutexPri > iBasePri)

		newp = iMutexPri;

	TInt oldp = iPriority;

	if (newp == oldp)

		{

		RelSLock();

		return;

		}

	NFastMutex* wfm = 0;

	if (iLinkedObj && iLinkedObjType==EWaitFastMutex)

		wfm = (NFastMutex*)iLinkedObj;

	if (wfm)

		{

		// if thread is attached to/waiting on a fast mutex, need to acquire mutex lock

		++iPauseCount;

		RelSLock();

		wfm->iMutexLock.LockOnly();

		AcqSLock();

		UnPauseT();

		wfm->iWaitQ.ChangePriority(&iWaitLink, newp);	// change position of this thread on mutex wait queue

		}

	if (iReady)

		{

		ChangeReadyThreadPriority();

		RelSLock();

		if (wfm && newp<=wfm->iWaitQ.HighestPriority())

			{

			// this thread was contending for the mutex but they may be other waiting threads

			// with higher or equal priority, so wake up the first thread on the list.

			NThreadBase* pT = _LOFF(wfm->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, wfm, KErrNone);

			pT->RelSLock();

			}

		}

	else

		{

		iPriority = (TUint8)newp;

		if (wfm && newp>oldp)

			{

			NThreadBase* pT = _LOFF(wfm->iWaitQ.First(), NThreadBase, iWaitLink);	// highest priority waiting thread

			if (pT==this)

				{

				// this is now highest priority waiting thread so wake it up

				iWaitState.UnBlockT(NThreadBase::EWaitFastMutex, wfm, KErrNone);

				}

			}

		RelSLock();

		}

	if (wfm)

		{

		NThreadBase* t = (NThreadBase*)(TLinAddr(wfm->iHoldingThread)&~3);

		if (t)

			t->SetMutexPriority(wfm);

		wfm->iMutexLock.UnlockOnly();

		}

	}

/** Set the inherited priority of a nanokernel thread.

	@pre	Kernel must be locked.

	@pre	Call in a thread context.

	@pre	The thread holds a fast mutex

	@post	Kernel is locked.

 */

void NThreadBase::SetMutexPriority(NFastMutex* aM)

	{

	TInt newp = aM->iWaitQ.HighestPriority();

	if (newp<0)

		newp = 0;

	AcqSLock();

	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nSetMPri %d->%d Base %d (mutex %08x)",this,iMutexPri,newp,iBasePri,aM));

	iMutexPri = TUint8(newp);

	if (iMutexPri < iBasePri)

		newp = iBasePri;

	TInt oldp = iPriority;

	if (newp == oldp)

		{

		RelSLock();

		return;

		}

	if (iReady)

		ChangeReadyThreadPriority();

	else

		iPriority = (TUint8)newp;

	RelSLock();

	}

void NThreadBase::LoseInheritedPriorityT()

	{

	__KTRACE_OPT(KNKERN,DEBUGPRINT("%T nLoseInhPri %d->%d",this,iPriority,iBasePri));

	TSubScheduler* ss = &SubScheduler();

	TInt newp = iBasePri;

	NSchedulable* g = iParent;

	ss->iReadyListLock.LockOnly();

	if (g!=this)

		{

		NThreadGroup* tg = (NThreadGroup*)g;

		tg->iNThreadList.ChangePriority(this, newp);

		TInt hp = tg->iNThreadList.HighestPriority();

		if (hp == tg->iPriority)

			{

			if (newp <= hp)

				RescheduleNeeded();

			goto out;

			}

		newp = hp;

		g = tg;

		}

	if (newp <= ss->HighestPriority())

		RescheduleNeeded();

	ss->ChangePriority(g, newp);

out:

	ss->iReadyListLock.UnlockOnly();

	}