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

//

#include <plat_priv.h>

#include "cache_maintenance.h"

#include "decompress.h"	// include for the generic BytePairDecompress().

#include "mm.h"

#include "mmu.h"

#include "mpager.h"

#include "mmanager.h"

#include "mmapping.h"

#include "mobject.h"

#include "mcleanup.h"

//

// DMemoryManager

//

TInt DMemoryManager::New(DMemoryObject*& aMemory, TUint aSizeInPages, TMemoryAttributes aAttributes, TMemoryCreateFlags aCreateFlags)

	{

	DMemoryObject* memory;

	if(aSizeInPages&(KChunkMask>>KPageShift))

		memory = DFineMemory::New(this,aSizeInPages,aAttributes,aCreateFlags);

	else

		memory = DCoarseMemory::New(this,aSizeInPages,aAttributes,aCreateFlags);

	aMemory = memory;

	if(!memory)

		return KErrNoMemory;

	return KErrNone;

	}

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

	{

	return KErrNotSupported;

	}

TInt DMemoryManager::AllocContiguous(DMemoryObject* /*aMemory*/, TUint /*aIndex*/, TUint /*aCount*/, TUint /*aAlign*/, TPhysAddr& /*aPhysAddr*/)

	{

	return KErrNotSupported;

	}

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

	{

	}

TInt DMemoryManager::Wipe(DMemoryObject* /*aMemory*/)

	{

	return KErrNotSupported;

	}

TInt DMemoryManager::AddPages(DMemoryObject* /*aMemory*/, TUint /*aIndex*/, TUint /*aCount*/, const TPhysAddr* /*aPages*/)

	{

	return KErrNotSupported;

	}

TInt DMemoryManager::AddContiguous(DMemoryObject* /*aMemory*/, TUint /*aIndex*/, TUint /*aCount*/, TPhysAddr /*aPhysAddr*/)

	{

	return KErrNotSupported;

	}

TInt DMemoryManager::RemovePages(DMemoryObject* /*aMemory*/, TUint /*aIndex*/, TUint /*aCount*/, TPhysAddr* /*aPages*/)

	{

	return KErrNotSupported;

	}

TInt DMemoryManager::AllowDiscard(DMemoryObject* /*aMemory*/, TUint /*aIndex*/, TUint /*aCount*/)

	{

	return KErrNotSupported;

	}

TInt DMemoryManager::DisallowDiscard(DMemoryObject* /*aMemory*/, TUint /*aIndex*/, TUint /*aCount*/)

	{

	return KErrNotSupported;

	}

TInt DMemoryManager::StealPage(DMemoryObject* /*aMemory*/, SPageInfo* /*aPageInfo*/)

	{

	return KErrNotSupported;

	}

TInt DMemoryManager::RestrictPage(DMemoryObject* /*aMemory*/, SPageInfo* /*aPageInfo*/, TRestrictPagesType /*aRestriction*/)

	{

	return KErrNotSupported;

	}

void DMemoryManager::CleanPages(TUint aPageCount, SPageInfo** aPageInfos, TBool /*aBackground*/)

	{

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

		__NK_ASSERT_DEBUG(!aPageInfos[i]->IsDirty());

	}

TInt DMemoryManager::HandleFault(	DMemoryObject* aMemory, TUint aIndex, DMemoryMapping* aMapping,

									TUint aMapInstanceCount, TUint aAccessPermissions)

	{

	(void)aMemory;

	(void)aIndex;

	(void)aMapping;

	(void)aMapInstanceCount;

	(void)aAccessPermissions;

//	Kern::Printf("DMemoryManager::HandlePageFault(0x%08x,0x%x,0x%08x,%d)",aMemory,aIndex,aMapping,aAccessPermissions);

	return KErrAbort;

	}

TInt DMemoryManager::MovePage(	DMemoryObject* aMemory, SPageInfo* aOldPageInfo, 

								TPhysAddr& aNewPage, TUint aBlockZoneId, TBool aBlockRest)

	{

	return KErrNotSupported;

	}

TInt DMemoryManager::MoveAndAllocPage(DMemoryObject*, SPageInfo*, TZonePageType)

	{

	__NK_ASSERT_DEBUG(0);	// This should only be invoked on managers that can move or discard pages.

	return KErrNotSupported;

	}

