// Copyright (c) 1998-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\misc\t_asid.cpp

// 

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32svr.h>

#include <u32std.h>

#include "t_asid.h"

#include "d_asid.h"

#define TEST_R(r, e) if (!(e)) {RDebug::Printf("Failure at line %d, r = %d", __LINE__, r); return r; }

_LIT(KDummyProcessName,"T_ASID_DUMMY");

RTest test(_L("T_ASID"));

const TUint KMaxAsids = 256; // On arm and current version of FMM has maximum of 256 active processes at once.

const TUint KLeakedProcesses = KMaxAsids<<1;

void TestMaxAsids()

	{

	test.Printf(_L("Attempt to load > %d zombie processes\n"), KMaxAsids);

	RProcess* processes = new RProcess[KLeakedProcesses];

	TUint i = 0;

	for (; i < KLeakedProcesses; i++)

		{

		test_KErrNone(processes[i].Create(KDummyProcessName, KNullDesC));

		TRequestStatus s;

		processes[i].Logon(s);

		test_Equal(KRequestPending, s.Int());

		processes[i].Resume();

		User::WaitForRequest(s);

		if (processes[i].ExitType()!=EExitKill || processes[i].ExitReason()!=KErrNone)

			{

			TExitCategoryName aExitCategory = processes[i].ExitCategory();

			test.Printf(_L("Exit      %d,%d,%S\n"),processes[i].ExitType(),processes[i].ExitReason(),&aExitCategory);

			test(0);

			}

		}

	// Clean up the process handles here.

	for (i = 0; i < KLeakedProcesses; i++)

		processes[i].Close();

	delete[] processes;

	}

TInt TestIpcThread(TAny*)

	{

	// Start a server for zombie to connect to.

	RServer2 ipcServer;

	TInt r = ipcServer.CreateGlobal(KAsidIpcServerName);

	TEST_R(r, r == KErrNone);

	RMessage2 ipcMessage;

	for (TUint i = 0; i < 300; i++)

		{

		// Start the process.

		RProcess zombie;

		TInt r = zombie.Create(KDummyProcessName, KAsidIpcServerName);

		TEST_R(r, r == KErrNone);

		TRequestStatus s;

		zombie.Logon(s);

		TEST_R(s.Int(), s.Int() == KRequestPending);

		zombie.Resume();

		// Wait for the connect and ipc message from the zombie

		ipcServer.Receive(ipcMessage);

		TEST_R(ipcMessage.Function(), ipcMessage.Function() == EConnect);

		ipcMessage.Complete(KErrNone);

		ipcServer.Receive(ipcMessage);

		TEST_R(ipcMessage.Function(), ipcMessage.Function() == EIpcData);

		TUint8 array1[KAsidDesLen];

		memset(array1, KAsidValue, KAsidDesLen);

		TPtr8 buf1(array1, KAsidDesLen, KAsidDesLen);

		TUint8 array[KAsidDesLen];

		TPtr8 buf(array, KAsidDesLen);

		test_Equal(KErrNone, ipcMessage.Read(0, buf));

		r = ipcMessage.Read(0, buf);

		TEST_R(r, r == KErrNone);

		r = buf.Compare(buf1);

		TEST_R(r, r == 0);

		ipcMessage.Complete(KErrNone);	

		// Try to read from the client while it is exiting.

		ipcServer.Receive(ipcMessage);

		TEST_R(ipcMessage.Function(), ipcMessage.Function() ==  EIpcData);

		User::After(5*i);

		r = ipcMessage.Read(0, buf);

		//RDebug::Printf("%d", r);

		// Wait for client to exit.

		User::WaitForRequest(s);

		TEST_R(s.Int(), s.Int() == KErrNone);

		ipcServer.Receive(ipcMessage);	// Clear out the disconnect message.

		TEST_R(ipcMessage.Function(), ipcMessage.Function() == EDisConnect);

		ipcMessage.Complete(KErrNone);

		zombie.Close();

		}

	ipcServer.Close();

	return KErrNone;

	}

