// 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 "mm.h"

#include "mmu.h"

#include "mobject.h"

#include "mmapping.h"

#include "mptalloc.h"

#include "mmanager.h"

#include "cache_maintenance.inl"

const TUint KMaxMappingsInOneGo = KMaxPageInfoUpdatesInOneGo; // must be power-of-2

//

// MemoryObjectLock

//

/**

The mutex pool used to assign locks to memory objects.

@see #MemoryObjectLock.

*/

DMutexPool MemoryObjectMutexPool;

void MemoryObjectLock::Lock(DMemoryObject* aMemory)

	{

	TRACE2(("MemoryObjectLock::Lock(0x%08x) try",aMemory));

	MemoryObjectMutexPool.Wait(aMemory->iLock);

	TRACE2(("MemoryObjectLock::Lock(0x%08x) acquired",aMemory));

	}

void MemoryObjectLock::Unlock(DMemoryObject* aMemory)

	{

	TRACE2(("MemoryObjectLock::Unlock(0x%08x)",aMemory));

	MemoryObjectMutexPool.Signal(aMemory->iLock);

	}

TBool MemoryObjectLock::IsHeld(DMemoryObject* aMemory)

	{

	return MemoryObjectMutexPool.IsHeld(aMemory->iLock);

	}

//

// DMemoryObject

//

DMemoryObject::DMemoryObject(DMemoryManager* aManager, TUint aFlags, TUint aSizeInPages, TMemoryAttributes aAttributes, TMemoryCreateFlags aCreateFlags)

	: iManager(aManager), iFlags(aFlags), iAttributes(Mmu::CanonicalMemoryAttributes(aAttributes)),

	  iSizeInPages(aSizeInPages)

	{

	__ASSERT_COMPILE(EMemoryAttributeMask<0x100); // make sure aAttributes fits into a TUint8

	TMemoryType type = (TMemoryType)(aAttributes&EMemoryAttributeTypeMask);

	iRamAllocFlags = type;

	if(aCreateFlags&EMemoryCreateNoWipe)

		iRamAllocFlags |= Mmu::EAllocNoWipe;

	else if(aCreateFlags&EMemoryCreateUseCustomWipeByte)

		{

		TUint8 wipeByte = (aCreateFlags>>EMemoryCreateWipeByteShift)&0xff;

		iRamAllocFlags |= wipeByte<<Mmu::EAllocWipeByteShift;

		iRamAllocFlags |= Mmu::EAllocUseCustomWipeByte;

		}

	if(aCreateFlags&EMemoryCreateDemandPaged)

		iFlags |= EDemandPaged;

	if(aCreateFlags&EMemoryCreateReserveAllResources)

		iFlags |= EReserveResources;

	if(aCreateFlags&EMemoryCreateDisallowPinning)

		iFlags |= EDenyPinning;

	if(aCreateFlags&EMemoryCreateReadOnly)

		iFlags |= EDenyWriteMappings;

	if(!(aCreateFlags&EMemoryCreateAllowExecution))

		iFlags |= EDenyExecuteMappings;

	}

TInt DMemoryObject::Construct()

	{

	TBool preAllocateMemory = iFlags&(EReserveResources|EDemandPaged);

	TInt r = iPages.Construct(iSizeInPages,preAllocateMemory);

	return r;

	}

DMemoryObject::~DMemoryObject()

	{

	TRACE(("DMemoryObject[0x%08x]::~DMemoryObject()",this));

	__NK_ASSERT_DEBUG(iMappings.IsEmpty());

	}

TBool DMemoryObject::CheckRegion(TUint aIndex, TUint aCount)

	{

	TUint end = aIndex+aCount;

	return end>=aIndex && end<=iSizeInPages;

	}

void DMemoryObject::ClipRegion(TUint& aIndex, TUint& aCount)

	{

	TUint end = aIndex+aCount;

	if(end<aIndex) // overflow?

		end = ~0u;

	if(end>iSizeInPages)

		end = iSizeInPages;

	if(aIndex>=end)

		aIndex = end;

	aCount = end-aIndex;

	}

void DMemoryObject::SetLock(DMutex* aLock)

	{

	__NK_ASSERT_DEBUG(!iLock);

	iLock = aLock;

	TRACE(("MemoryObject[0x%08x]::SetLock(0x%08x) \"%O\"",this,aLock,aLock));

	}

DMemoryMapping* DMemoryObject::CreateMapping(TUint, TUint)

	{

	return new DFineMapping();

	}

