// 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\examples\defrag\d_defrag_ref.cpp

// Reference LDD for invoking defrag APIs.

// 

//

#include <kernel/kern_priv.h>

#include "platform.h"

#include "nk_priv.h"

#include "d_defrag_ref.h"

const TInt KMajorVersionNumber=0;

const TInt KMinorVersionNumber=1;

const TInt KBuildVersionNumber=1;

#if 1  // Set true for tracing

#define TRACE(x) x

#else

#define TRACE(x)

#endif

const TInt KDefragCompleteThreadPriority = 27;

const TInt KDefragRamThreadPriority = 1;

_LIT(KDefragCompleteThread,"DefragCompleteThread");

class DDefragChannel;

/**

	Clean up item responsible for ensuring all memory commmited to a chunk is

	freed once the chunk is destroyed

*/

class TChunkCleanup : public TDfc

    {

public:

    TChunkCleanup(DDefragChannel* aDevice, TPhysAddr* aBufAddrs, TUint aBufPages);

	TChunkCleanup(DDefragChannel* aDevice, TPhysAddr aBufBase, TUint aBufBytes);

    static void ChunkDestroyed(TChunkCleanup* aSelf);

	void RemoveDevice();

private:

    void DoChunkDestroyed();

private:

	TPhysAddr* iBufAddrs;		/**< Pointer to an array of the addresses of discontiguous buffer pages*/

	TPhysAddr iBufBase;			/**< Physical base address of a physically contiguous the buffer*/

	TUint iBufSize;				/**< The number of pages or bytes in the buffer depending if this is 

								discontiguous or contiguous buffer, repsectively*/

	TBool iBufContiguous;		/**< ETrue when the memory to be freed is contiguous, EFalse otherwise*/

	DDefragChannel* iDevice; 	/**< The device to be informed when the chunk is destroyed */

    };

/**

	Reference defrag LDD factory.

*/

class DDefragChannelFactory : public DLogicalDevice

	{

public:

	DDefragChannelFactory();

	~DDefragChannelFactory();

	virtual TInt Install();								//overriding pure virtual

	virtual void GetCaps(TDes8& aDes) const;			//overriding pure virtual

	virtual TInt Create(DLogicalChannelBase*& aChannel);//overriding pure virtual

	TDynamicDfcQue* iDfcQ;

	};

/**

	Reference defrag logical channel.

*/

class DDefragChannel : public DLogicalChannelBase

	{

public:

	DDefragChannel(TDfcQue* aDfcQ);

	~DDefragChannel();

	void ChunkDestroyed();

protected:

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

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

	TInt DoAllocLowestZone();

	TInt DoClaimLowestZone();

	TInt DoChunkClose();

	TInt FindLowestPrefZone();

	static void DefragCompleteDfc(TAny* aSelf);

	void DefragComplete();

private:

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

	DSemaphore* iDefragSemaphore;/**< Semaphore to ensure only one defrag operation is active per channel*/

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

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

	TRamDefragRequest iDefragReq;/**< The defrag request used to queue defrag operations*/

	DChunk* iBufChunk;			/**< Pointer to a chunk that can be mapped to a physical RAM area*/

	TChunkCleanup* iChunkCleanup;/**< Pointer to iBufChunk's cleanup object */

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

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

	TBool iDefragDfcFree;		/**< Set to fase whenever a dfc defrag operation is still pending*/

	TUint iLowestPrefZoneId;	/**< The ID of the least preferable RAM zone*/

	TUint iLowestPrefZonePages;	/**< The number of pages in the least preferable RAM zone*/

	TUint iLowestPrefZoneIndex; /**< The test HAL function index of the least preferable RAM zone*/

	};

/**

Utility functions to wait for chunk clean dfc to be queued by waiting for the 

idle thread to be queued.

*/

void signal_sem(TAny* aPtr)

	{

	NKern::FSSignal((NFastSemaphore*)aPtr);

	}

