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

// e32\memmodel\epoc\mmubase\mmubase.cpp

// 

//

#include <memmodel/epoc/mmubase/mmubase.h>

#include <mmubase.inl>

#include <ramcache.h>

#include <demand_paging.h>

#include "cache_maintenance.h"

#include "highrestimer.h"

#include <defrag.h>

#include <ramalloc.h>

__ASSERT_COMPILE(sizeof(SPageInfo)==(1<<KPageInfoShift));

_LIT(KLitRamAlloc,"RamAlloc");

_LIT(KLitHwChunk,"HwChunk");

DMutex* MmuBase::HwChunkMutex;

DMutex* MmuBase::RamAllocatorMutex;

#ifdef BTRACE_KERNEL_MEMORY

TInt   Epoc::DriverAllocdPhysRam = 0;

TInt   Epoc::KernelMiscPages = 0;

#endif

/******************************************************************************

 * Code common to all MMU memory models

 ******************************************************************************/

const TInt KFreePagesStepSize=16;

void MmuBase::Panic(TPanic aPanic)

	{

	Kern::Fault("MMUBASE",aPanic);

	}

void SPageInfo::Lock()

	{

	CHECK_PRECONDITIONS(MASK_SYSTEM_LOCKED,"SPageInfo::Lock");

	++iLockCount;

	if(!iLockCount)

		MmuBase::Panic(MmuBase::EPageLockedTooManyTimes);

	}

TInt SPageInfo::Unlock()

	{

	CHECK_PRECONDITIONS(MASK_SYSTEM_LOCKED,"SPageInfo::Unlock");

	if(!iLockCount)

		MmuBase::Panic(MmuBase::EPageUnlockedTooManyTimes);

	return --iLockCount;

	}

#ifdef _DEBUG

void SPageInfo::Set(TType aType, TAny* aOwner, TUint32 aOffset)

	{

	CHECK_PRECONDITIONS(MASK_SYSTEM_LOCKED,"SPageInfo::Set");

	(TUint16&)iType = aType; // also sets iState to EStateNormal

	iOwner = aOwner;

	iOffset = aOffset;

	iModifier = 0;

	}

void SPageInfo::Change(TType aType,TState aState)

	{

	CHECK_PRECONDITIONS(MASK_SYSTEM_LOCKED,"SPageInfo::Change");

	iType = aType;

	iState = aState;

	iModifier = 0;

	}

void SPageInfo::SetState(TState aState)

	{

	CHECK_PRECONDITIONS(MASK_SYSTEM_LOCKED,"SPageInfo::SetState");

	iState = aState;

	iModifier = 0;

	}

void SPageInfo::SetModifier(TAny* aModifier)

	{

	CHECK_PRECONDITIONS(MASK_SYSTEM_LOCKED,"SPageInfo::SetModifier");

	iModifier = aModifier;

	}

TInt SPageInfo::CheckModified(TAny* aModifier)

	{

	CHECK_PRECONDITIONS(MASK_SYSTEM_LOCKED,"SPageInfo::CheckModified");

	return iModifier!=aModifier;

	}

void SPageInfo::SetZone(TUint8 aZoneIndex)

	{

	__ASSERT_ALWAYS(K::Initialising,Kern::Fault("SPageInfo::SetZone",0));

	iZone = aZoneIndex;

	}

#endif

MmuBase::MmuBase()

	: iRamCache(NULL), iDefrag(NULL)

	{

	}

TUint32 MmuBase::RoundToPageSize(TUint32 aSize)

	{

	return (aSize+KPageMask)&~KPageMask;

	}

TUint32 MmuBase::RoundToChunkSize(TUint32 aSize)

	{

	TUint32 mask=TheMmu->iChunkMask;

	return (aSize+mask)&~mask;

	}

