// 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\t_context.cpp
// Overview:
// Exercise kernel-side functions to get, set user-side context and 
// kernel-side exception handlers.
// API Information:
// RBusLogicalChannel, DLogicalChannel.
// Details:
// - Load the context logical device driver, open user side handle to 
// a LDD channel and check software exception scheme when handle is 
// not created.
// - Check user-side handler called when kernel-side handler is not
// created and exception is handled as expected.
// - Make a synchronous Kernel Executive type request to logical channel
// for a specific functionality and check that it is as expected.
// - Check that kernel-side handler is not triggered by IsExceptionHandler 
// method.
// - Test user-side, kernel-side handlers are as expected.
// - In the context of thread taking hardware exception with synchronous
// and asynchronous killing:
// - check context captured in hardware exception hook and
// context captured in RemoveThread hook are as expected.
// - In the context of thread taking software exception with synchronous 
// and asynchronous killing:
// - check context captured in software exception hook and
// context captured in RemoveThread hook are as expected.
// - In the context of thread blocked on WFAR:
// - check context captured while thread is blocked, 
// context can be modified while thread is blocked, 
// context captured in RemoveThread hook are as expected.
// - In the context of thread killed after being pre-empted by interrupt 
// while in user mode:
// - check context captured while thread is spinning, context can be 
// modified while thread is blocked, context captured in RemoveThread 
// hook are as expected.
// - Check whether heap has been corrupted by all the tests.
// - Check that the system doesn't crash when the context of a dead thread is
// set or retrieved.
// Platforms/Drives/Compatibility:
// Hardware (Automatic). 
// Assumptions/Requirement/Pre-requisites:
// Failures and causes:
// Base Port information:
// 
//

#define __E32TEST_EXTENSION__
#include <e32test.h>
#include <e32svr.h>
#include <e32def.h>
#include <e32def_private.h>
#include <u32hal.h>
#include "d_context.h"
#include "context.h"

enum TKillMode 
	{ 
	ESynchronousKill, // thread kills itself in exception handler
	EAsynchronousKill // thread suspends itself in exception handler and is killed by main thread
	};

_LIT(KUserExecPanic, "USER-EXEC");

RTest test(_L("T_CONTEXT"));

TInt KernelExcCount; // incremented when user-side exception handler called
TInt UserExcCount;   // incremented when kernel-side exception handler called
TExcType LastUserExcType; // set by user-side exception handler when called

RContextLdd Channel;


TInt CallDeviceDriverAndSpin(TAny* aExpected)
	{
	TArmRegSet* expectedContext = (TArmRegSet*)aExpected;
	expectedContext->iR13 = Channel.SpinInKernel(EFalse);
	Channel.SpinInKernel(ETrue);
	return 0;
	}

TInt UserRaiseExceptionThread(TAny* aExcType)
	{
	TExcType e = static_cast<TExcType>(reinterpret_cast<TInt>(aExcType));
	User::RaiseException(e);
	return 0;
	}

TInt RThreadRaiseExceptionThread(TAny* aExcType)
	{
	TExcType e = static_cast<TExcType>(reinterpret_cast<TInt>(aExcType));
	User::RaiseException(e);
	return 0;
	}

void UserExceptionHandler(TExcType aType)
	{
	// Check kernel-side handler was called before user-side one
	if (Channel.IsHooked() && KernelExcCount != 1)
		User::Invariant(); // force failure in RaiseExceptionHarness()

	LastUserExcType = aType;
	UserExcCount++;
	User::Panic(KUserExecPanic, ECausedException);
	}

TInt UserTrapExceptionThread(TAny* aExcType)
	{
	TInt r = User::SetExceptionHandler(UserExceptionHandler, 0xFFFFFFFF);
	if (r != KErrNone)
		return 0; // force failure in RaiseExceptionHarness()
	TExcType e = static_cast<TExcType>(reinterpret_cast<TInt>(aExcType));
	User::RaiseException(e);
	return 0;
	}
	
TInt NaturalDeathFunc(TAny*)
	{// Don't do too much but be sure to complete.
	return KErrNone;
	}


