// Copyright (c) 2007-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\defrag\d_testramdefrag.cpp

// 

//

//#define DEBUG_VER				// Uncomment for tracing

#include "platform.h"

#include <kernel/kern_priv.h>

#include <kernel/cache.h>

#include "t_ramdefrag.h"

//

// Class definitions

//

const TInt KMajorVersionNumber=0;

const TInt KMinorVersionNumber=1;

const TInt KBuildVersionNumber=1;

const TInt KDefragCompleteThreadPriority = 27;

_LIT(KDefragCompleteThread,"DefragCompleteThread");

class DRamDefragFuncTestFactory : public DLogicalDevice

	{

public:

	DRamDefragFuncTestFactory();

	~DRamDefragFuncTestFactory();

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DLogicalChannelBase*& aChannel);

	TDynamicDfcQue* iDfcQ;

	};

class DRamDefragFuncTestChannel : public DLogicalChannelBase

	{

public:

	DRamDefragFuncTestChannel(TDfcQue* aDfcQ);

	DRamDefragFuncTestChannel();

	~DRamDefragFuncTestChannel();

	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

	virtual TInt Request(TInt aFunction, TAny* a1, TAny* a2);

	TInt FreeAllFixedPages();

	TInt AllocFixedPages(TInt aNumPages);

	TInt AllocFixedArray(TInt aNumPages);

	TInt AllocateFixed2(TInt aNumPages);

	TInt GetAllocDiff(TUint aNumPages);

	TInt FreeAllFixedPagesRead();

	TInt AllocFixedPagesWrite(TInt aNumPages);

	TInt ZoneAllocContiguous(TUint aZoneID, TUint aNumBytes);

	TInt ZoneAllocContiguous(TUint* aZoneIdList, TUint aZoneIdCount, TUint aNumBytes);

	TInt ZoneAllocDiscontiguous(TUint aZoneID, TInt aNumPages);

	TInt ZoneAllocDiscontiguous(TUint* aZoneIdList, TUint aZoneIdCount, TInt aNumPages);

	TInt ZoneAllocToMany(TInt aZoneIndex, TInt aNumPages);

	TInt ZoneAllocToManyArray(TInt aZoneIndex, TInt aNumPages);

	TInt ZoneAllocToMany2(TInt aZoneIndex, TInt aNumPages);

	TInt AllocContiguous(TUint aNumBytes);

	TInt FreeZone(TInt aNumPages);

	TInt FreeFromAllZones();

	TInt FreeFromAddr(TInt aNumPages, TUint32 aAddr);

	TInt PageCount(TUint aId, STestUserSidePageCount* aPageData);

	TInt CancelDefrag();

	TInt CheckCancel(STestParameters* aParams);

	TInt CallDefrag(STestParameters* aParams);

	TInt CheckPriorities(STestParameters* aParams);

	TInt SetZoneFlag(STestFlagParams* aParams);

	TInt GetDefragOrder();

	TInt FreeRam();

	TInt DoSetDebugFlag(TInt aState);

	TInt ResetDriver();

	TInt ZoneAllocDiscontiguous2(TUint aZoneID, TInt aNumPages);

public:

	DRamDefragFuncTestFactory*	iFactory;

protected:

	static void DefragCompleteDfc(TAny* aSelf);

	void DefragComplete();

		static void Defrag2CompleteDfc(TAny* aSelf);

	void Defrag2Complete();

		static void Defrag3CompleteDfc(TAny* aSelf);

	void Defrag3Complete();

private:

	TPhysAddr				iContigAddr;		/**< The base address of fixed contiguous allocations*/

	TUint					iContigBytes;		/**< The no. of contiguous fixed bytes allocated*/

	TPhysAddr*				iAddrArray;	

	TUint					iAddrArrayPages;

	TUint					iAddrArraySize;

	TPhysAddr**				iAddrPtrArray;			

	TInt*					iNumPagesArray;

	TInt					iDebug;

	TInt					iThreadCounter;

	DChunk*					iChunk;

	TLinAddr				iKernAddrStart;

	TInt					iPageSize;

	TUint 					iPageShift;			/**< The system's page shift */

	TUint					iZoneCount;

	TRamDefragRequest		iDefragRequest;		//	Defrag request object

	TRamDefragRequest		iDefragRequest2;

	TRamDefragRequest		iDefragRequest3;

	TUint*					iZoneIdArray;		/**< Pointer to an kernel heap array of zone IDs*/

	DSemaphore*				iDefragSemaphore;	//	Semaphore enusre only one defrag operation is active per channel

	TRequestStatus*			iCompleteReq;		//	Pointer to a request status that will signal to the user side client once the defrag has completed

	TRequestStatus*			iCompleteReq2;

	TRequestStatus*			iCompleteReq3;		

	TRequestStatus			iTmpRequestStatus1;	

	TRequestStatus			iTmpRequestStatus2;

	DThread*				iRequestThread;		//	Pointer to the thread that made the defrag request

	DThread*				iRequestThread2;

	DThread*				iRequestThread3;		

	TDfcQue*				iDfcQ;				//	The DFC queue used for driver functions 

	TDfc					iDefragCompleteDfc;	//	DFC to be queued once a defrag operation has completed 

	TDfc					iDefragComplete2Dfc;

	TDfc					iDefragComplete3Dfc;

	TInt					iCounter;			//	Counts the number of defrags that have taken place

	TInt					iOrder;				//	Stores the order in which queued defrags took place

	};

