// Copyright (c) 2008-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:

//

#include <plat_priv.h>

#include "mm.h"

#include "mmu.h"

#include "mmanager.h"

#include "mobject.h"

#include "mmapping.h"

#include "mpager.h"

#include "mswap.h"

/**

Manages the swap via the data paging device.

*/

class DSwapManager

	{

public:

	enum TSwapFlags

		{

		EAllocated		= 1 << 0,

		EUninitialised	= 1 << 1,

		ESaved			= 1 << 2,

		ESwapFlagsMask 	= 0x7,

		ESwapIndexShift = 3,

		ESwapIndexMask = 0xffffffff << ESwapIndexShift,

		};

	TInt Create(DPagingDevice* aDevice);

	TInt ReserveSwap(DMemoryObject* aMemory, TUint aStartIndex, TUint aPageCount);

	TInt UnreserveSwap(DMemoryObject* aMemory, TUint aStartIndex, TUint aPageCount);

	TBool IsReserved(DMemoryObject* aMemory, TUint aStartIndex, TUint aPageCount);

	TInt ReadSwapPages(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TLinAddr aLinAddr, DPageReadRequest* aRequest, TPhysAddr* aPhysAddrs);

	TInt WriteSwapPages(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TLinAddr aLinAddr, DPageWriteRequest* aRequest);

	void DoDeleteNotify(TUint aSwapData);

	void GetSwapInfo(SVMSwapInfo& aInfoOut);

	TInt SetSwapThresholds(const SVMSwapThresholds& aThresholds);

	void CheckSwapThresholds(TUint aInitial, TUint aFinal);

protected:

	DPagingDevice* iDevice;

	TBitMapAllocator* iBitMap;

	TUint iBitMapFree;

	TUint iAllocOffset;

 	TUint iSwapThesholdLow;

 	TUint iSwapThesholdGood;

	TThreadMessage iDelNotifyMsg;

	};

/**

Manager for demand paged memory objects which contain writeable data.

The contents of the memory are written to a backing store whenever its

pages are 'paged out'.

@see DSwapManager

*/

class DDataPagedMemoryManager : public DPagedMemoryManager

	{

private:

	// from DMemoryManager...

	virtual TInt Alloc(DMemoryObject* aMemory, TUint aIndex, TUint aCount);

	virtual void Free(DMemoryObject* aMemory, TUint aIndex, TUint aCount);

	virtual TInt Wipe(DMemoryObject* aMemory);

	virtual TInt CleanPage(DMemoryObject* aMemory, SPageInfo* aPageInfo, TPhysAddr*& aPageArrayEntry);

	// Methods inherited from DPagedMemoryManager

	virtual void Init3();

	virtual TInt InstallPagingDevice(DPagingDevice* aDevice);

	virtual TInt AcquirePageReadRequest(DPageReadRequest*& aRequest, DMemoryObject* aMemory, TUint aIndex, TUint aCount);

	virtual TInt AcquirePageWriteRequest(DPageWriteRequest*& aRequest, DMemoryObject* aMemory, TUint aIndex, TUint aCount);

	virtual TInt ReadPages(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TPhysAddr* aPages, DPageReadRequest* aRequest);

	virtual TInt WritePages(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TPhysAddr* aPages, DPageWriteRequest* aRequest);

	virtual TBool IsAllocated(DMemoryObject* aMemory, TUint aIndex, TUint aCount);

public:

	void GetSwapInfo(SVMSwapInfo& aInfoOut);

	TInt SetSwapThresholds(const SVMSwapThresholds& aThresholds);

private:

	/**

	The paging device used for accessing the backing store.

	This is set by #InstallPagingDevice.

	*/

	DPagingDevice* iDevice;

	/**

	The instance of #DSwapManager being used by this manager.

	*/

	DSwapManager* iSwapManager;

public:

	/**

	The single instance of this manager class.

	*/

	static DDataPagedMemoryManager TheManager;

	};

DDataPagedMemoryManager DDataPagedMemoryManager::TheManager;

