// Copyright (c) 2003-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:

// e32test\debug\d_context.cpp

// Test LDD exercising hardware/software exception hooks 

// and get/set user context APIs.

// 

//

#include "platform.h"

#include <kernel/kern_priv.h>

#include "kern_test.h"

#include "d_context.h"

_LIT(KClientPanicCat, "D_CONTEXT");

extern TUint32 SpinInKernel(TBool);

DThread* ThreadFromId(TUint aId)

	{

	// This is risky because the thread could die on us an the DThread* become invalid.

	// We are relying on this never happening in our test code.

	NKern::ThreadEnterCS(); 

	DObjectCon& threads=*Kern::Containers()[EThread];

	threads.Wait(); 

	DThread* thread = Kern::ThreadFromId(aId);

	threads.Signal();

	NKern::ThreadLeaveCS(); 

	return thread;

	}

void ModifyContext(TArmRegSet& aContext)

	{

	TArmReg* end = (TArmReg*)(&aContext+1);

	for (TArmReg* p = (TArmReg*)&aContext; p<end; ++p)

		*p = ~*p;

	}

void DumpContext(TArmRegSet& aContext)

	{

	Kern::Printf("  r0 =%08x r1 =%08x r2 =%08x r3 =%08x",aContext.iR0,aContext.iR1,aContext.iR2,aContext.iR3);

	Kern::Printf("  r4 =%08x r5 =%08x r6 =%08x r7 =%08x",aContext.iR4,aContext.iR5,aContext.iR6,aContext.iR7);

	Kern::Printf("  r8 =%08x r9 =%08x r10=%08x r11=%08x",aContext.iR8,aContext.iR9,aContext.iR10,aContext.iR11);

	Kern::Printf("  r12=%08x r13=%08x r14=%08x r15=%08x",aContext.iR12,aContext.iR13,aContext.iR14,aContext.iR15);

	Kern::Printf("  cpsr=%08x dacr=%08x",aContext.iFlags, aContext.iDacr);

	}

inline TBool IsRegisterAvailable(TInt aReg, TUint32 aMask)

	{

	return aMask & (1<<aReg);

	}

TInt CheckSetContext(const TArmRegSet& aSetContext, const TArmRegSet& aContextAfterSet, TUint32 aAvailMask)

	{

	Kern::Printf("Checking all available registers have been modified (0%08x)", aAvailMask);

	const TArmReg* pSet = (const TArmReg*)&aSetContext;

	const TArmReg* pAfterSet = (const TArmReg*)&aContextAfterSet;

	for (int i=0; i<=EArmPc; ++i)

		{

		if (pAfterSet[i] == 0 && IsRegisterAvailable(i, aAvailMask) && pSet[i] != 0)

			{

			Kern::Printf("Register %d not set (expected %08x actual %08x)", i, pSet[i], pAfterSet[i]);

			return KErrCorrupt;

			}

		if (pAfterSet[i] != 0 && ! IsRegisterAvailable(i, aAvailMask))

			{

			Kern::Printf("Register %d incorrectly set (expected %08x actual %08x)", i, 0, pAfterSet[i]);

			return KErrCorrupt;

			}

		}

	return KErrNone;

	}

//////////////////////////////////////////////////////////////////////////////

