// Copyright (c) 2004-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\mmu\t_sharedchunk.cpp

// Overview:

// Test sharing an RChunk with a logical device

// API Information:

// RChunk

// Details:

// - Load and open the logical device driver ("D_SHAREDCHUNK"). Verify

// results.

// - Test and verify results of creating shared chunks under OOM conditions. Also verify 

// creating a chunk with a bad type, bad size and too large all fail as 

// expected.

// - Test and verify opening and closing chunk user handles work as expected.

// - Test and verify setting restrictions on RChunk if created as shared chunk are as expected.

// - Test and verify memory access for multiply and singly shared chunks, 

// is as expected. Including IPC, kernel, DFC and ISR reads & writes.

// - Test and verify discontinuous memory commits for multiply and singly 

// shared chunks are as expected.

// - Test and verify continuous memory commits for multiply and singly shared

// chunks are as expected.

// - Test and verify discontinuous and continuous physical memory commits for 

// multiply and singly shared chunks is as expected.

// - Test Kern::OpenSharedChunk for multiply and singly shared chunks. Verify

// results are as expected.

// - Test that physical memory can be freed immediately after the chunk that mapped 

// it has been closed.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

//! @file

//! @SYMTestCaseID KBASE-T_SHAREDCHUNK

//! @SYMREQ 3699

//! @SYMTestPriority High

//! @SYMTestActions Check creation, memory allocation and access to Shared Chunks

//! @SYMTestExpectedResults Test runs until this message is emitted: RTEST: SUCCESS : T_SHAREDCHUNK test completed O.K.

//! @SYMTestType UT

#define __E32TEST_EXTENSION__

#include "d_sharedchunk.h"

#include "d_gobble.h"

#include <e32test.h>

#include <e32hal.h>

#include "u32std.h"

#include <u32hal.h>

#include <e32svr.h>

#include <f32dbg.h>

#include <e32def.h>

#include <e32def_private.h>

#include "freeram.h"

enum TSlaveCommand

	{

	ESlaveCheckChunk,

	ESlaveCreateChunk,

	};

//

// Global data

//

RSharedChunkLdd Ldd;

RChunk TheChunk;

TInt PageSize;

TUint32 MemModelAttributes;

TBool PhysicalCommitSupported;

TBool CachingAttributesSupported;

TUint8 BssMem[100];

const TUint ChunkSize = 0x400000;	// 4 meg reserved space for test chunk

_LIT(KSecondProcessName,"t_sharedchunk");

#ifdef __T_SHAREDCHUNKF__

_LIT(KOtherProcessName,"t_sharedchunk");

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

#else

_LIT(KOtherProcessName,"t_sharedchunkf");

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

#endif

_LIT8(KTestString, "lks4b7qeyfcea5fyaifyaefyi4flwdysuxanabxa");

_LIT8(KTestString2,"jhfcalurnhfirlxszhrvcvduhrvndrucxnshxcsx");

const TUint32 KTestValue = 0x12345678;

const TUint32 KTestValue2 = KTestValue^0x0f0f0f0f;

//

// Utilitiies for use by tests

//

_LIT(KLitKernExec, "KERN-EXEC");

void CheckFailMessage(const char* n,const char* c,const char* f,TInt r)

	{

	TPtrC8 nn((const TUint8*)n);

	TPtrC8 cc((const TUint8*)c);

	TPtrC8 ff((const TUint8*)f);

	RBuf8 buf;

	buf.Create((nn.Size()+cc.Size()+ff.Size()+64)*2);

	buf.AppendFormat(_L8("\nCHECK failed: %S == 0x%x but was tested for %S%S\n"),&ff,r,&cc,&nn);

	test.Printf(buf.Expand());

	buf.Close();

	}