void RaiseExceptionHarness(TThreadFunction aFn, TExcType aType)
	{
	RThread t;
	TInt r = t.Create(_L("RaiseException"), aFn, KDefaultStackSize, NULL, 
						reinterpret_cast<TAny*>(aType));
	test(r == KErrNone);

	TRequestStatus s;
	t.Logon(s);
	TBool oldJitSetting = User::JustInTime();
	User::SetJustInTime(EFalse);
	t.Resume();
	User::WaitForRequest(s);
	User::SetJustInTime(oldJitSetting);

	test(t.ExitType() == EExitPanic);
	test(t.ExitCategory() == KUserExecPanic);
	test(t.ExitReason() == ECausedException);
	CLOSE_AND_WAIT(t);
	}


void TestSwExcNoHandlers()
	{
	test.Next(_L("Check software exception scheme when no handler"));

	RaiseExceptionHarness(UserRaiseExceptionThread, EExcGeneral);
	RaiseExceptionHarness(RThreadRaiseExceptionThread, EExcGeneral);
	}

void TestUserSwExcHandlerAlone()
	{
	test.Next(_L("Check user-side handler called when no kernel-side handler"));

	UserExcCount = 0;
	RaiseExceptionHarness(UserTrapExceptionThread, EExcIntegerDivideByZero);
	test(LastUserExcType == EExcIntegerDivideByZero);
	test(UserExcCount == 1);
	}

void TestUserAndKernelSwExcHandlers()
	{
	test.Next(_L("Check kernel-side exception handler"));
	test.Start(_L("Check kernel-side handler called"));

	KernelExcCount = 0;
	RaiseExceptionHarness(UserRaiseExceptionThread, EExcUserInterrupt);
	test(KernelExcCount == 1);
	test(Channel.LastException() == EExcUserInterrupt);

	KernelExcCount = 0;
	RaiseExceptionHarness(RThreadRaiseExceptionThread, EExcIntegerDivideByZero);
	test(KernelExcCount == 1);
	test(Channel.LastException() == EExcIntegerDivideByZero);

	test.Next(_L("Check kernel-side handler not triggered by IsExceptionHandler()"));
	
	KernelExcCount = 0;
	(void) User::IsExceptionHandled(EExcUserInterrupt);
	test(KernelExcCount == 0);

	test.Next(_L("Check user-side + kernel-side handler"));

	UserExcCount = 0;
	KernelExcCount = 0;
	RaiseExceptionHarness(UserTrapExceptionThread, EExcIntegerDivideByZero);
	test(LastUserExcType == EExcIntegerDivideByZero);
	test(UserExcCount == 1);
	test(KernelExcCount == 1);
	test(Channel.LastException() == EExcIntegerDivideByZero);

	test.End();
	}


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

void DumpContext(const TDesC& aTitle, TArmRegSet& aContext)
	{
	test.Printf(_L("%S\n"), &aTitle);
	test.Printf(_L("  r0 =%08x r1 =%08x r2 =%08x r3 =%08x\n"),aContext.iR0,aContext.iR1,aContext.iR2,aContext.iR3);
	test.Printf(_L("  r4 =%08x r5 =%08x r6 =%08x r7 =%08x\n"),aContext.iR4,aContext.iR5,aContext.iR6,aContext.iR7);
	test.Printf(_L("  r8 =%08x r9 =%08x r10=%08x r11=%08x\n"),aContext.iR8,aContext.iR9,aContext.iR10,aContext.iR11);
	test.Printf(_L("  r12=%08x r13=%08x r14=%08x r15=%08x\n"),aContext.iR12,aContext.iR13,aContext.iR14,aContext.iR15);
	test.Printf(_L("  cpsr=%08x dacr=%08x\n"),aContext.iFlags, aContext.iDacr);
	}

void ModifyContext(TArmRegSet& aContext)
	{
	TArmReg* end = (TArmReg*)(&aContext+1);
	for (TArmReg* p = (TArmReg*)&aContext; p<end; ++p)
		*p = ~*p;
	}