TInt DMemoryObject::MapPages(RPageArray::TIter aPages)

	{

	TRACE2(("DMemoryObject[0x%08x]::MapPages(?) index=0x%x count=0x%x",this,aPages.Index(),aPages.Count()));

	TUint offset = aPages.Index();

	TUint offsetEnd = aPages.IndexEnd();

	TInt r = KErrNone;

	iMappings.Lock();

	TMappingListIter iter;

	DMemoryMappingBase* mapping = iter.Start(iMappings);

	while(mapping)

		{

		if(mapping->IsPinned())

			{

			// pinned mappings don't change, so nothing to do...

			iMappings.Unlock();

			}

		else

			{

			// get region where pages overlap the mapping...

			TUint start = mapping->iStartIndex;

			TUint end = start+mapping->iSizeInPages;

			if(start<offset)

				start = offset;

			if(end>offsetEnd)

				end = offsetEnd;

			if(start>=end)

				{

				// the mapping doesn't contain the pages...

				iMappings.Unlock();

				}

			else

				{

				// map pages in the mapping...

				mapping->Open();

				TUint mapInstanceCount = mapping->MapInstanceCount();

				iMappings.Unlock();

				r = mapping->MapPages(aPages.Slice(start,end),mapInstanceCount);

				mapping->AsyncClose();

				if(r!=KErrNone)

					{

					iMappings.Lock();

					break;

					}

				}

			}

		iMappings.Lock();

		mapping = iter.Next();

		}

	iter.Finish();

	iMappings.Unlock();

	return r;

	}

void DMemoryObject::RemapPage(TPhysAddr& aPageArray, TUint aIndex, TBool aInvalidateTLB)

	{

	TRACE2(("DMemoryObject[0x%08x]::RemapPage(0x%x,%d,%d)",this,aPageArray,aIndex,aInvalidateTLB));

	iMappings.RemapPage(aPageArray, aIndex, aInvalidateTLB);

#ifdef COARSE_GRAINED_TLB_MAINTENANCE

	if (aInvalidateTLB)

		InvalidateTLB();

#endif

	}

void DMemoryObject::UnmapPages(RPageArray::TIter aPages, TBool aDecommitting)

	{

	TRACE2(("DMemoryObject[0x%08x]::UnmapPages(?,%d) index=0x%x count=0x%x",this,(bool)aDecommitting,aPages.Index(),aPages.Count()));

	TUint offset = aPages.Index();

	TUint offsetEnd = aPages.IndexEnd();

	if(offset==offsetEnd)

		return;

	iMappings.Lock();

	TMappingListIter iter;

	DMemoryMappingBase* mapping = iter.Start(iMappings);

	while(mapping)

		{

		// get region where pages overlap the mapping...

		TUint start = mapping->iStartIndex;

		TUint end = start+mapping->iSizeInPages;

		if(start<offset)

			start = offset;

		if(end>offsetEnd)

			end = offsetEnd;

		if(start>=end)

			{

			// the mapping doesn't contain the pages...

			iMappings.Unlock();

			}

		else

			{

			RPageArray::TIter pages = aPages.Slice(start,end);

			if(mapping->IsPinned())

				{

				// pinned mappings veto page unmapping...

				if(aDecommitting)

					__e32_atomic_ior_ord8(&mapping->Flags(), (TUint8)DMemoryMapping::EPageUnmapVetoed);

				iMappings.Unlock();

				TRACE2(("DFineMemoryMapping[0x%08x] veto UnmapPages, index=0x%x count=0x%x",mapping,pages.Index(),pages.Count()));

				pages.VetoUnmap();

				}

			else

				{

				// unmap pages in the mapping...

				mapping->Open();

				TUint mapInstanceCount = mapping->MapInstanceCount();

				iMappings.Unlock();

				mapping->UnmapPages(pages,mapInstanceCount);

				mapping->AsyncClose();

				}

			}

		iMappings.Lock();

		mapping = iter.Next();

		}

	iter.Finish();

	iMappings.Unlock();

#ifdef COARSE_GRAINED_TLB_MAINTENANCE

	InvalidateTLB();

#endif

	}