#define CHECK(n,c,f) \

	{	\

	TInt _r=(TInt)(f);	\

	if(!((TInt)(n)c(_r)))	\

		{	\

		CheckFailMessage(#n,#c,#f,_r);	\

		test(0);	\

		}	\

	}

#define KCHECK_MEMORY(result,offset)	\

	{	\

	/* test.Printf(_L("check offset 0x%08x\r"),offset); */	\

	CHECK(result,==,Ldd.CheckMemory(offset));	\

	}

#define KWRITE_MEMORY(offset,value)	\

	{	\

	CHECK(KErrNone,==,Ldd.WriteMemory(offset,value));	\

	}

#define UREAD_MEMORY(offset,value)	\

	{	\

	CHECK(value,==,*(TUint*)(Base+offset));	\

	}

inline TUint32 Tag(TUint32 offset)

	{ return (69069u*(offset*4+1)); }

TInt MemoryAccessThread(TAny* aAddress)

	{

	TInt r = *(volatile TUint8*)aAddress;	// read from aAddress

	(void)r;

	return 0;

	}

TInt CheckUMemory(TAny* aAddress)

	{

	RThread thread;

	thread.Create(KNullDesC,MemoryAccessThread,PageSize,&User::Heap(),aAddress);

	TRequestStatus status;

	thread.Logon(status);

	TBool jit = User::JustInTime();

	User::SetJustInTime(EFalse);

	thread.Resume();

	User::WaitForRequest(status);

	User::SetJustInTime(jit);

	TInt r;

	if(thread.ExitType()==EExitKill && thread.ExitReason()==0)

		r = 1;	// Memory access pass

	else if(thread.ExitType()==EExitPanic && thread.ExitCategory()==KLitKernExec && thread.ExitReason()==3 )

		r = 0;	// Memory access failed

	else

		r = -1;	// Unexpected result

	CLOSE_AND_WAIT(thread);

	return r;

	}

#define UCHECK_MEMORY(result,offset)	\

	{	\

	/* test.Printf(_L("ucheck offset 0x%08x\r"),offset); */	\

	CHECK(result,==,CheckUMemory(Base+offset));	\

	}

TInt CheckPlatSecPanic(TThreadFunction aThreadFunction,TInt aThreadArgument)

	{

	RThread thread;

	thread.Create(KNullDesC,aThreadFunction,PageSize,&User::Heap(),(TAny*)aThreadArgument);

	TRequestStatus status;

	thread.Logon(status);

	TBool jit = User::JustInTime();

	User::SetJustInTime(EFalse);

	thread.Resume();

	User::WaitForRequest(status);

	User::SetJustInTime(jit);

	TInt r;

	if(thread.ExitType()==EExitPanic && thread.ExitCategory()==KLitKernExec && thread.ExitReason()==46 )

		r = 1;	// PlatSec panic

	else if(thread.ExitType()==EExitKill && thread.ExitReason()==0)

		r = 0;	// Exit without error

	else

		r = -1;	// Unexpected result

	CLOSE_AND_WAIT(thread);

	return r;

	}

//

// The tests

//

void CreateWithOomCheck(TInt aCreateFlags)

	{

	TInt failResult=KErrGeneral;

	for(TInt failCount=1; failCount<1000; failCount++)

		{

		test.Printf(_L("alloc fail count = %d\n"),failCount);

		User::__DbgSetBurstAllocFail(ETrue,RAllocator::EFailNext,failCount,1000);

		__KHEAP_MARK;

		failResult = Ldd.CreateChunk(aCreateFlags);

		if(failResult==KErrNone)

			break;

		CHECK(KErrNoMemory,==,failResult);

		Ldd.IsDestroyed();	// This includes delay to let idle thread do cleanup

		__KHEAP_MARKEND;

		}

	User::__DbgSetAllocFail(ETrue,RAllocator::ENone,0);

	__KHEAP_RESET;

	CHECK(KErrNone,==,failResult);

	}

void TestCreate()

	{

	test.Start(_L("Creating chunk type Single,OwnsMemory"));

	CreateWithOomCheck(ChunkSize|ESingle|EOwnsMemory);

	CHECK(0,==,Ldd.IsDestroyed());

	test.Next(_L("Close kernel handle"));

	CHECK(1,==,Ldd.CloseChunk()); // 1==DObject::EObjectDeleted

	CHECK(1,==,Ldd.IsDestroyed());

	test.Next(_L("Creating chunk type Multiple,OwnsMemory"));

	CreateWithOomCheck(ChunkSize|EMultiple|EOwnsMemory);

	CHECK(0,==,Ldd.IsDestroyed());

	test.Next(_L("Close kernel handle"));

	CHECK(1,==,Ldd.CloseChunk()); // 1==DObject::EObjectDeleted

	CHECK(1,==,Ldd.IsDestroyed());

	if(PhysicalCommitSupported)

		{

		test.Next(_L("Creating chunk type Single,!OwnsMemory"));

		CreateWithOomCheck(ChunkSize|ESingle);

		CHECK(0,==,Ldd.IsDestroyed());

		test.Next(_L("Close kernel handle"));

		CHECK(1,==,Ldd.CloseChunk()); // 1==DObject::EObjectDeleted

		CHECK(1,==,Ldd.IsDestroyed());

		test.Next(_L("Creating chunk type Multiple,!OwnsMemory"));

		CreateWithOomCheck(ChunkSize|EMultiple);

		CHECK(0,==,Ldd.IsDestroyed());

		test.Next(_L("Close kernel handle"));

		CHECK(1,==,Ldd.CloseChunk()); // 1==DObject::EObjectDeleted

		CHECK(1,==,Ldd.IsDestroyed());

		}

	else

		{

		test.Next(_L("Try creating unsupported chunk type Single,!OwnsMemory"));

		CHECK(KErrNotSupported,==,Ldd.CreateChunk(ChunkSize|ESingle));

		test.Next(_L("Try creating unsupported chunk type Multiple,!OwnsMemory"));

		CHECK(KErrNotSupported,==,Ldd.CreateChunk(ChunkSize|EMultiple));

		}

	test.Next(_L("__KHEAP_MARK"));

	__KHEAP_MARK;

	test.Next(_L("Creating chunk (bad type)"));

	CHECK(KErrArgument,==,Ldd.CreateChunk(EBadType|EOwnsMemory|ChunkSize));

	test.Next(_L("Creating chunk (bad size)"));

	CHECK(KErrArgument,==,Ldd.CreateChunk(ESingle|EOwnsMemory|0xffffff00));

	test.Next(_L("Creating chunk (size too big)"));

	CHECK(KErrNoMemory,==,Ldd.CreateChunk(ESingle|EOwnsMemory|0x7fffff00));

	test.Next(_L("__KHEAP_MARKEND"));

	__KHEAP_MARKEND;

	test.End();

	}

void OpenWithOomCheck(RChunk& aChunk)

	{

	TInt failResult=KErrGeneral;

	for(TInt failCount=1; failCount<1000; failCount++)

		{

		test.Printf(_L("alloc fail count = %d\n"),failCount);

		User::__DbgSetBurstAllocFail(ETrue,RAllocator::EFailNext,failCount,1000);

		__KHEAP_MARK;

		failResult = Ldd.GetChunkHandle(aChunk);

		if(failResult==KErrNone)

			break;

		CHECK(KErrNoMemory,==,failResult);

		Ldd.IsDestroyed();	// This includes delay to let idle thread do cleanup

		__KHEAP_MARKEND;

		}

	User::__DbgSetAllocFail(ETrue,RAllocator::ENone,0);

	__KHEAP_RESET;

	CHECK(KErrNone,==,failResult);

	}

void TestHandles()

	{

	TUint ChunkAttribs = ChunkSize|ESingle|EOwnsMemory;

	test.Start(_L("Create chunk"));

	CHECK(KErrNone,==,Ldd.CreateChunk(ChunkAttribs));

	test.Next(_L("Open user handle"));

	OpenWithOomCheck(TheChunk);

	test.Next(_L("Close user handle"));

	TheChunk.Close();

	test.Next(_L("Check chunk not destroyed"));

	CHECK(0,==,Ldd.IsDestroyed());

	test.Next(_L("Close kernel handle"));

	CHECK(1,==,Ldd.CloseChunk()); // 1==DObject::EObjectDeleted

	test.Next(_L("Check chunk destroyed"));

	CHECK(1,==,Ldd.IsDestroyed());

	// Another chunk - closing handles in reverse order

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

	CHECK(KErrNone,==,Ldd.CreateChunk(ChunkAttribs));

	test.Next(_L("Open user handle"));

	OpenWithOomCheck(TheChunk);

	test.Next(_L("Close kernel handle"));

	CHECK(KErrNone,==,Ldd.CloseChunk());

	test.Next(_L("Check chunk not destroyed"));

	CHECK(0,==,Ldd.IsDestroyed());

	test.Next(_L("Using user handle to check chunk info"));

	if((MemModelAttributes&EMemModelTypeMask)!=EMemModelTypeDirect)

		{

		CHECK(0,==,TheChunk.Size());

		}

	CHECK(ChunkSize,==,TheChunk.MaxSize());

	test.Next(_L("Close user handle"));

	TheChunk.Close();

	test.Next(_L("Check chunk destroyed"));

	CHECK(1,==,Ldd.IsDestroyed());

	test.End();

	}

void SetCreateFlags(TUint& aCreateFlags,TCommitType aCommitType)

	{

	if(!((TInt)aCommitType&EPhysicalMask))

		aCreateFlags |= EOwnsMemory;

	else

		aCreateFlags &= ~EOwnsMemory;

	}

void TestAccess(TUint aCreateFlags,TCommitType aCommitType)

	{

	const TUint32 offset = 0;

	const TUint32 size = PageSize;

	SetCreateFlags(aCreateFlags,aCommitType);

	test.Start(_L("Create chunk"));

	TUint8* kernelAddress;

	CHECK(KErrNone,==,Ldd.CreateChunk(aCreateFlags|ChunkSize,(TAny**)&kernelAddress));

	if((MemModelAttributes&TUint32(EMemModelAttrNonExProt)) && (MemModelAttributes&EMemModelTypeMask)!=EMemModelTypeDirect)

		{

		test.Next(_L("Check can't access memory"));

		KCHECK_MEMORY(EFalse,offset);

		}

	test.Next(_L("Commit page to chunk"));

	CHECK(KErrNone,==,Ldd.CommitMemory(aCommitType|offset,size));

	test.Next(_L("Check can access memory kernel side"));

	KCHECK_MEMORY(ETrue, offset);

	if((MemModelAttributes&EMemModelAttrKernProt) && (MemModelAttributes&EMemModelTypeMask)!=EMemModelTypeDirect)

		{

		test.Next(_L("Check user side can't access kernel memory"));

		TUint8* Base = kernelAddress;

		UCHECK_MEMORY(EFalse, offset);

		}

	test.Next(_L("Open user handle"));

	CHECK(KErrNone,==,Ldd.GetChunkHandle(TheChunk));

	test.Next(_L("Get memory size info"));

	if((MemModelAttributes&EMemModelTypeMask)!=EMemModelTypeDirect)

		{

		CHECK(PageSize,==,TheChunk.Size());

		}

	CHECK(ChunkSize,==,TheChunk.MaxSize());

	TUint8* Base = TheChunk.Base();

	CHECK(Base,!=,0);

	test.Next(_L("Check can access memory user side"));

	UCHECK_MEMORY(ETrue, offset);

	test.Next(_L("Check user and kernel access same memory"));

	KWRITE_MEMORY(offset,~Tag(offset));

	UREAD_MEMORY(offset,~Tag(offset));

	KWRITE_MEMORY(offset,Tag(offset));

	UREAD_MEMORY(offset,Tag(offset));

	test.Next(_L("Close user handle"));

	CHECK(0,==,Ldd.CloseChunkHandle(TheChunk));

	CHECK(0,==,Ldd.IsDestroyed());

	if((MemModelAttributes&EMemModelAttrKernProt) && (MemModelAttributes&EMemModelTypeMask)!=EMemModelTypeDirect)

		{

		test.Next(_L("Check can no-longer access memory user side"));

		UCHECK_MEMORY(EFalse,offset);

		}

	test.Next(_L("Check can still access memory kernel side"));

	KCHECK_MEMORY(ETrue, offset);

	test.Next(_L("Open user handle again"));

	CHECK(KErrNone,==,Ldd.GetChunkHandle(TheChunk));

	test.Next(_L("Check can access chunk user side again"));

	CHECK(Base,==,TheChunk.Base());

	CHECK(ChunkSize,==,TheChunk.MaxSize());

	if((MemModelAttributes&EMemModelTypeMask)!=EMemModelTypeDirect)

		{

		CHECK(size,==,TheChunk.Size());

		}

	UREAD_MEMORY(offset,Tag(offset));

	test.Next(_L("Close kernel handle"));

	CHECK(0,==,Ldd.CloseChunk());

	CHECK(0,==,Ldd.IsDestroyed());

	test.Next(_L("Check can still access chunk user side"));

	CHECK(Base,==,TheChunk.Base());

	CHECK(ChunkSize,==,TheChunk.MaxSize());

	if((MemModelAttributes&EMemModelTypeMask)!=EMemModelTypeDirect)

		{

		CHECK(size,==,TheChunk.Size());

		}

	UREAD_MEMORY(offset,Tag(offset));

	test.Next(_L("Close user handle"));

	TheChunk.Close();

	CHECK(1,==,Ldd.IsDestroyed());

	test.Next(_L("Create chunk in another process"));

	// Create test server

	RServer2 server;

	RMessage2 message;

	TRequestStatus status;

	CHECK(KErrNone,==,server.CreateGlobal(KSecondProcessName));

	server.Receive(message,status);

	// Launch slave process

	RProcess process;

	CHECK(KErrNone,==,process.Create(KSecondProcessName,KNullDesC));

	CHECK(KErrNone,==,process.SetParameter(1,ESlaveCreateChunk));

	CHECK(KErrNone,==,process.SetParameter(2,(RBusLogicalChannel&)Ldd));

	CHECK(KErrNone,==,process.SetParameter(3,ChunkSize|aCreateFlags));

	CHECK(KErrNone,==,process.SetParameter(4,aCommitType));

	CHECK(KErrNone,==,process.SetParameter(5,PageSize));

	TRequestStatus logon;

	process.Logon(logon);

	process.Resume();

	// Wait for slave to connect to test server

	User::WaitForRequest(logon,status);

	CHECK(KRequestPending,==,logon.Int())

	CHECK(KErrNone,==,status.Int());

	CHECK(RMessage2::EConnect,==,message.Function());

	message.Complete(KErrNone);

	server.Receive(message,status);

	// Wait for message

	User::WaitForRequest(logon,status);

	CHECK(KRequestPending,==,logon.Int())

	CHECK(KErrNone,==,status.Int());

	CHECK(0,==,message.Function());

	test.Next(_L("Check IPC read/write"));

	RBuf8 buf;

	buf.Create(KTestString().Size());

	CHECK(KErrNone,==,message.Read(0,buf));

	CHECK(ETrue,==,buf==KTestString());

	CHECK(KErrNone,==,message.Write(0,KTestString2));

	CHECK(KErrNone,==,message.Read(0,buf));

	CHECK(ETrue,==,buf==KTestString2());

	test.Next(_L("Check Kernel read/write"));

	TInt n;

	TUint32 value;

	for(n=0; n<KTestString2().Size()-(TInt)sizeof(TInt)+1; n+=sizeof(TInt))

		{

		Ldd.ReadMemory(n,value);

		CHECK(*(TInt*)&KTestString2()[n],==,value);

		CHECK(KErrNone,==,Ldd.WriteMemory(n,*(TInt*)&KTestString()[n]));

		Ldd.ReadMemory(n,value);

		CHECK(*(TInt*)&KTestString()[n],==,value);

		}

	CHECK(KErrNone,==,message.Read(0,buf));

	CHECK(ETrue,==,buf==KTestString());

	buf.Close();