class DEventHandler : public DKernelEventHandler

	{

public:

	DEventHandler();

	TInt Create(DLogicalDevice* aDevice);

	~DEventHandler();

	void Cancel();

private:

	static TUint EventHandler(TKernelEvent aEvent, TAny* a1, TAny* a2, TAny* aThis);

	TUint HandleEvent(TKernelEvent aType, TAny* a1, TAny* a2);

	TBool HandleException(TRequestStatus*& aStatusPtr, TClientRequest*& aRequestPtr);

	void HandleThreadDeath();

	void Cleanup();

private:

	DThread* iClientThread;

	DMutex* iLock; // serialise calls to handler

public:

	DLogicalDevice* iDevice;	// open reference to LDD for avoiding lifetime issues

	// software exception fields

	TExcType iSwExcLastType;

	TInt* iSwExcCounterPtr;

	TRequestStatus* iSwExcStatusPtr;

	TClientRequest* iClientRequestSwExc;

	// hardware exception fields

	TRequestStatus* iHwExcStatusPtr;

	TClientRequest* iClientRequestHwExc;

	// fields used for both hardware and software exceptions

	TUint iExcThreadId;

	TAny* iExcContextPtr;

	TBool iExcKillThread;

	// thread death event fields

	TUint iDeathThreadId;

	TRequestStatus* iDeathStatusPtr;

	TAny* iDeathContextPtr;

	TClientRequest* iClientRequestDeath;

	};

DEventHandler::DEventHandler() 

	: 	DKernelEventHandler(EventHandler, this) 

	{

	}

TInt DEventHandler::Create(DLogicalDevice* aDevice)

	{

	TInt r;

	r = aDevice->Open();

	if (r != KErrNone)

		goto error;

	iDevice = aDevice;

	iClientThread = &Kern::CurrentThread();

	r = Kern::CreateClientRequest(iClientRequestSwExc);

	if (r != KErrNone)

		goto error;

	r = Kern::CreateClientRequest(iClientRequestHwExc);

	if (r != KErrNone)

		goto error;

	r = Kern::CreateClientRequest(iClientRequestDeath);

	if (r != KErrNone)

		goto error;

	r = Kern::MutexCreate(iLock, _L("EventHandlerLock"), KMutexOrdDebug);

	if (r != KErrNone)

		goto error;

	return Add();

error:

	Cleanup();

	return r;

	}

void DEventHandler::Cleanup()

	{

	if (iLock)

		iLock->Close(NULL);

	if (iDevice)

		iDevice->Close(NULL);

	if (iClientRequestSwExc)

		{

		Kern::DestroyClientRequest(iClientRequestSwExc);

		iClientRequestSwExc = NULL;

		}

	if (iClientRequestHwExc)

		{

		Kern::DestroyClientRequest(iClientRequestHwExc);

		iClientRequestHwExc = NULL;

		}

	if (iClientRequestDeath)

		{

		Kern::DestroyClientRequest(iClientRequestDeath);

		iClientRequestDeath = NULL;

		}

	}

DEventHandler::~DEventHandler()

	{

	Cleanup();

	}

void DEventHandler::Cancel()

	{

	Kern::MutexWait(*iLock);

	if (iHwExcStatusPtr)

		{

		Kern::QueueRequestComplete(iClientThread, iClientRequestHwExc, KErrCancel);

		iHwExcStatusPtr = NULL;

		}

	if (iSwExcStatusPtr)

		{

		Kern::QueueRequestComplete(iClientThread, iClientRequestSwExc, KErrCancel);

		iSwExcStatusPtr = NULL;

		}

	Kern::MutexSignal(*iLock);

	}

TUint DEventHandler::EventHandler(TKernelEvent aEvent, TAny* a1, TAny* a2, TAny* aThis)

	{

	return ((DEventHandler*)aThis)->HandleEvent(aEvent, a1, a2);

	}

// called in thread CS