DPagedMemoryManager* TheDataPagedMemoryManager = &DDataPagedMemoryManager::TheManager;

/**

Create a swap manager.

@param	aDevice	The demand paging device for access to the swap.

*/

TInt DSwapManager::Create(DPagingDevice* aDevice)

	{

	__ASSERT_COMPILE(!(ESwapIndexMask & ESwapFlagsMask));

	__NK_ASSERT_DEBUG(iDevice == NULL);

	iDevice = aDevice;

	// Create the structures required to track the swap usage.

	TUint swapPages = (iDevice->iSwapSize << iDevice->iReadUnitShift) >> KPageShift;

	// Can't have more swap pages than we can map.

	__NK_ASSERT_DEBUG(swapPages<=DMemoryObject::KMaxPagingManagerData);

	__NK_ASSERT_DEBUG(swapPages<=(KMaxTUint>>ESwapIndexShift));

	if ((TheMmu.TotalPhysicalRamPages() << 2) < swapPages)

		{// The swap is limited to a maximum of 4 times the amount of RAM.

		return KErrTooBig;

		}

	iBitMap = TBitMapAllocator::New(swapPages, ETrue);

	if (iBitMap == NULL)

		{// Not enough RAM to keep track of the swap.

		return KErrNoMemory;

		}

	iBitMapFree = swapPages;

	iAllocOffset = 0;

	return KErrNone;

	}

/**

Reserve some swap pages for the requested region of the memory object

@param aMemory		The memory object to reserve pages for.

@param aStartIndex	The page index in the memory object of the start of the region.

@param aPageCount	The number of pages to reserve.

@return KErrNone on success, KErrNoMemory if not enough swap space available.

@pre aMemory's lock is held.

@post aMemory's lock is held.

*/

TInt DSwapManager::ReserveSwap(DMemoryObject* aMemory, TUint aStartIndex, TUint aPageCount)

	{

	__NK_ASSERT_DEBUG(MemoryObjectLock::IsHeld(aMemory));

	__NK_ASSERT_DEBUG(RamAllocLock::IsHeld());

	const TUint indexEnd = aStartIndex + aPageCount;

	TUint index = aStartIndex;

#ifdef _DEBUG

	for (; index < indexEnd; index++)

		{// This page shouldn't already be in use.

		MmuLock::Lock();

		__NK_ASSERT_DEBUG(!(aMemory->PagingManagerData(index) & ESwapFlagsMask));

		MmuLock::Unlock();

		}

#endif

	if (iBitMapFree < aPageCount)

		{

		Kern::AsyncNotifyChanges(EChangesOutOfMemory);

		return KErrNoMemory;

		}

	// Reserve the required swap space and mark each page as allocated and uninitialised.

	TUint initFree = iBitMapFree;

	iBitMapFree -= aPageCount;

	for (index = aStartIndex; index < indexEnd; index++)

		{		

		// Grab MmuLock to stop manager data being accessed.

		MmuLock::Lock();

		TUint swapData = aMemory->PagingManagerData(index);

		__NK_ASSERT_DEBUG(!(swapData & EAllocated));

		swapData = EAllocated | EUninitialised;

		aMemory->SetPagingManagerData(index, swapData);

		MmuLock::Unlock();

		}

	CheckSwapThresholds(initFree, iBitMapFree);		

	return KErrNone;

	}

/**

Unreserve swap pages for the requested region of the memory object.

@param aMemory		The memory object to unreserve pages for.

@param aStartIndex	The page index in the memory object of the start of the region.

@param aPageCount	The number of pages to unreserve.

@return The number of pages freed.

@pre aMemory's lock is held.

@post aMemory's lock is held.

*/

