// 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\cppexceptions\t_unmap.cpp

// 

//

#include <e32std.h>

#include <e32std_private.h>

#include <e32base.h>

#include <e32base_private.h>

#include <e32test.h>

#include <e32svr.h>

#include <f32dbg.h>

#include <e32def.h>

#include <e32def_private.h>

#include "d_unmap.h"

_LIT(KTestName, "t_unmap");

_LIT(KTestThreadName, "t_unmap test thread");

_LIT(KNopThreadName, "nop [DLL unload checking] thread");

_LIT(KTUnmapPanic, "t_unmap");

_LIT(KThread, "Thread");

_LIT(KUnhandledExcCategory, "KERN-EXEC");

const TInt KUnhandledExcReason = 3;

enum TUnmapPanic

	{

	EPanickingThread = 123456789

	};

RTest test(KTestName);

RTest testThreadA(KTestThreadName);

RTest testThreadB(KTestThreadName);

RTest testThreadC(KTestThreadName);

RTest testThreadD(KTestThreadName);

RTest testThreadE(KTestThreadName);

RTest testThreadF(KTestThreadName);

RTest testThreadG(KTestThreadName);

RTest testThreadH(KTestThreadName);

RTest testThreadI(KTestThreadName);

RTest testThreadJ(KTestThreadName);

RTest testThreadK(KTestThreadName);

RSemaphore Thread1Semaphore;

RSemaphore Thread2Semaphore;

RSemaphore FinishedOpSemaphore;

RLibrary ThreadALibraryHandle;

RLibrary ThreadBLibraryHandle;

RLibrary ThreadCLibraryHandle;

RLibrary ThreadDLibraryHandle;

RLibrary ThreadELibraryHandle;

RLibrary ThreadFLibraryHandle;

RLibrary ThreadGLibraryHandle;

RLibrary ThreadHLibraryHandle;

RLibrary ThreadILibraryHandle;

RLibrary ThreadJLibraryHandle;

RLibrary ThreadKLibraryHandle;

TBool CheckKernelHeap;

void TestThreads();

TInt ThreadA(TAny*);

TInt ThreadB(TAny*);

TInt ThreadC(TAny*);

TInt ThreadD(TAny*);

TInt ThreadE(TAny*);

TInt ThreadF(TAny*);

TInt ThreadG(TAny*);

TInt ThreadH(TAny*);

TInt ThreadI(TAny*);

TInt ThreadJ(TAny*);

TInt ThreadK(TAny*);

TInt DoThreadAL(TAny*);

TInt DoThreadBL(TAny*);

TInt DoThreadCL(TAny*);

TInt DoThreadDL(TAny*);

TInt DoThreadEL(TAny*);

TInt DoThreadFL(TAny*);

TInt DoThreadGL(TAny*);

TInt DoThreadHL(TAny*);

TInt DoThreadIL(TAny*);

TInt DoThreadJL(TAny*);

TInt DoThreadKL(TAny*);

struct STestThreadInfo

	{

	TThreadFunction	iThreadFn;

	TExitType		iExitType;

	TInt			iMappedSignals;

	TInt			iLeaveSignals;

	};

static STestThreadInfo const TheThreadArray[] =

	{

		{ &ThreadA, EExitPanic, 0, 0 },

		{ &ThreadB, EExitKill, 0, 0 },

		{ &ThreadC, EExitPanic, 1, 0 },

		{ &ThreadD, EExitPanic, 2, 0 },

		{ &ThreadE, EExitKill, 2, 2 },

		{ &ThreadF, EExitPanic, 2, 1 },

		{ &ThreadG, EExitKill, 3, 1 },

		{ &ThreadH, EExitKill, 1, 1 },

		{ &ThreadI, EExitKill, 1, 3 },

		{ &ThreadJ, EExitPanic, 1, 2 },

		{ &ThreadK, EExitPanic, 1, 1 }

	};

struct SNopThreadInfo

	{

	TLibraryFunction iFunc;

#ifdef __WINS__

	TInt32 iOriginalContents;

#endif

	};

static SNopThreadInfo NopThreadInfo;

static const TInt TheThreadCount = (sizeof(TheThreadArray) / sizeof(STestThreadInfo));

static const TInt KHeapSize = 0x2000;

TInt E32Main()

   	{

	test.Start(_L("Check code seg unmapping over User::Leave()/C++ exceptions."));

	__UHEAP_MARK;

   	//

   	CTrapCleanup* cleanup = CTrapCleanup::New();

   	TInt r = KErrNoMemory;

   	if (cleanup)

   		{

		TRAP(r, TestThreads());

		test.Printf(_L("Returned %d, expected %d\n"), r, KErrNone);

		test(r == KErrNone);

   		}

	delete cleanup;

   	//

   	__UHEAP_MARKEND;

	test.End();

   	return r;

   	}

TInt NopThread(TAny*)

	{

#ifdef __WINS__

	TInt32 current = *(TInt*)NopThreadInfo.iFunc;

	if (current != NopThreadInfo.iOriginalContents)

		current = *(TInt32*)NULL; // cause panic

#endif

	TInt r = NopThreadInfo.iFunc();

	if (r)

		return KErrNone;

	else

		return KErrGeneral;

	}