//

// DRamDefragFuncTestFactory

//

DRamDefragFuncTestFactory::DRamDefragFuncTestFactory()

//

// Constructor

//

    {

    iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

    //iParseMask=0;//No units, no info, no PDD

    //iUnitsMask=0;//Only one thing

    }

TInt DRamDefragFuncTestFactory::Install()

	{

	return SetName(&KRamDefragFuncTestLddName);

	}

DRamDefragFuncTestFactory::~DRamDefragFuncTestFactory()

	{

	if (iDfcQ != NULL)

		{// Destroy the DFC queue created when this device drvier was loaded.

		iDfcQ->Destroy();

		}

	}

void DRamDefragFuncTestFactory::GetCaps(TDes8& /*aDes*/) const

	{

	// Not used but required as DLogicalDevice::GetCaps is pure virtual

	}

TInt DRamDefragFuncTestFactory::Create(DLogicalChannelBase*& aChannel)

	{

	DRamDefragFuncTestChannel* channel=new DRamDefragFuncTestChannel(iDfcQ);

	if(!channel)

		return KErrNoMemory;

	channel->iFactory = this;

	aChannel = channel;

	return KErrNone;

	}

DECLARE_STANDARD_LDD()

	{

	DRamDefragFuncTestFactory* factory = new DRamDefragFuncTestFactory;

	if (factory)

		{

		// Allocate a kernel thread to run the DFC 

		TInt r = Kern::DynamicDfcQCreate(factory->iDfcQ, KDefragCompleteThreadPriority, KDefragCompleteThread);

		if (r != KErrNone)

			{// Must close rather than delete factory as it is a DObject object.

			factory->AsyncClose();

			return NULL; 	

			} 	

		}

    return factory;

	}

//

// DRamDefragFuncTestChannel

//

