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

// 

//

#include <kernel/kern_priv.h>

#include "execs.h"

#include <kernel/emi.h>

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

#define iExiting			iWaitLink.iSpare2		// Allow a sensible name to be used for iExiting

#define iWaitListReserved	iWaitLink.iSpare3		// Allow a sensible name to be used for iWaitListReserved

#define __CHECK_PRIORITIES(t)	__ASSERT_DEBUG((t)->iWaitLink.iPriority==(t)->iNThread.i_NThread_BasePri,Kern::Fault("WaitLinkPriT",__LINE__))

_LIT(KLitKill,"Kill");

_LIT(KLitTerminate,"Terminate");

extern const SNThreadHandlers EpocThreadHandlers =

	{

	&DThread::EpocThreadExitHandler,

	NTHREAD_DEFAULT_STATE_HANDLER,

	&Exc::Dispatch,

	&DThread::EpocThreadTimeoutHandler

	};

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

 * Thread cleanup entries

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

EXPORT_C TThreadCleanup::TThreadCleanup()

	: iThread(NULL)

	{

	}

// Enter and return with system locked.

void TThreadCleanup::ChangePriority(TInt aNewPriority)

	{

	__KTRACE_OPT(KTHREAD,Kern::Printf("TThreadCleanup::ChangePriority %d to %d, thread %O nest %d",iPriority,aNewPriority,iThread,K::PINestLevel));

	if (aNewPriority != iPriority)

		{

		if (iThread)

			{

			iThread->iCleanupQ.ChangePriority(this,aNewPriority);

			if (++K::PINestLevel<KMaxPriorityInheritanceNesting)

				iThread->SetRequiredPriority();

			}

		else

			iPriority=TUint8(aNewPriority);

		}

	}

// Enter and return with system locked.

/**

	@pre Interrupts must be enabled.

	@pre Kernel must be unlocked.

	@pre System must be locked

	@pre Call in a thread context.

*/

EXPORT_C void TThreadCleanup::Remove()

	{

	CHECK_PRECONDITIONS(MASK_SYSTEM_LOCKED|MASK_KERNEL_UNLOCKED|MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR|MASK_NOT_IDFC,

		"TThreadCleanup::Remove");

//	__KTRACE_OPT(KTHREAD,Kern::Printf("TThreadCleanup::Remove priority %d, thread %O",iPriority,iThread));

	iThread->iCleanupQ.Remove(this);

	if (iPriority>=iThread->iNThread.i_NThread_BasePri)	// can't affect priority if lower than current

		iThread->SetRequiredPriority();

	}

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

 * Thread

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

#ifdef KTHREAD

void DThread::DefaultUnknownStateHandler(DThread* aThread, TInt anOperation, TInt aParameter)

#else

void DThread::DefaultUnknownStateHandler(DThread* aThread, TInt, TInt)

#endif

	{

	__KTRACE_OPT(KTHREAD,Kern::Printf("UNKNOWN THREAD MSTATE!! thread %O Mstate=%d, operation=%d, parameter=%d",

		aThread,aThread->iMState,anOperation,aParameter));

	Kern::Fault("THREAD STATE",aThread->iMState);

	}

DThread::DThread()

	:	iTls(KTlsArrayGranularity,_FOFF(STls,iHandle)),

		iDebugMask(0xffffffff), iKillDfc(NULL,this,K::SvMsgQ,2),

		iUnknownStateHandler(DefaultUnknownStateHandler),

		iExitType((TUint8)EExitPending)

#ifdef __SMP__

		, iSMPSafeCallback(SMPSafeCallback)

#endif

	{

	iKernMsg.iSem.iOwningThread=&iNThread;

	iMState=ECreated;

	iExiting=EFalse;

	}

// Enter and return with system unlocked.

