// Copyright (c) 2008-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\demandpaging\t_svrpinning.cpp

// Overview:

// Test the pinning of RMessage descriptor arguments.

// API Information:

// RMessage2, RMessagePtr2, RSessionBase, CSession2, CServer2

// Details:

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#define __E32TEST_EXTENSION__

#include <e32std.h>

#include <e32std_private.h>

#include <e32def.h>

#include <e32def_private.h>

#include <e32test.h>

#include <e32ver.h>

#include <e32panic.h>

#include <dptest.h>

#include <u32hal.h>

#include <hal.h>

const TInt KHeapMinSize=0x1000;

const TInt KHeapMaxSize=0x1000;

const TUint KPageSize = 0x1000;

TInt gPageSize;

TUint gPageMask;

TBool gDataPagingSupport = EFalse;

TBool gProcessPaged;

enum TServerPinning

	{

	EServerDefault,

	EServerPinning,

	EServerNotPinning,

	EServerSetPinningTooLate,

	EServerPinningCount,

	};

TInt gServerPinningState;

class CTestServer : public CServer2

	{

public:

	CTestServer(TInt aPriority);

protected:

	//override the pure virtual functions:

	virtual CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const;

	};

class CTestSession : public CSession2

	{

public:

	enum TTestMode

		{

		EStop,

		ETestPinAll,

		ETestPinEven,

		ETestPinOdd,

		ETestPin3,

		ETestPin2,

		ETestPin1,

		ETestPin0,

		ETestPinWritable,

		ETestUnpinWritable,

		ETestPinOOM,

		ETestPinDefault,

		ETestDeadServer,

		};

//Override pure virtual

	IMPORT_C virtual void ServiceL(const RMessage2& aMessage);

private:

	TInt CheckDesPresent(const RMessage2& aMessage, TUint aArgIndex, TBool aExpected, TBool aWrite);

	TInt CheckArgsPresent(const RMessage2& aMessage, TBool arg0Present, TBool arg1Present, TBool arg2Present, TBool arg3Present, TBool aWrite);

	TBool iClientDied;

	};

class CMyActiveScheduler : public CActiveScheduler

	{

public:

	virtual void Error(TInt anError) const; //override pure virtual error function

	};

class RSession : public RSessionBase

	{

public:

	TInt PublicSendReceive(TInt aFunction, const TIpcArgs &aPtr)

		{

		return (SendReceive(aFunction, aPtr));

		}

	TInt PublicCreateSession(const TDesC& aServer,TInt aMessageSlots)

		{

		return (CreateSession(aServer,User::Version(),aMessageSlots));

		}

	};

_LIT(KServerName,"CTestServer");

TBool UpdateExpected(TBool aExpected)

	{

	if (!gDataPagingSupport												// Data paging is not supported so memory should always be present

		|| gServerPinningState == EServerPinning						// The server is a pinning server.

		/*|| (gServerPinningState == EServerDefault && !gProcessPaged)*/// The process isn't paged and default server policy

		)

		{

		aExpected = ETrue;

		}

	return aExpected;

	}

CTestServer::CTestServer(TInt aPriority)

//

// Constructor - sets name

//

	: CServer2(aPriority)

	{}

CSession2* CTestServer::NewSessionL(const TVersion& aVersion,const RMessage2& /*aMessage*/) const

//

// Virtual fn - checks version supported and creates a CTestSession

//

	{

	TVersion version(KE32MajorVersionNumber,KE32MinorVersionNumber,KE32BuildVersionNumber);

	if (User::QueryVersionSupported(version,aVersion)==EFalse)

		User::Leave(KErrNotSupported);

	CTestSession* newCTestSession = new CTestSession;

	if (newCTestSession==NULL)

		User::Panic(_L("NewSessionL failure"), KErrNoMemory);

	return(newCTestSession);

	}

RSemaphore gSem;

RSemaphore gSem1;

