// 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 <kernel/cache.h>

#include "mm.h"

#include "mmu.h"

#include "mmanager.h"

#include "mobject.h"

#include "mmapping.h"

#include "mpager.h"

#include "mswap.h"

/**

Log2 of minimum number of pages to attempt to write at a time.

The value of 2 gives a minimum write size of 16KB.

*/

const TUint KMinPreferredWriteShift = 2;

/**

Log2 of maximum number of pages to attempt to write at a time.

The value of 4 gives a maximum write size of 64KB.

*/

const TUint KMaxPreferredWriteShift = 4;

__ASSERT_COMPILE((1 << KMaxPreferredWriteShift) <= KMaxPagesToClean);

/**

Whether the CPU has the page colouring restriction, where pages must be mapped in sequential colour

order.

*/

#ifdef __CPU_CACHE_HAS_COLOUR	

const TBool KPageColouringRestriction = ETrue;

#else

const TBool KPageColouringRestriction = EFalse;

#endif

/**

Manages the swap via the data paging device.

*/

class DSwapManager

	{

public:

	/// The state of swap for a logical page in a memory object.

	///

	/// Note that this does not always correspond to the state of the page in RAM - for example a

	/// page can be dirty in RAM but blank in swap if it has never been written out.

	enum TSwapState

		{

		EStateUnreserved = 0,	///< swap space not yet reserved, or page is being decommitted

		EStateBlank      = 1,	///< swap page has never been written

		EStateWritten    = 2,	///< swap page has been written out at least once

		EStateWriting    = 3	///< swap page is in the process of being written out

		};

	enum

		{

		ESwapIndexShift = 2,

		ESwapStateMask 	= (1 << ESwapIndexShift) - 1,

		ESwapIndexMask  = 0xffffffff & ~ESwapStateMask

		};

public:

	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, TPhysAddr* aPhysAddrs);

	TInt WriteSwapPages(DMemoryObject** aMemory, TUint* aIndex, TUint aCount, TLinAddr aLinAddr, TPhysAddr* aPhysAddrs, TBool aBackground);

	void GetSwapInfo(SVMSwapInfo& aInfoOut);

	TInt SetSwapThresholds(const SVMSwapThresholds& aThresholds);

	void SetSwapAlign(TUint aSwapAlign);

private:

	inline TSwapState SwapState(TUint aSwapData);

	inline TInt SwapIndex(TUint aSwapData);

	inline TUint SwapData(TSwapState aSwapState, TInt aSwapIndex);

	TInt AllocSwapIndex(TUint aCount);

	void FreeSwapIndex(TInt aSwapIndex);

	void CheckSwapThresholdsAndUnlock(TUint aInitial);

	void DoDeleteNotify(TUint aSwapIndex);

	TInt DoWriteSwapPages(DMemoryObject** aMemory, TUint* aIndex, TUint aCount, TLinAddr aLinAddr, TInt aPageIndex, TPhysAddr* aPhysAddrs, TInt aSwapIndex, TBool aBackground);

private:

	DPagingDevice* iDevice;			///< Paging device used to read and write swap pages

	NFastMutex iSwapLock;			///< Fast mutex protecting access to all members below

	TUint iFreePageCount;			///< Number of swap pages that have not been reserved

	TBitMapAllocator* iBitMap;		///< Bitmap of swap pages that have been allocated

	TUint iSwapAlign;				///< Log2 number of pages to align swap writes to

	TUint iAllocOffset;				///< Next offset to try when allocating a swap page

 	TUint iSwapThesholdLow;

 	TUint iSwapThesholdGood;

	};

/**

   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 void CleanPages(TUint aPageCount, SPageInfo** aPageInfos, TBool aBackground);

	// 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 TBool IsAllocated(DMemoryObject* aMemory, TUint aIndex, TUint aCount);

public:

	void GetSwapInfo(SVMSwapInfo& aInfoOut);

	TInt SetSwapThresholds(const SVMSwapThresholds& aThresholds);

	TBool PhysicalAccessSupported();

	TBool UsePhysicalAccess();

	void SetUsePhysicalAccess(TBool aUsePhysicalAccess);

	TUint PreferredWriteSize();

	TUint PreferredSwapAlignment();

	TInt SetWriteSize(TUint aWriteShift);

private:

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

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;

	/**

	   Whether to read and write pages by physical address without mapping them first.

	   Set if the paging media driver supports it.

	*/

	TBool iUsePhysicalAccess;

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 & ESwapStateMask));

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

		}

	iFreePageCount = swapPages;

	iAllocOffset = 0;

	return KErrNone;

	}

void DSwapManager::SetSwapAlign(TUint aSwapAlign)

	{

	TRACE(("WDP: Set swap alignment to %d (%d KB)", aSwapAlign, 4 << aSwapAlign));

	NKern::FMWait(&iSwapLock);

	iSwapAlign = aSwapAlign;

	NKern::FMSignal(&iSwapLock);

	}

inline DSwapManager::TSwapState DSwapManager::SwapState(TUint aSwapData)

	{

	TSwapState state = (TSwapState)(aSwapData & ESwapStateMask);

	__NK_ASSERT_DEBUG(state >= EStateWritten || (aSwapData & ~ESwapStateMask) == 0);

	return state;

	}

inline TInt DSwapManager::SwapIndex(TUint aSwapData)

	{

	return aSwapData >> ESwapIndexShift;

	}

inline TUint DSwapManager::SwapData(TSwapState aSwapState, TInt aSwapIndex)

	{

	return (aSwapIndex << ESwapIndexShift) | aSwapState;

	}