TInt WaitForIdle()

	{// Wait for chunk to be destroyed and then for the chunk cleanup dfc to run.

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

		{

		NFastSemaphore s(0);

		TDfc idler(&signal_sem, &s, Kern::SvMsgQue(), 0);	// supervisor thread, priority 0, so will run after destroyed DFC

		NTimer timer(&signal_sem, &s);

		idler.QueueOnIdle();

		timer.OneShot(NKern::TimerTicks(5000), ETrue);	// runs in DFCThread1

		NKern::FSWait(&s);	// wait for either idle DFC or timer

		TBool timeout = idler.Cancel();	// cancel idler, return TRUE if it hadn't run

		TBool tmc = timer.Cancel();	// cancel timer, return TRUE if it hadn't expired

		if (!timeout && !tmc)

			NKern::FSWait(&s);	// both the DFC and the timer went off - wait for the second one

		if (timeout)

			return KErrTimedOut;

		}

	return KErrNone;

	}

/** 

	Standard logical device driver entry point.  

	Called the first time this device driver is loaded.

*/

DECLARE_STANDARD_LDD()

	{

	DDefragChannelFactory* factory = new DDefragChannelFactory;

	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;

    }

/**

	Constructor

*/

DDefragChannelFactory::DDefragChannelFactory()

    {

    iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

    }

/**

	Destructor

*/

DDefragChannelFactory::~DDefragChannelFactory()

    {

	if (iDfcQ != NULL)

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

		iDfcQ->Destroy();

		}

    }

/**

	Create a new DDefragChannel on this logical device.

@param  aChannel On successful return this will point to the new channel.

@return KErrNone on success or KErrNoMemory if the channel couldn't be created.

*/

TInt DDefragChannelFactory::Create(DLogicalChannelBase*& aChannel)

    {

	aChannel = new DDefragChannel(iDfcQ);

	return (aChannel)? KErrNone : KErrNoMemory;

    }

/**

	Install the LDD - overriding pure virtual

@return KErrNone on success or one of the system wide error codes.

*/

TInt DDefragChannelFactory::Install()

    {

    return SetName(&KLddName);

    }

/**

	Get capabilities - overriding pure virtual

@param aDes A descriptor to be loaded with the capabilities.

*/

void DDefragChannelFactory::GetCaps(TDes8& aDes) const

    {

    TCapsDefragTestV01 b;

    b.iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

    Kern::InfoCopy(aDes,(TUint8*)&b,sizeof(b));

    }

/**

	Constructor

@param aDfcQ The DFC queue to use for defrag completion DFCs.

*/

DDefragChannel::DDefragChannel(TDfcQue* aDfcQ) 

		:

		iDefragSemaphore(NULL),

		iCompleteReq(NULL),

		iBufChunk(NULL),

		iChunkCleanup(NULL),

		iDfcQ(aDfcQ),

		iDefragCompleteDfc(DefragCompleteDfc, (TAny*)this, 1)  // DFC is priority '1', it is the only type of dfc on this queue.

    {

    }

/**

	Create channel.

@param aVer The version number required.

@return KErrNone on success, KErrNotSupported if the device doesn't support defragmentation.

*/

TInt DDefragChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)

    {

	// Check the client has ECapabilityPowerMgmt capability.

	if(!Kern::CurrentThreadHasCapability(ECapabilityPowerMgmt, __PLATSEC_DIAGNOSTIC_STRING("Checked by DDefragChannel")))

		{

		return KErrPermissionDenied;

		}

	TInt pageSize;

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

	if (r != KErrNone)

		{

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

		return r;

		}

	TUint32 pageMask = pageSize;

	TUint i = 0;

	for (; i < 32; i++)

		{

		if (pageMask & 1)

			{

			if (pageMask & ~1u)

				{

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

				return KErrNotSupported;

				}

			iPageShift = i;

			break;

			}

		pageMask >>= 1;

		}

	// Check the client is a supported version.

    if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber),aVer))

		{

    	return KErrNotSupported;

		}

	// Check this system has more than one RAM zone defined.

	// A real driver shouldn't need to do this as any driver that uses defrag should 

	// only be loaded on devices that support it.

	TInt ret = FindLowestPrefZone();

	if (ret != KErrNone)

		{// Only one zone so can't move pages anywhere or empty a zone

		return KErrNotSupported;

		}

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

		}

	// Create a client request for completing dfc defrag requests.

	ret = Kern::CreateClientRequest(iCompleteReq);

	if (ret != KErrNone)

		{

		iDefragSemaphore->Close(NULL);

		return ret;

		}

	// Setup a DFC to be invoked when a defrag operation completes.

	iDefragCompleteDfc.SetDfcQ(iDfcQ);

	iDefragDfcFree = ETrue;

	return KErrNone;

	}