TInt MmuBase::RoundUpRangeToPageSize(TUint32& aBase, TUint32& aSize)

	{

	TUint32 mask=KPageMask;

	TUint32 shift=KPageShift;

	TUint32 offset=aBase&mask;

	aBase&=~mask;

	aSize=(aSize+offset+mask)&~mask;

	return TInt(aSize>>shift);

	}

void MmuBase::Wait()

	{

	Kern::MutexWait(*RamAllocatorMutex);

	if (RamAllocatorMutex->iHoldCount==1)

		{

		MmuBase& m=*TheMmu;

		m.iInitialFreeMemory=Kern::FreeRamInBytes();

		m.iAllocFailed=EFalse;

		}

	}

void MmuBase::Signal()

	{

	if (RamAllocatorMutex->iHoldCount>1)

		{

		Kern::MutexSignal(*RamAllocatorMutex);

		return;

		}

	MmuBase& m=*TheMmu;

	TInt initial=m.iInitialFreeMemory;

	TBool failed=m.iAllocFailed;

	TInt final=Kern::FreeRamInBytes();

	Kern::MutexSignal(*RamAllocatorMutex);

	K::CheckFreeMemoryLevel(initial,final,failed);

	}

void MmuBase::WaitHwChunk()

	{

	Kern::MutexWait(*HwChunkMutex);

	}

void MmuBase::SignalHwChunk()

	{

	Kern::MutexSignal(*HwChunkMutex);

	}

void MmuBase::MapRamPage(TLinAddr aAddr, TPhysAddr aPage, TPte aPtePerm)

	{

	__KTRACE_OPT(KMMU,Kern::Printf("MmuBase::MapRamPage %08x@%08x perm %08x", aPage, aAddr, aPtePerm));

	TInt ptid=PageTableId(aAddr);

	NKern::LockSystem();

	MapRamPages(ptid,SPageInfo::EInvalid,0,aAddr,&aPage,1,aPtePerm);

	NKern::UnlockSystem();

	}

//

// Unmap and free pages from a global area

//

void MmuBase::UnmapAndFree(TLinAddr aAddr, TInt aNumPages)

	{

	__KTRACE_OPT(KMMU,Kern::Printf("MmuBase::UnmapAndFree(%08x,%d)",aAddr,aNumPages));

	while(aNumPages)

		{

		TInt pt_np=(iChunkSize-(aAddr&iChunkMask))>>iPageShift;

		TInt np=Min(aNumPages,pt_np);

		aNumPages-=np;

		TInt id=PageTableId(aAddr);

		if (id>=0)

			{

			while(np)

				{

				TInt np2=Min(np,KFreePagesStepSize);

				TPhysAddr phys[KFreePagesStepSize];

				TInt nptes;

				TInt nfree;

				NKern::LockSystem();

				UnmapPages(id,aAddr,np2,phys,true,nptes,nfree,NULL);

				NKern::UnlockSystem();

				if (nfree)

					{

					if (iDecommitThreshold)

						CacheMaintenanceOnDecommit(phys, nfree);

					iRamPageAllocator->FreeRamPages(phys,nfree,EPageFixed);

					}

				np-=np2;

				aAddr+=(np2<<iPageShift);

				}

			}

		else

			{

			aAddr+=(np<<iPageShift);

			}

		}

	}

void MmuBase::FreePages(TPhysAddr* aPageList, TInt aCount, TZonePageType aPageType)

	{

	__KTRACE_OPT(KMMU,Kern::Printf("MmuBase::FreePages(%08x,%d)",aPageList,aCount));

	if (!aCount)

		return;

	TBool sync_decommit = (TUint(aCount)<iDecommitThreshold);

	TPhysAddr* ppa=aPageList;

	TPhysAddr* ppaE=ppa+aCount;

	NKern::LockSystem();

	while (ppa<ppaE)

		{

		TPhysAddr pa=*ppa++;

		SPageInfo* pi=SPageInfo::SafeFromPhysAddr(pa);

		if (pi)

			{

			pi->SetUnused();

			if (pi->LockCount())

				ppa[-1]=KPhysAddrInvalid;	// don't free page if it's locked down

			else if (sync_decommit)

				{

				NKern::UnlockSystem();

				CacheMaintenanceOnDecommit(pa);

				NKern::LockSystem();

				}

			}

		if (!sync_decommit)

			NKern::FlashSystem();

		}

	NKern::UnlockSystem();

	if (iDecommitThreshold && !sync_decommit)

		CacheMaintenance::SyncPhysicalCache_All();

	iRamPageAllocator->FreeRamPages(aPageList,aCount, aPageType);

	}