TZonePageType DMemoryManager::PageType()

	{// This should not be invoked on memory managers that do not use the methods

	// AllocPages() and FreePages().

	__NK_ASSERT_DEBUG(0);

	return EPageFixed;

	}

static TMemoryCleanup Cleanup;

DMemoryObject* DMemoryManager::iCleanupHead = 0;

TSpinLock DMemoryManager::iCleanupLock(TSpinLock::EOrderGenericIrqHigh3);

void DMemoryManager::CleanupFunction(TAny*)

	{

	for(;;)

		{

		__SPIN_LOCK_IRQ(iCleanupLock);

		// get an object from queue...

		DMemoryObject* memory = iCleanupHead;

		if(!memory)

			{

			// none left, so end...

			__SPIN_UNLOCK_IRQ(iCleanupLock);

			return;

			}

		if(memory->iCleanupFlags&ECleanupDecommitted)

			{

			// object requires cleanup of decommitted pages...

			memory->iCleanupFlags &= ~ECleanupDecommitted;

			__SPIN_UNLOCK_IRQ(iCleanupLock);

			memory->iManager->DoCleanupDecommitted(memory);

			}

		else

			{

			// object has no more cleanup operations to perform,

			// so remove it from the cleanup queue...

			__NK_ASSERT_DEBUG(memory->iCleanupFlags==ECleanupIsQueued); // no operations left, just flag to say its in the cleanup queue

			memory->iCleanupFlags &= ~ECleanupIsQueued;

			iCleanupHead = memory->iCleanupNext;

			memory->iCleanupNext = NULL;

			__SPIN_UNLOCK_IRQ(iCleanupLock);

			// close reference which was added when object was queued...

			memory->Close();

			}

		}

	}

void DMemoryManager::QueueCleanup(DMemoryObject* aMemory, TCleanupOperationFlag aCleanupOp)

	{

	// add new cleanup operation...

	__SPIN_LOCK_IRQ(iCleanupLock);

	TUint32 oldFlags = aMemory->iCleanupFlags;

	aMemory->iCleanupFlags = oldFlags|aCleanupOp|ECleanupIsQueued;

	__SPIN_UNLOCK_IRQ(iCleanupLock);

	// if cleanup was already requested...

	if(oldFlags)

		return; // nothing more to do

	// increase reference count...

	aMemory->Open();

	// add object to cleanup queue...

	__SPIN_LOCK_IRQ(iCleanupLock);

	aMemory->iCleanupNext = iCleanupHead;

	iCleanupHead = aMemory;

	__SPIN_UNLOCK_IRQ(iCleanupLock);

	// queue cleanup function to run...

	Cleanup.Add((TMemoryCleanupCallback)CleanupFunction,0);

	}

void DMemoryManager::DoCleanupDecommitted(DMemoryObject* aMemory)

	{

	TRACE2(("DMemoryManager::DoCleanupDecommitted(0x%08x)",aMemory));

	__NK_ASSERT_DEBUG(0);

	}

void DMemoryManager::ReAllocDecommitted(DMemoryObject* aMemory, TUint aIndex, TUint aCount)

	{

	__NK_ASSERT_DEBUG(MemoryObjectLock::IsHeld(aMemory));

	// make iterator for region...

	RPageArray::TIter pageIter;

	aMemory->iPages.FindStart(aIndex,aCount,pageIter);

	for(;;)

		{

		// find some pages...

		RPageArray::TIter pageList;

		TUint n = pageIter.Find(pageList);

		if(!n)

			break;

		// check each existing page...

		RamAllocLock::Lock();

		TPhysAddr* pages;

		while(pageList.Pages(pages))

			{

			TPhysAddr page = *pages;

			if(RPageArray::State(page)==RPageArray::EDecommitted)

				{

				// decommitted pages need re-initialising...

				TPhysAddr pagePhys = page&~KPageMask;

				*pages = pagePhys|RPageArray::ECommitted;

				TheMmu.PagesAllocated(&pagePhys,1,aMemory->RamAllocFlags(),true);

				}

			pageList.Skip(1);

			}

		RamAllocLock::Unlock();

		// move on...

		pageIter.FindRelease(n);

		}

	aMemory->iPages.FindEnd(aIndex,aCount);

	}