TUint DEventHandler::HandleEvent(TKernelEvent aType, TAny* a1, TAny* a2)

	{

	// Ensure handler always called in thread critical section

	NThread& nt = Kern::CurrentThread().iNThread;

	__ASSERT_ALWAYS(nt.iCsCount != 0, (NKern::Lock(),*(TInt*)0xfaece5=0));

	TUint r = DKernelEventHandler::ERunNext;

	switch (aType)

		{

	case EEventSwExc:

		// HACK, EVIL UNSAFE MEMORY ACCESS FOLLOWS...

		TInt counter;

		// folowing will kill system if memory is bad (because we're in a critical section)

		umemget32(&counter, iSwExcCounterPtr, sizeof(TInt*));

		++counter;

		umemput32(iSwExcCounterPtr, &counter, sizeof(TInt));

		Kern::MutexWait(*iLock);

		iSwExcLastType = (TExcType)(TInt)a1;

		if (iSwExcStatusPtr)

			HandleException(iSwExcStatusPtr, iClientRequestSwExc);

		Kern::MutexSignal(*iLock);

		break;

	case EEventHwExc:

		Kern::MutexWait(*iLock);

		if (iHwExcStatusPtr)

			if (HandleException(iHwExcStatusPtr, iClientRequestHwExc))

				r |= (TUint)EExcHandled;

		Kern::MutexSignal(*iLock);

		break;

	case EEventKillThread:

		Kern::MutexWait(*iLock);

		HandleThreadDeath();

		Kern::MutexSignal(*iLock);

		break;

	default:

		// NO-OP

		break;

		}

	return r;

	}

// called in thread CS

TBool DEventHandler::HandleException(TRequestStatus*& aStatusPtr, TClientRequest*& aRequestPtr)

	{

	DThread& t = Kern::CurrentThread();

	TBool handled = EFalse;

	if (iExcThreadId == t.iId)

		{

		Kern::Printf("Trapped exception");

		TArmRegSet context1;

		TUint32 availmask;

		NKern::ThreadGetUserContext(&t.iNThread, &context1, availmask);

		XTRAPD(r, XT_DEFAULT, umemput(iExcContextPtr, &context1, sizeof(context1)));

		if (r == KErrNone)

			{

			if (iExcKillThread)

				{

				// We must preserve PC for software exceptions because execution

				// goes back user-side and only then is the thread panicked.

				TArmReg r15usr = context1.iR15;

				ModifyContext(context1);

				context1.iR15 = r15usr;

				NKern::ThreadSetUserContext(&t.iNThread, &context1);

				TArmRegSet context2;

				memclr(&context2, sizeof context2);

				NKern::ThreadGetUserContext(&t.iNThread, &context2, availmask);

				r = CheckSetContext(context1, context2, availmask);

				}

			else

				{

				Kern::ThreadSuspend(t, 1);

				handled = ETrue;

				}

			}

		Kern::QueueRequestComplete(iClientThread, aRequestPtr, r);

		aStatusPtr = NULL;

		}

	return handled;

	}

// called in thread CS

void DEventHandler::HandleThreadDeath()

	{

	DThread& t = Kern::CurrentThread();

	if (iDeathStatusPtr && iDeathThreadId == t.iId)

		{

		Kern::Printf("Trapping thread death: %O", &t);

		TArmRegSet context;

		TUint32 unused;

		NKern::ThreadGetUserContext(&t.iNThread, &context, unused);

		XTRAPD(r, XT_DEFAULT, umemput(iDeathContextPtr, &context, sizeof(context)));

		Kern::QueueRequestComplete(iClientThread, iClientRequestDeath, r);

		iDeathStatusPtr = NULL;

		}

	}

//////////////////////////////////////////////////////////////////////////////

class DTestChannel : public DLogicalChannelBase

	{

public:

	virtual ~DTestChannel();

protected:

	// from DLogicalChannelBase

	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

	virtual TInt Request(TInt aFunction, TAny* a1, TAny* a2);

private:

	TInt SetAndGetBackContext(TUint aId, TAny* aContext);

	TInt SetAndGetFullContext(TUint aId, TAny* aContext);

	void GetContext(TUint aId, TAny* aContext);

	void GetKernelContext(TUint aId, TAny* aContext);

	void AddUserCallback(TUint aId, TUserCallbackState aCallback);

private:

	DEventHandler* iHandler;

	};

// called in thread critical section

TInt DTestChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)

	{

	return KErrNone;

	}

// called in thread critical section