void DThread::Destruct()

	{

	__KTRACE_OPT(KTHREAD,Kern::Printf("DThread::Destruct %O",this));

	__NK_ASSERT_DEBUG(((TUint)iNThread.iUserModeCallbacks & ~3) == NULL);

	iTls.Close();

	if (iSyncMsgPtr)

		{

		// The sync message might still be outstanding; in particular it may be

		// on the kernel server's list of messages to be cleaned up on behalf of

		// dead clients. So we only release it here if it's free; otherwise, we

		// mutate the type, so that cleanup will return it to the Global pool.

		NKern::LockSystem();

		if (iSyncMsgPtr->IsFree())

			{

			NKern::UnlockSystem();

			__KTRACE_OPT(KSERVER,Kern::Printf("DThread::Destruct(%08X) releasing sync message at %08X", this, iSyncMsgPtr));

			iSyncMsgPtr->ReleaseMessagePool(RMessageK::ESync, 1);

			}

		else

			{

			__KTRACE_OPT(KSERVER,Kern::Printf("DThread::Destruct(%08X) mutating sync message at %08X", this, iSyncMsgPtr));

			iSyncMsgPtr->iMsgType = RMessageK::EGlobal;

			NKern::UnlockSystem();

			}

		iSyncMsgPtr = NULL;

		}

	FreeSupervisorStack();

	iHandles.Close(iOwningProcess);

	Kern::SafeClose(iExtTempObj,NULL);

	if (iNThread.iExtraContextSize > 0)

		Kern::Free(iNThread.iExtraContext);

	}

// Enter and return with system unlocked.

void DThread::Release()

	{

	__KTRACE_OPT(KTHREAD,Kern::Printf("Thread %O Release()",this));

	if (iWaitListReserved)

		{

		iWaitListReserved = 0;

		TThreadWaitList::ThreadDestroyed();

		}

	iTls.Close();

	__KTRACE_OPT(KTHREAD,Kern::Printf("Close temporary object %O",iTempObj));

	Kern::SafeClose(iTempObj,NULL);

	__KTRACE_OPT(KTHREAD,Kern::Printf("Decrement temporary message %08x",iTempMsg));

	if (iTempMsg)

		{

		NKern::LockSystem();

		iTempMsg->CloseRef();

		NKern::UnlockSystem();

		}

	iTempMsg=NULL;

	__KTRACE_OPT(KTHREAD,Kern::Printf("Free temporary allocation %08x",iTempAlloc));

	Kern::Free(iTempAlloc);

	iTempAlloc=NULL;

	__KTRACE_OPT(KTHREAD,Kern::Printf("Removing closing libraries"));

	if (!iClosingLibs.IsEmpty())

		RemoveClosingLibs();

	__KTRACE_OPT(KTHREAD, Kern::Printf("Unmapping code segs delayed by User::Leave() (if any)"));

	if (iLeaveDepth)

		CleanupLeave(iLeaveDepth);

	__KTRACE_OPT(KTHREAD,Kern::Printf("Deleting handles..."));

	iHandles.Close(iOwningProcess);

	__KTRACE_OPT(KTHREAD,Kern::Printf("Deleted handles"));

	// deallocate the user stack if any

	if (iThreadType==EThreadUser)

		FreeUserStack();

	// cancel the timer

	__KTRACE_OPT(KTHREAD,Kern::Printf("Cancelling timer"));

	iTimer.Cancel(NULL);

	__KTRACE_OPT(KTHREAD,Kern::Printf("Freeing supervisor-mode stack"));

	FreeSupervisorStack();

#ifdef BTRACE_THREAD_IDENTIFICATION

	BTrace12(BTrace::EThreadIdentification,BTrace::EThreadDestroy,&iNThread,iOwningProcess,iId);

#endif

	__DEBUG_EVENT(EEventRemoveThread, this);

	__KTRACE_OPT(KTHREAD,Kern::Printf("Closing thread"));

	Close(iOwningProcess);					// close the thread

	}

// Enter and return with system locked.

/**

	@pre Interrupts must be enabled.

	@pre Kernel must be unlocked.

	@pre System must be locked

	@pre Call in a thread context.

*/