TInt DRamDefragFuncTestChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)

	{

	TInt ret = Kern::HalFunction(EHalGroupRam, ERamHalGetZoneCount, (TAny*)&iZoneCount, NULL);

	// Retrieve the page size and use it to detemine the page shift (assumes 32-bit system).

	TInt r = Kern::HalFunction(EHalGroupKernel, EKernelHalPageSizeInBytes, &iPageSize, 0);

	if (r != KErrNone)

		{

		TESTDEBUG(Kern::Printf("ERROR - Unable to determine page size"));

		return r;

		}

	TUint32 pageMask = iPageSize;

	TUint i = 0;

	for (; i < 32; i++)

		{

		if (pageMask & 1)

			{

			if (pageMask & ~1u)

				{

				TESTDEBUG(Kern::Printf("ERROR - page size not a power of 2"));

				return KErrNotSupported;

				}

			iPageShift = i;

			break;

			}

		pageMask >>= 1;

		}

	// Create a semaphore to protect defrag invocation.  OK to just use one name as

	// the semaphore is not global so it's name doesn't need to be unique.

	ret = Kern::SemaphoreCreate(iDefragSemaphore, _L("DefragRefSem"), 1);

	if (ret != KErrNone)

		{

		return ret;

		}

	iDefragCompleteDfc.SetDfcQ(iDfcQ);

	iDefragComplete2Dfc.SetDfcQ(iDfcQ);

	iDefragComplete3Dfc.SetDfcQ(iDfcQ);

	// Create an array to store some RAM zone IDs for use but the multi-zone 

	// specific allcoation methods.

	NKern::ThreadEnterCS();

	iZoneIdArray = new TUint[KMaxRamZones];

	if (iZoneIdArray == NULL)

		{

		ret = KErrNoMemory;

		}

	NKern::ThreadLeaveCS();

	return ret;

	}

DRamDefragFuncTestChannel::DRamDefragFuncTestChannel(TDfcQue* aDfcQ)

	: 

	iContigAddr(KPhysAddrInvalid),

	iContigBytes(0),

	iAddrArray(NULL), 

	iAddrArrayPages(0),

	iAddrArraySize(0),

	iAddrPtrArray(NULL),

	iNumPagesArray(NULL),

	iDebug(0), 

	iThreadCounter(1),

	iChunk(NULL),

	iPageSize(0), 

	iPageShift(0),

	iZoneCount(0),

	iZoneIdArray(NULL),

	iDefragSemaphore(NULL),

	iCompleteReq(NULL),

	iCompleteReq2(NULL),

	iCompleteReq3(NULL),

	iRequestThread(NULL),

	iRequestThread2(NULL),

	iRequestThread3(NULL),

	iDfcQ(aDfcQ),

	iDefragCompleteDfc(DefragCompleteDfc, (TAny*)this, 1),

	iDefragComplete2Dfc(Defrag2CompleteDfc, (TAny*)this, 1), 

	iDefragComplete3Dfc(Defrag3CompleteDfc, (TAny*)this, 1), 

	iCounter(0), 

	iOrder(0)

	{

	}

DRamDefragFuncTestChannel::~DRamDefragFuncTestChannel()

	{

	if (iDefragSemaphore != NULL)

		{

		iDefragSemaphore->Close(NULL);

		}

	if (iZoneIdArray != NULL)

		{

		NKern::ThreadEnterCS();

		delete[] iZoneIdArray;

		NKern::ThreadLeaveCS();

		}

	}