TInt DSwapManager::UnreserveSwap(DMemoryObject* aMemory, TUint aStartIndex, TUint aPageCount)

	{

	__NK_ASSERT_DEBUG(MemoryObjectLock::IsHeld(aMemory));

	__NK_ASSERT_DEBUG(RamAllocLock::IsHeld());

	TUint initFree = iBitMapFree;

	TUint freedPages = 0;

	const TUint indexEnd = aStartIndex + aPageCount;

	for (TUint index = aStartIndex; index < indexEnd; index++)

		{

		// Grab MmuLock to stop manager data being accessed.

		MmuLock::Lock();

		TUint swapData = aMemory->PagingManagerData(index);

		TUint swapIndex = swapData >> ESwapIndexShift;

		TBool notifyDelete = EFalse;

		if (swapData & EAllocated)

			{

			if (swapData & ESaved)

				{

				notifyDelete = ETrue;

				iBitMap->Free(swapIndex);

				}

			freedPages++;

			aMemory->SetPagingManagerData(index, 0);

			}

#ifdef _DEBUG

		else

			__NK_ASSERT_DEBUG(swapData == 0);

#endif

		MmuLock::Unlock();

		if (notifyDelete)

			DoDeleteNotify(swapIndex);

		}

	iBitMapFree += freedPages;

	CheckSwapThresholds(initFree, iBitMapFree);	

	return freedPages;

	}

/**

Determine whether the specified pages in the memory object have swap reserved for them.

@param aMemory		The memory object that owns the pages.

@param aStartIndex	The first index of the pages to check.

@param aPageCount	The number of pages to check.

@return ETrue if swap is reserved for all the pages, EFalse otherwise.

*/

TBool DSwapManager::IsReserved(DMemoryObject* aMemory, TUint aStartIndex, TUint aPageCount)

	{// MmuLock required to protect manager data.

	__NK_ASSERT_DEBUG(MmuLock::IsHeld());

	__NK_ASSERT_DEBUG(aStartIndex < aMemory->iSizeInPages);

	__NK_ASSERT_DEBUG(aStartIndex + aPageCount <= aMemory->iSizeInPages);

	const TUint indexEnd = aStartIndex + aPageCount;

	for (TUint index = aStartIndex; index < indexEnd; index++)

		{

		if (!(aMemory->PagingManagerData(index) & DSwapManager::EAllocated))

			{// This page is not allocated by swap manager.

			return EFalse;

			}

		}

	return ETrue;

	}

/**

Read from the swap the specified pages associated with the memory object.

@param aMemory 	The memory object to read the pages for

@param aIndex	The index of the first page within the memory object.

@param aCount	The number of pages to read.

@param aLinAddr	The address to copy the pages to.

@param aRequest	The request to use for the read.

@param aPhysAddrs	An array of the physical addresses for each page to read in.

*/

TInt DSwapManager::ReadSwapPages(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TLinAddr aLinAddr, DPageReadRequest* aRequest, TPhysAddr* aPhysAddrs)

	{

	TInt r = KErrNone;

	const TUint readUnitShift = iDevice->iReadUnitShift;

	TUint readSize = KPageSize >> readUnitShift;

	TThreadMessage* msg = const_cast<TThreadMessage*>(&aRequest->iMessage);

	// Determine the wipe byte values for uninitialised pages.

	TUint allocFlags = aMemory->RamAllocFlags();

	TBool wipePages = !(allocFlags & Mmu::EAllocNoWipe);

	TUint8 wipeByte = (allocFlags & Mmu::EAllocUseCustomWipeByte) ? (allocFlags >> Mmu::EAllocWipeByteShift) & 0xff : 0x03;

	const TUint indexEnd = aIndex + aCount;

	for (TUint index = aIndex; index < indexEnd; index++, aLinAddr += KPageSize, aPhysAddrs++)

		{

		START_PAGING_BENCHMARK;

		MmuLock::Lock();	// MmuLock required for atomic access to manager data.

		TUint swapData = aMemory->PagingManagerData(index);

		if (!(swapData & EAllocated))

			{// This page is not committed to the memory object

			MmuLock::Unlock();

			return KErrNotFound;			

			}

		if (swapData & EUninitialised)

			{// This page has not been written to yet so don't read from swap 

			// just wipe it if required.

			MmuLock::Unlock();

			if (wipePages)

				{

				memset((TAny*)aLinAddr, wipeByte, KPageSize);

				}

			}

		else

			{

			__NK_ASSERT_DEBUG(swapData & ESaved);

			TUint swapIndex = swapData >> ESwapIndexShift;

			// OK to release as if the object's data is decommitted the pager 

			// will check that data is still valid before mapping it.

			MmuLock::Unlock();

			TUint readStart = (swapIndex << KPageShift) >> readUnitShift;

			START_PAGING_BENCHMARK;

			r = iDevice->Read(msg, aLinAddr, readStart, readSize, DPagingDevice::EDriveDataPaging);

			if (r != KErrNone)

				__KTRACE_OPT(KPANIC, Kern::Printf("DSwapManager::ReadSwapPages: error reading media at %08x + %x: %d", readStart << readUnitShift, readSize << readUnitShift, r));				

			__NK_ASSERT_DEBUG(r!=KErrNoMemory); // not allowed to allocate memory, therefore can't fail with KErrNoMemory

			END_PAGING_BENCHMARK(EPagingBmReadDataMedia);

			// TODO: Work out what to do if page in fails, unmap all pages????

			__NK_ASSERT_ALWAYS(r == KErrNone);

			}

		END_PAGING_BENCHMARK(EPagingBmReadDataPage);

		}

	return r;

	}