void TestHwExcContext(TKillMode aKillMode, TUserCallbackState aCallback)
	{
	test.Next(_L("Check context of thread taking hardware exception"));
	if (aKillMode == EAsynchronousKill)
		test.Printf(_L("Thread will be asynchronously killed\n"));
	else
		test.Printf(_L("Thread will kill itself\n"));

	TArmRegSet expectedContext;
	RThread t;
	TInt r = t.Create(_L("ContextHwExc"), ThreadContextHwExc, KDefaultStackSize, NULL, &expectedContext);
	test(r == KErrNone);

	TArmRegSet exceptionContext;
	TRequestStatus exceptionStatus;
	Channel.TrapNextHwExc(t.Id(), &exceptionContext, exceptionStatus, aKillMode==ESynchronousKill);

	TRequestStatus deathStatus;
	TArmRegSet deathContext;
	Channel.TrapNextDeath(t.Id(), &deathContext, deathStatus);

	TBool oldJitSetting = User::JustInTime();
	User::SetJustInTime(EFalse);
	t.Resume();
	User::WaitForRequest(exceptionStatus);
	User::SetJustInTime(oldJitSetting);
	test(exceptionStatus == KErrNone); // See CheckSetContext() in LDD

	test.Start(_L("Check context captured in hardware exception hook"));
	exceptionContext.iR15 += 4; // See CheckContextHwExc()
	DumpContext(_L("Expected context:"), expectedContext);
	DumpContext(_L("Context in hw exception hook:"), exceptionContext);
	test(CheckContextHwExc(&exceptionContext, &expectedContext));

	if (aCallback != ENoCallback)
		{
		test.Printf(_L("Adding user callback type %d\n"), aCallback);
		Channel.AddUserCallback(t.Id(), aCallback);
		Channel.ResumeTrappedThread(t.Id());
		User::After(500000);

		test.Next(_L("Check context captured while thread is in callback"));
		TArmRegSet callbackContext;
		Channel.GetContext(t.Id(), &callbackContext);
		callbackContext.iR15 += 4; // See CheckContextHwExc()
		DumpContext(_L("Expected context:"), expectedContext);
		DumpContext(_L("Actual context:"), callbackContext);
		test(CheckContextHwExc(&callbackContext, &expectedContext));
		}

	ModifyContext(expectedContext);
	DumpContext(_L("Expected context after modification:"), expectedContext);

	if (aKillMode == EAsynchronousKill)
		{
		test.Next(_L("Check context can be modified by another thread"));
		TArmRegSet modifiedContext = expectedContext;
		test(Channel.SetAndGetBackContext(t.Id(), &modifiedContext) == KErrNone);
		modifiedContext.iR15 = exceptionContext.iR15; // See CheckContextHwExc()
		DumpContext(_L("Actual context after modification:"), modifiedContext);
		test(CheckContextHwExc(&modifiedContext, &expectedContext));

		User::SetJustInTime(EFalse);
		t.Panic(_L("TEST"), 42);
		}
	else
		{
		// The thread has modified its own user context in the exception hook.
		User::SetJustInTime(EFalse);
		}

	User::WaitForRequest(deathStatus);
	User::SetJustInTime(oldJitSetting);
	CLOSE_AND_WAIT(t);

	test.Next(_L("Check context captured in RemoveThread hook"));
	deathContext.iR15 = exceptionContext.iR15; // See CheckContextHwExc()
	DumpContext(_L("context in RemoveThread hook:"), deathContext);
	test(CheckContextHwExc(&deathContext, &expectedContext));
	test.End();
	}