TInt DRamDefragFuncTestChannel::Request(TInt aFunction, TAny* a1, TAny* a2)

	{

	TInt threadCount = __e32_atomic_tas_ord32(&iThreadCounter, 1, 1, 0);

	if (threadCount >= 2)

		{

		Kern::Printf("DRamDefragFuncTestChannel::Request threadCount = %d\n", threadCount);

		}

	Kern::SemaphoreWait(*iDefragSemaphore);

	TInt retVal = KErrNotSupported;

	switch(aFunction)

		{

		case RRamDefragFuncTestLdd::EAllocateFixed:

			retVal = DRamDefragFuncTestChannel::AllocFixedPages((TInt)a1);

			break;

		case RRamDefragFuncTestLdd::EAllocFixedArray:

			retVal = DRamDefragFuncTestChannel::AllocFixedArray((TInt)a1);

			break;

		case RRamDefragFuncTestLdd::EAllocateFixed2:

			retVal = DRamDefragFuncTestChannel::AllocateFixed2((TInt)a1);

			break;

		case RRamDefragFuncTestLdd::EGetAllocDiff:

			retVal = DRamDefragFuncTestChannel::GetAllocDiff((TUint)a1);

			break;

		case RRamDefragFuncTestLdd::EFreeAllFixed:

			retVal = DRamDefragFuncTestChannel::FreeAllFixedPages();

			break;

		case RRamDefragFuncTestLdd::EAllocateFixedWrite:

			retVal = DRamDefragFuncTestChannel::AllocFixedPagesWrite((TInt)a1);

			break;

		case RRamDefragFuncTestLdd::EFreeAllFixedRead:

			retVal = DRamDefragFuncTestChannel::FreeAllFixedPagesRead();

			break;

		case RRamDefragFuncTestLdd::EZoneAllocContiguous:

			retVal = DRamDefragFuncTestChannel::ZoneAllocContiguous((TUint)a1, (TUint)a2);

			break;

		case RRamDefragFuncTestLdd::EMultiZoneAllocContiguous:

			{

			SMultiZoneAlloc multiZone;

			kumemget(&multiZone, a1, sizeof(SMultiZoneAlloc));

			retVal = DRamDefragFuncTestChannel::ZoneAllocContiguous(multiZone.iZoneId, multiZone.iZoneIdSize, (TUint)a2);

			}

			break;

		case RRamDefragFuncTestLdd::EZoneAllocDiscontiguous:

			retVal = DRamDefragFuncTestChannel::ZoneAllocDiscontiguous((TUint)a1, (TUint)a2);	

			break;

		case RRamDefragFuncTestLdd::EMultiZoneAllocDiscontiguous:

			{

			SMultiZoneAlloc multiZone;

			kumemget(&multiZone, a1, sizeof(SMultiZoneAlloc));

			retVal = DRamDefragFuncTestChannel::ZoneAllocDiscontiguous(multiZone.iZoneId, multiZone.iZoneIdSize, (TUint)a2);	

			}

			break;

		case RRamDefragFuncTestLdd::EZoneAllocDiscontiguous2:

			retVal = DRamDefragFuncTestChannel::ZoneAllocDiscontiguous2((TUint)a1, (TUint)a2);	

			break;

		case RRamDefragFuncTestLdd::EZoneAllocToMany:

			retVal = DRamDefragFuncTestChannel::ZoneAllocToMany((TUint)a1, (TInt)a2);	

			break;

		case RRamDefragFuncTestLdd::EZoneAllocToManyArray:

			retVal = DRamDefragFuncTestChannel::ZoneAllocToManyArray((TUint)a1, (TInt)a2);	

			break;

		case RRamDefragFuncTestLdd::EZoneAllocToMany2:

			retVal = DRamDefragFuncTestChannel::ZoneAllocToMany2((TUint)a1, (TInt)a2);	

			break;

		case RRamDefragFuncTestLdd::EAllocContiguous:

			retVal = DRamDefragFuncTestChannel::AllocContiguous((TUint)a1);	

			break;

		case RRamDefragFuncTestLdd::EFreeZone:

			retVal = DRamDefragFuncTestChannel::FreeZone((TInt)a1);

			break;

		case RRamDefragFuncTestLdd::EFreeFromAllZones:

			retVal = DRamDefragFuncTestChannel::FreeFromAllZones();	

			break;

		case RRamDefragFuncTestLdd::EFreeFromAddr:

			retVal = DRamDefragFuncTestChannel::FreeFromAddr((TInt)a1, (TUint32)a2);	

			break;

		case RRamDefragFuncTestLdd::EPageCount:

			retVal = DRamDefragFuncTestChannel::PageCount((TUint)a1, (STestUserSidePageCount*)a2);	

			break;

		case RRamDefragFuncTestLdd::ECheckCancel:

			retVal = DRamDefragFuncTestChannel::CheckCancel((STestParameters*)a1);	

			break;

		case RRamDefragFuncTestLdd::ECallDefrag:

			retVal = DRamDefragFuncTestChannel::CallDefrag((STestParameters*)a1);	

			break;

		case RRamDefragFuncTestLdd::ESetZoneFlag:

			retVal = DRamDefragFuncTestChannel::SetZoneFlag((STestFlagParams*)a1);	

			break;

		case RRamDefragFuncTestLdd::ECheckPriorities:

			retVal = DRamDefragFuncTestChannel::CheckPriorities((STestParameters*)a1);	

			break;

		case RRamDefragFuncTestLdd::EGetDefragOrder:

			retVal = DRamDefragFuncTestChannel::GetDefragOrder();	

			break;

		case RRamDefragFuncTestLdd::EDoSetDebugFlag:

			retVal = DoSetDebugFlag((TInt) a1);

			break;

		case RRamDefragFuncTestLdd::EResetDriver:

			retVal = ResetDriver();

			break;

		default: 

			break;

		}

	Kern::SemaphoreSignal(*iDefragSemaphore);

	__e32_atomic_tas_ord32(&iThreadCounter, 1, -1, 0);

	return retVal;

	}