/**

	Destructor

*/

DDefragChannel::~DDefragChannel()

    {

	// Clean up any heap objects.

	if (iDefragSemaphore != NULL)

		{

		iDefragSemaphore->Close(NULL);

		}

	// Unregister from any chunk cleanup object as we are to be deleted.

	if (iChunkCleanup != NULL)

		{

		iChunkCleanup->RemoveDevice();

		}

	// Clean up any client request object.

	if (iCompleteReq)

		{

		Kern::DestroyClientRequest(iCompleteReq);

		}

	// Free any existing chunk.

	DoChunkClose();

    }

/**

	Handle the requests for this channel.

@param aFunction 	The operation the LDD should perform.

@param a1 			The first argument for the operation.

@param a2 			The second argument for the operation.

@return KErrNone on success or one of the system wide error codes.

*/

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

	{

	TInt r = KErrNone;

	NKern::ThreadEnterCS();

	Kern::SemaphoreWait(*iDefragSemaphore);

	if (!iDefragDfcFree && aFunction != RDefragChannel::EControlGeneralDefragDfcComplete)

		{// Only allow a single defrag operation at a time.

		r = KErrInUse;

		goto exit;

		}

	switch (aFunction)

		{

		case RDefragChannel::EControlGeneralDefragDfc:

			// Queue a defrag operation so that on completion it queues a

			// DFC on this driver.

			iRequestThread = &Kern::CurrentThread();

			iRequestThread->Open();

			// Open a reference on this channel to stop the destructor running before

			// the defrag request has completed.

			Open();

			r = iCompleteReq->SetStatus((TRequestStatus*)a1);

			if (r == KErrNone)

				r = iDefragReq.DefragRam(&iDefragCompleteDfc, KDefragRamThreadPriority);

			if (r != KErrNone)

				{// defrag operation didn't start so close all openned handles

				AsyncClose();

				iRequestThread->AsyncClose();

				iRequestThread = NULL;

				}

			else

				iDefragDfcFree = EFalse;

			break;

		case RDefragChannel::EControlGeneralDefragDfcComplete:

			if (iRequestThread != NULL)

				{// The defrag dfc hasn't completed so this shouldn't have been invoked.

				r = KErrGeneral;

				}

			else

				{

				iDefragDfcFree = ETrue;

				}

			break;

		case RDefragChannel::EControlGeneralDefragSem:

			{// Queue a defrag operation so that it will signal a fast mutex once

			// it has completed.

			NFastSemaphore sem;

			NKern::FSSetOwner(&sem, 0);

			r = iDefragReq.DefragRam(&sem, KDefragRamThreadPriority);

			if (r != KErrNone)

				{// Error occurred attempting to queue the defrag operation.

				break;

				}

			// Defrag operation has now been queued so wait for it to finish.

			// Could do some extra kernel side work here before waiting on the 

			// semaphore.

			NKern::FSWait(&sem);

			r = iDefragReq.Result();

			}

			break;

		case RDefragChannel::EControlGeneralDefrag:

			// Synchronously perform a defrag.

			{

			r = iDefragReq.DefragRam(KDefragRamThreadPriority);

			}

			break;

		case RDefragChannel::EControlAllocLowestZone:

			// Allocate from the lowest preference zone

			r = DoAllocLowestZone();

			break;

		case RDefragChannel::EControlClaimLowestZone:

			// Claims the lowest preference zone

			r = DoClaimLowestZone();

			break;

		case RDefragChannel::EControlCloseChunk:

			// Have finished with the chunk so close it then free the RAM mapped by it

			r = DoChunkClose();

			TRACE( if (r != KErrNone) {Kern::Printf("ChunkClose returns %d", r);});

			break;

		default:

			r=KErrNotSupported;

			break;

		}

exit:

	Kern::SemaphoreSignal(*iDefragSemaphore);

	NKern::ThreadLeaveCS();

	TRACE(if (r!=KErrNone)	{Kern::Printf("DDefragChannel::Request returns %d", r);	});

	return r;

	}

