// Copyright (c) 1994-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\kernel\skernel.cpp

// 

//

#include <kernel/kern_priv.h>

#include "execs.h"

#define iMState		iWaitLink.iSpare1		// Allow a sensible name to be used for iMState

#ifdef BTRACE_SYMBIAN_KERNEL_SYNC

#define	BTRACE_KS(sub,obj)					{BTraceContext4(BTrace::ESymbianKernelSync, (sub), (obj));}

#define	COND_BTRACE_KS(cond,sub,obj)		if (cond) {BTraceContext4(BTrace::ESymbianKernelSync, (sub), (obj));}

#define	BTRACE_KS2(sub,obj1,obj2)			{BTraceContext8(BTrace::ESymbianKernelSync, (sub), (obj1), (obj2));}

#define	COND_BTRACE_KS2(cond,sub,obj1,obj2)	if (cond) {BTraceContext4(BTrace::ESymbianKernelSync, (sub), (obj1), (obj2));}

#define	BTRACE_KSC(sub)						{TKName n; Name(n); BTraceContextN(BTrace::ESymbianKernelSync, (sub), this, iOwner, n.Ptr(), n.Size());}

#define	COND_BTRACE_KSC(cond,sub)			if (cond) {TKName n; Name(n); BTraceContextN(BTrace::ESymbianKernelSync, (sub), this, iOwner, n.Ptr(), n.Size());}

#else

#define	BTRACE_KS(sub,obj)

#define	COND_BTRACE_KS(cond,sub,obj)

#define	BTRACE_KS2(sub,obj1,obj2)

#define	COND_BTRACE_KS2(cond,sub,obj1,obj2)

#define	BTRACE_KSC(sub)

#define	COND_BTRACE_KSC(cond,sub)

#endif

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

 * Semaphore

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

// Enter and return with system unlocked.

DSemaphore::~DSemaphore()

	{

	NKern::LockSystem();

	Reset();

	BTRACE_KS(BTrace::ESemaphoreDestroy, this);

	NKern::UnlockSystem();

	}

// Enter and return with system unlocked.

TInt DSemaphore::Create(DObject* aOwner, const TDesC* aName, TInt aInitialCount, TBool aVisible)

	{

	if (aInitialCount<0)

		return KErrArgument;

	SetOwner(aOwner);

	TInt r=KErrNone;

	if (aName && aName->Length())

		{

		r=SetName(aName);

		if (r!=KErrNone)

			return r;

		}

	iCount=aInitialCount;

	r = iWaitQ.Construct();

	if (r==KErrNone && aVisible)

		r=K::AddObject(this,ESemaphore);

	COND_BTRACE_KSC(r==KErrNone, BTrace::ESemaphoreCreate);

	return r;

	}

// Wait for semaphore with timeout

// Enter with system locked, return with system unlocked.

TInt DSemaphore::Wait(TInt aNTicks)

	{

	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Semaphore %O Wait %d Timeout %d",this,iCount,aNTicks));

	__ASSERT_DEBUG(TheCurrentThread->iMState==DThread::EReady,K::Fault(K::ESemWaitBadState));

	__ASSERT_DEBUG(!TheCurrentThread->iWaitObj,K::Fault(K::ESemWaitBadWaitObj));

	TInt r=KErrNone;

	if (iResetting)

		r=KErrGeneral;

	else if (--iCount<0)

		{

		DThread* pC=TheCurrentThread;

		pC->iMState=DThread::EWaitSemaphore;

		pC->iWaitObj=this;

		iWaitQ.Add(pC);

		BTRACE_KS(BTrace::ESemaphoreBlock, this);

		r=NKern::Block(aNTicks,NKern::ERelease,SYSTEM_LOCK);

		__ASSERT_DEBUG(pC->iMState==DThread::EReady,K::Fault(K::ESemWaitBadState));

		COND_BTRACE_KS(r==KErrNone, BTrace::ESemaphoreAcquire, this);

		return r;

		}

#ifdef BTRACE_SYMBIAN_KERNEL_SYNC

	else

		BTRACE_KS(BTrace::ESemaphoreAcquire, this);

#endif

	NKern::UnlockSystem();

	return r;

	}