/**

Write the specified memory object's pages from the RAM into the swap.

@param	aMemory		The memory object who owns the pages.

@param	aIndex		The index within the memory object.

@param 	aCount		The number of pages to write out.

@param	aLinAddr	The location of the pages to write out.

@param	aRequest	The demand paging request to use.

*/

TInt DSwapManager::WriteSwapPages(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TLinAddr aLinAddr, DPageWriteRequest* aRequest)

	{// The RamAllocLock prevents the object's swap pages being reassigned.

	__NK_ASSERT_DEBUG(RamAllocLock::IsHeld());

	// Write the page out to the swap.

	TInt r = KErrNone;

	const TUint readUnitShift = iDevice->iReadUnitShift;

	TUint writeSize = KPageSize >> readUnitShift;

	TThreadMessage* msg = const_cast<TThreadMessage*>(&aRequest->iMessage);

	const TUint indexEnd = aIndex + aCount;

	for (TUint index = aIndex; index < indexEnd; index++)

		{

		START_PAGING_BENCHMARK;

		MmuLock::Lock();

		TUint swapData = aMemory->PagingManagerData(index);

		// OK to release as ram alloc lock prevents manager data being updated.

		MmuLock::Unlock();

		if (!(swapData & EAllocated))

			{// This page is being decommited from aMemory so it is clean/unrequired.

			continue;

			}

		TInt swapIndex = swapData >> ESwapIndexShift;

		if (swapData & ESaved)

			{// An old version of this page has been saved to swap so free it now

			// as it will be out of date.

			iBitMap->Free(swapIndex);

			DoDeleteNotify(swapIndex);

			}

		// Get a new swap location for this page.

		swapIndex = iBitMap->AllocFrom(iAllocOffset);

		__NK_ASSERT_DEBUG(swapIndex != -1 && swapIndex < iBitMap->iSize);

		iAllocOffset = swapIndex + 1;

		if (iAllocOffset == (TUint)iBitMap->iSize)

			iAllocOffset = 0;

		TUint writeOffset = (swapIndex << KPageShift) >> readUnitShift;

		{

		START_PAGING_BENCHMARK;

		r = iDevice->Write(msg, aLinAddr, writeOffset, writeSize, EFalse);

		if (r != KErrNone)

			__KTRACE_OPT(KPANIC, Kern::Printf("DSwapManager::WriteSwapPages: error writing media at %08x + %x: %d", writeOffset << readUnitShift, writeSize << readUnitShift, r));				

		__NK_ASSERT_DEBUG(r!=KErrNoMemory); // not allowed to allocate memory, therefore can't fail with KErrNoMemory

		END_PAGING_BENCHMARK(EPagingBmWriteDataMedia);

		}

		// TODO: Work out what to do if page out fails.

		__NK_ASSERT_ALWAYS(r == KErrNone);

		MmuLock::Lock();

		// The swap data should not have been modified.

		__NK_ASSERT_DEBUG(swapData == aMemory->PagingManagerData(index));

		// Store the new swap location and mark the page as saved.

		swapData &= ~(EUninitialised | ESwapIndexMask);

		swapData |= (swapIndex << ESwapIndexShift) | ESaved;

		aMemory->SetPagingManagerData(index, swapData);

		MmuLock::Unlock();

		END_PAGING_BENCHMARK(EPagingBmWriteDataPage);

		}

	return r;

	}