void TestSwExcContext(TKillMode aKillMode, TUserCallbackState aCallback)
	{
	test.Next(_L("Check context of thread taking software exception (slow executive call)"));
	if (aKillMode == EAsynchronousKill)
		test.Printf(_L("Thread will be asynchronously killed\n"));
	else
		test.Printf(_L("Thread will kill itself\n"));

	TArmRegSet expectedContext;
	RThread t;
	TInt r = t.Create(_L("ContextSwExc"), ThreadContextSwExc, KDefaultStackSize, NULL, &expectedContext);
	test(r == KErrNone);

	TArmRegSet exceptionContext;
	TRequestStatus exceptionStatus;
	Channel.TrapNextSwExc(t.Id(), &exceptionContext, exceptionStatus, aKillMode == ESynchronousKill);

	TRequestStatus deathStatus;
	TArmRegSet deathContext;
	Channel.TrapNextDeath(t.Id(), &deathContext, deathStatus);

	TBool oldJitSetting = User::JustInTime();
	User::SetJustInTime(EFalse);
	t.Resume();
	User::WaitForRequest(exceptionStatus);
	User::SetJustInTime(oldJitSetting);
	test(exceptionStatus == KErrNone); // See CheckSetContext() in LDD

	test.Start(_L("Check context captured in software exception hook"));
	DumpContext(_L("Expected context:"), expectedContext);
	DumpContext(_L("Context in sw exception hook:"), exceptionContext);
	test(CheckContextSwExc(&exceptionContext, &expectedContext));

	if (aCallback != ENoCallback)
		{
		test.Printf(_L("Adding user callback type %d\n"), aCallback);
		Channel.AddUserCallback(t.Id(), aCallback);
		Channel.ResumeTrappedThread(t.Id());
		User::After(500000);

		test.Next(_L("Check context captured while thread is in callback"));
		TArmRegSet callbackContext;
		Channel.GetContext(t.Id(), &callbackContext);
		DumpContext(_L("Expected context:"), expectedContext);
		DumpContext(_L("Actual context:"), callbackContext);
		test(CheckContextSwExc(&callbackContext, &expectedContext));
		}

	ModifyContext(expectedContext);
	DumpContext(_L("Expected context after modification:"), expectedContext);

	if (aKillMode == EAsynchronousKill)
		{
		test.Next(_L("Check context can be modified by another thread"));
		TArmRegSet modifiedContext = expectedContext;
		test(Channel.SetAndGetBackContext(t.Id(), &modifiedContext) == KErrNone);
		modifiedContext.iR14 = exceptionContext.iR14; // See CheckContextSwExc()
		modifiedContext.iR15 = exceptionContext.iR15; // See CheckContextSwExc()
		DumpContext(_L("Actual context after modification:"), modifiedContext);
		test(CheckContextSwExc(&modifiedContext, &expectedContext));

		User::SetJustInTime(EFalse);
		t.Panic(_L("TEST"), 24);
		}
	else
		{
		// The thread has modified its own user context in the exception hook.
		User::SetJustInTime(EFalse);
		}

	User::WaitForRequest(deathStatus);
	User::SetJustInTime(oldJitSetting);
	CLOSE_AND_WAIT(t);

	test.Next(_L("Check context captured in RemoveThread hook"));
	deathContext.iR14 = exceptionContext.iR14; // See CheckContextSwExc()
	deathContext.iR15 = exceptionContext.iR15; // See CheckContextSwExc()
	DumpContext(_L("context in RemoveThread hook:"), deathContext);
	test(CheckContextSwExc(&deathContext, &expectedContext));
	test.End();
	}