void TestLoadWhileUnload();

void TestThreads()

	{

	__KHEAP_MARK;

	test.Next(_L("Create synchronisation semaphores"));

	TInt r = Thread1Semaphore.CreateLocal(0);

	test(r == KErrNone);

	r = Thread2Semaphore.CreateLocal(0);

	test(r == KErrNone);

	r = FinishedOpSemaphore.CreateLocal(0);

	test(r == KErrNone);

	// Turn off JIT [threads can panic to test exit cleanup]

	TBool jit = User::JustInTime();

	User::SetJustInTime(EFalse);

	TInt count, count2;

	// Do kernel heap checking

	CheckKernelHeap = ETrue;

	test.Next(_L("Run threads on their own"));

	for (count = 0; count < TheThreadCount ; ++count)

		{

		// Set up descriptor for thread's name

		TBuf16<7> name(KThread);

		name.Append('A' + count);

		// Create thread

		RThread thread;

		TInt r = thread.Create(

			name,

			TheThreadArray[count].iThreadFn,

			KDefaultStackSize,

			KHeapSize,

			KHeapSize,

			&Thread1Semaphore

		);

		test(r == KErrNone);

		// Set up notification of thread's death

		TRequestStatus status;

		thread.Logon(status);

		// Load library

		RLibrary library;

		r = library.Load(KLeavingDll);

		test(r == KErrNone);

		// Remember the address of the NOP function

		NopThreadInfo.iFunc = library.Lookup(2);

#ifdef __WINS__

		NopThreadInfo.iOriginalContents = *(TInt32*)NopThreadInfo.iFunc;

#endif

		// Run thread

		thread.Resume();

		// Wait until it has an open handle to the library

		FinishedOpSemaphore.Wait();

		// Close our handle to the library

		library.Close();

		// Check library is still loaded

		for (count2 = 0; count2 < TheThreadArray[count].iMappedSignals; ++count2)

			{

			// Tell it we're ready to go

			Thread1Semaphore.Signal();

			// Wait for it to finish next step

			FinishedOpSemaphore.Wait();

			// Create NOP thread to call NOP function to check DLL still loaded

			RThread nopThread;

			r = nopThread.Create(

				KNopThreadName,

				NopThread,

				KDefaultStackSize,

				KHeapSize,

				KHeapSize,

				NULL

			);

			test(r == KErrNone);

			// Set up notification of thread's death

			TRequestStatus nopStatus;

			nopThread.Logon(nopStatus);

			// Run thread

			nopThread.Resume();

			// Wait for it to die

			User::WaitForRequest(nopStatus);

			// Check the exit info

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

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

			// Close thread handle

			CLOSE_AND_WAIT(nopThread);

			}

		// Check User::Leave() library unloading behaviour

		for (count2 = 0; count2 < TheThreadArray[count].iLeaveSignals; ++count2)

			{

			// Tell it we're ready to go

			Thread1Semaphore.Signal();

			// Wait for it to finish next step

			FinishedOpSemaphore.Wait();

			// Create NOP thread to call NOP function to check whether DLL is still loaded

			RThread nopThread;

			r = nopThread.Create(

				KNopThreadName,

				NopThread,

				KDefaultStackSize,

				KHeapSize,

				KHeapSize,

				NULL

			);

			test(r == KErrNone);

			// Set up notification of thread's death

			TRequestStatus nopStatus;

			nopThread.Logon(nopStatus);

			// Run thread

			nopThread.Resume();

			// Wait for it to die

			User::WaitForRequest(nopStatus);

			// Check the exit info

#ifdef __LEAVE_EQUALS_THROW__

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

			test(nopThread.ExitReason() == KErrGeneral);

#else //!__LEAVE_EQUALS_THROW__

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

			test(nopThread.ExitCategory() == KUnhandledExcCategory);

			test(nopThread.ExitReason() == KUnhandledExcReason);

#endif //__LEAVE_EQUALS_THROW__

			// Close thread handle

			CLOSE_AND_WAIT(nopThread);

			}

		// Tell it we're ready to go again

		Thread1Semaphore.Signal();

		if (TheThreadArray[count].iExitType == EExitKill)

			{

			// Wait for it to finish last step

			FinishedOpSemaphore.Wait();

			User::After(100000);	// let supervisor run

			// Create NOP thread to call NOP function to check DLL is unloaded

			RThread nopThread;

			r = nopThread.Create(

				KNopThreadName,

				NopThread,

				KDefaultStackSize,

				KHeapSize,

				KHeapSize,

				NULL

			);

			test(r == KErrNone);

			// Set up notification of thread's death

			TRequestStatus nopStatus;

			nopThread.Logon(nopStatus);

			// Run thread

			nopThread.Resume();

			// Wait for it to die

			User::WaitForRequest(nopStatus);

			// Check the exit info

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

			test(nopThread.ExitCategory() == KUnhandledExcCategory);

			test(nopThread.ExitReason() == KUnhandledExcReason);

			// Close thread handle

			CLOSE_AND_WAIT(nopThread);

			// Let main thread die now

			Thread1Semaphore.Signal();

			}

		// Wait for thread to exit

		User::WaitForRequest(status);

		// Check the exit type & category

		test(thread.ExitType() == TheThreadArray[count].iExitType);

		// Check category & reason, if appropriate

		if (thread.ExitType() == EExitPanic)

			{

			test(thread.ExitCategory() == KTUnmapPanic);

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

			}

		// Close thread handle

		thread.Close();

		}

	// Turn off kernel heap checking

	CheckKernelHeap = EFalse;

	test.Next(_L("Run threads against each other"));

	for (count = 0; count < TheThreadCount ; ++count)

		{

		for (count2 = 0; count2 < TheThreadCount ; ++count2)

			{

			// Can't run the same threads back to back

			if (count == count2)

				{

				continue;

				}

			// Set up descriptors for threads' names

			_LIT(KFirstThread, " - 1");

			_LIT(KSecondThread, " - 2");

			TBuf16<11> name(KThread);

			TBuf16<11> name2(KThread);

			name.Append('A' + count);

			name.Append(KFirstThread);

			name2.Append('A' + count2);

			name2.Append(KSecondThread);

			// Create threads

			RThread thread;

			TInt r = thread.Create(

				name,

				TheThreadArray[count].iThreadFn,

				KDefaultStackSize,

				KHeapSize,

				KHeapSize,

				&Thread1Semaphore

			);

			test(r == KErrNone);

			RThread thread2;

			r = thread2.Create(

				name2,

				TheThreadArray[count2].iThreadFn,

				KDefaultStackSize,

				KHeapSize,

				KHeapSize,

				&Thread2Semaphore

			);

			test(r == KErrNone);

			// Set up notification of threads' death

			TRequestStatus status, status2;

			thread.Logon(status);

			thread2.Logon(status2);

			// Run first thread

			thread.Resume();

			// Wait until just before it's closed the library handle

			FinishedOpSemaphore.Wait();

			// Run second thread

			thread2.Resume();

			// Wait until just before it's closed the library handle

			FinishedOpSemaphore.Wait();

			// Tell first thread we're ready to go

			TInt signals =	TheThreadArray[count].iMappedSignals +

							TheThreadArray[count].iLeaveSignals +

							((TheThreadArray[count].iExitType == EExitPanic) ? 1 : 2);

			Thread1Semaphore.Signal(signals);

			// Eat up 'FinishedOp' signals

			while(--signals>0)

				FinishedOpSemaphore.Wait();

			// Wait for it to finish

			User::WaitForRequest(status);

			// Check the exit type & category of the first thread

			test(thread.ExitType() == TheThreadArray[count].iExitType);

			// Check category & reason of the first thread, if appropriate

			if (thread.ExitType() == EExitPanic)

				{

				test(thread.ExitCategory() == KTUnmapPanic);

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

				}

			// Tell second thread we're ready to go

			signals = TheThreadArray[count2].iMappedSignals +

					  TheThreadArray[count2].iLeaveSignals +

					  ((TheThreadArray[count2].iExitType == EExitPanic) ? 1 : 2);

			Thread2Semaphore.Signal(signals);

			// Eat up 'FinishedOp' signals

			while(--signals>0)

				FinishedOpSemaphore.Wait();

			// Wait for it to finish

			User::WaitForRequest(status2);

			// Check the exit type & category of the second thread

			test(thread2.ExitType() == TheThreadArray[count2].iExitType);

			// Check category & reason of the second thread, if appropriate

			if (thread2.ExitType() == EExitPanic)

				{

				test(thread2.ExitCategory() == KTUnmapPanic);

				test(thread2.ExitReason() == EPanickingThread);

				}

			// Close thread handles

			CLOSE_AND_WAIT(thread);

			CLOSE_AND_WAIT(thread2);

			}

		}

	// Test two processes at once to deal with race conditions

	test.Printf(_L("Create two processes at once to map the same library\n"));

	RSemaphore procSem1, procSem2;

	test(procSem1.CreateGlobal(KNullDesC, 0)==KErrNone);

	test(procSem2.CreateGlobal(KNullDesC, 0)==KErrNone);

	RProcess proc1, proc2;

	test(proc1.Create(_L("T_UNMAP2"), KNullDesC)==KErrNone);

	test(proc2.Create(_L("T_UNMAP2"), KNullDesC)==KErrNone);

	test(proc1.SetParameter(1, procSem1)==KErrNone);

	test(proc1.SetParameter(2, procSem2)==KErrNone);

	test(proc2.SetParameter(1, procSem2)==KErrNone);

	test(proc2.SetParameter(2, procSem1)==KErrNone);

	TRequestStatus proc1stat, proc2stat;

	proc1.Logon(proc1stat);

	proc2.Logon(proc2stat);

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

	proc1.Resume();

	proc2.Resume();