// Copyright (c) 1996-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\system\t_prot.cpp

// Overview:

// Tests that the kernel panics the user rather than dying in 

// various situations

// API Information:

// N/A

// Details:

// - Verify that printing a long string does not panic.

// - Verify that a stack overflow in a thread causes a panic.

// - Create the thread which panics a dead thread, verify that 

// it isn't panicked for doing this.

// - Create the thread which panics a bad handle, verify that 

// it isn't panicked for doing this.

// - Verify that an RSession send from an uninitialised handle

// causes a panic.

// - Verify that the thread causing an exception, for a variety

// of reasons, is panicked.

// - Verify thread writing to kernel data is panicked.

// - Verify that RAM disk access either causes a panic or is

// denied, based on the platform security settings.

// - Verify that an RThread::RequestComplete() with an invalid

// address causes a panic. Verify results are as expected.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

#include "u32std.h"

#include <e32panic.h>

#include "../mmu/mmudetect.h"

void DoUndefinedInstruction();

const TInt KHeapSize=0x200;

const TInt KThreadReturnValue=9999;

_LIT(KLitKernExec,"KERN-EXEC");

class RSessionTest : public RSessionBase

	{

public:

	void DoSend();

	};

void RSessionTest::DoSend()

	{

    Send(34,TIpcArgs(78));

	//Send(34,(TAny*)78);

	};

LOCAL_D RTest test(_L("T_PROT"));

LOCAL_D RTest t(_L("T_PROT thread"));

enum TAction

	{

	EDataAbort=0,

	EPrefetchAbort=1,

	EUndefinedInstruction=2,

	};

typedef void (*PFV)(void);

#ifndef __MARM__

void DoUndefinedInstruction()

	{

#ifdef __GCC32__	

	asm("int 6");

#else

	_asm int 6;

#endif

	}

#endif

LOCAL_C TInt ExceptionThread(TAny* anAction)

	{

	TAction action=(TAction)((TInt) anAction);

	switch (action)

		{

		case EDataAbort:

			*(TInt*)0=0;

			break;

		case EPrefetchAbort:

			{

//			PFV f=(PFV)NULL;

			PFV f=(PFV)0x80000;	// don't use NULL since it is readable on Snowdrop

			(*f)();

			break;

			}

		case EUndefinedInstruction:

			DoUndefinedInstruction();

			break;

		};

	return 0;

	}

LOCAL_C void RunTestThread(TAction anAction)

	{

	RThread t;

	TInt r=t.Create(_L("TestThread"),ExceptionThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)anAction);

	test(r==KErrNone);

	TRequestStatus s;

	t.Logon(s);

	test(s==KRequestPending);

	t.Resume();

	User::WaitForRequest(s);

	test(t.ExitType()==EExitPanic);

	test(t.ExitCategory()==_L("KERN-EXEC"));

	test(t.ExitReason()==ECausedException);

	CLOSE_AND_WAIT(t);

	}

LOCAL_C TInt UnintThread(TAny* )

	{

	RSessionTest rsb;

	rsb.DoSend();

	FOREVER

		;

	}

void testSession()

//

// Test 1

//

	{

	RThread thread;

	TRequestStatus stat;

	test.Next(_L("Create UnintThread"));

	TInt r=thread.Create(_L("UnintThread"),UnintThread,KDefaultStackSize,KHeapSize,KHeapSize,0);

	test(r==KErrNone);

	thread.Logon(stat);

	test(thread.ExitType()==EExitPending);

	test.Next(_L("Resume UnintThread"));

	thread.Resume();

	User::WaitForRequest(stat);

	test.Next(_L("Check UnintThread panicked"));

	test(thread.ExitCategory()==_L("KERN-EXEC"));

//	test(thread.ExitReason()==EBadHandle);

	test(thread.ExitType()==EExitPanic);

	CLOSE_AND_WAIT(thread);

	}

TInt dummy(TAny*)

	{

	return(KErrNone);

	}

// Dennis - modified this to panic a dead thread rather than a bad handle