void TestKillWFAR(TUserCallbackState aCallback)
	{
	test.Next(_L("Check context of thread blocked on WFAR"));

	TArmRegSet expectedContext;
	RThread t;
	TInt r = t.Create(_L("ContextWFAR"), ThreadContextWFAR, KDefaultStackSize, NULL, &expectedContext);
	test(r == KErrNone);

	TRequestStatus deathStatus;
	TArmRegSet deathContext;
	Channel.TrapNextDeath(t.Id(), &deathContext, deathStatus);

	// Boost thread's priority and kick it off.  This ensures we'll 
	// run again only after it is blocked on its request semaphore.
	t.SetPriority(EPriorityMore);
	t.Resume();

	if (aCallback != ENoCallback)
		{
		test.Printf(_L("Adding user callback type %d\n"), aCallback);
		Channel.AddUserCallback(t.Id(), aCallback);
		t.SetPriority(EPriorityNormal);
		t.RequestSignal();
		User::After(500000);
		}

	test.Start(_L("Check context captured while thread is blocked"));
	TArmRegSet blockedContext;
	Channel.GetContext(t.Id(), &blockedContext);
	DumpContext(_L("Expected context:"), expectedContext);
	DumpContext(_L("Actual context:"), blockedContext);
	test(CheckContextWFAR(&blockedContext, &expectedContext));

	test.Next(_L("Check context can be modified while thread is blocked"));
	ModifyContext(expectedContext);
	expectedContext.iR14 = blockedContext.iR14; // See CheckContextWFAR()
	expectedContext.iR15 = blockedContext.iR15; // See CheckContextWFAR()
	TArmRegSet modifiedContext = expectedContext;
	test(Channel.SetAndGetBackContext(t.Id(), &modifiedContext) == KErrNone);
	DumpContext(_L("Expected context after modification:"), expectedContext);
	DumpContext(_L("Actual context after modification:"), modifiedContext);
	test(CheckContextWFAR(&modifiedContext, &expectedContext));
	
	TBool oldJitSetting = User::JustInTime();
	User::SetJustInTime(EFalse);
	t.Panic(_L("TEST"), 999);
	User::WaitForRequest(deathStatus);
	User::SetJustInTime(oldJitSetting);
	CLOSE_AND_WAIT(t);

	test.Next(_L("Check context captured in RemoveThread hook"));
	DumpContext(_L("Expected context:"), expectedContext);
	DumpContext(_L("context in RemoveThread hook:\n"), deathContext);
	test(CheckContextWFARDied(&deathContext, &expectedContext));
	test.End();
	}

void TestKillInterrupt(TUserCallbackState aCallback)
	{
	test.Next(_L("Check context of thread killed after being preempted by interrupt while in user mode"));

	TArmRegSet expectedContext;
	RThread t;
	TInt r = t.Create(_L("ContextKillInterrupt"), ThreadContextUserInt, KDefaultStackSize, NULL, &expectedContext);
	test(r == KErrNone);

	TArmRegSet trappedContext;
	TRequestStatus trapStatus;
	Channel.TrapNextDeath(t.Id(), &trappedContext, trapStatus);
	
	t.Resume();
	User::After(500000);

	if (aCallback != ENoCallback)
		{
		test.Printf(_L("Adding user callback type %d\n"), aCallback);
		Channel.AddUserCallback(t.Id(), aCallback);
		User::After(500000);
		}

	test.Start(_L("Check context captured while thread is spinning"));
	TArmRegSet spinContext;
	Channel.GetContext(t.Id(), &spinContext);
	DumpContext(_L("Expected context:"), expectedContext);
	DumpContext(_L("Actual context:"), spinContext);
	test(CheckContextUserInt(&spinContext, &expectedContext));

	test.Next(_L("Check context can be modified while thread is spinning"));
	ModifyContext(expectedContext);
	expectedContext.iR15 = spinContext.iR15; // see CheckContextUserInt()
	expectedContext.iFlags = spinContext.iFlags; // must be left unmodified
	expectedContext.iDacr = spinContext.iDacr; // must be left unmodified
	DumpContext(_L("Expected context after modification:"), expectedContext);
	TArmRegSet modifiedContext = expectedContext;
	test(Channel.SetAndGetBackContext(t.Id(), &modifiedContext) == KErrNone);
	DumpContext(_L("Actual context after modification:"), modifiedContext);
	test(CheckContextUserInt(&modifiedContext, &expectedContext));
	
	TBool oldJitSetting = User::JustInTime();
	User::SetJustInTime(EFalse);
	t.Kill(-1);
	User::WaitForRequest(trapStatus);
	User::SetJustInTime(oldJitSetting);
	CLOSE_AND_WAIT(t);

	test.Next(_L("Check context captured in RemoveThread hook"));
	DumpContext(_L("Expected context:"), expectedContext);
	DumpContext(_L("Trapped context:"), trappedContext);
	test(CheckContextUserIntDied(&trappedContext, &expectedContext));
	test.End();
	}