/**

   Allocate one or more page's worth of space within the swap area.

   The location is represented by a page-based index into the swap area.

   @param aCount The number of page's worth of space to allocate.

   @return The swap index of the first location allocated.

*/

TInt DSwapManager::AllocSwapIndex(TUint aCount)

	{

	TRACE2(("DSwapManager::AllocSwapIndex %d", aCount));

	__NK_ASSERT_DEBUG(aCount <= KMaxPagesToClean);

	NKern::FMWait(&iSwapLock);

	TInt carry;

	TInt l = KMaxTInt;

	TInt swapIndex = -1;

	// if size suitable for alignment, search for aligned run of aCount from iAllocOffset to end,

	// then from beginning

	// 

	// note that this aligns writes that at least as large as the alignment size - an alternative

	// policy might be to align writes that are an exact multiple of the alignment size

	if (iSwapAlign && aCount >= (1u << iSwapAlign))

		{

		carry = 0;

		swapIndex = iBitMap->AllocAligned(aCount, iSwapAlign, 0, EFalse, carry, l, iAllocOffset);

		if (swapIndex < 0)

			{

			carry = 0;

			swapIndex = iBitMap->AllocAligned(aCount, iSwapAlign, 0, EFalse, carry, l, 0);

			}

		}

	// if not doing aligned search, or aligned search failed, retry without alignment

	if (swapIndex < 0)

		{

		carry = 0;

		swapIndex = iBitMap->AllocAligned(aCount, 0, 0, EFalse, carry, l, iAllocOffset);

		if (swapIndex < 0)

			{

			carry = 0;

			swapIndex = iBitMap->AllocAligned(aCount, 0, 0, EFalse, carry, l, 0);

			}

		}

	// if we found one then mark it as allocated and update iAllocOffset

	if (swapIndex >= 0)

		{

		__NK_ASSERT_DEBUG(swapIndex <= (TInt)(iBitMap->iSize - aCount));

		iBitMap->Alloc(swapIndex, aCount);

		iAllocOffset = (swapIndex + aCount) % iBitMap->iSize;

		}

	NKern::FMSignal(&iSwapLock);

	__NK_ASSERT_DEBUG(swapIndex >= 0 || aCount > 1); // can't fail to allocate single page

	TRACE2(("DSwapManager::AllocSwapIndex returns %d", swapIndex));	

	return swapIndex;

	}

/**

   Free one page's worth of space within the swap area.

   The index must have been previously allocated with AllocSwapIndex().

*/

void DSwapManager::FreeSwapIndex(TInt aSwapIndex)

	{

	__NK_ASSERT_DEBUG(aSwapIndex >= 0 && aSwapIndex < iBitMap->iSize);

	DoDeleteNotify(aSwapIndex);

	NKern::FMWait(&iSwapLock);

	iBitMap->Free(aSwapIndex);

	NKern::FMSignal(&iSwapLock);

	}

/**

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

	NKern::FMWait(&iSwapLock);

	TUint initFree = iFreePageCount;

	if (iFreePageCount < aPageCount)

		{

		NKern::FMSignal(&iSwapLock);

		Kern::AsyncNotifyChanges(EChangesOutOfMemory);

		return KErrNoMemory;

		}

	iFreePageCount -= aPageCount;

	CheckSwapThresholdsAndUnlock(initFree);		

	// Mark each page as allocated and uninitialised.

	const TUint indexEnd = aStartIndex + aPageCount;

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

		{		

		// Grab MmuLock to stop manager data being accessed.

		MmuLock::Lock();

		__NK_ASSERT_DEBUG(SwapState(aMemory->PagingManagerData(index)) == EStateUnreserved);

		aMemory->SetPagingManagerData(index, EStateBlank);

		MmuLock::Unlock();

		}

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

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

		TSwapState state = SwapState(swapData);

		if (state != EStateUnreserved)

			{

			freedPages++;

			aMemory->SetPagingManagerData(index, EStateUnreserved);

			}

		MmuLock::Unlock();

		if (state == EStateWritten)

			FreeSwapIndex(SwapIndex(swapData));

		else if (state == EStateWriting)

			{

			// Wait for cleaning to finish before deallocating swap space

			PageCleaningLock::Lock();

			PageCleaningLock::Unlock();

#ifdef _DEBUG

			MmuLock::Lock();

			__NK_ASSERT_DEBUG(SwapState(aMemory->PagingManagerData(index)) == EStateUnreserved);

			MmuLock::Unlock();

#endif

			}

		}

	NKern::FMWait(&iSwapLock);

	TUint initFree = iFreePageCount;

	iFreePageCount += freedPages;

	CheckSwapThresholdsAndUnlock(initFree);	

	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 (SwapState(aMemory->PagingManagerData(index)) == EStateUnreserved)

			{// 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, TPhysAddr* aPhysAddrs)

	{

	__ASSERT_CRITICAL;

	TInt r = KErrNone;

	const TUint readUnitShift = iDevice->iReadUnitShift;

	TUint readSize = KPageSize >> readUnitShift;

	TThreadMessage message;

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

		TSwapState state = SwapState(swapData);

		if (state == EStateUnreserved)

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

			MmuLock::Unlock();

			return KErrNotFound;			

			}

		else if (state == EStateBlank)

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

			// just wipe it if required.

			TUint allocFlags = aMemory->RamAllocFlags();

			MmuLock::Unlock();

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

			if (wipePages)

				{

				TUint8 wipeByte = (allocFlags & Mmu::EAllocUseCustomWipeByte) ?

					(allocFlags >> Mmu::EAllocWipeByteShift) & 0xff :

					0x03;

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

				}

			}

		else