// 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;

	}