void DMemoryObject::RestrictPages(RPageArray::TIter aPages, TRestrictPagesType aRestriction)

	{

	TRACE2(("DMemoryObject[0x%08x]::RestrictPages(?,%d) index=0x%x count=0x%x",this,aRestriction,aPages.Index(),aPages.Count()));

	TUint offset = aPages.Index();

	TUint offsetEnd = aPages.IndexEnd();

	if(offset==offsetEnd)

		return;

	iMappings.Lock();

	TMappingListIter iter;

	DMemoryMappingBase* mapping = iter.Start(iMappings);

	while(mapping)

		{

		// get region where pages overlap the mapping...

		TUint start = mapping->iStartIndex;

		TUint end = start+mapping->iSizeInPages;

		if(start<offset)

			start = offset;

		if(end>offsetEnd)

			end = offsetEnd;

		if(start>=end)

			{

			// the mapping doesn't contain the pages...

			iMappings.Unlock();

			}

		else

			{

			RPageArray::TIter pages = aPages.Slice(start,end);

			if(mapping->IsPhysicalPinning() ||

				(!(aRestriction & ERestrictPagesForMovingFlag) && mapping->IsPinned()))

				{

				// Pinned mappings veto page restrictions except for page moving 

				// where only physically pinned mappings block page moving.

				iMappings.Unlock();

				TRACE2(("DFineMemoryMapping[0x%08x] veto RestrictPages, index=0x%x count=0x%x",mapping,pages.Index(),pages.Count()));

				pages.VetoRestrict(aRestriction & ERestrictPagesForMovingFlag);

				// Mappings lock required for iter.Finish() as iter will be removed from the mappings list.

				iMappings.Lock();

				break;

				}

			else

				{

				// pages not pinned so do they need restricting...

				if(aRestriction == ERestrictPagesForMovingFlag)

					{

					// nothing to do when just checking for pinned mappings for 

					// page moving purposes and not restricting to NA.

					iMappings.Unlock();

					}

				else

					{

					// restrict pages in the mapping...

					mapping->Open();

					TUint mapInstanceCount = mapping->MapInstanceCount();

					iMappings.Unlock();

					mapping->RestrictPagesNA(pages, mapInstanceCount);

					mapping->AsyncClose();

					}

				}

			}

		iMappings.Lock();

		mapping = iter.Next();

		}

	if(aRestriction & ERestrictPagesForMovingFlag)

		{// Clear the mappings addded flag so page moving can detect whether any 

		// new mappings have been added

		ClearMappingAddedFlag();

		}

	iter.Finish();

	iMappings.Unlock();

	#ifdef COARSE_GRAINED_TLB_MAINTENANCE

	// Writable memory objects will have been restricted no access so invalidate TLB.

	if (aRestriction != ERestrictPagesForMovingFlag)

		InvalidateTLB();

	#endif

	}

TInt DMemoryObject::CheckNewMapping(DMemoryMappingBase* aMapping)

	{

	if(iFlags&EDenyPinning && aMapping->IsPinned())

		return KErrAccessDenied;

	if(iFlags&EDenyMappings)

		return KErrAccessDenied;

	if(iFlags&EDenyWriteMappings && !aMapping->IsReadOnly())

		return KErrAccessDenied;

#ifdef MMU_SUPPORTS_EXECUTE_NEVER

	if((iFlags&EDenyExecuteMappings) && aMapping->IsExecutable())

		return KErrAccessDenied;

#endif

	return KErrNone;

	}

TInt DMemoryObject::AddMapping(DMemoryMappingBase* aMapping)

	{

	__NK_ASSERT_DEBUG(!aMapping->IsCoarse());

	// check mapping allowed...

	MmuLock::Lock();

	iMappings.Lock();

	TInt r = CheckNewMapping(aMapping);

	if(r == KErrNone)

		{

		Open();

		aMapping->LinkToMemory(this, iMappings);

		}

	iMappings.Unlock();

	MmuLock::Unlock();

	TRACE(("DMemoryObject[0x%08x]::AddMapping(0x%08x)  returns %d", this, aMapping, r));

	return r;

	}

void DMemoryObject::RemoveMapping(DMemoryMappingBase* aMapping)

	{

	aMapping->UnlinkFromMemory(iMappings);

	Close();

	}

TInt DMemoryObject::SetReadOnly()

	{

	TRACE(("DMemoryObject[0x%08x]::SetReadOnly()",this));

	__NK_ASSERT_DEBUG(MemoryObjectLock::IsHeld(this));

	TInt r = KErrNone;

	iMappings.Lock();

	if (iFlags & EDenyWriteMappings)

		{// The object is already read only.

		iMappings.Unlock();

		return KErrNone;

		}		

	TMappingListIter iter;

	DMemoryMappingBase* mapping = iter.Start(iMappings);

	while(mapping)

		{

		if (!mapping->IsReadOnly())

			{

			r = KErrInUse;

			goto exit;

			}

		// This will flash iMappings.Lock to stop it being held too long.

		// This is safe as new mappings will be added to the end of the list so we

		// won't miss them.

		mapping = iter.Next();

		}

	// Block any writable mapping from being added to this memory object.

	// Use atomic operation as iMappings.Lock protects EDenyWriteMappings

	// but not the whole word.

	__e32_atomic_ior_ord8(&iFlags, (TUint8)EDenyWriteMappings);

exit:

	iter.Finish();

	iMappings.Unlock();

	return r;

	}