/**

Notify the media driver that the page written to swap is no longer required.

*/

void DSwapManager::DoDeleteNotify(TUint aSwapIndex)

	{

	// Ram Alloc lock prevents the swap location being assigned to another page.

	__NK_ASSERT_DEBUG(RamAllocLock::IsHeld());

#ifdef __PAGING_DELETE_NOTIFY_ENABLED

	const TUint readUnitShift = iDevice->iReadUnitShift;

	const TUint size = KPageSize >> readUnitShift;

	TUint offset = (aSwapIndex << KPageShift) >> readUnitShift;

	START_PAGING_BENCHMARK;

	// Ignore the return value as this is just an optimisation that is not supported on all media.

	(void)iDevice->DeleteNotify(&iDelNotifyMsg, offset, size);

	END_PAGING_BENCHMARK(EPagingBmDeleteNotifyDataPage);

#endif

	}

// Check swap thresholds and notify (see K::CheckFreeMemoryLevel)

void DSwapManager::CheckSwapThresholds(TUint aInitial, TUint aFinal)

	{

	TUint changes = 0;

	if (aFinal < iSwapThesholdLow && aInitial >= iSwapThesholdLow)

		changes |= (EChangesFreeMemory | EChangesLowMemory);

	if (aFinal >= iSwapThesholdGood && aInitial < iSwapThesholdGood)

		changes |= EChangesFreeMemory;

	if (changes)

		Kern::AsyncNotifyChanges(changes);

	}

void DSwapManager::GetSwapInfo(SVMSwapInfo& aInfoOut)

	{

	__NK_ASSERT_DEBUG(RamAllocLock::IsHeld());

	aInfoOut.iSwapSize = iBitMap->iSize << KPageShift;

	aInfoOut.iSwapFree = iBitMapFree << KPageShift;

	}

TInt DSwapManager::SetSwapThresholds(const SVMSwapThresholds& aThresholds)

	{

	__NK_ASSERT_DEBUG(RamAllocLock::IsHeld());

	if (aThresholds.iLowThreshold > aThresholds.iGoodThreshold)

		return KErrArgument;		

	TInt low = (aThresholds.iLowThreshold + KPageSize - 1) >> KPageShift;

	TInt good = (aThresholds.iGoodThreshold + KPageSize - 1) >> KPageShift;

	if (good > iBitMap->iSize)

		return KErrArgument;

	iSwapThesholdLow = low;

	iSwapThesholdGood = good;

	return KErrNone;

	}