TInt pdThread(TAny*)

	{

	RThread thread;

	TRequestStatus stat;

	TInt r=thread.Create(_L("dummy"),dummy,KDefaultStackSize,KHeapSize,KHeapSize,0);

	test(r==KErrNone);

	thread.Logon(stat);

	test(thread.ExitType()==EExitPending);

	thread.Resume();

	User::WaitForRequest(stat);

	test(thread.ExitType()==EExitKill);

	test(stat.Int()==KErrNone);

	thread.Panic(_L("MYPANIC"),0x666); // this shouldn't panic pdThread

	test(thread.ExitType()==EExitKill);

	test(thread.ExitReason()==KErrNone);

	CLOSE_AND_WAIT(thread);

	return(KErrNone);

	}

void testPanicDeadThread()

//

// Dennis - modified this to panic a dead thread rather than a bad handle

// Create the thread which panics a dead thread /*bad handle*/

// Check that it isn't panicked for doing this

//

	{

	RThread thread;

	TRequestStatus stat;

	test.Next(_L("Create PanicDeadThread"));

	TInt r=thread.Create(_L("PanicDeadThread"),pdThread,KDefaultStackSize,KHeapSize,KHeapSize,0);

	test(r==KErrNone);

	thread.Logon(stat);

	test(thread.ExitType()==EExitPending);

	test.Next(_L("Resume PanicDeadThread"));

	thread.Resume();

	User::WaitForRequest(stat);

	test.Next(_L("Check PanicDeadThread did not panic"));

	test(thread.ExitReason()==KErrNone);

	test(thread.ExitType()==EExitKill);

	test(thread.ExitCategory()==_L("Kill"));

	CLOSE_AND_WAIT(thread);

	}

TInt doDeadThreadStuff(TAny*)

	{

	RThread thread;

	TRequestStatus stat;

	TInt r=thread.Create(_L("dummy2"),dummy,KDefaultStackSize,KHeapSize,KHeapSize,0);

	test(r==KErrNone);

	thread.Logon(stat);

	test(thread.ExitType()==EExitPending);

	thread.Resume();

	User::WaitForRequest(stat);

	thread.SetPriority(EPriorityNormal);

	CLOSE_AND_WAIT(thread);

	return(KErrNone);

	}

void testDeadThread()

//

// Create the thread which panics a bad handle

// Check that it isn't panicked for doing this

//

	{

	RThread thread;

	TRequestStatus stat;

	test.Next(_L("Create doDeadThreadStuff"));

	TInt r=thread.Create(_L("doDeadThreadStuff"),doDeadThreadStuff,KDefaultStackSize,KHeapSize,KHeapSize,0);

	test(r==KErrNone);

	thread.Logon(stat);

	test(thread.ExitType()==EExitPending);

	test.Next(_L("Resume doDeadThreadStuff"));

	thread.Resume();

	User::WaitForRequest(stat);

	test.Next(_L("Check doDeadThreadStuff did not panic"));

	test(thread.ExitReason()==KErrNone);

	test(thread.ExitType()==EExitKill);

	test(thread.ExitCategory()==_L("Kill"));

	CLOSE_AND_WAIT(thread);

	}

TInt MinimalThread(TAny*)

//

// Minimal thread, used in test 5

//

	{

	return(KErrNone);

	}

LOCAL_C TInt ExceptThread(TAny* )

	{

	TUint* nullPtr=0;

	*nullPtr=0xdead; // BANG!!

	return KErrNone;

	}

void testExcept()

//

// Test thread causing exception is panicked

//

	{

	RThread thread;

	TRequestStatus stat;

	test.Next(_L("Create ExceptThread"));

	TInt r=thread.Create(_L("ExceptThread"),ExceptThread,KDefaultStackSize,KHeapSize,KHeapSize,0);

	test(r==KErrNone);

	thread.Logon(stat);

	test(thread.ExitType()==EExitPending);

	test.Next(_L("Resume ExceptThread"));

	thread.Resume();

	User::WaitForRequest(stat);

	test.Next(_L("Check ExceptThread panicked"));

	test(thread.ExitCategory()==_L("KERN-EXEC"));

	test(thread.ExitReason()==ECausedException);

	test(thread.ExitType()==EExitPanic);

	CLOSE_AND_WAIT(thread);

	}

