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

			}

		}

	// Create a chunk cleanup object which will free the physical RAM when the 

	// chunk is detroyed

	iChunkCleanup = new TChunkCleanup(this, bufAddrs, bufPages);

	if (!iChunkCleanup)

		{

		TRACE(Kern::Printf("iChunkCleanup creation failed"));

		r = Epoc::FreePhysicalRam(bufPages, bufAddrs);

		if (r != KErrNone)

			{

			TRACE(Kern::Printf("ERROR - freeing physical memory when chunkCleanup create failed"));

			}

		else

			{

			r = KErrNoMemory;

			}

		goto exit;

		}

	// Map the allocated buffer pages to a chunk so we can use it.	

	createInfo.iType = TChunkCreateInfo::ESharedKernelSingle; // could also be ESharedKernelMultiple

	createInfo.iMaxSize = bufPages << iPageShift;

	createInfo.iMapAttr = EMapAttrFullyBlocking; // Non-cached - See TMappingAttributes for all options

	createInfo.iOwnsMemory = EFalse; // Must be false as the physical RAM has already been allocated

	createInfo.iDestroyedDfc = iChunkCleanup;

	r = Kern::ChunkCreate(createInfo, iBufChunk, chunkAddr, mapAttr);

	if (r != KErrNone)

		{

		TRACE(Kern::Printf("ChunkCreate returns %d size %x pages %x", r, createInfo.iMaxSize, bufPages));

		goto exit;

		}

	// Map the physical memory to the chunk

	r = Kern::ChunkCommitPhysical(iBufChunk, 0, createInfo.iMaxSize, bufAddrs);

	if (r != KErrNone)

		{

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

		goto exit;

		}

	// Now that the RAM is mapped into a chunk get the kernel-side virtual 

	// base address of the buffer.

	r = Kern::ChunkAddress(iBufChunk, 0, createInfo.iMaxSize, bufBaseAddr);

	// Using bufBaseAddr a real driver may now do something with the buffer.  We'll just return.

exit:

	return r;

	}

/**

	Claims 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::DoClaimLowestZone()

	{

	TInt r = KErrNone;

	TChunkCreateInfo createInfo;

	TLinAddr bufBaseAddr;

	TLinAddr chunkAddr;

	TUint32 mapAttr = NULL;

	TPhysAddr bufBase;

	TUint bufBytes;

	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;

			}

		}

	// Claim the zone the base address of which will be stored in iBufBase.

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

	if (r != KErrNone)

		{

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

		goto exit;

		}

	// Create a chunk cleanup object which will free the physical RAM when the 

	// chunk is detroyed

	bufBytes = iLowestPrefZonePages << iPageShift;

	iChunkCleanup = new TChunkCleanup(this, bufBase, bufBytes);

	if (!iChunkCleanup)

		{

		TRACE(Kern::Printf("chunkCleanup creation failed"));

		r = Epoc::FreePhysicalRam(bufBytes, bufBase);

		if (r != KErrNone)

			{

			TRACE(Kern::Printf("ERROR - freeing physical memory when chunkCleanup create failed"));

			}

		else

			{

			r = KErrNoMemory;

			}

		goto exit;

		}

	// Map the allocated buffer pages to a chunk so we can use it.	

	createInfo.iType = TChunkCreateInfo::ESharedKernelSingle; // could also be ESharedKernelMultiple

	createInfo.iMaxSize = bufBytes;

	createInfo.iMapAttr = EMapAttrFullyBlocking; // Non-cached - See TMappingAttributes for all options

	createInfo.iOwnsMemory = EFalse; // Must be false as the physical RAM has already been allocated

	createInfo.iDestroyedDfc = iChunkCleanup;

	r = Kern::ChunkCreate(createInfo, iBufChunk, chunkAddr, mapAttr);

	if (r != KErrNone)

		{

		TRACE(Kern::Printf("ChunkCreate returns %d size %x bytes %x", r, createInfo.iMaxSize, bufBytes));

		goto exit;

		}

	// Map the physically contiguous memory to the chunk

	r = Kern::ChunkCommitPhysical(iBufChunk, 0, createInfo.iMaxSize, bufBase);

	if (r != KErrNone)

		{

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

		goto exit;

		}

	// Now that the RAM is mapped into a chunk get the kernel-side virtual 

	// base address of the buffer.

	r = Kern::ChunkAddress(iBufChunk, 0, createInfo.iMaxSize, bufBaseAddr);

	// Using bufBaseAddr a real driver may now do something with the buffer.  We'll just return.

exit:

	return r;

	}

/**

	Determine the lowest preference zone.

@return KErrNone on success or KErrNotFound if there is only one zone.

*/