DTestChannel::~DTestChannel()

	{

	if (iHandler)

		{

		iHandler->Cancel();

		iHandler->Close();

		}

	}

TInt DTestChannel::Request(TInt aFunction, TAny* a1, TAny* a2)

	{

	RContextLdd::TTrapInfo info;

	DThread* pT;

	TInt r = KErrNone;

	switch (aFunction)

		{

	case RContextLdd::EHook:

		NKern::ThreadEnterCS();

		iHandler = new DEventHandler;

		if (!iHandler)

			r = KErrNoMemory;

		else

			{

			r = iHandler->Create(iDevice);

			iHandler->iSwExcCounterPtr = (TInt*)a1;

			}

		NKern::ThreadLeaveCS();

		break;

	case RContextLdd::EGetLastExc:

		r = iHandler->iSwExcLastType;

		break;

	case RContextLdd::ETrapNextSwExc:

	case RContextLdd::ETrapNextHwExc:

		umemget(&info, a1, sizeof(info));

		if (aFunction == RContextLdd::ETrapNextHwExc)

			{

			__ASSERT_ALWAYS(iHandler->iSwExcStatusPtr==NULL, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

			iHandler->iHwExcStatusPtr = info.iStatusPtr;

			r = iHandler->iClientRequestHwExc->SetStatus(iHandler->iHwExcStatusPtr);

			__ASSERT_ALWAYS(r==KErrNone, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

			}

		else

			{

			__ASSERT_ALWAYS(iHandler->iHwExcStatusPtr==NULL, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

			iHandler->iSwExcStatusPtr = info.iStatusPtr;

			r = iHandler->iClientRequestSwExc->SetStatus(iHandler->iSwExcStatusPtr);

			__ASSERT_ALWAYS(r==KErrNone, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

			}

		iHandler->iExcThreadId = info.iThreadId;

		iHandler->iExcContextPtr = info.iContextPtr;

		iHandler->iExcKillThread = info.iKillThread;

		break;

	case RContextLdd::ETrapNextDeath:

		umemget(&info, a1, sizeof(info));

		iHandler->iDeathThreadId = info.iThreadId;

		iHandler->iDeathContextPtr = info.iContextPtr;

		iHandler->iDeathStatusPtr = info.iStatusPtr;

		r = iHandler->iClientRequestDeath->SetStatus(iHandler->iDeathStatusPtr);

		__ASSERT_ALWAYS(r==KErrNone, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

		break;

	case RContextLdd::EGetContext:

		GetContext((TUint)a1, a2);

		break;

	case RContextLdd::ESetGetContext:

		r = SetAndGetBackContext((TUint)a1, a2);

		break;

	case RContextLdd::ESetGetFullContext:

		r = SetAndGetFullContext((TUint)a1, a2);

		break;

	case RContextLdd::EGetKernelContext:

		GetKernelContext((TUint)a1, a2);

		break;

	case RContextLdd::ESpinInKernel:

		r = SpinInKernel((TBool)a1);

		break;

	case RContextLdd::EAddUserCallback:

		AddUserCallback((TUint)a1, (TUserCallbackState)(TUint)a2);

		break;

	case RContextLdd::EResumeTrappedThread:

		pT = ThreadFromId((TUint)a1);

		Kern::ThreadResume(*pT);

		break;

	default:

		Kern::PanicCurrentThread(KClientPanicCat, __LINE__);

		break;

		}

	return r;

	}

TInt DTestChannel::SetAndGetBackContext(TUint aId, TAny* aContext)

	{

	DThread* pT = ThreadFromId(aId);

	__ASSERT_ALWAYS(pT!=NULL, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	// The following code assumes the inspected thread does not run between the

	// set context and get context call.

	TArmRegSet context1;

	umemget(&context1, aContext, sizeof context1);

	NKern::ThreadSetUserContext(&pT->iNThread, &context1);

	TArmRegSet context2;

	memclr(&context2, sizeof context2);

	TUint32 availmask;

	NKern::ThreadGetUserContext(&pT->iNThread, &context2, availmask);

	umemput(aContext, &context2, sizeof context2);

	return CheckSetContext(context1, context2, availmask);

	}

#ifdef __SMP__

class NKTest

	{

public:

	static TBool IsDead(NThreadBase* aT)

		{ return aT->iWaitState.ThreadIsDead(); }

	};

#endif

TInt DTestChannel::SetAndGetFullContext(TUint aId, TAny* aContext)

	{

	DThread* pT = ThreadFromId(aId);

	__ASSERT_ALWAYS(pT != NULL, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	TBool dead;

#ifdef __SMP__

	dead = NKTest::IsDead(&pT->iNThread);

#else

	dead = pT->iNThread.iSpare1 == NThreadBase::EDead;

#endif

	__ASSERT_ALWAYS(dead, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	TArmFullContext contextData;

	umemget(&contextData, aContext, sizeof contextData);

	NKern::ThreadSetUserContext(&pT->iNThread, &contextData.iUserContext);

	NKern::ThreadGetUserContext(&pT->iNThread, &contextData.iUserContext, contextData.iUserAvail);

	NKern::ThreadGetSystemContext(&pT->iNThread, &contextData.iSystemContext, contextData.iSystemAvail);

	umemput(aContext, &contextData, sizeof contextData);

	return KErrNone;

	}

void DTestChannel::GetContext(TUint aId, TAny* aContext)

	{

	DThread* pT = ThreadFromId(aId);

	__ASSERT_ALWAYS(pT!=NULL, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	TArmRegSet context;

	memclr(&context, sizeof context);

	TUint32 unused;

	NKern::ThreadGetUserContext(&pT->iNThread, &context, unused);

	umemput(aContext, &context, sizeof context);

	}

void DTestChannel::GetKernelContext(TUint aId, TAny* aContext)

	{

	DThread* pT = ThreadFromId(aId);

	__ASSERT_ALWAYS(pT!=NULL, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	TArmRegSet context;

	memclr(&context, sizeof context);

	TUint32 unused;

	NKern::ThreadGetSystemContext(&pT->iNThread, &context, unused);

	umemput(aContext, &context, sizeof context);

	}

void DTestChannel::AddUserCallback(TUint aId, TUserCallbackState aCallback)

	{

	DThread* pT = ThreadFromId(aId);

	__ASSERT_ALWAYS(pT!=NULL, Kern::PanicCurrentThread(KClientPanicCat, __LINE__));

	switch (aCallback)

		{

	case ESpinningCallback:

		KernTest::Test(KernTest::EUserModeCallbackSpin, pT);

		break;

	case ESleepingCallback:

		KernTest::Test(KernTest::EUserModeCallbackSleep, pT);

		break;

	default:

		Kern::PanicCurrentThread(KClientPanicCat, __LINE__);

		}

	}

//////////////////////////////////////////////////////////////////////////////

class DTestFactory : public DLogicalDevice

	{

public:

	DTestFactory();

	// from DLogicalDevice

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DLogicalChannelBase*& aChannel);

	};

DTestFactory::DTestFactory()

    {

    iVersion = RContextLdd::Version();

    // iParseMask = 0; // no unit, no info, no PDD

    // iUnitsMask = 0; // only one thing

    }

TInt DTestFactory::Create(DLogicalChannelBase*& aChannel)

    {

	aChannel=new DTestChannel;

	return aChannel ? KErrNone : KErrNoMemory;

    }

TInt DTestFactory::Install()

    {

    return SetName(&KTestLddName);

    }

void DTestFactory::GetCaps(TDes8& /*aDes*/) const

    {

    }

//////////////////////////////////////////////////////////////////////////////

DECLARE_STANDARD_LDD()

	{

    return new DTestFactory;

	}