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