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

// 

//

// NThreadBase member data

#define __INCLUDE_NTHREADBASE_DEFINES__

#include <e32cmn.h>

#include <e32cmn_private.h>

#include "nk_priv.h"

extern "C" void ExcFault(TAny*);

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

 * Fast mutex

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

/** Create a fast mutex

	@publishedPartner

	@released

*/

EXPORT_C NFastMutex::NFastMutex()

	: iHoldingThread(0), iMutexLock(TSpinLock::EOrderFastMutex)

	{

	}

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

 * NSchedulable

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

NSchedulable::NSchedulable()

	:	iSSpinLock(TSpinLock::EOrderThread)

	{

	iPriority = 0;

	iReady = 0;

	iCurrent = 0;

	iLastCpu = 0;

	iNSchedulableSpare1 = 0;

	iPauseCount = 0;

	iSuspended = 0;

	iNSchedulableSpare2 = 0;

	iCpuChange = 0;

	iStopping = 0;

	iFreezeCpu = 0;

	iParent = (NSchedulable*)0xdeadbeef;

	iCpuAffinity = 0;

	new (i_IDfcMem) TDfc(&DeferredReadyIDfcFn, this);

	iEventState = 0;

	iTotalCpuTime64 = 0;

	}

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

 * NThreadGroup

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

NThreadGroup::NThreadGroup()

	{

	iParent = 0;

	iThreadCount = 0;

	new (&iSSpinLock) TSpinLock(TSpinLock::EOrderThreadGroup);

	}

/** Create a thread group

	@publishedPartner

	@prototype

*/

EXPORT_C TInt NKern::GroupCreate(NThreadGroup* aGroup, SNThreadGroupCreateInfo& aInfo)

	{

	new (aGroup) NThreadGroup();

	aGroup->iCpuAffinity = aInfo.iCpuAffinity;

	return KErrNone;

	}

/** Destroy a thread group

	@pre Call in thread context, interrupts enabled, preemption enabled

	@pre No fast mutex held

	@pre Calling thread in critical section

	@pre All threads have left the group

	@publishedPartner

	@prototype

*/

EXPORT_C void NKern::GroupDestroy(NThreadGroup* aGroup)

	{

	NKern::ThreadEnterCS();

	aGroup->DetachTiedEvents();

	NKern::ThreadLeaveCS();

	}

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

 * Thread

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

void InvalidExec()

	{

	FAULT();

	}

static const SFastExecTable DefaultFastExecTable={0,{0}};

static const SSlowExecTable DefaultSlowExecTable={0,(TLinAddr)InvalidExec,0,{{0,0}}};

const SNThreadHandlers NThread_Default_Handlers =

	{

	NTHREAD_DEFAULT_EXIT_HANDLER,

	NTHREAD_DEFAULT_STATE_HANDLER,

	NTHREAD_DEFAULT_EXCEPTION_HANDLER,

	NTHREAD_DEFAULT_TIMEOUT_HANDLER

	};

NThreadWaitState::NThreadWaitState()

	:	iTimer(&TimerExpired, this)

	{

	iWtSt64 = 0;

	iTimer.iTriggerTime = 0;

	iTimer.iNTimerSpare1 = 0;

	}

NThreadBase::NThreadBase()

	:	iRequestSemaphore(), iWaitState()

	{

	iParent = this;

	iWaitLink.iPriority = 0;

	iBasePri = 0;

	iMutexPri = 0;

	i_NThread_Initial = 0;

	iLinkedObjType = EWaitNone;

	i_ThrdAttr = 0;

	iNThreadBaseSpare10 = 0;

	iFastMutexDefer = 0;

	iRequestSemaphore.iOwningThread = (NThreadBase*)this;

	iTime = 0;

	iTimeslice = 0;

	iSavedSP = 0;

	iAddressSpace = 0;

	iHeldFastMutex = 0;

	iUserModeCallbacks = 0;

	iLinkedObj = 0;

	iNewParent = 0;

	iFastExecTable = 0;

	iSlowExecTable = 0;

	iCsCount = 0;

	iCsFunction = 0;

	iHandlers = 0;

	iSuspendCount = 0;

	iStackBase = 0;

	iStackSize = 0;

	iExtraContext = 0;

	iExtraContextSize = 0;

	iNThreadBaseSpare6 = 0;

	iNThreadBaseSpare7 = 0;

	iNThreadBaseSpare8 = 0;

	iNThreadBaseSpare9 = 0;

	// KILL

	iTag = 0;

	iVemsData = 0;

	}