TInt MmuBase::InitPageTableInfo(TInt aId)

	{

	__KTRACE_OPT(KMMU,Kern::Printf("MmuBase::InitPageTableInfo(%x)",aId));

	TInt ptb=aId>>iPtBlockShift;

	if (++iPtBlockCount[ptb]==1)

		{

		// expand page table info array

		TPhysAddr pagePhys;

		if (AllocRamPages(&pagePhys,1, EPageFixed)!=KErrNone)

			{

			__KTRACE_OPT(KMMU,Kern::Printf("Unable to allocate page"));

			iPtBlockCount[ptb]=0;

			iAllocFailed=ETrue;

			return KErrNoMemory;

			}

#ifdef BTRACE_KERNEL_MEMORY

		BTrace4(BTrace::EKernelMemory, BTrace::EKernelMemoryMiscAlloc, 1<<KPageShift);

		++Epoc::KernelMiscPages;

#endif

		TLinAddr pil=PtInfoBlockLinAddr(ptb);

		NKern::LockSystem();

		SPageInfo::FromPhysAddr(pagePhys)->SetPtInfo(ptb);

		NKern::UnlockSystem();

		MapRamPage(pil, pagePhys, iPtInfoPtePerm);

		memclr((TAny*)pil, iPageSize);

		}

	return KErrNone;

	}

TInt MmuBase::DoAllocPageTable(TPhysAddr& aPhysAddr)

//

// Allocate a new page table but don't map it.

// Return page table id and page number/phys address of new page if any.

//

	{

	__KTRACE_OPT(KMMU,Kern::Printf("MmuBase::DoAllocPageTable()"));

#ifdef _DEBUG

	if(K::CheckForSimulatedAllocFail())

		return KErrNoMemory;

#endif

	TInt id=iPageTableAllocator?iPageTableAllocator->Alloc():-1;

	if (id<0)

		{

		// need to allocate a new page

		if (AllocRamPages(&aPhysAddr,1, EPageFixed)!=KErrNone)

			{

			__KTRACE_OPT(KMMU,Kern::Printf("Unable to allocate page"));

			iAllocFailed=ETrue;

			return KErrNoMemory;

			}

		// allocate an ID for the new page

		id=iPageTableLinearAllocator->Alloc();

		if (id>=0)

			{

			id<<=iPtClusterShift;

			__KTRACE_OPT(KMMU,Kern::Printf("Allocated ID %04x",id));

			}

		if (id<0 || InitPageTableInfo(id)!=KErrNone)

			{

			__KTRACE_OPT(KMMU,Kern::Printf("Unable to allocate page table info"));

			iPageTableLinearAllocator->Free(id>>iPtClusterShift);

			if (iDecommitThreshold)

				CacheMaintenanceOnDecommit(aPhysAddr);

			iRamPageAllocator->FreeRamPage(aPhysAddr, EPageFixed);

			iAllocFailed=ETrue;

			return KErrNoMemory;

			}

		// Set up page info for new page

		NKern::LockSystem();

		SPageInfo::FromPhysAddr(aPhysAddr)->SetPageTable(id>>iPtClusterShift);

		NKern::UnlockSystem();

#ifdef BTRACE_KERNEL_MEMORY

		BTrace4(BTrace::EKernelMemory, BTrace::EKernelMemoryMiscAlloc, 1<<KPageShift);

		++Epoc::KernelMiscPages;

#endif

		// mark all subpages other than first as free for use as page tables

		if (iPtClusterSize>1)

			iPageTableAllocator->Free(id+1,iPtClusterSize-1);

		}

	else

		aPhysAddr=KPhysAddrInvalid;

	__KTRACE_OPT(KMMU,Kern::Printf("DoAllocPageTable returns %d (%08x)",id,aPhysAddr));

	PtInfo(id).SetUnused();

	return id;

	}