EXPORT_C void DThread::AddCleanup(TThreadCleanup* aCleanup)

	{

	CHECK_PRECONDITIONS(MASK_SYSTEM_LOCKED|MASK_KERNEL_UNLOCKED|MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR|MASK_NOT_IDFC,

		"DThread::AddCleanup");

	aCleanup->iThread=this;

	iCleanupQ.Add(aCleanup);

	if (aCleanup->iPriority>iNThread.i_NThread_BasePri)	// can't affect priority unless it's higher than current

		SetActualPriority(aCleanup->iPriority);	// this cleanup item must be the highest priority

	}

// Enter and return with system locked.

void DThread::Suspend(TInt aCount)

	{

	__KTRACE_OPT(KTHREAD,Kern::Printf("Suspend thread %O, count %d",this,aCount));

	TBool r=NKern::ThreadSuspend(&iNThread,aCount);

	if (!r)

		return;		// suspend was deferred (always so if self-suspend)

	// suspend has taken effect - fix up wait queues

	K::PINestLevel=0;

	switch (iMState)

		{

		case ECreated:

		case EDead:

		case EReady:

		case EWaitSemaphoreSuspended:

		case EWaitMutexSuspended:

		case EWaitCondVarSuspended:

			break;

		case EWaitSemaphore:

			((DSemaphore*)iWaitObj)->SuspendWaitingThread(this);

			break;

		case EWaitMutex:

			((DMutex*)iWaitObj)->SuspendWaitingThread(this);

			break;

		case EHoldMutexPending:

			((DMutex*)iWaitObj)->SuspendPendingThread(this);

			break;

		case EWaitCondVar:

			((DCondVar*)iWaitObj)->SuspendWaitingThread(this);

			break;

		default:

			UnknownState(ESuspend,0);

			break;

		}

	}

// Enter and return with system locked.

void DThread::Resume()

	{

	__KTRACE_OPT(KTHREAD,Kern::Printf("Resume thread %O",this));

	TBool r=NKern::ThreadResume(&iNThread);

	if (!r)

		return;				// just cancelled deferred suspends

	// resume has taken effect - fix up wait queues

	K::PINestLevel=0;

	switch (iMState)

		{

		case ECreated:

		case EDead:

		case EReady:

		case EWaitSemaphore:

		case EWaitMutex:

		case EHoldMutexPending:

		case EWaitCondVar:

			break;

		case EWaitSemaphoreSuspended:

			((DSemaphore*)iWaitObj)->ResumeWaitingThread(this);

			break;

		case EWaitMutexSuspended:

			((DMutex*)iWaitObj)->ResumeWaitingThread(this);

			break;

		case EWaitCondVarSuspended:

			((DCondVar*)iWaitObj)->ResumeWaitingThread(this);

			break;

		default:

			UnknownState(EResume,0);

			break;

		}

	}

void DThread::ForceResume()

//

// Resume the thread regardless of nested suspensions

// Enter and return with system locked.

//

	{

	__KTRACE_OPT(KTHREAD,Kern::Printf("ForceResume thread %O",this));

	TBool r=NKern::ThreadForceResume(&iNThread);

	if (!r)

		return;				// just cancelled deferred suspends

	// resume has taken effect - fix up wait queues

	K::PINestLevel=0;

	switch (iMState)

		{

		case ECreated:

		case EDead:

		case EReady:

		case EWaitSemaphore:

		case EWaitMutex:

		case EHoldMutexPending:

		case EWaitCondVar:

			break;

		case EWaitSemaphoreSuspended:

			((DSemaphore*)iWaitObj)->ResumeWaitingThread(this);

			break;

		case EWaitMutexSuspended:

			((DMutex*)iWaitObj)->ResumeWaitingThread(this);

			break;

		case EWaitCondVarSuspended:

			((DCondVar*)iWaitObj)->ResumeWaitingThread(this);

			break;

		default:

			UnknownState(EResume,0);

			break;

		}

	}

// Cancel the thread's timer

// Enter and return with system locked.

EXPORT_C void DThread::CancelTimer()

	{

	iTimer.Cancel(NULL);

	iTimer.iState = (TUint8)TTimer::EIdle;

	}

// Release the thread's wait on any sync object (not explicit suspend)

// Enter and return with system locked.