TInt TestDesThread(TAny*)

	{

	RAsidLdd asidLdd;

	TInt r = asidLdd.Open();

	TEST_R(r, r == KErrNone);

	RMessage2 desMessage;

	RServer2 desServer;

	// Start a server for zombie to connect to.

	r = desServer.CreateGlobal(KAsidDesServerName);

	TEST_R(r, r == KErrNone);

	for (TUint i = 0; i < 300; i++)

		{

		// Start the process.

		RProcess zombie;

		r = zombie.Create(KDummyProcessName, KAsidDesServerName);

		TEST_R(r, r == KErrNone);

		TRequestStatus s;

		zombie.Logon(s);

		TEST_R(s.Int(), s.Int() == KRequestPending);

		zombie.Resume();

		// Wait for the connect and des message from the zombie

		desServer.Receive(desMessage);

		TEST_R(desMessage.Function(), desMessage.Function() == EConnect);

		desMessage.Complete(KErrNone);

		desServer.Receive(desMessage);

		TEST_R(desMessage.Function(), desMessage.Function() == EDesData);

		TAny* desPtr = (TAny*)desMessage.Ptr0();

		TAny* threadPtr = (TAny*)desMessage.Ptr1();

		// Open a handle on the client's thread to stop it being deleted.

		r = asidLdd.OpenThread(threadPtr);

		TEST_R(r, r == KErrNone);

		SDesHeader desHdr;

		desHdr.iDes = desPtr;

		r = asidLdd.ReadDesHeader(threadPtr, desHdr);

		TEST_R(r, r == KErrNone);

		TEST_R(desHdr.iLength, desHdr.iLength == KAsidDesLen);

		TEST_R(desHdr.iMaxLength, desHdr.iMaxLength == KAsidDesLen);

		desMessage.Complete(KErrNone);

		// Wait for further des message from client.

		desServer.Receive(desMessage);

		TEST_R(desMessage.Function(), desMessage.Function() == EDesData);

		desPtr = (TAny*)desMessage.Ptr0();

		TEST_R((TInt)desMessage.Ptr1(), (TInt)desMessage.Ptr1() == (TInt)threadPtr);

		// Try to read descriptor header from the client while it is exiting.

		TInt r = asidLdd.ReadDesHeader(threadPtr, desHdr);

		User::After(5*i);

		//RDebug::Printf("%d", r);

		if (r == KErrNone)

			{

			TEST_R(desHdr.iLength, desHdr.iLength == KAsidDesLen);

			TEST_R(desHdr.iMaxLength, desHdr.iMaxLength == KAsidDesLen);

			}

		// Wait for client to exit.

		User::WaitForRequest(s);

		TEST_R(s.Int(), s.Int() == KErrNone);

		desServer.Receive(desMessage);	// Clear out the disconnect message.

		TEST_R(desMessage.Function(), desMessage.Function() == EDisConnect);

		desMessage.Complete(KErrNone);

		// Close handles in client process and thread.

		r = asidLdd.CloseThread();

		TEST_R(r, r == KErrNone);

		zombie.Close();

		}

	desServer.Close();

	asidLdd.Close();

	return KErrNone;

	}

GLDEF_C TInt E32Main()

	{

	test.Title();

	test.Start(_L("Test zombie processes release their ASIDs"));

	// Get memory model.

	if ((UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, NULL, NULL)&EMemModelTypeMask) < EMemModelTypeFlexible)

		{

		test.Printf(_L("SKIPPING TEST - Older memory models don't release ASIDs from zombie processes\n"));

		test.End();

		return KErrNone;

		}

	TestMaxAsids();

	test.Next(_L("Test ipc message copy to a zombie process"));

	test_KErrNone(TestIpcThread(NULL));

	TestMaxAsids();

	test.Next(_L("Test reading descriptor header from a zombie process"));

	test_KErrNone(TestDesThread(NULL));

	TestMaxAsids();

	test.Next(_L("Test ipc and des header to zombie processes concurrently"));

	RThread ipcThread;

	RThread desThread;

	ipcThread.Create(KNullDesC, TestIpcThread, 0x2000, NULL, NULL);

	desThread.Create(KNullDesC, TestDesThread, 0x2000, NULL, NULL);

	TRequestStatus ipcStatus;

	TRequestStatus desStatus;

	ipcThread.Logon(ipcStatus);

	desThread.Logon(desStatus);

	ipcThread.Resume();

	desThread.Resume();

	// Wait for threads to complete.

	User::WaitForRequest(ipcStatus);

	test_KErrNone(ipcStatus.Int());

	User::WaitForRequest(desStatus);

	test_KErrNone(desStatus.Int());

	TestMaxAsids();

	test.End();

	return KErrNone;

	}