TInt CTestSession::CheckDesPresent(const RMessage2& aMessage, TUint aArgIndex, TBool aExpected, TBool aWrite)

	{

	if (aExpected)

		RDebug::Printf("  Checking message argument at %d is present", aArgIndex);

	else

		RDebug::Printf("  Checking message argument at %d is not present", aArgIndex);

	// Get the length of the descriptor and verify it is as expected.

	TInt length = aMessage.GetDesLength(aArgIndex);

	if (length < KErrNone)

		{

		RDebug::Printf("  Error getting descriptor length %d", length);

		return length;

		}

	if (length < 3)

		{// The incorrect descriptor length.

		RDebug::Printf("  Error - Descriptor length too small %d", length);

		return KErrArgument;

		}

	if (!aWrite)

		{// Now read the descriptor and verify that it is present or not.

		TBuf8<5> des;

		TInt r = aMessage.Read(aArgIndex, des);

		TBool pass;

		if (iClientDied)

			pass = r == KErrDied || r == KErrBadDescriptor;

		else

			pass = r == (aExpected ? KErrNone : KErrBadDescriptor);

		if (!pass)

			{

			RDebug::Printf("  Error reading descriptor data r %d", r);

			return KErrGeneral;

			}

		if (r==KErrNone && (des[0] != 'a' || des[1] != 'r' || des[2] != 'g'))

			{// The incorrect descriptor data has been passed.

			RDebug::Printf("  Error in descriptor data is corrupt r %d", r);

			return KErrArgument;

			}

		}

	else

		{// Now write to the maximum length of the descriptor.

		TInt max = aMessage.GetDesMaxLength(aArgIndex);

		if (max < 0)

			{

			RDebug::Printf("  Error getting descriptor max. length %d", max);

			return length;

			}

		HBufC8* argTmp = HBufC8::New(max);

		TPtr8 argPtr = argTmp->Des();

		argPtr.SetLength(max);

		for (TInt i = 0; i < max; i++)

			argPtr[i] = (TUint8)aArgIndex;

		TInt r = aMessage.Write(aArgIndex, argPtr);

		TBool pass;

		if (iClientDied)

			pass = r == KErrDied || r == KErrBadDescriptor;

		else

			pass = r == (aExpected ? KErrNone : KErrBadDescriptor);

		if (!pass)

			{

			RDebug::Printf("  Error writing to the descriptor data r %d", r);

			return KErrGeneral;

			}

		}

	if (!aExpected)

		{// The client should have been killed as the data wasn't present.

		if(!iClientDied)

			User::After(500000); // allow time for client to die before next test

		iClientDied = ETrue;

		}

	return KErrNone;

	}

TInt CTestSession::CheckArgsPresent(const RMessage2& aMessage, TBool arg0Present, TBool arg1Present, TBool arg2Present, TBool arg3Present, TBool aWrite=EFalse)

	{

	// Adjust the pinning status expected based on the default policies.

	// (Must do this before anything else as UpdateExpected() accessed paged global data)

	arg0Present = UpdateExpected(arg0Present);

	arg1Present = UpdateExpected(arg1Present);

	arg2Present = UpdateExpected(arg2Present);

	arg3Present = UpdateExpected(arg3Present);

	// Flush the cache so on paged systems, unpinned paged memory will be discarded.

	DPTest::FlushCache();

	TInt r = User::SetRealtimeState(User::ERealtimeStateOn);

	if (r != KErrNone)

		{

		RDebug::Printf("Error setting realtime state r = %d", r);

		return r;

		}

	r = CheckDesPresent(aMessage, 0, arg0Present, aWrite);

	if (r == KErrNone)

		r = CheckDesPresent(aMessage, 1, arg1Present, aWrite);

	if (r == KErrNone)

		r = CheckDesPresent(aMessage, 2, arg2Present, aWrite);

	if (r == KErrNone)

		r = CheckDesPresent(aMessage, 3, arg3Present, aWrite);

	User::SetRealtimeState(User::ERealtimeStateOff);

	return r;

	}

void CTestSession::ServiceL(const RMessage2& aMessage)

//

// Virtual message-handler

//

	{

	TInt r = KErrNone;

	iClientDied = EFalse;

	switch (aMessage.Function())

		{

		case EStop:

			CActiveScheduler::Stop();

			break;

		case ETestPinAll:

			r = CheckArgsPresent(aMessage, ETrue, ETrue, ETrue, ETrue);

			break;

		case ETestPinOdd:

			r = CheckArgsPresent(aMessage, EFalse, ETrue, EFalse, ETrue);

			break;

		case ETestPinEven:

			r = CheckArgsPresent(aMessage, ETrue, EFalse, ETrue, EFalse);

			break;

		case ETestPin3:

			r = CheckArgsPresent(aMessage, ETrue, ETrue, ETrue, EFalse);

			break;

		case ETestPin2:

			r = CheckArgsPresent(aMessage, ETrue, ETrue, EFalse, EFalse);

			break;

		case ETestPin1:

			r = CheckArgsPresent(aMessage, ETrue, EFalse, EFalse, EFalse);

			break;

		case ETestPin0:

		case ETestPinDefault:

			r = CheckArgsPresent(aMessage, EFalse, EFalse, EFalse, EFalse);

			break;

		case ETestPinWritable:

			r = CheckArgsPresent(aMessage, ETrue, ETrue, ETrue, ETrue, ETrue);

			break;

		case ETestUnpinWritable:

			r = CheckArgsPresent(aMessage, EFalse, EFalse, EFalse, EFalse, ETrue);

			break;

		default:

			r = KErrNotSupported;

		}

 	aMessage.Complete(r);

	// If descriptors aren't as expected then panic so the test will fail.

	if (r != KErrNone)

		User::Panic(_L("ServiceL failure"), r);

	}