TInt NThreadBase::Create(SNThreadCreateInfo& aInfo, TBool aInitial)

	{

	__KTRACE_OPT(KNKERN,DEBUGPRINT(">NThreadBase::Create %08x(%08x,%d)", this, &aInfo, aInitial));

	if (aInfo.iPriority<0 || aInfo.iPriority>63)

		return KErrArgument;

	if (aInfo.iPriority==0 && !aInitial)

		return KErrArgument;

//	if (aInfo.iCpu!=KCpuAny && aInfo.iCpu>=TheScheduler.iNumCpus)

//		return KErrArgument;

	iStackBase=(TLinAddr)aInfo.iStackBase;

	iStackSize=aInfo.iStackSize;

	iTimeslice=(aInfo.iTimeslice>0)?aInfo.iTimeslice:-1;

	iTime=iTimeslice;

	iPriority=TUint8(aInfo.iPriority);

	iBasePri=TUint8(aInfo.iPriority);

	iCpuAffinity = aInfo.iCpuAffinity;

	iHandlers = aInfo.iHandlers ? aInfo.iHandlers : &NThread_Default_Handlers;

	iFastExecTable=aInfo.iFastExecTable?aInfo.iFastExecTable:&DefaultFastExecTable;

	iSlowExecTable=(aInfo.iSlowExecTable?aInfo.iSlowExecTable:&DefaultSlowExecTable)->iEntries;

	i_ThrdAttr=(TUint8)aInfo.iAttributes;

	if (aInitial)

		{

		TSubScheduler& ss = SubScheduler();

		iLastCpu = (TUint8)ss.iCpuNum;

		iReady = (TUint8)(iLastCpu | EReadyOffset);

		iCurrent = iReady;

		iCpuAffinity = iLastCpu;

		iEventState = (iLastCpu<<EEventCpuShift) | (iLastCpu<<EThreadCpuShift);

		ss.Add(this);

		i_NThread_Initial = TRUE;

		ss.iInitialThread = (NThread*)this;

		NKern::Unlock();		// now that current thread is defined

		}

	else

		{

		iSuspendCount = 1;

		iSuspended = 1;

		TInt ecpu;

		if (iCpuAffinity & NTHREADBASE_CPU_AFFINITY_MASK)

			{

			ecpu = __e32_find_ls1_32(iCpuAffinity);

			if (ecpu >= TheScheduler.iNumCpus)

				ecpu = 0;	// FIXME: Inactive CPU?

			}

		else

			ecpu = iCpuAffinity;

		iEventState = (ecpu<<EEventCpuShift) | (ecpu<<EThreadCpuShift);

		if (aInfo.iGroup)

			{

			NKern::Lock();

			AcqSLock();

			aInfo.iGroup->AcqSLock();

			iParent = (NSchedulable*)aInfo.iGroup;

			++aInfo.iGroup->iThreadCount;

			iEventState |= EEventParent;

			RelSLock();

			NKern::Unlock();

			}

		}

	__KTRACE_OPT(KNKERN,DEBUGPRINT("<NThreadBase::Create OK"));

	return KErrNone;

	}

void NThread_Default_State_Handler(NThread* __DEBUG_ONLY(aThread), TInt __DEBUG_ONLY(aOperation), TInt __DEBUG_ONLY(aParameter))

	{

//	__KTRACE_OPT(KPANIC,DEBUGPRINT("Unknown NState %d: thread %T op %08x par %08x",aThread,aThread->iNState,aOperation,aParameter));

#ifdef _DEBUG

	DEBUGPRINT("UnknownState: thread %T op %08x par %08x",aThread,aOperation,aParameter);

#endif

	FAULT();

	}