void DMemoryManager::FreeDecommitted(DMemoryObject* aMemory, TUint aIndex, TUint aCount)

	{

	TRACE2(("DMemoryManager::FreeDecommitted(0x%08x,0x%x,0x%x)",aMemory, aIndex, aCount));

	__NK_ASSERT_DEBUG(MemoryObjectLock::IsHeld(aMemory));

	// make iterator for region...

	RPageArray::TIter pageIter;

	aMemory->iPages.FindStart(aIndex,aCount,pageIter);

	for(;;)

		{

		// find some pages...

		RPageArray::TIter pageList;

		TUint findCount = pageIter.Find(pageList);

		if(!findCount)

			break;

		// search for decommitted pages...

		RamAllocLock::Lock();

		TPhysAddr* pages;

		TUint numPages;

		while((numPages=pageList.Pages(pages))!=0)

			{

			TUint n=0;

			if(RPageArray::State(pages[n])!=RPageArray::EDecommitted)

				{

				// skip pages which aren't EDecommitted...

				while(++n<numPages && RPageArray::State(pages[n])!=RPageArray::EDecommitted)

					{}

				}

			else

				{

				// find range of pages which are EDecommitted...

				while(++n<numPages && RPageArray::State(pages[n])==RPageArray::EDecommitted)

					{}

				RPageArray::TIter decommittedList(pageList.Left(n));

				// free pages...

				TUint freedCount = FreePages(aMemory,decommittedList);

				(void)freedCount;

				TRACE2(("DMemoryManager::FreeDecommitted(0x%08x) freed %d in 0x%x..0x%x",aMemory,freedCount,decommittedList.Index(),decommittedList.IndexEnd()));

				}

			pageList.Skip(n);

			}

		RamAllocLock::Unlock();

		// move on...

		pageIter.FindRelease(findCount);

		}

	aMemory->iPages.FindEnd(aIndex,aCount);

	}

void DMemoryManager::DoFree(DMemoryObject* aMemory, TUint aIndex, TUint aCount)

	{

	TRACE2(("DMemoryManager::DoFree(0x%08x,0x%x,0x%x)",aMemory, aIndex, aCount));

	__NK_ASSERT_DEBUG(MemoryObjectLock::IsHeld(aMemory));

	RPageArray::TIter pageIter;

	aMemory->iPages.FindStart(aIndex,aCount,pageIter);

	for(;;)

		{

		// find some pages...

		RPageArray::TIter pageList;

		TUint n = pageIter.RemoveFind(pageList);

		if(!n)

			break;

		// free pages...

		FreePages(aMemory,pageList);

		// move on...

		pageIter.FindRelease(n);

		}

	aMemory->iPages.FindEnd(aIndex,aCount);

	}

TInt DMemoryManager::FreePages(DMemoryObject* aMemory, RPageArray::TIter aPageList)

	{

	// unmap the pages...

	aMemory->UnmapPages(aPageList,true);

	RamAllocLock::Lock();

	// remove and free pages...

	Mmu& m = TheMmu;

	TUint count = 0;

	TPhysAddr pages[KMaxPagesInOneGo];

	TUint n;

	while((n=aPageList.Remove(KMaxPagesInOneGo,pages))!=0)

		{

		count += n;

		m.FreeRam(pages, n, aMemory->iManager->PageType());

		}

	RamAllocLock::Unlock();

	return count;

	}

/**

Manager for memory objects containing normal unpaged program memory (RAM) which

is allocated from a system wide pool. The physical pages allocated to this

memory are fixed until explicitly freed.

This is normally used for kernel memory and any other situation where it

is not permissible for memory accesses to generate page faults of any kind.

*/