// CTestSession funtions

void CMyActiveScheduler::Error(TInt anError) const

//

// Virtual error handler

//

	{

	User::Panic(_L("CMyActiveScheduer::Error"), anError);

	}

TInt ServerThread(TAny* aPinningAttrib)

//

// Passed as the server thread in 2 tests - sets up and runs CTestServer

//

	{

	RTest test(_L("T_SVRPINNING...server"));

	CMyActiveScheduler* pScheduler = new CMyActiveScheduler;

	if (pScheduler == NULL)

		{

		gSem.Signal();

		test(0);

		}

	CActiveScheduler::Install(pScheduler);

	CTestServer* pServer = new CTestServer(0);

	if (pServer == NULL)

		{

		gSem.Signal();

		test(0);

		}

	// Set the pinning attributes of the server.

	TServerPinning pinningAttrib = (TServerPinning)(TInt)aPinningAttrib;

	switch (pinningAttrib)

		{

		case EServerDefault :

		case EServerSetPinningTooLate :

			break;

		case EServerPinning :

			pServer->SetPinClientDescriptors(ETrue);

			break;

		case EServerNotPinning :

			pServer->SetPinClientDescriptors(EFalse);

			break;

		default :

			break;

		}

	//Starting a CServer2 also Adds it to the ActiveScheduler

	TInt r = pServer->Start(KServerName);

	if (r != KErrNone)

		{

		gSem.Signal();

		test(0);

		}

	if (pinningAttrib == EServerSetPinningTooLate)

		{

		pServer->SetPinClientDescriptors(EFalse);

		}

	test.Next(_L("Start ActiveScheduler and signal to client"));

	test.Printf(_L("        There might be something going on beneath this window\n"));

	gSem.Signal();

	CActiveScheduler::Start();

	test.Next(_L("Destroy ActiveScheduler"));

	delete pScheduler;

	delete pServer;

	test.Close();

	return (KErrNone);

	}

#include <e32svr.h>

void dummyFunction(TUint8* /*a0*/, TUint8* /*a1*/, TUint8* /*a2*/, TUint8* /*a3*/, TUint8* /*a4*/, TUint8* /*a5*/)

	{

	}

TInt ClientThread(TAny* aTestMode)

//

// Passed as the first client thread - signals the server to do several tests