TInt MmuBase::MapPageTable(TInt aId, TPhysAddr aPhysAddr, TBool aAllowExpand)

	{

	__KTRACE_OPT(KMMU,Kern::Printf("MmuBase::MapPageTable(%d,%08x)",aId,aPhysAddr));

	TLinAddr ptLin=PageTableLinAddr(aId);

	TInt ptg=aId>>iPtGroupShift;

	if (++iPtGroupCount[ptg]==1)

		{

		// need to allocate a new page table

		__ASSERT_ALWAYS(aAllowExpand, Panic(EMapPageTableBadExpand));

		TPhysAddr xptPhys;

		TInt xptid=DoAllocPageTable(xptPhys);

		if (xptid<0)

			{

			__KTRACE_OPT(KMMU,Kern::Printf("Unable to allocate extra page table"));

			iPtGroupCount[ptg]=0;

			return KErrNoMemory;

			}

		if (xptPhys==KPhysAddrInvalid)

			xptPhys=aPhysAddr + ((xptid-aId)<<iPageTableShift);

		BootstrapPageTable(xptid, xptPhys, aId, aPhysAddr);	// initialise XPT and map it

		}

	else

		MapRamPage(ptLin, aPhysAddr, iPtPtePerm);

	return KErrNone;

	}

TInt MmuBase::AllocPageTable()

//

// Allocate a new page table, mapped at the correct linear address.

// Clear all entries to Not Present. Return page table id.

//

	{

	__KTRACE_OPT(KMMU,Kern::Printf("MmuBase::AllocPageTable()"));

	__ASSERT_MUTEX(MmuBase::RamAllocatorMutex);

	TPhysAddr ptPhys;

	TInt id=DoAllocPageTable(ptPhys);

	if (id<0)

		return KErrNoMemory;

	if (ptPhys!=KPhysAddrInvalid)

		{

		TInt r=MapPageTable(id,ptPhys);

		if (r!=KErrNone)

			{

			DoFreePageTable(id);

			SPageInfo* pi=SPageInfo::FromPhysAddr(ptPhys);

			NKern::LockSystem();

			pi->SetUnused();

			NKern::UnlockSystem();

			if (iDecommitThreshold)

				CacheMaintenanceOnDecommit(ptPhys);

			iRamPageAllocator->FreeRamPage(ptPhys, EPageFixed);

			return r;

			}

		}

	ClearPageTable(id);

	__KTRACE_OPT(KMMU,Kern::Printf("AllocPageTable returns %d",id));

	return id;

	}

TBool MmuBase::DoFreePageTable(TInt aId)

//

// Free an empty page table. We assume that all pages mapped by the page table have

// already been unmapped and freed.

//

	{

	__KTRACE_OPT(KMMU,Kern::Printf("MmuBase::DoFreePageTable(%d)",aId));

	SPageTableInfo& s=PtInfo(aId);

	__NK_ASSERT_DEBUG(!s.iCount); // shouldn't have any pages mapped

	s.SetUnused();

	TInt id=aId &~ iPtClusterMask;

	if (iPageTableAllocator)

		{

		iPageTableAllocator->Free(aId);

		if (iPageTableAllocator->NotFree(id,iPtClusterSize))

			{

			// some subpages still in use

			return ETrue;

			}

		__KTRACE_OPT(KMMU,Kern::Printf("Freeing whole page, id=%d",id));

		// whole page is now free

		// remove it from the page table allocator

		iPageTableAllocator->Alloc(id,iPtClusterSize);

		}

	TInt ptb=aId>>iPtBlockShift;

	if (--iPtBlockCount[ptb]==0)

		{

		// shrink page table info array

		TLinAddr pil=PtInfoBlockLinAddr(ptb);

		UnmapAndFree(pil,1);	// remove PTE, null page info, free page

#ifdef BTRACE_KERNEL_MEMORY

		BTrace4(BTrace::EKernelMemory, BTrace::EKernelMemoryMiscFree, 1<<KPageShift);

		--Epoc::KernelMiscPages;

#endif

		}

	// free the page table linear address

	iPageTableLinearAllocator->Free(id>>iPtClusterShift);

	return EFalse;

	}