TInt DDataPagedMemoryManager::InstallPagingDevice(DPagingDevice* aDevice)

	{

	TRACEB(("DDataPagedMemoryManager::InstallPagingDevice(0x%08x)",aDevice));

	TUint dataPolicy = TheSuperPage().KernelConfigFlags() & EKernelConfigDataPagingPolicyMask;

	TRACEB(("Data Paging Policy = %d", dataPolicy >> EKernelConfigDataPagingPolicyShift));

	if (dataPolicy == EKernelConfigDataPagingPolicyNoPaging)

		{// No paging allowed so don't register the device.

		return KErrNone;

		}

	// Store the device, blocking any other devices from installing.

	if (!NKern::CompareAndSwap((TAny*&)iDevice, (TAny*)NULL, (TAny*)aDevice))

		{// Data paging device already installed.

		__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf("**** Attempt to install more than one data paging device !!!!!!!! ****"));

		return KErrAlreadyExists;

		}

	// Now we can determine the size of the swap, create the swap manager.

	iSwapManager = new DSwapManager;

	__NK_ASSERT_ALWAYS(iSwapManager);

	TInt r = iSwapManager->Create(iDevice);

	if (r != KErrNone)

		{// Couldn't create the swap manager.

		delete iSwapManager;

		iSwapManager = NULL;

		NKern::SafeSwap(NULL, (TAny*&)iDevice);

		return r;

		}

 	NKern::LockedSetClear(K::MemModelAttributes, 0, EMemModelAttrDataPaging);

	return r;

	}

TInt DDataPagedMemoryManager::AcquirePageReadRequest(DPageReadRequest*& aRequest, DMemoryObject* aMemory, TUint aIndex, TUint aCount)

	{

	aRequest = iDevice->iRequestPool->AcquirePageReadRequest(aMemory,aIndex,aCount);

	return KErrNone;

	}

TInt DDataPagedMemoryManager::AcquirePageWriteRequest(DPageWriteRequest*& aRequest, DMemoryObject* aMemory, TUint aIndex, TUint aCount)

	{

	aRequest = iDevice->iRequestPool->AcquirePageWriteRequest(aMemory,aIndex,aCount);

	return KErrNone;

	}

void DDataPagedMemoryManager::Init3()

	{

	}

TInt DDataPagedMemoryManager::Alloc(DMemoryObject* aMemory, TUint aIndex, TUint aCount)

	{

	__NK_ASSERT_DEBUG(MemoryObjectLock::IsHeld(aMemory));

	// re-initialise any decommitted pages which we may still own because they were pinned...

	ReAllocDecommitted(aMemory,aIndex,aCount);

	// Reserve the swap pages required.

	RamAllocLock::Lock();

	TInt r = iSwapManager->ReserveSwap(aMemory, aIndex, aCount);

	RamAllocLock::Unlock();

	return r;

	}

void DDataPagedMemoryManager::Free(DMemoryObject* aMemory, TUint aIndex, TUint aCount)

	{

	TRACE2(("DDataPagedMemoryManager::Free(0x%08x,0x%x,0x%x)", aMemory, aIndex, aCount));

	__NK_ASSERT_DEBUG(MemoryObjectLock::IsHeld(aMemory));

	// Unreserve the swap pages associated with the memory object.  Do this before

	// removing the page array entries to prevent a page fault reallocating these pages.

	RamAllocLock::Lock();

	TInt freed = iSwapManager->UnreserveSwap(aMemory, aIndex, aCount);

	(void)freed;

	RamAllocLock::Unlock();

	DoFree(aMemory,aIndex,aCount);

	}

/**

@copydoc DMemoryManager::Wipe

@todo	Not yet implemented.

		Need to handle this smartly, e.g. throw RAM away and set to uninitialised 

*/

TInt DDataPagedMemoryManager::Wipe(DMemoryObject* aMemory)

	{

	__NK_ASSERT_ALWAYS(0); // not implemented yet

	return KErrNotSupported;

	}

TInt DDataPagedMemoryManager::ReadPages(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TPhysAddr* aPages, DPageReadRequest* aRequest)

	{

	__NK_ASSERT_DEBUG(aRequest->CheckUse(aMemory,aIndex,aCount));

	// Map pages temporarily so that we can copy into them.

	const TLinAddr linAddr = aRequest->MapPages(aIndex, aCount, aPages);

	TInt r = iSwapManager->ReadSwapPages(aMemory, aIndex, aCount, linAddr, aRequest, aPages);

	// The memory object allows executable mappings then need IMB.

	aRequest->UnmapPages(aMemory->IsExecutable());

	return r;

	}