LOCAL_C TInt StackThread(TAny* )

	{

	TFileName heresAnotherOne;

	StackThread((TAny*)heresAnotherOne.Ptr()); // go recursive

	return KErrNone;

	}

void testStackOverflow()

//

// Thread overflowing its stack is panicked

//

	{

	RThread thread;

	TRequestStatus stat;

	test.Next(_L("Create StackThread"));

	TInt r=thread.Create(_L("StackThread"),StackThread,KDefaultStackSize,KHeapSize,KHeapSize,0);

	test(r==KErrNone);

	thread.Logon(stat);

	test(thread.ExitType()==EExitPending);

	test.Next(_L("Resume StackThread"));

	thread.Resume();

	User::WaitForRequest(stat);

	test.Next(_L("Check StackThread panicked"));

	test(thread.ExitCategory()==_L("KERN-EXEC"));

	test(thread.ExitReason()==ECausedException);

	test(thread.ExitType()==EExitPanic);

	CLOSE_AND_WAIT(thread);

	}

LOCAL_C TInt KernWriter(TAny* )

	{

	TUint* kernPtr=(TUint*)KernData();

	*kernPtr=0xdead; // BANG!!

	return KErrNone;

	}

LOCAL_C TInt RamDiskWriter(TAny* )

	{

	TFindChunk fChunk(_L("*TheRamDriveChunk*"));

	TFullName n;

	TInt r=fChunk.Next(n);

	RChunk ch;

	r=ch.Open(fChunk);

	if(r!=KErrNone)

		return r;

	TUint8* rdPtr=ch.Base();

	*rdPtr=0xaa; // BANG!!

	return KErrNone;

	}

void testKernelWriter()

//

// Thread writing to kernel data is panicked

//

	{

	RThread thread;

	TRequestStatus stat;

	test.Next(_L("Create KernWriter"));

	TInt r=thread.Create(_L("KernWriter"),KernWriter,KDefaultStackSize,KHeapSize,KHeapSize,0);

	test(r==KErrNone);

	thread.Logon(stat);

	test(thread.ExitType()==EExitPending);

	test.Next(_L("Resume KernWriter"));

	thread.Resume();

	User::WaitForRequest(stat);

	test.Next(_L("Check KernWriter panicked"));

	test(thread.ExitCategory()==_L("KERN-EXEC"));

	test(thread.ExitReason()==ECausedException);

	test(thread.ExitType()==EExitPanic);

	CLOSE_AND_WAIT(thread);

	}

void testRamDiskAccess()

	{

	RThread thread;

	TRequestStatus stat;

	test.Next(_L("Create RamDiskWriter"));

	TInt r=thread.Create(_L("RamDiskWriter"),RamDiskWriter,KDefaultStackSize,KHeapSize,KHeapSize,0);

	test(r==KErrNone);

	thread.Logon(stat);

	test(thread.ExitType()==EExitPending);

	test.Next(_L("Resume RamDiskWriter"));

	thread.Resume();

	User::WaitForRequest(stat);

	if((!PlatSec::ConfigSetting(PlatSec::EPlatSecProcessIsolation))||(!PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement)))

		{

		test.Next(_L("Check RamDiskWriter panicked"));

		test(thread.ExitCategory()==_L("KERN-EXEC"));

		test(thread.ExitReason()==ECausedException);

		test(thread.ExitType()==EExitPanic);

		}

	else

		{

		test.Next(_L("Check RamDiskWriter was refused access"));

		test(thread.ExitReason()==KErrPermissionDenied);

		test(thread.ExitType()==EExitKill);

		}

	CLOSE_AND_WAIT(thread);

	}

RThread MainThread;

TInt RequestCompleteThread(TAny* aPtr)

	{

	TRequestStatus** pS=(TRequestStatus**)aPtr;

	MainThread.RequestComplete(*pS,123);

	return 0;

	}

_LIT(KReqCompThreadName,"ReqCompThread");