// Enter with system locked, return with system unlocked.

void DSemaphore::Signal()

	{

	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Semaphore %O Signal %d",this,iCount));

	__ASSERT_DEBUG(TheCurrentThread->iMState==DThread::EReady,K::Fault(K::ESemSignalBadState));

	COND_BTRACE_KS(!iResetting, BTrace::ESemaphoreRelease, this);

	if (!iResetting && ++iCount<=0)

		{

		DThread* pT=iWaitQ.First();

		iWaitQ.Remove(pT);

		pT->iMState=DThread::EReady;

		pT->iWaitObj=NULL;

#if defined(_DEBUG) && !defined(__SMP__)

		// For crazy scheduler: if next thread is same priority as current, let it run

		// Check before releasing it in case it preempts us and exits

		TBool yield = EFalse;

		if (TheSuperPage().KernelConfigFlags() & EKernelConfigCrazyScheduling

				&& NCurrentThread()->iPriority == pT->iNThread.iPriority)

			yield = ETrue;

#endif

		NKern::ThreadRelease(&pT->iNThread,0,SYSTEM_LOCK);

#if defined(_DEBUG) && !defined(__SMP__)

		// Actually do the yield

		if (yield)

			NKern::YieldTimeslice();

#endif

		return;

		}

	NKern::UnlockSystem();

	}

// Enter and return with system locked.

void DSemaphore::SignalN(TInt aCount)

	{

	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Semaphore %O SignalN(%d) %d",this,aCount,iCount));

	__ASSERT_DEBUG(TheCurrentThread->iMState==DThread::EReady,K::Fault(K::ESemSignalBadState));

	if (iResetting)

		return;

	if (iCount<0 && aCount>0)

		{

		while(aCount--)

			{

			BTRACE_KS(BTrace::ESemaphoreRelease, this);

			if (++iCount<=0)

				{

				DThread* pT=iWaitQ.First();

				iWaitQ.Remove(pT);

				pT->iMState=DThread::EReady;

				pT->iWaitObj=NULL;

#if defined(_DEBUG) && !defined(__SMP__)

				// For crazy scheduler: if next thread is same priority as current, let it run

				// Check before releasing it in case it preempts us and exits

				TBool yield = EFalse;

				if (TheSuperPage().KernelConfigFlags() & EKernelConfigCrazyScheduling

						&& NCurrentThread()->iPriority == pT->iNThread.iPriority)

					yield = ETrue;

#endif

				NKern::ThreadRelease(&pT->iNThread,0,SYSTEM_LOCK);

#if defined(_DEBUG) && !defined(__SMP__)

				// Actually do the yield

				if (yield)

					NKern::YieldTimeslice();

#endif

				NKern::LockSystem();

				if (iResetting)

					return;

				}

			else

				{

				iCount+=aCount;

				break;

				}

			}

		}

	else if (aCount>0)

		iCount+=aCount;

	}

// Enter and return with system locked.

void DSemaphore::Reset()

	{

	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Semaphore %O Reset %d",this,iCount));

	if (iResetting)

		return;

	iResetting = TRUE;

	// We release the waiting threads before the suspended threads.

	// Other code relies on this.

	while(iCount<0)

		{

		iCount++;

		DThread* pT=iWaitQ.First();

		iWaitQ.Remove(pT);

		pT->iMState=DThread::EReady;

		pT->iWaitObj=NULL;

		NKern::ThreadRelease(&pT->iNThread,KErrGeneral,SYSTEM_LOCK);

		NKern::LockSystem();

		}

	while (!iSuspendedQ.IsEmpty())

		{

		DThread* pT=_LOFF(iSuspendedQ.First()->Deque(),DThread,iWaitLink);

		pT->iMState=DThread::EReady;

		pT->iWaitObj=NULL;

		NKern::ThreadRelease(&pT->iNThread,KErrGeneral,SYSTEM_LOCK);

		NKern::LockSystem();

		}

	iResetting = FALSE;

	iCount=0;

	}

// Enter and return with system locked.