TInt DDefragChannel::FindLowestPrefZone()

	{

	TUint zoneCount;

	TInt r = Kern::HalFunction(EHalGroupRam, ERamHalGetZoneCount, (TAny*)&zoneCount, NULL);

	if(r!=KErrNone)

		return r;

	if (zoneCount == 1)

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

		return KErrNotFound;

		}

	SRamZoneConfig zoneConfig;

	SRamZoneUtilisation zoneUtil;

	Kern::HalFunction(EHalGroupRam, ERamHalGetZoneConfig, (TAny*)0, (TAny*)&zoneConfig);

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

	TUint lowestPref = zoneConfig.iPref;

	TUint lowestFreePages = zoneUtil.iFreePages;

	iLowestPrefZoneIndex = 0;

	iLowestPrefZoneId = zoneConfig.iZoneId;

	TUint i = 1;

	for (; i < zoneCount; i++)

		{

		Kern::HalFunction(EHalGroupRam, ERamHalGetZoneConfig, (TAny*)i, (TAny*)&zoneConfig);

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

		// When zones have the same preference the zone higher in the zone list is picked.

		if (zoneConfig.iPref > lowestPref || 

			(zoneConfig.iPref == lowestPref && zoneUtil.iFreePages >= lowestFreePages))

			{

			lowestPref = zoneConfig.iPref;

			lowestFreePages = zoneUtil.iFreePages;

			iLowestPrefZoneIndex = i;

			iLowestPrefZoneId = zoneConfig.iZoneId;

			}

		}

	// Now that we know the current least preferable zone store its size.

	Kern::HalFunction(EHalGroupRam, ERamHalGetZoneConfig, (TAny*)iLowestPrefZoneIndex, (TAny*)&zoneConfig);

	iLowestPrefZonePages = zoneConfig.iPhysPages;

	TRACE(Kern::Printf("LowestPrefZone %x size %x", iLowestPrefZoneId, iLowestPrefZonePages));

	return KErrNone;

	}

/**

	DFC callback called when a defrag operation has completed.

@param aSelf A pointer to the DDefragChannel that requested the defrag operation

*/

void DDefragChannel::DefragCompleteDfc(TAny* aSelf)

	{

	// Just call non-static method

	((DDefragChannel*)aSelf)->DefragComplete();

	}

/**

	Invoked by the DFC callback which is called when a defrag 

	operation has completed.

*/

void DDefragChannel::DefragComplete()

	{

	TRACE(Kern::Printf(">DDefragChannel::DefragComplete"));

	TInt result = iDefragReq.Result();

	TRACE(Kern::Printf("complete code %d", result));

	Kern::SemaphoreWait(*iDefragSemaphore);

	Kern::QueueRequestComplete(iRequestThread, iCompleteReq, result);

	iRequestThread->AsyncClose();

	iRequestThread = NULL;

	Kern::SemaphoreSignal(*iDefragSemaphore);

	TRACE(Kern::Printf("<DDefragChannel::DefragComplete"));

	// Close the handle on this channel - WARNING this channel may be 

	// deleted immmediately after this call so don't access any members

	AsyncClose();

	}

/**

	Close the chunk.

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

*/

TInt DDefragChannel::DoChunkClose()

	{

	if (iBufChunk == NULL)

		{// Someone tried to close the chunk before using it

		return KErrNotFound;

		}

	// Rely on the chunk cleanup object being called as that

	// is what will actually free the physical RAM commited to the chunk.

	Kern::ChunkClose(iBufChunk);

	return KErrNone;

	}

/**

	The chunk has now been destroyed so reset the pointers to allow a new

	chunk to be created.

*/

void DDefragChannel::ChunkDestroyed()

	{

	__e32_atomic_store_ord_ptr(&iBufChunk, 0);

	__e32_atomic_store_ord_ptr(&iChunkCleanup, 0);

	}

/**

	Contruct a Shared Chunk cleanup object which will free the chunk's discontiguous

	physical memory when a chunk is destroyed.

@param aDevice The device to inform when the chunk is destroyed.

@param aBufBase The physical base addresses of each of the chunk's memory pages.

@param aBufPages The total number of the chunk's pages.

*/

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

    : TDfc((TDfcFn)TChunkCleanup::ChunkDestroyed,this,Kern::SvMsgQue(),0),

    iBufAddrs(aBufAddrs),

	iBufSize(aBufPages),

	iBufContiguous(EFalse),

	iDevice(aDevice)

    {}

/**

	Contruct a Shared Chunk cleanup object which will free the chunk's contiguous 

	physical memory when a chunk is destroyed.

@param aDevice The device to inform when the chunk is destroyed.

@param aBufBase The physical base address of the chunk's memory.

@param aBufBytes The total number of the chunk's bytes.

*/

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

    : TDfc((TDfcFn)TChunkCleanup::ChunkDestroyed,this,Kern::SvMsgQue(),0),

    iBufBase(aBufBase),

	iBufSize(aBufBytes),

	iBufContiguous(ETrue),

	iDevice(aDevice)

    {}

/**

	Callback function which is called the DFC runs, i.e. when a chunk is destroyed 

	and frees the physical memory allocated when the chunk was created.

@param aSelf Pointer to the cleanup object associated with the chunk that has 

been destroyed.

*/

void TChunkCleanup::ChunkDestroyed(TChunkCleanup* aSelf)

	{

	aSelf->DoChunkDestroyed();

    // We've finished so now delete ourself

    delete aSelf;

	}

/**

	The chunk has been destroyed so free the physical RAM that was allocated

	for its use and inform iDevice that it has been destroyed.

*/

void TChunkCleanup::DoChunkDestroyed()

    {

	if (iBufContiguous)

		{

		__NK_ASSERT_ALWAYS(Epoc::FreePhysicalRam(iBufBase, iBufSize) == KErrNone);

		}

	else

		{

		__NK_ASSERT_ALWAYS(Epoc::FreePhysicalRam(iBufSize, iBufAddrs) == KErrNone);

		}

	if (iDevice != NULL)

		{// Allow iDevice to perform any cleanup it requires for this chunk.

		iDevice->ChunkDestroyed();

		}

    }

/**

	Remove the device so its ChunkDestroyed() method isn't invoked  when the chunk is 

	destroyed.

*/

void TChunkCleanup::RemoveDevice()

	{

	__e32_atomic_store_ord_ptr(&iDevice, 0);

	}