void DMemoryObject::DenyMappings()

	{

	TRACE(("DMemoryObject[0x%08x]::LockMappings()",this));

	MmuLock::Lock();

	// Use atomic operation as MmuLock protects EDenyMappings

	// but not the whole word.

	__e32_atomic_ior_ord8(&iFlags, (TUint8)EDenyMappings);

	MmuLock::Unlock();

	}

TInt DMemoryObject::PhysAddr(TUint aIndex, TUint aCount, TPhysAddr& aPhysicalAddress, TPhysAddr* aPhysicalPageList)

	{

	TRACE2(("DMemoryObject[0x%08x]::PhysAddr(0x%x,0x%x,?,?)",this,aIndex,aCount));

	TInt r = iPages.PhysAddr(aIndex,aCount,aPhysicalAddress,aPhysicalPageList);

	TRACE2(("DMemoryObject[0x%08x]::PhysAddr(0x%x,0x%x,?,?) returns %d aPhysicalAddress=0x%08x",this,aIndex,aCount,r,aPhysicalAddress));

	return r;

	}

void DMemoryObject::BTraceCreate()

	{

	BTraceContext8(BTrace::EFlexibleMemModel,BTrace::EMemoryObjectCreate,this,iSizeInPages);

	}

TUint DMemoryObject::PagingManagerData(TUint aIndex)

	{

	TRACE2(("DMemoryObject[0x%08x]::PagingManagerData(0x%x)",this,aIndex));

	__NK_ASSERT_DEBUG(IsDemandPaged());

	TUint value = iPages.PagingManagerData(aIndex);

	TRACE2(("DMemoryObject[0x%08x]::PagingManagerData(0x%x) returns 0x%x",this,aIndex,value));

	return value;

	}

void DMemoryObject::SetPagingManagerData(TUint aIndex, TUint aValue)

	{

	TRACE(("DMemoryObject[0x%08x]::SetPagingManagerData(0x%x,0x%08x)",this,aIndex,aValue));

	__NK_ASSERT_DEBUG(IsDemandPaged());

	iPages.SetPagingManagerData(aIndex, aValue);

	__NK_ASSERT_DEBUG(iPages.PagingManagerData(aIndex)==aValue);

	}

//

// DCoarseMemory::DPageTables

//

DCoarseMemory::DPageTables::DPageTables(DCoarseMemory* aMemory, TInt aNumPts, TUint aPteType)

	: iMemory(aMemory), iPteType(aPteType), iPermanenceCount(0), iNumPageTables(aNumPts)

	{

	aMemory->Open();

	iBlankPte = Mmu::BlankPte(aMemory->Attributes(),aPteType);

	}

DCoarseMemory::DPageTables* DCoarseMemory::DPageTables::New(DCoarseMemory* aMemory, TUint aNumPages, TUint aPteType)

	{

	TRACE2(("DCoarseMemory::DPageTables::New(0x%08x,0x%x,0x%08x)",aMemory, aNumPages, aPteType));

	__NK_ASSERT_DEBUG(MemoryObjectLock::IsHeld(aMemory));

	__NK_ASSERT_DEBUG((aNumPages&(KChunkMask>>KPageShift))==0);

	TUint numPts = aNumPages>>(KChunkShift-KPageShift);

	DPageTables* self = (DPageTables*)Kern::AllocZ(sizeof(DPageTables)+(numPts-1)*sizeof(TPte*));

	if(self)

		{

		new (self) DPageTables(aMemory,numPts,aPteType);

		TInt r = self->Construct();

		if(r!=KErrNone)

			{

			self->Close();

			self = 0;

			}

		}

	TRACE2(("DCoarseMemory::DPageTables::New(0x%08x,0x%x,0x%08x) returns 0x%08x",aMemory, aNumPages, aPteType, self));

	return self;

	}

TInt DCoarseMemory::DPageTables::Construct()

	{

	if(iMemory->IsDemandPaged())

		{

		// do nothing, allow pages to be mapped on demand...

		return KErrNone;

		}