void DSemaphore::WaitCancel(DThread* aThread)

	{

	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Semaphore %O WaitCancel(%O) %d",this,aThread,iCount));

	iWaitQ.Remove(aThread);

	++iCount;

	}

// Enter and return with system locked.

void DSemaphore::WaitCancelSuspended(DThread* aThread)

	{

	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Semaphore %O WaitCanSusp(%O) %d",this,aThread,iCount));

	aThread->iWaitLink.Deque();

	}

// Enter and return with system locked.

void DSemaphore::SuspendWaitingThread(DThread* aThread)

	{

	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Semaphore %O SuspWait(%O) %d",this,aThread,iCount));

	++iCount;

	iWaitQ.Remove(aThread);

	iSuspendedQ.Add(&aThread->iWaitLink);	// OK if resetting since suspended queue is processed after wait queue

	aThread->iMState=DThread::EWaitSemaphoreSuspended;

	}

// Enter and return with system locked.

void DSemaphore::ResumeWaitingThread(DThread* aThread)

	{

	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Semaphore %O ResumeWait(%O) %d",this,aThread,iCount));

	aThread->iWaitLink.Deque();

	if (!iResetting && --iCount<0)

		{

		iWaitQ.Add(aThread);

		aThread->iMState=DThread::EWaitSemaphore;

		}

	else

		{

		aThread->iMState=DThread::EReady;

		aThread->iWaitObj=NULL;

		NKern::ThreadRelease(&aThread->iNThread,iResetting?KErrGeneral:KErrNone);

		}

	}

// Enter and return with system locked.

void DSemaphore::ChangeWaitingThreadPriority(DThread* aThread, TInt aNewPriority)

	{

	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Semaphore %O ChangeWaitPri(%O,%d)",this,aThread,aNewPriority));

	iWaitQ.ChangePriority(aThread,aNewPriority);

	}

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

 * Mutex

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

inline TThreadMutexCleanup::TThreadMutexCleanup(DMutex* aMutex)

	: iMutex(aMutex)

	{}

// Enter and return with system locked.

void TThreadMutexCleanup::Cleanup()

	{

	__KTRACE_OPT(KTHREAD,Kern::Printf("TThreadCleanup::Cleanup Free mutex %O",iMutex));

	if (iMutex->iResetting)

		{

		iMutex->iCleanup.Remove();

		iMutex->iCleanup.iThread=NULL;

#ifdef _DEBUG

		iMutex->iOrderLink.Deque();

#endif

		}

	else

		{

		iMutex->iHoldCount=1;

		iMutex->Signal();

		NKern::LockSystem();

		}

	}

DMutex::DMutex()

	: iCleanup(this)

	{}

// Enter and return with system unlocked.

DMutex::~DMutex()

	{

	NKern::LockSystem();

	Reset();

	BTRACE_KS(BTrace::EMutexDestroy, this);

	NKern::UnlockSystem();

	}

// Enter and return with system unlocked.

TInt DMutex::Create(DObject* aOwner, const TDesC* aName, TBool aVisible, TUint aOrder)

	{

	iOrder = (TUint8)aOrder;

	SetOwner(aOwner);

	TInt r=KErrNone;

	if (aName && aName->Length())

		{

		r=SetName(aName);

		if (r!=KErrNone)

			return r;

		}

	r = iWaitQ.Construct();

	if (r==KErrNone && aVisible)

		r=K::AddObject(this,EMutex);

	COND_BTRACE_KSC(r==KErrNone, BTrace::EMutexCreate);

	return r;

	}

#ifdef _DEBUG

extern const SNThreadHandlers EpocThreadHandlers;

#endif

// Enter and return with system locked.