void MmuBase::FreePageTable(TInt aId)

//

// Free an empty page table. We assume that all pages mapped by the page table have

// already been unmapped and freed.

//

	{

	__KTRACE_OPT(KMMU,Kern::Printf("MmuBase::FreePageTable(%d)",aId));

	if (DoFreePageTable(aId))

		return;

	TInt id=aId &~ iPtClusterMask;

	// calculate linear address of page

	TLinAddr ptLin=PageTableLinAddr(id);

	__KTRACE_OPT(KMMU,Kern::Printf("Page lin %08x",ptLin));

	// unmap and free the page

	UnmapAndFree(ptLin,1);

#ifdef BTRACE_KERNEL_MEMORY

	BTrace4(BTrace::EKernelMemory, BTrace::EKernelMemoryMiscFree, 1<<KPageShift);

	--Epoc::KernelMiscPages;

#endif

	TInt ptg=aId>>iPtGroupShift;

	--iPtGroupCount[ptg];

	// don't shrink the page table mapping for now

	}

TInt MmuBase::AllocPhysicalRam(TInt aSize, TPhysAddr& aPhysAddr, TInt aAlign)

	{

	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::AllocPhysicalRam() size=%x align=%d",aSize,aAlign));

	TInt r=AllocContiguousRam(aSize, aPhysAddr, aAlign);

	if (r!=KErrNone)

		{

		iAllocFailed=ETrue;

		return r;

		}

	TInt n=TInt(TUint32(aSize+iPageMask)>>iPageShift);

	SPageInfo* pI=SPageInfo::FromPhysAddr(aPhysAddr);

	SPageInfo* pE=pI+n;

	for (; pI<pE; ++pI)

		{

		NKern::LockSystem();

		__NK_ASSERT_DEBUG(pI->Type()==SPageInfo::EUnused);

		pI->Lock();

		NKern::UnlockSystem();

		}

	return KErrNone;

	}

/** Attempt to allocate a contiguous block of RAM from the specified zone.

@param aZoneIdList	An array of the IDs of the RAM zones to allocate from.

@param aZoneIdCount	The number of RAM zone IDs listed in aZoneIdList.

@param aSize 		The number of contiguous bytes to allocate

@param aPhysAddr 	The physical address of the start of the contiguous block of 

					memory allocated

@param aAlign		Required alignment

@return KErrNone on success, KErrArgument if zone doesn't exist or aSize is larger than the

size of the RAM zone or KErrNoMemory when the RAM zone is too full.

*/

TInt MmuBase::ZoneAllocPhysicalRam(TUint* aZoneIdList, TUint aZoneIdCount, TInt aSize, TPhysAddr& aPhysAddr, TInt aAlign)

	{

	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::ZoneAllocPhysicalRam() size=0x%x align=%d", aSize, aAlign));

	TInt r = ZoneAllocContiguousRam(aZoneIdList, aZoneIdCount, aSize, aPhysAddr, aAlign);

	if (r!=KErrNone)

		{

		iAllocFailed=ETrue;

		return r;

		}

	TInt n=TInt(TUint32(aSize+iPageMask)>>iPageShift);

	SPageInfo* pI=SPageInfo::FromPhysAddr(aPhysAddr);

	SPageInfo* pE=pI+n;

	for (; pI<pE; ++pI)