/**

	Allocates RAM from the lowest preference zone and maps it to a shared chunk.

	Real drivers would not need to determine which zone to allocate from as they

	will know the zone's ID.

@return KErrNone on success, otherwise one of the system wide error codes.

*/

TInt DDefragChannel::DoAllocLowestZone()

	{

	TInt r = KErrNone;

	TLinAddr chunkAddr = NULL;

	TUint32 mapAttr = NULL;

	TChunkCreateInfo createInfo;

	TLinAddr bufBaseAddr;

	TUint bufPages;

	TPhysAddr* bufAddrs;

	if (iBufChunk != NULL)

		{// The buffer chunk is already mapped so can't use again until it is 

		// freed/closed. Wait a short while for it to be freed as it may be in the 

		// process of being destroyed.

		if (WaitForIdle() != KErrNone || iBufChunk != NULL)

			{// chunk still hasn't been freed so can't proceed.

			r = KErrInUse;

			goto exit;

			}

		}

	// Attempt to allocate all the pages it should be possible to allocate.

	// Real device drivers will now how much they need to allocate so they

	// wouldn't determine it here.

	SRamZoneUtilisation zoneUtil;

	Kern::HalFunction(EHalGroupRam, ERamHalGetZoneUtilisation, (TAny*)iLowestPrefZoneIndex, (TAny*)&zoneUtil);

	bufPages = iLowestPrefZonePages - (zoneUtil.iAllocFixed + zoneUtil.iAllocUnknown + zoneUtil.iAllocOther);

	bufAddrs = new TPhysAddr[bufPages];

	if (!bufAddrs)

		{

		TRACE(Kern::Printf("Failed to allocate an array for bufAddrs"));

		r = KErrNoMemory;

		goto exit;

		}

	// Update the page count as bufAddrs allocation may have caused the kernel 

	// heap to grow.

	Kern::HalFunction(EHalGroupRam, ERamHalGetZoneUtilisation, (TAny*)iLowestPrefZoneIndex, (TAny*)&zoneUtil);

	bufPages = iLowestPrefZonePages - (zoneUtil.iAllocFixed + zoneUtil.iAllocUnknown + zoneUtil.iAllocOther);

	// Allocate discontiguous pages from the zone

	r = Epoc::ZoneAllocPhysicalRam(iLowestPrefZoneId, bufPages, bufAddrs);

	if (r != KErrNone && r != KErrNoMemory)

		{

		TRACE(Kern::Printf("Zone Alloc returns %d bufPages %x", r, bufPages));

		goto exit;

		}

	// If we couldn't allocate all the required pages then empty the zone

	// and retry.

	if (r == KErrNoMemory)

		{

		r = iDefragReq.EmptyRamZone(iLowestPrefZoneId, TRamDefragRequest::KInheritPriority);

		if (r != KErrNone)

			{

			TRACE(Kern::Printf("Empty returns %d", r));

			goto exit;

			}

		r = Epoc::ZoneAllocPhysicalRam(iLowestPrefZoneId, bufPages, bufAddrs);

		if (r != KErrNone)

			{

			TRACE(Kern::Printf("ZoneAlloc1 returns %d bufPages %x", r, bufPages));

			goto exit;

			}

		}