void NThread_Default_Exception_Handler(TAny* aContext, NThread*)

	{

	ExcFault(aContext);

	}

/** Create a nanothread.

	This function is intended to be used by the EPOC kernel and by personality

	layers. A nanothread may not use most of the functions available to normal

	Symbian OS threads. Use Kern::ThreadCreate() to create a Symbian OS thread.

	@param aThread Pointer to control block for thread to create.

	@param aInfo Information needed for creating the thread.

	@see SNThreadCreateInfo

	@see Kern::ThreadCreate

	@pre	Call in a thread context.

	@pre	Interrupts must be enabled.

	@pre	Kernel must be unlocked.

 */

EXPORT_C TInt NKern::ThreadCreate(NThread* aThread, SNThreadCreateInfo& aInfo)

	{

	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED|MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR|MASK_NOT_IDFC,"NKern::ThreadCreate");

	return aThread->Create(aInfo,FALSE);

	}

// User-mode callbacks

TUserModeCallback::TUserModeCallback(TUserModeCallbackFunc aFunc)

	:	iNext(KUserModeCallbackUnqueued),

		iFunc(aFunc)

	{

	}

TUserModeCallback::~TUserModeCallback()

	{

	__NK_ASSERT_DEBUG(iNext == KUserModeCallbackUnqueued);

	}

void NKern::CancelUserModeCallbacks()

	{

	// Call any queued callbacks with the EUserModeCallbackCancel reason code, in the current

	// thread.

	TUserModeCallback* listHead =

		(TUserModeCallback*)__e32_atomic_swp_ord_ptr(&NCurrentThread()->iUserModeCallbacks, NULL);

	while (listHead)

		{

		TUserModeCallback* callback = listHead;

		listHead = listHead->iNext;

		callback->iNext = KUserModeCallbackUnqueued;

		__e32_memory_barrier();

		callback->iFunc(callback, EUserModeCallbackCancel);

		}

	}

void NKern::MoveUserModeCallbacks(NThreadBase* aDestThread, NThreadBase* aSrcThread)

	{

	// Move all queued user-mode callbacks from the source thread to the destination thread, and

	// prevent any more from being queued.  Used by the kernel thread code so that callbacks get

	// cancelled in another thread if the thread they were originally queued on dies.

	// Atomically remove list of callbacks and set pointer to 1

	// The latter ensures any subsequent attempts to add callbacks fail

	TUserModeCallback* sourceListStart =

		(TUserModeCallback*)__e32_atomic_swp_ord_ptr(&aSrcThread->iUserModeCallbacks, (TAny*)1);

	__NK_ASSERT_DEBUG(((TUint)sourceListStart & 3) == 0);  // check this only gets called once per thread

	if (sourceListStart == NULL)

		return;

	TUserModeCallback* sourceListEnd = sourceListStart;

	while (sourceListEnd->iNext != NULL)

		sourceListEnd = sourceListEnd->iNext;

	NKern::Lock();

	TUserModeCallback* destListStart = aDestThread->iUserModeCallbacks;

	do

		{

		__NK_ASSERT_DEBUG(((TUint)destListStart & 3) == 0);  // dest thread must not die

		sourceListEnd->iNext = destListStart;

		} while (!__e32_atomic_cas_ord_ptr(&aDestThread->iUserModeCallbacks, &destListStart, sourceListStart));

	NKern::Unlock();

	}

/** Initialise the null thread

	@internalComponent

*/

void NKern::Init(NThread* aThread, SNThreadCreateInfo& aInfo)

	{

	aInfo.iFunction=NULL;			// irrelevant

	aInfo.iPriority=0;				// null thread has lowest priority

	aInfo.iTimeslice=0;				// null thread not timesliced

	aInfo.iAttributes=0;			// null thread does not require implicit locks

	aThread->Create(aInfo,TRUE);	// create the null thread

	}