TInt DDataPagedMemoryManager::WritePages(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TPhysAddr* aPages, DPageWriteRequest* aRequest)

	{

	__NK_ASSERT_DEBUG(aRequest->CheckUse(aMemory,aIndex,aCount));

	// Map pages temporarily so that we can copy into them.

	const TLinAddr linAddr = aRequest->MapPages(aIndex, aCount, aPages);

	TInt r = iSwapManager->WriteSwapPages(aMemory, aIndex, aCount, linAddr, aRequest);

	// The memory object allows executable mappings then need IMB.

	aRequest->UnmapPages(aMemory->IsExecutable());

	return r;

	}

TInt DDataPagedMemoryManager::CleanPage(DMemoryObject* aMemory, SPageInfo* aPageInfo, TPhysAddr*& aPageArrayEntry)

	{

	if(aPageInfo->IsDirty()==false)

		return KErrNone;

	// shouldn't be asked to clean a page which is writable...

	__NK_ASSERT_DEBUG(aPageInfo->IsWritable()==false);

	// mark page as being modified by us...

	TUint modifierInstance; // dummy variable used only for it's storage address on the stack

	aPageInfo->SetModifier(&modifierInstance);

	// get info about page...

	TUint index = aPageInfo->Index();

	TPhysAddr physAddr = aPageInfo->PhysAddr();

	// Release the mmu lock while we write out the page.  This is safe as the 

	// RamAllocLock stops the physical address being freed from this object.

	MmuLock::Unlock();

	// get paging request object...

	DPageWriteRequest* req;

	TInt r = AcquirePageWriteRequest(req, aMemory, index, 1);

	__NK_ASSERT_DEBUG(r==KErrNone); // we should always get a write request because the previous function blocks until it gets one

	__NK_ASSERT_DEBUG(req); // we should always get a write request because the previous function blocks until it gets one

	r = WritePages(aMemory, index, 1, &physAddr, req);

	req->Release();

	MmuLock::Lock();

	if(r!=KErrNone)

		return r;

	// check if page is clean...

	if(aPageInfo->CheckModified(&modifierInstance) || aPageInfo->IsWritable())

		{

		// someone else modified the page, or it became writable, so fail...

		r = KErrInUse;

		}

	else

		{

		// page is now clean!

		ThePager.SetClean(*aPageInfo);

		}

	return r;

	}

TBool DDataPagedMemoryManager::IsAllocated(DMemoryObject* aMemory, TUint aIndex, TUint aCount)

	{// MmuLock required to protect manager data.

	// DPagedMemoryManager::DoPageInDone() won't allow MmuLock to be released

	// so can only cope with a maximum of KMaxPagesInOneGo.

	__NK_ASSERT_DEBUG(MmuLock::IsHeld());

	__NK_ASSERT_DEBUG(aCount <= KMaxPagesInOneGo);

	return iSwapManager->IsReserved(aMemory, aIndex, aCount);

	}

void DDataPagedMemoryManager::GetSwapInfo(SVMSwapInfo& aInfoOut)

	{

	NKern::ThreadEnterCS();

	RamAllocLock::Lock();

	iSwapManager->GetSwapInfo(aInfoOut);

	RamAllocLock::Unlock();

	NKern::ThreadLeaveCS();

	}

TInt DDataPagedMemoryManager::SetSwapThresholds(const SVMSwapThresholds& aThresholds)

	{

	NKern::ThreadEnterCS();

	RamAllocLock::Lock();

	TInt r = iSwapManager->SetSwapThresholds(aThresholds);

	RamAllocLock::Unlock();

	NKern::ThreadLeaveCS();

	return r;

	}

void GetSwapInfo(SVMSwapInfo& aInfoOut)

	{

	((DDataPagedMemoryManager*)TheDataPagedMemoryManager)->GetSwapInfo(aInfoOut);

	}

TInt SetSwapThresholds(const SVMSwapThresholds& aThresholds)

	{

	return ((DDataPagedMemoryManager*)TheDataPagedMemoryManager)->SetSwapThresholds(aThresholds);

	}