class DUnpagedMemoryManager : public DMemoryManager

	{

public:

	// from DMemoryManager...

	virtual void Destruct(DMemoryObject* aMemory);

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

	virtual TInt AllocContiguous(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TUint aAlign, TPhysAddr& aPhysAddr);

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

	virtual TInt Pin(DMemoryObject* aMemory, DMemoryMappingBase* aMapping, TPinArgs& aPinArgs);

	virtual void Unpin(DMemoryObject* aMemory, DMemoryMappingBase* aMapping, TPinArgs& aPinArgs);

	virtual TInt Wipe(DMemoryObject* aMemory);

	virtual TZonePageType PageType();

private:

	// from DMemoryManager...

	virtual void DoCleanupDecommitted(DMemoryObject* aMemory);

	/**

	Implementation factor for implementation of #Alloc.

	*/

	static TInt AllocPages(DMemoryObject* aMemory, RPageArray::TIter aPageList);

	/**

	Implementation factor for implementation of #AllocContiguous.

	*/

	static TInt AllocContiguousPages(DMemoryObject* aMemory, RPageArray::TIter aPageList, TUint aAlign, TPhysAddr& aPhysAddr);

	/**

	Implementation factor for implementation of #Wipe.

	*/

	static void WipePages(DMemoryObject* aMemory, RPageArray::TIter aPageList);

public:

	/**

	The single instance of this manager class.

	*/

	static DUnpagedMemoryManager TheManager;

	};

DUnpagedMemoryManager DUnpagedMemoryManager::TheManager;

DMemoryManager* TheUnpagedMemoryManager = &DUnpagedMemoryManager::TheManager;

void DUnpagedMemoryManager::Destruct(DMemoryObject* aMemory)

	{

	MemoryObjectLock::Lock(aMemory);

	Free(aMemory,0,aMemory->iSizeInPages);

	MemoryObjectLock::Unlock(aMemory);

	aMemory->Close();

	}

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

	{

	TRACE2(("DUnpagedMemoryManager::Alloc(0x%08x,0x%x,0x%x)",aMemory, aIndex, 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);

	// check and allocate page array entries...

	RPageArray::TIter pageList;

	TInt r = aMemory->iPages.AddStart(aIndex,aCount,pageList,true);

	if(r!=KErrNone)

		return r;

	// allocate RAM and add it to page array...

	r = AllocPages(aMemory,pageList);

	// map pages...

	if(r==KErrNone)

		r = aMemory->MapPages(pageList);

	// release page array entries...

	aMemory->iPages.AddEnd(aIndex,aCount);

	// revert if error...

	if(r!=KErrNone)

		Free(aMemory,aIndex,aCount);

	return r;

	}

TInt DUnpagedMemoryManager::AllocContiguous(DMemoryObject* aMemory, TUint aIndex, TUint aCount, TUint aAlign, TPhysAddr& aPhysAddr)

	{

	TRACE2(("DUnpagedMemoryManager::AllocContiguous(0x%08x,0x%x,0x%x,%d,?)",aMemory, aIndex, aCount, aAlign));

	__NK_ASSERT_DEBUG(MemoryObjectLock::IsHeld(aMemory));

	// set invalid memory in case of error...

	aPhysAddr = KPhysAddrInvalid;

	// check and allocate page array entries...

	RPageArray::TIter pageList;

	TInt r = aMemory->iPages.AddStart(aIndex,aCount,pageList);

	if(r!=KErrNone)

		return r;

	// allocate memory...

	TPhysAddr physAddr;

	r = AllocContiguousPages(aMemory, pageList, aAlign, physAddr);

	// map memory...

	if(r==KErrNone)

		{

		r = aMemory->MapPages(pageList);

		if(r==KErrNone)

			aPhysAddr = physAddr;

		}

	// release page array entries...

	aMemory->iPages.AddEnd(aIndex,aCount);

	// revert if error...

	if(r!=KErrNone)

		Free(aMemory,aIndex,aCount);

	return r;

	}

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

	{

	DoFree(aMemory,aIndex,aCount);

	}

TInt DUnpagedMemoryManager::AllocPages(DMemoryObject* aMemory, RPageArray::TIter aPageList)

	{

	TInt r = KErrNone;

	RamAllocLock::Lock();

	Mmu& m = TheMmu;

	for(;;)

		{

		// find entries in page array to allocate...

		RPageArray::TIter allocList;

		TUint n = aPageList.AddFind(allocList);

		if(!n)

			break;

		do