/** @internalTechnology */

EXPORT_C void NKern::RecordIntLatency(TInt /*aLatency*/, TInt /*aIntMask*/)

	{

	}

/** @internalTechnology */

EXPORT_C void NKern::RecordThreadLatency(TInt /*aLatency*/)

	{

	}

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

 * Deterministic Priority List Implementation

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

/** Construct a priority list with the specified number of priorities

	@param aNumPriorities The number of priorities (must be 1-64).

 */

EXPORT_C TPriListBase::TPriListBase(TInt aNumPriorities)

	{

	memclr(this, sizeof(TPriListBase)+(aNumPriorities-1)*sizeof(SDblQueLink*) );

	}

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

 * Miscellaneous

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

/** Get the current value of the high performance counter.

    If a high performance counter is not available, this uses the millisecond

    tick count instead.

*/

EXPORT_C TUint32 NKern::FastCounter()

	{

	return (TUint32)Timestamp();

	}

/** Get the frequency of counter queried by NKern::FastCounter().

*/

EXPORT_C TInt NKern::FastCounterFrequency()

	{

	return (TInt)TimestampFrequency();

	}

extern "C" {

TUint32 CrashState;

}

EXPORT_C TBool NKern::Crashed()

	{

	return CrashState!=0;

	}

/**	Returns number of nanokernel timer ticks since system started.

	@return tick count

	@pre any context

 */

EXPORT_C TUint32 NKern::TickCount()

	{

	return NTickCount();

	}

TUint32 BTrace::BigTraceId = 0;

TBool BTrace::DoOutBig(TUint32 a0, TUint32 a1, const TAny* aData, TInt aDataSize, TUint32 aContext, TUint32 aPc)

	{

	SBTraceData& traceData = BTraceData;

	// see if trace is small enough to fit in single record...

	if(TUint(aDataSize)<=TUint(KMaxBTraceDataArray+4))

		{

		a0 += aDataSize;

		TUint32 a2 = 0;

		TUint32 a3 = 0;

		if(aDataSize)

			{

			a2 = *((TUint32*&)aData)++; // first 4 bytes into a2

			if(aDataSize>=4 && aDataSize<=8)

				a3 = *(TUint32*)aData; // only 4 more bytes, so pass by value, not pointer

			else

				a3 = (TUint32)aData;

			}

		__ACQUIRE_BTRACE_LOCK();

		TBool r = traceData.iHandler(a0,0,aContext,a1,a2,a3,0,aPc);

		__RELEASE_BTRACE_LOCK();

		return r;

		}

	// adjust for header2, extra, and size word...

	a0 |= BTrace::EHeader2Present<<(BTrace::EFlagsIndex*8)|BTrace::EExtraPresent<<(BTrace::EFlagsIndex*8);

	a0 += 12;

	TUint32 traceId = __e32_atomic_add_ord32(&BigTraceId, 1);

	TUint32 header2 = BTrace::EMultipartFirst;

	TInt offset = 0;

	do

		{

		TUint32 size = aDataSize-offset;

		if(size>KMaxBTraceDataArray)

			size = KMaxBTraceDataArray;

		else

			header2 = BTrace::EMultipartLast;

		if(size<=4)

			*(TUint32*)&aData = *(TUint32*)aData; // 4 bytes or less are passed by value, not pointer

		__ACQUIRE_BTRACE_LOCK();

		TBool result = traceData.iHandler(a0+size,header2,aContext,aDataSize,a1,(TUint32)aData,traceId,aPc);

		__RELEASE_BTRACE_LOCK();

		if (!result)

			return result;

		offset += size;

		*(TUint8**)&aData += size;

		header2 = BTrace::EMultipartMiddle;

		a1 = offset;

		}

	while(offset<aDataSize);

	return TRUE;

	}

EXPORT_C TSpinLock* BTrace::LockPtr()

	{

#ifdef __USE_BTRACE_LOCK__

	return &BTraceLock;

#else

	return 0;

#endif

	}