/**

	@pre Interrupts must be enabled.

	@pre Kernel must be unlocked.

	@pre System must be locked

	@pre Call in a thread context.

*/

EXPORT_C TInt DThread::ReleaseWait(TInt aReturnCode)

	{

	CHECK_PRECONDITIONS(MASK_SYSTEM_LOCKED|MASK_KERNEL_UNLOCKED|MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR|MASK_NOT_IDFC,

		"DThread::ReleaseWait");	

	__KTRACE_OPT(KTHREAD,Kern::Printf("Thread %O ReleaseWait() retcode=%d",this,aReturnCode));

	switch(iMState)

		{

		case ECreated:

		case EDead:

		case EReady:

			return KErrGeneral;

		case EWaitSemaphore:

			((DSemaphore*)iWaitObj)->WaitCancel(this);

			break;

		case EWaitSemaphoreSuspended:

			((DSemaphore*)iWaitObj)->WaitCancelSuspended(this);

			break;

		case EWaitMutex:

			((DMutex*)iWaitObj)->WaitCancel(this);

			break;

		case EWaitMutexSuspended:

			((DMutex*)iWaitObj)->WaitCancelSuspended(this);

			break;

		case EHoldMutexPending:

			((DMutex*)iWaitObj)->RemovePendingThread(this);

			break;

		case EWaitCondVar:

			((DCondVar*)iWaitObj)->WaitCancel(this);

			break;

		case EWaitCondVarSuspended:

			((DCondVar*)iWaitObj)->WaitCancelSuspended(this);

			break;

		default:

			UnknownState(EReleaseWait,aReturnCode);

			break;

		}

	iWaitObj=NULL;

	iMState=EReady;

	NKern::ThreadRelease(&iNThread,aReturnCode);

	return KErrNone;

	}

void DThread::EpocThreadTimeoutHandler(NThread* aThread, TInt aOp)

	{

	if (aOp == NThreadBase::ETimeoutPreamble)

		{

		NKern::LockSystem();

		return;

		}

	if (aOp == NThreadBase::ETimeoutPostamble)

		{

		DThread* pT = _LOFF(aThread, DThread, iNThread);

		pT->ReleaseWait(KErrTimedOut);

		}

	NKern::UnlockSystem();

	}

#ifdef SYMBIAN_CURB_SYSTEMSERVER_PRIORITIES

const TUint8 KPrioritySystemServerMore = 23;

#else

const TUint8 KPrioritySystemServerMore = 24;

#endif // SYMBIAN_CURB_SYSTEMSERVER_PRIORITIES

const TInt KMaxPriorityWithoutProtServ = KPrioritySystemServerMore;

// Mapping table for thread+process priority to thread absolute priority

LOCAL_D const TUint8 ThreadPriorityTable[64] =

	{

//                  Idle MuchLess Less Normal                       More MuchMore RealTime

/*Low*/               1,     1,     2,     3,                         4,     5,      22,       0,

/*Background*/        3,     5,     6,     7,                         8,     9,      22,       0,

/*Foreground*/        3,     10,   11,    12,                        13,    14,      22,       0,

/*High*/              3,     17,   18,    19,                        20,    22,      23,       0,

/*SystemServer1*/     9,     15,   16,    21, KPrioritySystemServerMore,    25,      28,       0,

/*SystemServer2*/     9,     15,   16,    21, KPrioritySystemServerMore,    25,      28,       0,

/*SystemServer3*/     9,     15,   16,    21, KPrioritySystemServerMore,    25,      28,       0,

/*RealTimeServer*/   18,     26,   27,    28,                        29,    30,      31,       0

	};

TInt DThread::CalcDefaultThreadPriority()

	{

	TInt r;

	TInt tp=iThreadPriority;

	if (tp>=0)

		r=(tp<KNumPriorities)?tp:KNumPriorities-1;	// absolute thread priorities

	else

		{

		tp+=8;

		if (tp<0)

			tp=0;

		TInt pp=iOwningProcess->iPriority;	// process priority in range 0 to 7

		TInt i=(pp<<3)+tp;

		r=ThreadPriorityTable[i];	// map thread+process priority to actual priority

		if ((r > KMaxPriorityWithoutProtServ) &&

			!(this->HasCapability(ECapabilityProtServ,__PLATSEC_DIAGNOSTIC_STRING("Warning: thread priority capped to below realtime range"))))

			r = KMaxPriorityWithoutProtServ;

		}

	__KTRACE_OPT(KTHREAD,Kern::Printf("CalcDefaultThreadPriority tp %d pp %d abs %d",iThreadPriority,iOwningProcess->iPriority,r));

	return r;

	}