void StartRequestCompleteThread(RThread& aThread, TRequestStatus** aStatus)

	{

	TInt r=aThread.Create(KReqCompThreadName,RequestCompleteThread,0x1000,0x1000,0x10000,aStatus);

	test (r==KErrNone);

	aThread.SetPriority(EPriorityMore);

	TRequestStatus s;

	aThread.Logon(s);

	aThread.Resume();

	User::WaitForRequest(s);

	}

_LIT(KLitUserCBase,"E32USER-CBase");

GLDEF_C TInt E32Main()

//

// Main

//

	{	

	// don't want just in time debugging as we trap panics

	TBool justInTime=User::JustInTime(); 

	User::SetJustInTime(EFalse); 

	test.Title();

	test.Start(_L("Test protection & panicking"));

#if defined(__EPOC32__)

	// this next test doesn't work under WINS because the string needs to be converted

	// from UNICODE to ascii for printing to STDOUT, and that requires the string to be

	// zero-terminated which panics because the string is too long.

	test.Next(_L("Printing long string doesn't get me shot"));

	test.Printf(_L("012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"));

	test.Printf(_L("\n"));

#endif

	if (HaveVirtMem())

		{

		test.Next(_L("Stack overflow shoots the thread not the kernel"));

		testStackOverflow();

		}

	test.Next(_L("Panicking a closed thread doesn't panic the panicker!!"));

	testPanicDeadThread();

	test.Next(_L("Dead thread tests"));

	testDeadThread();

	test.Next(_L("RSession send from uninitialised handle"));

	testSession();

	test.Next(_L("Thread causing exception is killed"));

	if (HaveVirtMem())

		{

		testExcept();

		RunTestThread(EDataAbort);

		RunTestThread(EPrefetchAbort);

		}

#ifndef __WINS__

	RunTestThread(EUndefinedInstruction);

#endif

#if defined(__EPOC32__)

	if (HaveDirectKernProt())

		{

		test.Next(_L("Thread writing to kernel data is killed"));

		testKernelWriter();

		}

	if (HaveProcessProt())

		{

		test.Next(_L("Check access to RamDisk is denied"));

		testRamDiskAccess();

		}

	if (HaveMMU())

		{

		test.Next(_L("RequestComplete() with bad address"));

		TInt rqc=RThread().RequestCount();

		test(MainThread.Duplicate(RThread())==KErrNone);

		RThread t;

		TRequestStatus s=KRequestPending;

		TRequestStatus* pS=&s;

		StartRequestCompleteThread(t,&pS);

		test(t.ExitType()==EExitKill);

		test(t.ExitReason()==KErrNone);

		CLOSE_AND_WAIT(t);

		test(s==123);

		test(pS==NULL);

		test(RThread().RequestCount()==rqc+1);

		TRequestStatus** bad=(TRequestStatus**)0x80000000;	// kernel space

		StartRequestCompleteThread(t,bad);

		test(t.ExitType()==EExitPanic);

		test(t.ExitReason()==ECausedException);

		test(t.ExitCategory()==KLitKernExec);

		CLOSE_AND_WAIT(t);

		test(RThread().RequestCount()==rqc+1);

		pS=(TRequestStatus*)0x80000000;

		StartRequestCompleteThread(t,&pS);

		// Request status poked user side, so we expect a KERN-EXEC 3...

		test(t.ExitType()==EExitPanic);

		test(t.ExitReason()==ECausedException);

		test(t.ExitCategory()==KLitKernExec);

		CLOSE_AND_WAIT(t);

		test(pS==NULL);

		test(RThread().RequestCount()==rqc+1);

		pS=(TRequestStatus*)(((TUint8*)&s)+0x80000);		// aligned, within chunk max size but invalid

		StartRequestCompleteThread(t,&pS);

		// Request status poked user side, so we expect a KERN-EXEC 3...

		test(t.ExitType()==EExitPanic);

		test(t.ExitReason()==ECausedException);

		test(t.ExitCategory()==KLitKernExec);

		CLOSE_AND_WAIT(t);

		test(pS==NULL);

		test(RThread().RequestCount()==rqc+1);

		}

#endif

	test.End();

	User::SetJustInTime(justInTime);

	return(KErrNone);

	}