void TestKernelContext()
	{
	test.Start(_L("Test kernel context function"));
	
	TArmRegSet kernelContext, expectedContext;
	for (TInt i=0; i<15; ++i)
		*(((TUint32*)&expectedContext)+i) = 0xa0000000 + i;
	
	RThread t;
	TInt r = t.Create(_L("SpinInKernel"), CallDeviceDriverAndSpin, KDefaultStackSize, NULL, &expectedContext);
	test(r == KErrNone);
	t.Resume();
	
	User::After(500000);
	Channel.GetKernelContext(t.Id(), &kernelContext);
	
	TBool oldJitSetting = User::JustInTime();
	User::SetJustInTime(EFalse);
	t.Kill(-1);
	User::SetJustInTime(oldJitSetting);
	CLOSE_AND_WAIT(t);

	test.Next(_L("Check kernel context is as expected"));
	DumpContext(_L("Expected context:"), expectedContext);
	DumpContext(_L("Actual context:"), kernelContext);
	test(CheckContextKernel(&kernelContext, &expectedContext));

	test.End();
	}

void TestNaturalDeathContext()
	{
	test.Start(_L("Test setting and retrieving the context of a dead thread"));
	TArmFullContext context;
	memclr(&context, sizeof context);

	RThread t;
	TInt r = t.Create(_L("NaturalDeath"), NaturalDeathFunc, KDefaultStackSize, NULL, NULL);
	test_KErrNone(r);
	t.Resume();
	
	User::After(500000);
	Channel.SetAndGetFullContext(t.Id(), &context);

	// Verify that no registers should be available for this dead thread.
	test_Equal(0, context.iUserAvail);
	test_Equal(0, context.iSystemAvail);

	t.Close();
	test.End();
	}

TInt E32Main()
	{
	test.Title();
	
	test.Start(_L("Loading LDD"));
	TInt r = User::LoadLogicalDevice(_L("D_CONTEXT"));
	test(r == KErrNone || r == KErrAlreadyExists);
	
	// Must be after LDD loading because User::FreeLogicalDevice() does not
	// free anything currently.
	__KHEAP_MARK; 

	test.Next(_L("Opening LDD channel"));
	r = Channel.Open();
	test(r == KErrNone);

	TestSwExcNoHandlers();
	TestUserSwExcHandlerAlone();

	test.Next(_L("Enable event hook"));
	r = Channel.Hook(&KernelExcCount);
	test(r == KErrNone);

	TestUserAndKernelSwExcHandlers();
	TestHwExcContext(ESynchronousKill, ENoCallback);
	TestHwExcContext(EAsynchronousKill, ENoCallback);
	TestSwExcContext(ESynchronousKill, ENoCallback);
	TestSwExcContext(EAsynchronousKill, ENoCallback);
	TestKillWFAR(ENoCallback);
	TestKillInterrupt(ENoCallback);
	TestKernelContext();
	TestNaturalDeathContext();
#ifdef _DEBUG
	TestHwExcContext(EAsynchronousKill, ESpinningCallback);
	TestHwExcContext(EAsynchronousKill, ESleepingCallback);
	TestSwExcContext(EAsynchronousKill, ESpinningCallback);
	TestSwExcContext(EAsynchronousKill, ESleepingCallback);
	TestKillWFAR(ESpinningCallback);
	TestKillWFAR(ESleepingCallback);
	TestKillInterrupt(ESpinningCallback);
	TestKillInterrupt(ESleepingCallback);
#endif

	Channel.Close();

	// Wait for idle + async cleanup (waits for DKernelEventHandler to go away)
	r = UserSvr::HalFunction(EHalGroupKernel, EKernelHalSupervisorBarrier, (TAny*)5000, 0);
	test_KErrNone(r);

	__KHEAP_MARKEND;

	// Don't check user heap because if TLS is stored on the user-side this will not be freed when
	// the thread exits due to an exception.

	test.End();
	return 0;
	}