TInt DMutex::Wait()

	{

	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Mutex %O Wait hold %O hldc=%d wtc=%d",this,iCleanup.iThread,iHoldCount,iWaitCount));

	__ASSERT_SYSTEM_LOCK;

	__ASSERT_DEBUG(NCurrentThread()->iHandlers==&EpocThreadHandlers, K::Fault(K::EMutexWaitNotDThread));

	DThread* pC=TheCurrentThread;

	__ASSERT_DEBUG(pC->iMState==DThread::EReady,K::Fault(K::EMutexWaitBadState));

	__ASSERT_DEBUG(!pC->iWaitObj,K::Fault(K::EMutexWaitBadWaitObj));

#ifdef _DEBUG

	SDblQue& ml = pC->iMutexList;

	DMutex* m = ml.IsEmpty() ? NULL : _LOFF(ml.First(), DMutex, iOrderLink);

	TUint last_mutex_order = m ? m->iOrder : KMutexOrdNone;

	if (iCleanup.iThread!=pC && iOrder<KMutexOrdUser && iOrder>=last_mutex_order)

		{

		__KTRACE_OPT(KPANIC,Kern::Printf("Mutex ordering violation: holding mutex %O (%08x) order %d, trying to acquire mutex %O (%08x) order %d",m,m,last_mutex_order,this,this,iOrder));

		K::Fault(K::EMutexOrderingViolation);

		}

#endif

	while(!iResetting && iCleanup.iThread)

		{

		if (iCleanup.iThread==pC)

			{

			++iHoldCount;

			BTRACE_KS(BTrace::EMutexAcquire, this);

			return KErrNone;

			}

		K::PINestLevel=0;

		pC->iMState=DThread::EWaitMutex;

		pC->iWaitObj=this;

		++iWaitCount;

		iWaitQ.Add(pC);

		TInt p=pC->iWaitLink.iPriority;

		if (p>iCleanup.iPriority)

			iCleanup.ChangePriority(p);

		BTRACE_KS(BTrace::EMutexBlock, this);

		// If the thread is woken up normally as a result of the mutex being released

		// this function will KErrNone and this thread will have been placed in

		// EHoldMutexPending state. If the thread is killed while waiting this function

		// will not return (since the exit handler will run instead).

		// If the mutex is reset (or deleted) while the thread is waiting this function

		// will return KErrGeneral and the thread will have been placed into EReady

		// state. If however the mutex is reset (or deleted) while the thread is in

		// EHoldMutexPending state, having already been woken up normally as a result

		// of the mutex being released, this function will return KErrNone (since the

		// return value is set at the point where the thread is released from its wait

		// condition). However we can still detect this situation since the thread will

		// have been placed into the EReady state when the mutex was reset.

		TInt r=NKern::Block(0, NKern::ERelease|NKern::EClaim|NKern::EObstruct, SYSTEM_LOCK);

		if (r==KErrNone && pC->iMState==DThread::EReady)

			r = KErrGeneral;	// mutex has been reset

		if (r!=KErrNone)		// if we get an error here...

			{

			__ASSERT_DEBUG(pC->iMState==DThread::EReady,K::Fault(K::EMutexWaitBadState));

			return r;		// ...bail out now - this mutex may no longer exist

			}

		pC->iMState=DThread::EReady;

		pC->iWaitObj=NULL;

		pC->iWaitLink.Deque();		// remove thread from iPendingQ

		}

	if (iResetting)

		return KErrGeneral;

	BTRACE_KS(BTrace::EMutexAcquire, this);

	iHoldCount=1;

	iCleanup.iPriority=TUint8(HighestWaitingPriority());

	pC->AddCleanup(&iCleanup);

#ifdef _DEBUG

	ml.AddHead(&iOrderLink);

#endif

	return KErrNone;

	}

// Enter with system locked, return with system unlocked.