#define CHECK(c) { if(!(c)) { Kern::Printf("Fail  %d", __LINE__); ; retVal = __LINE__;} }

//

// FreeAllFixedPages

//

// Free ALL of the fixed pages that were allocated

//

TInt DRamDefragFuncTestChannel::FreeAllFixedPages()

	{

	NKern::ThreadEnterCS();

	TInt retVal = KErrNone;

	if (iAddrArray != NULL)

		{

		retVal = Epoc::FreePhysicalRam(iAddrArrayPages, iAddrArray);

		CHECK(retVal == KErrNone);

		delete[] iAddrArray;

		iAddrArray = NULL;

		iAddrArrayPages = 0;

		}

	if (iContigAddr != KPhysAddrInvalid)

		{

		retVal = Epoc::FreePhysicalRam(iContigAddr, iContigBytes);

		iContigAddr = KPhysAddrInvalid;

		iContigBytes = 0;

		CHECK(retVal == KErrNone);

		}

	NKern::ThreadLeaveCS();

	retVal = FreeFromAllZones();

	return retVal;

	}

//

// FreeAllFixedPagesRead()

//

// Read the fixed pages that were mapped to iChunk and verify that 

// the contents have not changed.  Then free the fixed pages 

// that were allocated for iChunk.

//

TInt DRamDefragFuncTestChannel::FreeAllFixedPagesRead()

	{

	TInt retVal = KErrNone;

	TUint index;

	if (iAddrArray == NULL || iChunk == NULL || !iAddrArrayPages)

		{

		return KErrCorrupt;

		}

	TInt r = Kern::ChunkAddress(iChunk, 0, iAddrArrayPages << iPageShift, iKernAddrStart);

	if (r != KErrNone)

		{

		Kern::Printf("ERROR ? FreeAllFixedPages : Couldn't get linear address of iChunk! %d", r);

		}

	else

		{

		for (index = 0; index < iAddrArrayPages; index ++)

			{

			if (iAddrArray[index] != NULL)

				{

				TUint* pInt = (TUint *)(iKernAddrStart + (index << iPageShift));

				TUint* pIntEnd = pInt + (iPageSize / sizeof(TInt));

				// Read each word in this the page and verify that 

				// they are still the index of the current page in the chunk.

				while (pInt < pIntEnd)

					{

					if (*pInt++ != index)

						{

						Kern::Printf("ERROR ? FreeAllFixedPages : page at index %d is corrupt! 0x%08x", index, *pInt);

						}

					}

				}

			}

		}

	NKern::ThreadEnterCS();

	// Must close chunk before we free memory otherwise it would still be 

	// possible to access memory that has been freed and potentially reused.

	Kern::ChunkClose(iChunk);