//

	{

	// Create the message arguments to be pinned.  Should be one of each type of

	// descriptor to test that the pinning code can correctly pin each type 

	// descriptor data.  Each descriptor's data should in a separate page in 

	// thread's stack to ensure that access to each argument will cause a 

	// separate page fault.

	TUint8 argBufs[KPageSize*(6+2)]; // enough for 6 whole pages

	TUint8* argBuf0 = (TUint8*)(TUintPtr(argBufs+gPageMask)&~gPageMask);

	TUint8* argBuf1 = argBuf0+KPageSize;

	TUint8* argBuf2 = argBuf1+KPageSize;

	TUint8* argBuf3 = argBuf2+KPageSize;

	TUint8* argBuf4 = argBuf3+KPageSize;

	TUint8* argBuf5 = argBuf4+KPageSize;

	argBuf0[0]='a'; argBuf0[1]='r'; argBuf0[2]='g'; argBuf0[3]='0'; argBuf0[4]='\0';

	TPtr8 arg0(argBuf0, 5, 20);

	TBufC8<5>& arg1 = *(TBufC8<5>*)argBuf1;

	new (&arg1) TBufC8<5>((const TUint8*)"arg1");

	argBuf2[0]='a'; argBuf2[1]='r'; argBuf2[2]='g'; argBuf2[3]='1'; argBuf2[4]='\0';

	TPtrC8 arg2((const TUint8*)argBuf2);

	TBuf8<50>& arg3 = *(TBuf8<50>*)argBuf3;

	new (&arg3) TBuf8<50>((const TUint8*)"arg3");

	// For some tests use this 5th and final type of descriptor.

	HBufC8* argTmp = HBufC8::New(7);

	*argTmp = (const TUint8*)"argTmp";

	RBuf8 argTmpBuf(argTmp);

	// Need a couple of extra writable argments

	argBuf4[0]='a'; argBuf4[1]='r'; argBuf4[2]='g'; argBuf4[3]='4'; argBuf4[4]='\0';

	TPtr8 arg4(argBuf4, 5, 20);

	argBuf5[0]='a'; argBuf5[1]='r'; argBuf5[2]='g'; argBuf5[3]='5'; argBuf5[4]='\0';

	TPtr8 arg5(argBuf5, 5, 20);

	RTest test(_L("T_SVRPINNING...client"));

	RSession session;

	TInt r = session.PublicCreateSession(_L("CTestServer"),5);

	if (r != KErrNone)

		{

		gSem.Signal();

		test(0);

		}

	switch((TInt)aTestMode)

		{

		case CTestSession::ETestPinAll:

			test.Printf(_L("Test pinning all args\n"));

			r = session.PublicSendReceive(CTestSession::ETestPinAll, TIpcArgs(&arg0, &arg1, &arg2, &arg3).PinArgs());

			break;

		case CTestSession::ETestPinOdd:

			test.Printf(_L("Test pinning odd args\n"));

			r = session.PublicSendReceive(CTestSession::ETestPinOdd, TIpcArgs(&arg0, &argTmpBuf, &arg2, &arg3).PinArgs(EFalse, ETrue, EFalse, ETrue));

			break;

		case CTestSession::ETestPinEven:

			test.Printf(_L("Test pinning even args\n"));

			r = session.PublicSendReceive(CTestSession::ETestPinEven, TIpcArgs(&arg0, &arg1, argTmp, &arg3).PinArgs(ETrue, EFalse, ETrue, EFalse));

			break;

		case CTestSession::ETestPin3:

			test.Printf(_L("Test pinning 3 args\n"));

			r = session.PublicSendReceive(CTestSession::ETestPin3, TIpcArgs(&arg0, &arg1, &arg2, &arg3).PinArgs(ETrue, ETrue, ETrue, EFalse));

			break;

		case CTestSession::ETestPin2:

			test.Printf(_L("Test pinning 2 args\n"));

			r = session.PublicSendReceive(CTestSession::ETestPin2, TIpcArgs(argTmp, &arg1, &arg2, &arg3).PinArgs(ETrue, ETrue, EFalse, EFalse));

			break;

		case CTestSession::ETestPin1:

			test.Printf(_L("Test pinning 1 args\n"));

			r = session.PublicSendReceive(CTestSession::ETestPin1, TIpcArgs(&argTmpBuf, &arg1, &arg2, &arg3).PinArgs(ETrue, EFalse, EFalse, EFalse));

			break;

		case CTestSession::ETestPin0:

			test.Printf(_L("Test pinning 0 args\n"));

			r = session.PublicSendReceive(CTestSession::ETestPin0, TIpcArgs(&arg0, &arg1, &arg2, &arg3).PinArgs(EFalse, EFalse, EFalse, EFalse));

			break;

		case CTestSession::ETestPinDefault:

			test.Printf(_L("Test the default pinning policy of this server\n"));

			r = session.PublicSendReceive(CTestSession::ETestPinDefault, TIpcArgs(&arg0, &arg1, &arg2, argTmp));

			break;

		case CTestSession::ETestPinWritable:

			test.Printf(_L("Test writing to pinned descriptors\n"));

			r = session.PublicSendReceive(CTestSession::ETestPinWritable, TIpcArgs(&arg0, &arg3, &arg4, &arg5).PinArgs(ETrue, ETrue, ETrue, ETrue));

			// Verify the index of each argument has been written to each descriptor.

			{

			TUint maxLength = arg0.MaxLength();

			test_Equal(maxLength, arg0.Length());

			TUint j = 0;

			for (; j < maxLength; j++)

				test_Equal(0, arg0[j]);

			maxLength = arg3.MaxLength();

			test_Equal(maxLength, arg3.Length());

			for (j = 0; j < maxLength; j++)

				test_Equal(1, arg3[j]);

			maxLength = arg4.MaxLength();

			test_Equal(maxLength, arg4.Length());

			for (j = 0; j < maxLength; j++)

				test_Equal(2, arg4[j]);

			maxLength = arg5.MaxLength();

			test_Equal(maxLength, arg5.Length());

			for (j = 0; j < maxLength; j++)

				test_Equal(3, arg5[j]);

			}

			break;

		case CTestSession::ETestUnpinWritable:

			test.Printf(_L("Test writing to unpinned descriptors\n"));

			r = session.PublicSendReceive(CTestSession::ETestUnpinWritable, TIpcArgs(&arg0, &arg3, &arg4, &arg5).PinArgs(EFalse, EFalse, EFalse, EFalse));

			// Verify the index of each argument has been written to each descriptor.

			// Unless this is a pinnning server than the thread will be panicked before we reach there.

			{

			TUint maxLength = arg0.MaxLength();

			test_Equal(maxLength, arg0.Length());

			TUint j = 0;

			for (j = 0; j < maxLength; j++)

				test_Equal(0, arg0[j]);

			maxLength = arg3.MaxLength();

			test_Equal(maxLength, arg3.Length());

			for (j = 0; j < maxLength; j++)