// Enter and return with system locked.

/**

	@pre Interrupts must be enabled.

	@pre Kernel must be unlocked.

	@pre System must be locked

	@pre Call in a thread context.

*/

EXPORT_C void DThread::SetThreadPriority(TInt aThreadPriority)

	{

	CHECK_PRECONDITIONS(MASK_SYSTEM_LOCKED|MASK_KERNEL_UNLOCKED|MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR|MASK_NOT_IDFC,

		"DThread::SetThreadPriority");

	__KTRACE_OPT(KTHREAD,Kern::Printf("DThread %O SetThreadPriority %d",this,aThreadPriority));

	iThreadPriority=aThreadPriority;

	TInt def=CalcDefaultThreadPriority();

	SetDefaultPriority(def);

	}

// Enter and return with system locked.

void DThread::SetDefaultPriority(TInt aDefaultPriority)

	{

	__KTRACE_OPT(KTHREAD,Kern::Printf("Thread %O SetDefaultPriority %d",this,aDefaultPriority));

#ifdef BTRACE_THREAD_PRIORITY

	BTrace12(BTrace::EThreadPriority,BTrace::EDThreadPriority,&this->iNThread,iThreadPriority,aDefaultPriority);

#endif

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

	// Cap priorities at 1 if we're doing crazy scheduling

	if (TheSuperPage().KernelConfigFlags() & EKernelConfigCrazyScheduling && aDefaultPriority > 1)

		aDefaultPriority = 1;

#endif

	iDefaultPriority=aDefaultPriority;

	NKern::ThreadSetNominalPriority(&iNThread, aDefaultPriority);

	K::PINestLevel=0;

	SetRequiredPriority();

	}

// Enter and return with system locked.

void DThread::SetRequiredPriority()

	{

	TInt p=iDefaultPriority;

	TInt c=iCleanupQ.HighestPriority();

	__KTRACE_OPT(KTHREAD,Kern::Printf("Thread %O SetRequiredPriority def %d cleanup %d nest %d",

								this,p,c,K::PINestLevel));

	if (c>p)

		p=c;

	if (p!=iNThread.i_NThread_BasePri)

		SetActualPriority(p);

	}

// Enter and return with system locked.

void DThread::SetActualPriority(TInt anActualPriority)

	{

	__KTRACE_OPT(KTHREAD,Kern::Printf("Thread %O MState %d SetActualPriority %d",this,iMState,anActualPriority));

	TInt newp=anActualPriority;

	__ASSERT_DEBUG(newp>=0 && newp<KNumPriorities, K::Fault(K::EBadThreadPriority));

	NKern::ThreadSetPriority(&iNThread,newp);

	switch(iMState)

		{

		case ECreated:

		case EWaitSemaphoreSuspended:

		case EWaitMutexSuspended:

		case EWaitCondVarSuspended:

		case EReady:

		case EDead:

			iWaitLink.iPriority=TUint8(newp);

			break;

		case EWaitSemaphore:

			((DSemaphore*)iWaitObj)->ChangeWaitingThreadPriority(this,newp);

			break;

		case EWaitMutex:

			((DMutex*)iWaitObj)->ChangeWaitingThreadPriority(this,newp);

			break;

		case EHoldMutexPending:

			((DMutex*)iWaitObj)->ChangePendingThreadPriority(this,newp);

			break;

		case EWaitCondVar:

			((DCondVar*)iWaitObj)->ChangeWaitingThreadPriority(this,newp);

			break;

		default:

			UnknownState(EChangePriority,newp);

			break;

		}

	__CHECK_PRIORITIES(this);

	}

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