void DMutex::Signal()

	{

	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Mutex %O Signal hold=%O hldc=%d wtc=%d",this,iCleanup.iThread,iHoldCount,iWaitCount));

	__ASSERT_SYSTEM_LOCK;

	DThread* pC=TheCurrentThread;

	__ASSERT_DEBUG(iCleanup.iThread==pC,K::Fault(K::EMutexSignalWrongThread));

	__ASSERT_DEBUG(pC->iMState==DThread::EReady,K::Fault(K::EMutexSignalBadState));

	COND_BTRACE_KS(!iResetting, BTrace::EMutexRelease, this);

	if (!iResetting && --iHoldCount==0)

		{

		if (iWaitQ.NonEmpty())

			{

			// Wake up the next waiting thread.

			// We MUST do this before reliquishing our inherited priority.

			// We won't thrash on the system lock because inheritance ensures our priority is not

			// lower than the waiting thread's and the scheduler will not round-robin a thread which

			// holds a fast mutex (the system lock in this case).

			WakeUpNextThread();

			}

		else

			{

			__ASSERT_DEBUG(iCleanup.iPriority==0,Kern::Fault("MutSigBadClnPri",iCleanup.iPriority));

			}

		iCleanup.iThread=NULL;

#ifdef _DEBUG

		iOrderLink.Deque();

#endif

		pC->iCleanupQ.Remove(&iCleanup);	// remove cleanup item but don't set priority yet

		if (iCleanup.iPriority!=0)			// if cleanup item had nonzero priority may need to revert our priority

			{

			// Revert this thread's priority and release the system lock without thrashing.

			// Relies on the fact that our MState is READY here.

			pC->RevertPriority();

			return;

			}

		}

	NKern::UnlockSystem();

	}

// Enter and return with system locked.

void DMutex::Reset()

	{

	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Mutex %O Reset hold=%O hldc=%d wtc=%d",this,iCleanup.iThread,iHoldCount,iWaitCount));

	__ASSERT_SYSTEM_LOCK;

	if (iResetting)

		return;

	K::PINestLevel=0;

	iResetting = TRUE;

	// We release the pending threads first, then waiting threads, then suspended threads.

	// Other code relies on this.

	while (!iPendingQ.IsEmpty())

		{

		DThread* pT=_LOFF(iPendingQ.First()->Deque(),DThread,iWaitLink);

		pT->iMState=DThread::EReady;

		pT->iWaitObj=NULL;

		NKern::FlashSystem();

		}

	while (iWaitQ.NonEmpty())

		{

		DThread* pT=iWaitQ.First();

		iWaitQ.Remove(pT);

		pT->iMState=DThread::EReady;

		pT->iWaitObj=NULL;

		NKern::ThreadRelease(&pT->iNThread,KErrGeneral,SYSTEM_LOCK);

		NKern::LockSystem();

		}

	while (!iSuspendedQ.IsEmpty())

		{

		DThread* pT=_LOFF(iSuspendedQ.First()->Deque(),DThread,iWaitLink);

		pT->iMState=DThread::EReady;

		pT->iWaitObj=NULL;

		NKern::ThreadRelease(&pT->iNThread,KErrGeneral,SYSTEM_LOCK);

		NKern::LockSystem();

		}

	if (iCleanup.iThread)

		{

		iCleanup.Remove();

		iCleanup.iThread=NULL;

#ifdef _DEBUG

		iOrderLink.Deque();

#endif

		}

	iCleanup.iPriority=0;

	iHoldCount=0;

	iWaitCount=0;

	iResetting = FALSE;

	}

// Enter and return with system locked.

void DMutex::WaitCancel(DThread* aThread)

	{

	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Mutex %O WaitCancel(%O)",this,aThread));

	iWaitQ.Remove(aThread);

	--iWaitCount;

	K::PINestLevel=0;

	TInt p=HighestWaitingPriority();

	iCleanup.ChangePriority(p);

	}

// Enter and return with system locked.

void DMutex::WaitCancelSuspended(DThread* aThread)

	{

	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Mutex %O WaitCanSusp(%O)",this,aThread));

	aThread->iWaitLink.Deque();

	--iWaitCount;

	}

// Enter and return with system locked.

void DMutex::SuspendWaitingThread(DThread* aThread)

	{

	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Mutex %O SuspWait(%O)",this,aThread));

	iWaitQ.Remove(aThread);

	iSuspendedQ.Add(&aThread->iWaitLink);	// OK if resetting since suspended queue is processed after wait queue

	aThread->iMState=DThread::EWaitMutexSuspended;

	K::PINestLevel=0;

	TInt p=HighestWaitingPriority();

	iCleanup.ChangePriority(p);

	}

// Enter and return with system locked.

void DMutex::ResumeWaitingThread(DThread* aThread)

	{

	__KTRACE_OPT(KSEMAPHORE,Kern::Printf("Mutex %O ResumeWait(%O)",this,aThread));

	aThread->iWaitLink.Deque();

	if (!iResetting)