// 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)
		{
		NKern::LockSystem();
		__NK_ASSERT_DEBUG(pI->Type()==SPageInfo::EUnused);
		pI->Lock();
		NKern::UnlockSystem();
		}
	return KErrNone;
	}


/** Attempt to allocate discontiguous RAM pages.

@param aNumPages	The number of pages to allocate.
@param aPageList 	Pointer to an array where each element will be the physical 
					address of each page allocated.
@return KErrNone on success, KErrNoMemory otherwise
*/
TInt MmuBase::AllocPhysicalRam(TInt aNumPages, TPhysAddr* aPageList)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::AllocPhysicalRam() numpages=%x", aNumPages));
	TInt r = AllocRamPages(aPageList, aNumPages, EPageFixed);
	if (r!=KErrNone)
		{
		iAllocFailed=ETrue;
		return r;
		}
	TPhysAddr* pageEnd = aPageList + aNumPages;
	for (TPhysAddr* page = aPageList; page < pageEnd; page++)
		{
		SPageInfo* pageInfo = SPageInfo::FromPhysAddr(*page);
		NKern::LockSystem();
		__NK_ASSERT_DEBUG(pageInfo->Type() == SPageInfo::EUnused);
		pageInfo->Lock();
		NKern::UnlockSystem();
		}
	return KErrNone;
	}


/** Attempt to allocate discontiguous RAM pages from the specified RAM zones.

@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 aNumPages	The number of pages to allocate.
@param aPageList 	Pointer to an array where each element will be the physical 
					address of each page allocated.
@return KErrNone on success, KErrArgument if zone doesn't exist or aNumPages is 
larger than the total number of pages in the RAM zone or KErrNoMemory when the RAM 
zone is too full.
*/
TInt MmuBase::ZoneAllocPhysicalRam(TUint* aZoneIdList, TUint aZoneIdCount, TInt aNumPages, TPhysAddr* aPageList)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::ZoneAllocPhysicalRam() numpages 0x%x zones 0x%x", aNumPages, aZoneIdCount));
	TInt r = ZoneAllocRamPages(aZoneIdList, aZoneIdCount, aPageList, aNumPages, EPageFixed);
	if (r!=KErrNone)
		{
		iAllocFailed=ETrue;
		return r;
		}

	TPhysAddr* pageEnd = aPageList + aNumPages;
	for (TPhysAddr* page = aPageList; page < pageEnd; page++)
		{
		SPageInfo* pageInfo = SPageInfo::FromPhysAddr(*page);
		NKern::LockSystem();
		__NK_ASSERT_DEBUG(pageInfo->Type() == SPageInfo::EUnused);
		pageInfo->Lock();
		NKern::UnlockSystem();
		}
	return KErrNone;
	}


TInt MmuBase::FreePhysicalRam(TPhysAddr aPhysAddr, TInt aSize)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::FreePhysicalRam(%08x,%x)",aPhysAddr,aSize));

	TInt n=TInt(TUint32(aSize+iPageMask)>>iPageShift);
	SPageInfo* pI=SPageInfo::FromPhysAddr(aPhysAddr);
	SPageInfo* pE=pI+n;
	for (; pI<pE; ++pI)
		{
		NKern::LockSystem();
		__ASSERT_ALWAYS(pI->Type()==SPageInfo::EUnused && pI->Unlock()==0, Panic(EBadFreePhysicalRam));
		NKern::UnlockSystem();
		}
	TInt r=iRamPageAllocator->FreePhysicalRam(aPhysAddr, aSize);
	return r;
	}

/** Free discontiguous RAM pages that were previously allocated using discontiguous
overload of MmuBase::AllocPhysicalRam() or MmuBase::ZoneAllocPhysicalRam().

Specifying one of the following may cause the system to panic: 
a) an invalid physical RAM address.
b) valid physical RAM addresses where some had not been previously allocated.
c) an adrress not aligned to a page boundary.

@param aNumPages	Number of pages to free
@param aPageList	Array of the physical address of each page to free

@return KErrNone if the operation was successful.
		
*/
TInt MmuBase::FreePhysicalRam(TInt aNumPages, TPhysAddr* aPageList)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::FreePhysicalRam(%08x,%08x)", aNumPages, aPageList));
	
	TPhysAddr* pageEnd = aPageList + aNumPages;
	TInt r = KErrNone;

	for (TPhysAddr* page = aPageList; page < pageEnd && r == KErrNone; page++)
		{
		SPageInfo* pageInfo = SPageInfo::FromPhysAddr(*page);
		NKern::LockSystem();
		__ASSERT_ALWAYS(pageInfo->Type()==SPageInfo::EUnused && pageInfo->Unlock()==0, Panic(EBadFreePhysicalRam));
		NKern::UnlockSystem();
		
		// Free the page
		r = iRamPageAllocator->FreePhysicalRam(*page, KPageSize);
		}
	return r;
	}


TInt MmuBase::ClaimPhysicalRam(TPhysAddr aPhysAddr, TInt aSize)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::ClaimPhysicalRam(%08x,%x)",aPhysAddr,aSize));
	TUint32 pa=aPhysAddr;
	TUint32 size=aSize;
	TInt n=RoundUpRangeToPageSize(pa,size);
	TInt r=iRamPageAllocator->ClaimPhysicalRam(pa, size);
	if (r==KErrNone)
		{
		SPageInfo* pI=SPageInfo::FromPhysAddr(pa);
		SPageInfo* pE=pI+n;
		for (; pI<pE; ++pI)
			{
			NKern::LockSystem();
			__NK_ASSERT_DEBUG(pI->Type()==SPageInfo::EUnused && pI->LockCount()==0);
			pI->Lock();
			NKern::UnlockSystem();
			}
		}
	return r;
	}

/** 
Allocate a set of discontiguous RAM pages from the specified zone.

@param aZoneIdList	The array of IDs of the RAM zones to allocate from.
@param aZoneIdCount	The number of RAM zone IDs in aZoneIdList.
@param aPageList 	Preallocated array of TPhysAddr elements that will receive the
physical address of each page allocated.
@param aNumPages 	The number of pages to allocate.
@param aPageType 	The type of the pages being allocated.

@return KErrNone on success, KErrArgument if a zone of aZoneIdList doesn't exist, 
KErrNoMemory if there aren't enough free pages in the zone
*/
TInt MmuBase::ZoneAllocRamPages(TUint* aZoneIdList, TUint aZoneIdCount, TPhysAddr* aPageList, TInt aNumPages, TZonePageType aPageType)
	{
#ifdef _DEBUG
	if(K::CheckForSimulatedAllocFail())
		return KErrNoMemory;
#endif
	__NK_ASSERT_DEBUG(aPageType == EPageFixed);

	return iRamPageAllocator->ZoneAllocRamPages(aZoneIdList, aZoneIdCount, aPageList, aNumPages, aPageType);
	}


TInt MmuBase::AllocRamPages(TPhysAddr* aPageList, TInt aNumPages, TZonePageType aPageType, TUint aBlockedZoneId, TBool aBlockRest)
	{
#ifdef _DEBUG
	if(K::CheckForSimulatedAllocFail())
		return KErrNoMemory;
#endif
	TInt missing = iRamPageAllocator->AllocRamPages(aPageList, aNumPages, aPageType, aBlockedZoneId, aBlockRest);

	// If missing some pages, ask the RAM cache to donate some of its pages.
	// Don't ask it for discardable pages as those are intended for itself.
	if(missing && aPageType != EPageDiscard && iRamCache->GetFreePages(missing))
		missing = iRamPageAllocator->AllocRamPages(aPageList, aNumPages, aPageType, aBlockedZoneId, aBlockRest);
	return missing ? KErrNoMemory : KErrNone;
	}


TInt MmuBase::AllocContiguousRam(TInt aSize, TPhysAddr& aPhysAddr, TInt aAlign)
	{
#ifdef _DEBUG
	if(K::CheckForSimulatedAllocFail())
		return KErrNoMemory;
#endif
	TUint contigPages = (aSize + KPageSize - 1) >> KPageShift;
	TInt r = iRamPageAllocator->AllocContiguousRam(contigPages, aPhysAddr, aAlign);
	if (r == KErrNoMemory && contigPages > KMaxFreeableContiguousPages)
		{// Allocation failed but as this is a large allocation flush the RAM cache 
		// and reattempt the allocation as large allocation wouldn't discard pages.
		iRamCache->FlushAll();
		r = iRamPageAllocator->AllocContiguousRam(contigPages, aPhysAddr, aAlign);
		}
	return r;
	}


/**
Allocate contiguous RAM from the specified RAM zones.
@param aZoneIdList	An array of IDs of the RAM zones to allocate from
@param aZoneIdCount	The number of IDs listed in aZoneIdList
@param aSize		The number of bytes to allocate
@param aPhysAddr 	Will receive the physical base address of the allocated RAM
@param aAlign 		The log base 2 alginment required
*/
TInt MmuBase::ZoneAllocContiguousRam(TUint* aZoneIdList, TUint aZoneIdCount, TInt aSize, TPhysAddr& aPhysAddr, TInt aAlign)
	{
#ifdef _DEBUG
	if(K::CheckForSimulatedAllocFail())
		return KErrNoMemory;
#endif
	return iRamPageAllocator->ZoneAllocContiguousRam(aZoneIdList, aZoneIdCount, aSize, aPhysAddr, aAlign);
	}

SPageInfo* SPageInfo::SafeFromPhysAddr(TPhysAddr aAddress)
	{
	TUint index = aAddress>>(KPageShift+KPageShift-KPageInfoShift);
	TUint flags = ((TUint8*)KPageInfoMap)[index>>3];
	TUint mask = 1<<(index&7);
	if(!(flags&mask))
		return 0; // no SPageInfo for aAddress
	SPageInfo* info = FromPhysAddr(aAddress);
	if(info->Type()==SPageInfo::EInvalid)
		return 0;
	return info;
	}

/** HAL Function wrapper for the RAM allocator.
 */

TInt RamHalFunction(TAny*, TInt aFunction, TAny* a1, TAny* a2)
	{
	DRamAllocator *pRamAlloc = MmuBase::TheMmu->iRamPageAllocator;
	
	if (pRamAlloc)
		return pRamAlloc->HalFunction(aFunction, a1, a2);
	return KErrNotSupported;
	}


/******************************************************************************
 * Initialisation
 ******************************************************************************/

void MmuBase::Init1()
	{
	__KTRACE_OPT2(KBOOT,KMMU,Kern::Printf("MmuBase::Init1"));
	iInitialFreeMemory=0;
	iAllocFailed=EFalse;
	}

void MmuBase::Init2()
	{
	__KTRACE_OPT2(KBOOT,KMMU,Kern::Printf("MmuBase::Init2"));
	TInt total_ram=TheSuperPage().iTotalRamSize;
	TInt total_ram_pages=total_ram>>iPageShift;
	iNumPages = total_ram_pages;
	const SRamInfo& info=*(const SRamInfo*)TheSuperPage().iRamBootData;
	iRamPageAllocator=DRamAllocator::New(info, RamZoneConfig, RamZoneCallback);

	TInt max_pt=total_ram>>iPageTableShift;
	if (max_pt<iMaxPageTables)
		iMaxPageTables=max_pt;
	iMaxPageTables &= ~iPtClusterMask;
	__KTRACE_OPT2(KBOOT,KMMU,Kern::Printf("iMaxPageTables=%d",iMaxPageTables));
	TInt max_ptpg=iMaxPageTables>>iPtClusterShift;
	__KTRACE_OPT2(KBOOT,KMMU,Kern::Printf("max_ptpg=%d",max_ptpg));
	iPageTableLinearAllocator=TBitMapAllocator::New(max_ptpg,ETrue);
	__KTRACE_OPT2(KBOOT,KMMU,Kern::Printf("iPageTableLinearAllocator=%08x",iPageTableLinearAllocator));
	__ASSERT_ALWAYS(iPageTableLinearAllocator,Panic(EPtLinAllocCreateFailed));
	if (iPtClusterShift)	// if more than one page table per page
		{
		iPageTableAllocator=TBitMapAllocator::New(iMaxPageTables,EFalse);
		__KTRACE_OPT2(KBOOT,KMMU,Kern::Printf("iPageTableAllocator=%08x",iPageTableAllocator));
		__ASSERT_ALWAYS(iPageTableAllocator,Panic(EPtAllocCreateFailed));
		}
	TInt max_ptb=(iMaxPageTables+iPtBlockMask)>>iPtBlockShift;
	__KTRACE_OPT2(KBOOT,KMMU,Kern::Printf("max_ptb=%d",max_ptb));
	iPtBlockCount=(TInt*)Kern::AllocZ(max_ptb*sizeof(TInt));
	__KTRACE_OPT2(KBOOT,KMMU,Kern::Printf("iPtBlockCount=%08x",iPtBlockCount));
	__ASSERT_ALWAYS(iPtBlockCount,Panic(EPtBlockCountCreateFailed));
	TInt max_ptg=(iMaxPageTables+iPtGroupMask)>>iPtGroupShift;
	__KTRACE_OPT2(KBOOT,KMMU,Kern::Printf("ptg_shift=%d, max_ptg=%d",iPtGroupShift,max_ptg));
	iPtGroupCount=(TInt*)Kern::AllocZ(max_ptg*sizeof(TInt));
	__KTRACE_OPT2(KBOOT,KMMU,Kern::Printf("iPtGroupCount=%08x",iPtGroupCount));
	__ASSERT_ALWAYS(iPtGroupCount,Panic(EPtGroupCountCreateFailed));


	// Clear the inital (and only so far) page table info page so all unused
	// page tables will be marked as unused.
	memclr((TAny*)KPageTableInfoBase, KPageSize);

	// look for page tables - assume first page table (id=0) maps page tables
	TPte* pPte=(TPte*)iPageTableLinBase;
	TInt i;
	for (i=0; i<iChunkSize/iPageSize; ++i)
		{
		TPte pte=*pPte++;
		if (!PteIsPresent(pte))	// after boot, page tables are contiguous
			break;
		iPageTableLinearAllocator->Alloc(i,1);
		TPhysAddr ptpgPhys=PtePhysAddr(pte, i);
		SPageInfo* pi = SPageInfo::SafeFromPhysAddr(ptpgPhys);
		__ASSERT_ALWAYS(pi, Panic(EInvalidPageTableAtBoot));
		pi->SetPageTable(i);
		pi->Lock();
		TInt id=i<<iPtClusterShift;
		TInt ptb=id>>iPtBlockShift;
		++iPtBlockCount[ptb];
		TInt ptg=id>>iPtGroupShift;
		++iPtGroupCount[ptg];
		}

	// look for mapped pages
	TInt npdes=1<<(32-iChunkShift);
	TInt npt=0;
	for (i=0; i<npdes; ++i)
		{
		TLinAddr cAddr=TLinAddr(i<<iChunkShift);
		if (cAddr>=PP::RamDriveStartAddress && TUint32(cAddr-PP::RamDriveStartAddress)<TUint32(PP::RamDriveRange))
			continue;	// leave RAM drive for now
		TInt ptid=PageTableId(cAddr);
		TPhysAddr pdePhys = PdePhysAddr(cAddr);	// check for whole PDE mapping
		pPte = NULL;
		if (ptid>=0)
			{
			++npt;
			__KTRACE_OPT(KMMU,Kern::Printf("Addr %08x -> page table %d", cAddr, ptid));
			pPte=(TPte*)PageTableLinAddr(ptid);
			}
#ifdef KMMU
		if (pdePhys != KPhysAddrInvalid)
			{
			__KTRACE_OPT(KMMU,Kern::Printf("Addr %08x -> Whole PDE Phys %08x", cAddr, pdePhys));
			}
#endif
		if (ptid>=0 || pdePhys != KPhysAddrInvalid)
			{
			TInt j;
			TInt np=0;
			for (j=0; j<iChunkSize/iPageSize; ++j)
				{
				TBool present = ETrue;	// all pages present if whole PDE mapping
				TPte pte = 0;
				if (pPte)
					{
					pte = pPte[j];
					present = PteIsPresent(pte);
					}
				if (present)
					{
					++np;
					TPhysAddr pa = pPte ? PtePhysAddr(pte, j) : (pdePhys + (j<<iPageShift));
					SPageInfo* pi = SPageInfo::SafeFromPhysAddr(pa);
					__KTRACE_OPT(KMMU,Kern::Printf("Addr: %08x PA=%08x",
														cAddr+(j<<iPageShift), pa));
					if (pi)	// ignore non-RAM mappings
						{//these pages will never be freed and can't be moved
						TInt r = iRamPageAllocator->MarkPageAllocated(pa, EPageFixed);
						// allow KErrAlreadyExists since it's possible that a page is doubly mapped
						__ASSERT_ALWAYS(r==KErrNone || r==KErrAlreadyExists, Panic(EBadMappedPageAfterBoot));
						SetupInitialPageInfo(pi,cAddr,j);
#ifdef BTRACE_KERNEL_MEMORY
						if(r==KErrNone)
							++Epoc::KernelMiscPages;
#endif
						}
					}
				}
			__KTRACE_OPT(KMMU,Kern::Printf("Addr: %08x #PTEs=%d",cAddr,np));
			if (ptid>=0)
				SetupInitialPageTableInfo(ptid,cAddr,np);
			}
		}

	TInt oddpt=npt & iPtClusterMask;
	if (oddpt)
		oddpt=iPtClusterSize-oddpt;
	__KTRACE_OPT(KBOOT,Kern::Printf("Total page tables %d, left over subpages %d",npt,oddpt));
	if (oddpt)
		iPageTableAllocator->Free(npt,oddpt);

	DoInit2();

	// Save current free RAM size - there can never be more free RAM than this
	TInt max_free = Kern::FreeRamInBytes();
	K::MaxFreeRam = max_free;
	if (max_free < PP::RamDriveMaxSize)
		PP::RamDriveMaxSize = max_free;

	if (K::ColdStart)
		ClearRamDrive(PP::RamDriveStartAddress);
	else
		RecoverRamDrive();

	TInt r=K::MutexCreate((DMutex*&)RamAllocatorMutex, KLitRamAlloc, NULL, EFalse, KMutexOrdRamAlloc);
	if (r!=KErrNone)
		Panic(ERamAllocMutexCreateFailed);
	r=K::MutexCreate((DMutex*&)HwChunkMutex, KLitHwChunk, NULL, EFalse, KMutexOrdHwChunk);
	if (r!=KErrNone)
		Panic(EHwChunkMutexCreateFailed);
	
#ifdef __DEMAND_PAGING__
	if (DemandPaging::RomPagingRequested() || DemandPaging::CodePagingRequested())
		iRamCache = DemandPaging::New();
	else
		iRamCache = new RamCache;
#else
	iRamCache = new RamCache;
#endif
	if (!iRamCache)
		Panic(ERamCacheAllocFailed);
	iRamCache->Init2();
	RamCacheBase::TheRamCache = iRamCache;

	// Get the allocator to signal to the variant which RAM zones are in use so far
	iRamPageAllocator->InitialCallback();
	}

void MmuBase::Init3()
	{
	__KTRACE_OPT2(KBOOT,KMMU,Kern::Printf("MmuBase::Init3"));

	// Initialise demand paging
#ifdef __DEMAND_PAGING__
	M::DemandPagingInit();
#endif

	// Register a HAL Function for the Ram allocator.
	TInt r = Kern::AddHalEntry(EHalGroupRam, RamHalFunction, 0);
	__NK_ASSERT_ALWAYS(r==KErrNone);

	//
	// Perform the intialisation for page moving and RAM defrag object.
	//

	// allocate a page to use as an alt stack
	MmuBase::Wait();
	TPhysAddr stackpage;
	r = AllocPhysicalRam(KPageSize, stackpage);
	MmuBase::Signal();
	if (r!=KErrNone)
		Panic(EDefragStackAllocFailed);

	// map it at a predetermined address
	TInt ptid = PageTableId(KDefragAltStackAddr);
	TPte perm = PtePermissions(EKernelStack);
	NKern::LockSystem();
	MapRamPages(ptid, SPageInfo::EFixed, NULL, KDefragAltStackAddr, &stackpage, 1, perm);
	NKern::UnlockSystem();
	iAltStackBase = KDefragAltStackAddr + KPageSize;

	__KTRACE_OPT(KMMU,Kern::Printf("Allocated defrag alt stack page at %08x, mapped to %08x, base is now %08x", stackpage, KDefragAltStackAddr, iAltStackBase));

	// Create the actual defrag object and initialise it.
	iDefrag = new Defrag;
	if (!iDefrag)
		Panic(EDefragAllocFailed);
	iDefrag->Init3(iRamPageAllocator);
	}

void MmuBase::CreateKernelSection(TLinAddr aEnd, TInt aHwChunkAlign)
	{
	TLinAddr base=(TLinAddr)TheRomHeader().iKernelLimit;
	iKernelSection=TLinearSection::New(base, aEnd);
	__ASSERT_ALWAYS(iKernelSection!=NULL, Panic(ECreateKernelSectionFailed));
	iHwChunkAllocator=THwChunkAddressAllocator::New(aHwChunkAlign, iKernelSection);
	__ASSERT_ALWAYS(iHwChunkAllocator!=NULL, Panic(ECreateHwChunkAllocFailed));
	}

// Recover RAM drive contents after a reset
TInt MmuBase::RecoverRamDrive()
	{
	__KTRACE_OPT(KMMU,Kern::Printf("MmuBase::RecoverRamDrive()"));
	TLinAddr ptlin;
	TLinAddr chunk = PP::RamDriveStartAddress;
	TLinAddr end = chunk + (TLinAddr)PP::RamDriveRange;
	TInt size = 0;
	TInt limit = RoundToPageSize(TheSuperPage().iRamDriveSize);
	for( ; chunk<end; chunk+=iChunkSize)
		{
		if (size==limit)		// have reached end of ram drive
			break;
		TPhysAddr ptphys = 0;
		TInt ptid = BootPageTableId(chunk, ptphys);	// ret KErrNotFound if PDE not present, KErrUnknown if present but as yet unknown page table
		__KTRACE_OPT(KMMU,Kern::Printf("Addr %08x: PTID=%d PTPHYS=%08x", chunk, ptid, ptphys));
		if (ptid==KErrNotFound)
			break;		// no page table so stop here and clear to end of range
		TPhysAddr ptpgphys = ptphys & ~iPageMask;
		TInt r = iRamPageAllocator->MarkPageAllocated(ptpgphys, EPageMovable);
		__KTRACE_OPT(KMMU,Kern::Printf("MPA: r=%d",r));
		if (r==KErrArgument)
			break;		// page table address was invalid - stop here and clear to end of range
		if (r==KErrNone)
			{
			// this page was currently unallocated
			if (ptid>=0)
				break;	// ID has been allocated - bad news - bail here
			ptid = iPageTableLinearAllocator->Alloc();
			__ASSERT_ALWAYS(ptid>=0, Panic(ERecoverRamDriveAllocPTIDFailed));
			SPageInfo* pi = SPageInfo::SafeFromPhysAddr(ptpgphys);
			__ASSERT_ALWAYS(pi, Panic(ERecoverRamDriveBadPageTable));
			pi->SetPageTable(ptid);	// id = cluster number here
			ptid <<= iPtClusterShift;
			MapPageTable(ptid, ptpgphys, EFalse);
			if (iPageTableAllocator)
				iPageTableAllocator->Free(ptid, iPtClusterSize);
			ptid |= ((ptphys>>iPageTableShift)&iPtClusterMask);
			ptlin = PageTableLinAddr(ptid);
			__KTRACE_OPT(KMMU,Kern::Printf("Page table ID %d lin %08x", ptid, ptlin));
			if (iPageTableAllocator)
				iPageTableAllocator->Alloc(ptid, 1);
			}
		else
			{
			// this page was already allocated
			if (ptid<0)
				break;	// ID not allocated - bad news - bail here
			ptlin = PageTableLinAddr(ptid);
			__KTRACE_OPT(KMMU,Kern::Printf("Page table lin %08x", ptlin));
			if (iPageTableAllocator)
				iPageTableAllocator->Alloc(ptid, 1);
			}
		TInt pte_index;
		TBool chunk_inc = 0;
		TPte* page_table = (TPte*)ptlin;
		for (pte_index=0; pte_index<(iChunkSize>>iPageSize); ++pte_index)
			{
			if (size==limit)		// have reached end of ram drive
				break;
			TPte pte = page_table[pte_index];
			if (PteIsPresent(pte))
				{
				TPhysAddr pa=PtePhysAddr(pte, pte_index);
				SPageInfo* pi = SPageInfo::SafeFromPhysAddr(pa);
				if (!pi)
					break;
				TInt r = iRamPageAllocator->MarkPageAllocated(pa, EPageMovable);
				__ASSERT_ALWAYS(r==KErrNone, Panic(ERecoverRamDriveBadPage));
				size+=iPageSize;
				chunk_inc = iChunkSize;
				}
			}
		if (pte_index < (iChunkSize>>iPageSize) )
			{
			// if we recovered pages in this page table, leave it in place
			chunk += chunk_inc;

			// clear from here on
			ClearPageTable(ptid, pte_index);
			break;
			}
		}
	if (chunk < end)
		ClearRamDrive(chunk);
	__KTRACE_OPT(KMMU,Kern::Printf("Recovered RAM drive size %08x",size));
	if (size<TheSuperPage().iRamDriveSize)
		{
		__KTRACE_OPT(KMMU,Kern::Printf("Truncating RAM drive from %08x to %08x", TheSuperPage().iRamDriveSize, size));
		TheSuperPage().iRamDriveSize=size;
		}
	return KErrNone;
	}

TInt MmuBase::AllocShadowPage(TLinAddr aRomAddr)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("MmuBase:AllocShadowPage(%08x)", aRomAddr));
	aRomAddr &= ~iPageMask;
	TPhysAddr orig_phys = KPhysAddrInvalid;
	if (aRomAddr>=iRomLinearBase && aRomAddr<=(iRomLinearEnd-iPageSize))
		orig_phys = LinearToPhysical(aRomAddr);
	__KTRACE_OPT(KMMU,Kern::Printf("OrigPhys = %08x",orig_phys));
	if (orig_phys == KPhysAddrInvalid)
		{
		__KTRACE_OPT(KMMU,Kern::Printf("Invalid ROM address"));
		return KErrArgument;
		}
	SPageInfo* pi = SPageInfo::SafeFromPhysAddr(orig_phys);
	if (pi && pi->Type()==SPageInfo::EShadow)
		{
		__KTRACE_OPT(KMMU,Kern::Printf("ROM address already shadowed"));
		return KErrAlreadyExists;
		}
	TInt ptid = PageTableId(aRomAddr);
	__KTRACE_OPT(KMMU, Kern::Printf("Shadow PTID %d", ptid));
	TInt newptid = -1;
	if (ptid<0)
		{
		newptid = AllocPageTable();
		__KTRACE_OPT(KMMU, Kern::Printf("New shadow PTID %d", newptid));
		if (newptid<0)
			return KErrNoMemory;
		ptid = newptid;
		PtInfo(ptid).SetShadow( (aRomAddr-iRomLinearBase)>>iChunkShift );
		InitShadowPageTable(ptid, aRomAddr, orig_phys);
		}
	TPhysAddr shadow_phys;

	if (AllocRamPages(&shadow_phys, 1, EPageFixed) != KErrNone)
		{
		__KTRACE_OPT(KMMU,Kern::Printf("Unable to allocate page"));
		iAllocFailed=ETrue;
		if (newptid>=0)
			{
			FreePageTable(newptid);
			}
		return KErrNoMemory;
		}
#ifdef BTRACE_KERNEL_MEMORY
	BTrace4(BTrace::EKernelMemory, BTrace::EKernelMemoryMiscAlloc, 1<<KPageShift);
	++Epoc::KernelMiscPages;
#endif
	InitShadowPage(shadow_phys, aRomAddr);	// copy original ROM contents
	NKern::LockSystem();
	Pagify(ptid, aRomAddr);
	MapRamPages(ptid, SPageInfo::EShadow, (TAny*)orig_phys, (aRomAddr-iRomLinearBase), &shadow_phys, 1, iShadowPtePerm);
	NKern::UnlockSystem();
	if (newptid>=0)
		{
		NKern::LockSystem();
		AssignShadowPageTable(newptid, aRomAddr);
		NKern::UnlockSystem();
		}
	FlushShadow(aRomAddr);
	__KTRACE_OPT(KMMU,Kern::Printf("AllocShadowPage successful"));
	return KErrNone;
	}

TInt MmuBase::FreeShadowPage(TLinAddr aRomAddr)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("MmuBase:FreeShadowPage(%08x)", aRomAddr));
	aRomAddr &= ~iPageMask;
	TPhysAddr shadow_phys = KPhysAddrInvalid;
	if (aRomAddr>=iRomLinearBase || aRomAddr<=(iRomLinearEnd-iPageSize))
		shadow_phys = LinearToPhysical(aRomAddr);
	__KTRACE_OPT(KMMU,Kern::Printf("ShadowPhys = %08x",shadow_phys));
	if (shadow_phys == KPhysAddrInvalid)
		{
		__KTRACE_OPT(KMMU,Kern::Printf("Invalid ROM address"));
		return KErrArgument;
		}
	TInt ptid = PageTableId(aRomAddr);
	SPageInfo* pi = SPageInfo::SafeFromPhysAddr(shadow_phys);
	if (ptid<0 || !pi || pi->Type()!=SPageInfo::EShadow)
		{
		__KTRACE_OPT(KMMU,Kern::Printf("No shadow page at this address"));
		return KErrGeneral;
		}
	TPhysAddr orig_phys = (TPhysAddr)pi->Owner();
	DoUnmapShadowPage(ptid, aRomAddr, orig_phys);
	SPageTableInfo& pti = PtInfo(ptid);
	if (pti.Attribs()==SPageTableInfo::EShadow && --pti.iCount==0)
		{
		TInt r = UnassignShadowPageTable(aRomAddr, orig_phys);
		if (r==KErrNone)
			FreePageTable(ptid);
		else
			pti.SetGlobal(aRomAddr>>iChunkShift);
		}

	FreePages(&shadow_phys, 1, EPageFixed);
	__KTRACE_OPT(KMMU,Kern::Printf("FreeShadowPage successful"));
#ifdef BTRACE_KERNEL_MEMORY
	BTrace4(BTrace::EKernelMemory, BTrace::EKernelMemoryMiscFree, 1<<KPageShift);
	--Epoc::KernelMiscPages;
#endif
	return KErrNone;
	}

TInt MmuBase::FreezeShadowPage(TLinAddr aRomAddr)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("MmuBase:FreezeShadowPage(%08x)", aRomAddr));
	aRomAddr &= ~iPageMask;
	TPhysAddr shadow_phys = KPhysAddrInvalid;
	if (aRomAddr>=iRomLinearBase || aRomAddr<=(iRomLinearEnd-iPageSize))
		shadow_phys = LinearToPhysical(aRomAddr);
	__KTRACE_OPT(KMMU,Kern::Printf("ShadowPhys = %08x",shadow_phys));
	if (shadow_phys == KPhysAddrInvalid)
		{
		__KTRACE_OPT(KMMU,Kern::Printf("Invalid ROM address"));
		return KErrArgument;
		}
	TInt ptid = PageTableId(aRomAddr);
	SPageInfo* pi = SPageInfo::SafeFromPhysAddr(shadow_phys);
	if (ptid<0 || pi==0)
		{
		__KTRACE_OPT(KMMU,Kern::Printf("No shadow page at this address"));
		return KErrGeneral;
		}
	DoFreezeShadowPage(ptid, aRomAddr);
	__KTRACE_OPT(KMMU,Kern::Printf("FreezeShadowPage successful"));
	return KErrNone;
	}

TInt MmuBase::CopyToShadowMemory(TLinAddr aDest, TLinAddr aSrc, TUint32 aLength)
	{
	memcpy ((TAny*)aDest, (const TAny*)aSrc, aLength);
	return KErrNone;
	}

void M::BTracePrime(TUint aCategory)
	{
	(void)aCategory;

#ifdef BTRACE_KERNEL_MEMORY
	// Must check for -1 as that is the default value of aCategory for
	// BTrace::Prime() which is intended to prime all categories that are 
	// currently enabled via a single invocation of BTrace::Prime().
	if(aCategory==BTrace::EKernelMemory || (TInt)aCategory == -1)
		{
		NKern::ThreadEnterCS();
		Mmu::Wait();
		BTrace4(BTrace::EKernelMemory,BTrace::EKernelMemoryInitialFree,TheSuperPage().iTotalRamSize);
		BTrace4(BTrace::EKernelMemory,BTrace::EKernelMemoryCurrentFree,Kern::FreeRamInBytes());
		BTrace4(BTrace::EKernelMemory, BTrace::EKernelMemoryMiscAlloc, Epoc::KernelMiscPages<<KPageShift);
		#ifdef __DEMAND_PAGING__
		if (DemandPaging::ThePager) 
			BTrace4(BTrace::EKernelMemory,BTrace::EKernelMemoryDemandPagingCache,DemandPaging::ThePager->iMinimumPageCount << KPageShift);
		#endif
		BTrace8(BTrace::EKernelMemory,BTrace::EKernelMemoryDrvPhysAlloc, Epoc::DriverAllocdPhysRam, -1);
		Mmu::Signal();
		NKern::ThreadLeaveCS();
		}
#endif

#ifdef BTRACE_RAM_ALLOCATOR
	// Must check for -1 as that is the default value of aCategory for
	// BTrace::Prime() which is intended to prime all categories that are 
	// currently enabled via a single invocation of BTrace::Prime().
	if(aCategory==BTrace::ERamAllocator || (TInt)aCategory == -1)
		{
		NKern::ThreadEnterCS();
		Mmu::Wait();
		Mmu::Get().iRamPageAllocator->DoBTracePrime();
		Mmu::Signal();
		NKern::ThreadLeaveCS();
		}
#endif
	}


/******************************************************************************
 * Code common to all virtual memory models
 ******************************************************************************/

void RHeapK::Mutate(TInt aOffset, TInt aMaxLength)
//
// Used by the kernel to mutate a fixed heap into a chunk heap.
//
	{
	iMinLength += aOffset;
	iMaxLength = aMaxLength + aOffset;
	iOffset = aOffset;
	iChunkHandle = (TInt)K::HeapInfo.iChunk;
	iPageSize = M::PageSizeInBytes();
	iGrowBy = iPageSize;
	iFlags = 0;
	}

TInt M::PageSizeInBytes()
	{
	return KPageSize;
	}

TInt MmuBase::FreeRamInBytes()
	{
	TInt free = iRamPageAllocator->FreeRamInBytes();
	if(iRamCache)
		free += iRamCache->NumberOfFreePages()<<iPageShift;
	return free;
	}

/**	Returns the amount of free RAM currently available.

@return The number of bytes of free RAM currently available.
@pre	any context
 */
EXPORT_C TInt Kern::FreeRamInBytes()
	{
	return MmuBase::TheMmu->FreeRamInBytes();
	}


/**	Rounds up the argument to the size of a MMU page.

	To find out the size of a MMU page:
	@code
	size = Kern::RoundToPageSize(1);
	@endcode

	@param aSize Value to round up
	@pre any context
 */
EXPORT_C TUint32 Kern::RoundToPageSize(TUint32 aSize)
	{
	return MmuBase::RoundToPageSize(aSize);
	}


/**	Rounds up the argument to the amount of memory mapped by a MMU page 
	directory entry.

	Chunks occupy one or more consecutive page directory entries (PDE) and
	therefore the amount of linear and physical memory allocated to a chunk is
	always a multiple of the amount of memory mapped by a page directory entry.
 */
EXPORT_C TUint32 Kern::RoundToChunkSize(TUint32 aSize)
	{
	return MmuBase::RoundToChunkSize(aSize);
	}


/**
Allows the variant to specify the details of the RAM zones. This should be invoked 
by the variant in its implementation of the pure virtual function Asic::Init1().

There are some limitations to how the RAM zones can be specified:
- Each RAM zone's address space must be distinct and not overlap with any 
other RAM zone's address space
- Each RAM zone's address space must have a size that is multiples of the 
ASIC's MMU small page size and be aligned to the ASIC's MMU small page size, 
usually 4KB on ARM MMUs.
- When taken together all of the RAM zones must cover the whole of the physical RAM
address space as specified by the bootstrap in the SuperPage members iTotalRamSize
and iRamBootData;.
- There can be no more than KMaxRamZones RAM zones specified by the base port

Note the verification of the RAM zone data is not performed here but by the ram 
allocator later in the boot up sequence.  This is because it is only possible to
verify the zone data once the physical RAM configuration has been read from 
the super page. Any verification errors result in a "RAM-ALLOC" panic 
faulting the kernel during initialisation.

@param aZones Pointer to an array of SRamZone structs containing the details for all 
the zones. The end of the array is specified by an element with an iSize of zero. The array must 
remain in memory at least until the kernel has successfully booted.

@param aCallback Pointer to a call back function that the kernel may invoke to request 
one of the operations specified by TRamZoneOp.

@return KErrNone if successful, otherwise one of the system wide error codes

@see TRamZoneOp
@see SRamZone
@see TRamZoneCallback
*/
EXPORT_C TInt Epoc::SetRamZoneConfig(const SRamZone* aZones, TRamZoneCallback aCallback)
	{
	// Ensure this is only called once and only while we are initialising the kernel
	if (!K::Initialising || MmuBase::RamZoneConfig != NULL)
		{// fault kernel, won't return
		K::Fault(K::EBadSetRamZoneConfig);
		}

	if (NULL == aZones)
		{
		return KErrArgument;
		}
	MmuBase::RamZoneConfig=aZones;
	MmuBase::RamZoneCallback=aCallback;
	return KErrNone;
	}


/**
Modify the specified RAM zone's flags.

This allows the BSP or device driver to configure which type of pages, if any,
can be allocated into a RAM zone by the system.

Note: updating a RAM zone's flags can result in
	1 - memory allocations failing despite there being enough free RAM in the system.
	2 - the methods TRamDefragRequest::EmptyRamZone(), TRamDefragRequest::ClaimRamZone()
	or TRamDefragRequest::DefragRam() never succeeding.

The flag masks KRamZoneFlagDiscardOnly, KRamZoneFlagMovAndDisOnly and KRamZoneFlagNoAlloc
are intended to be used with this method.

@param aId			The ID of the RAM zone to modify.
@param aClearMask	The bit mask to clear, each flag of which must already be set on the RAM zone.
@param aSetMask		The bit mask to set.

@return KErrNone on success, KErrArgument if the RAM zone of aId not found or if 
aSetMask contains invalid flag bits.

@see TRamDefragRequest::EmptyRamZone()
@see TRamDefragRequest::ClaimRamZone()
@see TRamDefragRequest::DefragRam()

@see KRamZoneFlagDiscardOnly
@see KRamZoneFlagMovAndDisOnly
@see KRamZoneFlagNoAlloc
*/
EXPORT_C TInt Epoc::ModifyRamZoneFlags(TUint aId, TUint aClearMask, TUint aSetMask)
	{
	MmuBase& m = *MmuBase::TheMmu;
	MmuBase::Wait();

	TInt ret = m.ModifyRamZoneFlags(aId, aClearMask, aSetMask);

	MmuBase::Signal();
	return ret;
	}

TInt MmuBase::ModifyRamZoneFlags(TUint aId, TUint aClearMask, TUint aSetMask)
	{
	return iRamPageAllocator->ModifyZoneFlags(aId, aClearMask, aSetMask);
	}


/**
Gets the current count of a particular RAM zone's pages by type.

@param aId The ID of the RAM zone to enquire about
@param aPageData If successful, on return this contains the page count

@return KErrNone if successful, KErrArgument if a RAM zone of aId is not found or
one of the system wide error codes 

@pre Calling thread must be in a critical section.
@pre Interrupts must be enabled.
@pre Kernel must be unlocked.
@pre No fast mutex can be held.
@pre Call in a thread context.

@see SRamZonePageCount
*/
EXPORT_C TInt Epoc::GetRamZonePageCount(TUint aId, SRamZonePageCount& aPageData)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Epoc::GetRamZonePageCount");

	MmuBase& m = *MmuBase::TheMmu;
	MmuBase::Wait(); // Gets RAM alloc mutex

	TInt r = m.GetRamZonePageCount(aId, aPageData);

	MmuBase::Signal();	

	return r;
	}

TInt MmuBase::GetRamZonePageCount(TUint aId, SRamZonePageCount& aPageData)
	{
	return iRamPageAllocator->GetZonePageCount(aId, aPageData);
	}

/**
Replace a page of the system's execute-in-place (XIP) ROM image with a page of
RAM having the same contents. This RAM can subsequently be written to in order
to apply patches to the XIP ROM or to insert software breakpoints for debugging
purposes.
Call Epoc::FreeShadowPage() when you wish to revert to the original ROM page.

@param	aRomAddr	The virtual address of the ROM page to be replaced.
@return	KErrNone if the operation completed successfully.
		KErrArgument if the specified address is not a valid XIP ROM address.
		KErrNoMemory if the operation failed due to insufficient free RAM.
		KErrAlreadyExists if the XIP ROM page at the specified address has
			already been shadowed by a RAM page.

@pre Calling thread must be in a critical section.
@pre Interrupts must be enabled.
@pre Kernel must be unlocked.
@pre No fast mutex can be held.
@pre Call in a thread context.
*/
EXPORT_C TInt Epoc::AllocShadowPage(TLinAddr aRomAddr)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Epoc::AllocShadowPage");

	TInt r;
	r=M::LockRegion(aRomAddr,1);
	if(r!=KErrNone && r!=KErrNotFound)
		return r;
	MmuBase& m=*MmuBase::TheMmu;
	MmuBase::Wait();
	r=m.AllocShadowPage(aRomAddr);
	MmuBase::Signal();
	if(r!=KErrNone)
		M::UnlockRegion(aRomAddr,1);
	return r;
	}

/**
Copies data into shadow memory. Source data is presumed to be in Kernel memory.

@param	aSrc	Data to copy from.
@param	aDest	Address to copy into.
@param	aLength	Number of bytes to copy. Maximum of 32 bytes of data can be copied.
.
@return	KErrNone 		if the operation completed successfully.
		KErrArgument 	if any part of destination region is not shadow page or
						if aLength is greater then 32 bytes.

@pre Calling thread must be in a critical section.
@pre Interrupts must be enabled.
@pre Kernel must be unlocked.
@pre No fast mutex can be held.
@pre Call in a thread context.
*/
EXPORT_C TInt Epoc::CopyToShadowMemory(TLinAddr aDest, TLinAddr aSrc, TUint32 aLength)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Epoc::CopyToShadowMemory");

	if (aLength>32)
		return KErrArgument;
	MmuBase& m=*MmuBase::TheMmu;
	// This is a simple copy operation except on platforms with __CPU_MEMORY_TYPE_REMAPPING defined,
	// where shadow page is read-only and it has to be remapped before it is written into.
	return m.CopyToShadowMemory(aDest, aSrc, aLength);
	}
/**
Revert an XIP ROM address which has previously been shadowed to the original
page of ROM.

@param	aRomAddr	The virtual address of the ROM page to be reverted.
@return	KErrNone if the operation completed successfully.
		KErrArgument if the specified address is not a valid XIP ROM address.
		KErrGeneral if the specified address has not previously been shadowed
			using Epoc::AllocShadowPage().

@pre Calling thread must be in a critical section.
@pre Interrupts must be enabled.
@pre Kernel must be unlocked.
@pre No fast mutex can be held.
@pre Call in a thread context.
*/
EXPORT_C TInt Epoc::FreeShadowPage(TLinAddr aRomAddr)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Epoc::FreeShadowPage");
	MmuBase& m=*MmuBase::TheMmu;
	MmuBase::Wait();
	TInt r=m.FreeShadowPage(aRomAddr);
	MmuBase::Signal();
	if(r==KErrNone)
		M::UnlockRegion(aRomAddr,1);
	return r;
	}


/**
Change the permissions on an XIP ROM address which has previously been shadowed
by a RAM page so that the RAM page may no longer be written to.

Note: Shadow page on the latest platforms (that use the reduced set of access permissions:
arm11mpcore, arm1176, cortex) is implemented with read only permissions. Therefore, calling
this function in not necessary, as shadow page is already created as 'frozen'.

@param	aRomAddr	The virtual address of the shadow RAM page to be frozen.
@return	KErrNone if the operation completed successfully.
		KErrArgument if the specified address is not a valid XIP ROM address.
		KErrGeneral if the specified address has not previously been shadowed
			using Epoc::AllocShadowPage().

@pre Calling thread must be in a critical section.
@pre Interrupts must be enabled.
@pre Kernel must be unlocked.
@pre No fast mutex can be held.
@pre Call in a thread context.
*/
EXPORT_C TInt Epoc::FreezeShadowPage(TLinAddr aRomAddr)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Epoc::FreezeShadowPage");
	MmuBase& m=*MmuBase::TheMmu;
	MmuBase::Wait();
	TInt r=m.FreezeShadowPage(aRomAddr);
	MmuBase::Signal();
	return r;
	}


/**
Allocate a block of physically contiguous RAM with a physical address aligned
to a specified power of 2 boundary.
When the RAM is no longer required it should be freed using
Epoc::FreePhysicalRam()

@param	aSize		The size in bytes of the required block. The specified size
					is rounded up to the page size, since only whole pages of
					physical RAM can be allocated.
@param	aPhysAddr	Receives the physical address of the base of the block on
					successful allocation.
@param	aAlign		Specifies the number of least significant bits of the
					physical address which are required to be zero. If a value
					less than log2(page size) is specified, page alignment is
					assumed. Pass 0 for aAlign if there are no special alignment
					constraints (other than page alignment).
@return	KErrNone if the allocation was successful.
		KErrNoMemory if a sufficiently large physically contiguous block of free
		RAM	with the specified alignment could not be found.
@pre Calling thread must be in a critical section.
@pre Interrupts must be enabled.
@pre Kernel must be unlocked.
@pre No fast mutex can be held.
@pre Call in a thread context.
@pre Can be used in a device driver.
*/
EXPORT_C TInt Epoc::AllocPhysicalRam(TInt aSize, TPhysAddr& aPhysAddr, TInt aAlign)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Epoc::AllocPhysicalRam");
	MmuBase& m=*MmuBase::TheMmu;
	MmuBase::Wait();
	TInt r=m.AllocPhysicalRam(aSize,aPhysAddr,aAlign);
	if (r == KErrNone)
		{
		// For the sake of platform security we have to clear the memory. E.g. the driver
		// could assign it to a chunk visible to user side.
		m.ClearPages(Kern::RoundToPageSize(aSize)>>m.iPageShift, (TPhysAddr*)(aPhysAddr|1));
#ifdef BTRACE_KERNEL_MEMORY
		TUint size = Kern::RoundToPageSize(aSize);
		BTrace8(BTrace::EKernelMemory, BTrace::EKernelMemoryDrvPhysAlloc, size, aPhysAddr);
		Epoc::DriverAllocdPhysRam += size;
#endif
		}
	MmuBase::Signal();
	return r;
	}

/**
Allocate a block of physically contiguous RAM with a physical address aligned
to a specified power of 2 boundary from the specified zone.
When the RAM is no longer required it should be freed using Epoc::FreePhysicalRam().

Note that this method only repsects the KRamZoneFlagNoAlloc flag and will always attempt
to allocate regardless of whether the other flags are set for the specified RAM zones 
or not.

When the RAM is no longer required it should be freed using Epoc::FreePhysicalRam().

@param 	aZoneId		The ID of the zone to attempt to allocate from.
@param	aSize		The size in bytes of the required block. The specified size
					is rounded up to the page size, since only whole pages of
					physical RAM can be allocated.
@param	aPhysAddr	Receives the physical address of the base of the block on
					successful allocation.
@param	aAlign		Specifies the number of least significant bits of the
					physical address which are required to be zero. If a value
					less than log2(page size) is specified, page alignment is
					assumed. Pass 0 for aAlign if there are no special alignment
					constraints (other than page alignment).
@return	KErrNone if the allocation was successful.
		KErrNoMemory if a sufficiently large physically contiguous block of free
		RAM	with the specified alignment could not be found within the specified 
		zone.
		KErrArgument if a RAM zone of the specified ID can't be found or if the
		RAM zone has a total number of physical pages which is less than those 
		requested for the allocation.

@pre Calling thread must be in a critical section.
@pre Interrupts must be enabled.
@pre Kernel must be unlocked.
@pre No fast mutex can be held.
@pre Call in a thread context.
@pre Can be used in a device driver.
*/
EXPORT_C TInt Epoc::ZoneAllocPhysicalRam(TUint aZoneId, TInt aSize, TPhysAddr& aPhysAddr, TInt aAlign)
	{
	return ZoneAllocPhysicalRam(&aZoneId, 1, aSize, aPhysAddr, aAlign);
	}


/**
Allocate a block of physically contiguous RAM with a physical address aligned
to a specified power of 2 boundary from the specified RAM zones.
When the RAM is no longer required it should be freed using Epoc::FreePhysicalRam().

RAM will be allocated into the RAM zones in the order they are specified in the 
aZoneIdList parameter. If the contiguous allocations are intended to span RAM zones 
when required then aZoneIdList should be listed with the RAM zones in ascending 
physical address order.

Note that this method only repsects the KRamZoneFlagNoAlloc flag and will always attempt
to allocate regardless of whether the other flags are set for the specified RAM zones 
or not.

When the RAM is no longer required it should be freed using Epoc::FreePhysicalRam().

@param 	aZoneIdList	A pointer to an array of RAM zone IDs of the RAM zones to 
					attempt to allocate from.
@param 	aZoneIdCount The number of RAM zone IDs contained in aZoneIdList.
@param	aSize		The size in bytes of the required block. The specified size
					is rounded up to the page size, since only whole pages of
					physical RAM can be allocated.
@param	aPhysAddr	Receives the physical address of the base of the block on
					successful allocation.
@param	aAlign		Specifies the number of least significant bits of the
					physical address which are required to be zero. If a value
					less than log2(page size) is specified, page alignment is
					assumed. Pass 0 for aAlign if there are no special alignment
					constraints (other than page alignment).
@return	KErrNone if the allocation was successful.
		KErrNoMemory if a sufficiently large physically contiguous block of free
		RAM	with the specified alignment could not be found within the specified 
		zone.
		KErrArgument if a RAM zone of a specified ID can't be found or if the
		RAM zones have a total number of physical pages which is less than those 
		requested for the allocation.

@pre Calling thread must be in a critical section.
@pre Interrupts must be enabled.
@pre Kernel must be unlocked.
@pre No fast mutex can be held.
@pre Call in a thread context.
@pre Can be used in a device driver.
*/
EXPORT_C TInt Epoc::ZoneAllocPhysicalRam(TUint* aZoneIdList, TUint aZoneIdCount, TInt aSize, TPhysAddr& aPhysAddr, TInt aAlign)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Epoc::ZoneAllocPhysicalRam");
	MmuBase& m=*MmuBase::TheMmu;
	MmuBase::Wait();
	TInt r = m.ZoneAllocPhysicalRam(aZoneIdList, aZoneIdCount, aSize, aPhysAddr, aAlign);
	if (r == KErrNone)
		{
		// For the sake of platform security we have to clear the memory. E.g. the driver
		// could assign it to a chunk visible to user side.
		m.ClearPages(Kern::RoundToPageSize(aSize)>>m.iPageShift, (TPhysAddr*)(aPhysAddr|1));
#ifdef BTRACE_KERNEL_MEMORY
		TUint size = Kern::RoundToPageSize(aSize);
		BTrace8(BTrace::EKernelMemory, BTrace::EKernelMemoryDrvPhysAlloc, size, aPhysAddr);
		Epoc::DriverAllocdPhysRam += size;
#endif
		}
	MmuBase::Signal();
	return r;
	}


/**
Attempt to allocate discontiguous RAM pages.

When the RAM is no longer required it should be freed using Epoc::FreePhysicalRam().

@param	aNumPages	The number of discontiguous pages required to be allocated
@param	aPageList	This should be a pointer to a previously allocated array of
					aNumPages TPhysAddr elements.  On a succesful allocation it 
					will receive the physical addresses of each page allocated.

@return	KErrNone if the allocation was successful.
		KErrNoMemory if the requested number of pages can't be allocated

@pre Calling thread must be in a critical section.
@pre Interrupts must be enabled.
@pre Kernel must be unlocked.
@pre No fast mutex can be held.
@pre Call in a thread context.
@pre Can be used in a device driver.
*/
EXPORT_C TInt Epoc::AllocPhysicalRam(TInt aNumPages, TPhysAddr* aPageList)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL, "Epoc::AllocPhysicalRam");
	MmuBase& m = *MmuBase::TheMmu;
	MmuBase::Wait();
	TInt r = m.AllocPhysicalRam(aNumPages, aPageList);
	if (r == KErrNone)
		{
		// For the sake of platform security we have to clear the memory. E.g. the driver
		// could assign it to a chunk visible to user side.
		m.ClearPages(aNumPages, aPageList);

#ifdef BTRACE_KERNEL_MEMORY
		if (BTrace::CheckFilter(BTrace::EKernelMemory))
			{// Only loop round each page if EKernelMemory tracing is enabled
			TPhysAddr* pAddr = aPageList;
			TPhysAddr* pAddrEnd = aPageList + aNumPages;
			while (pAddr < pAddrEnd)
				{
				BTrace8(BTrace::EKernelMemory, BTrace::EKernelMemoryDrvPhysAlloc, KPageSize, *pAddr++);
				Epoc::DriverAllocdPhysRam += KPageSize;
				}
			}
#endif
		}
	MmuBase::Signal();
	return r;
	}


/**
Attempt to allocate discontiguous RAM pages from the specified zone.

Note that this method only repsects the KRamZoneFlagNoAlloc flag and will always attempt
to allocate regardless of whether the other flags are set for the specified RAM zones 
or not.

When the RAM is no longer required it should be freed using Epoc::FreePhysicalRam().

@param 	aZoneId		The ID of the zone to attempt to allocate from.
@param	aNumPages	The number of discontiguous pages required to be allocated 
					from the specified zone.
@param	aPageList	This should be a pointer to a previously allocated array of
					aNumPages TPhysAddr elements.  On a succesful 
					allocation it will receive the physical addresses of each 
					page allocated.
@return	KErrNone if the allocation was successful.
		KErrNoMemory if the requested number of pages can't be allocated from the 
		specified zone.
		KErrArgument if a RAM zone of the specified ID can't be found or if the
		RAM zone has a total number of physical pages which is less than those 
		requested for the allocation.

@pre Calling thread must be in a critical section.
@pre Interrupts must be enabled.
@pre Kernel must be unlocked.
@pre No fast mutex can be held.
@pre Call in a thread context.
@pre Can be used in a device driver.
*/
EXPORT_C TInt Epoc::ZoneAllocPhysicalRam(TUint aZoneId, TInt aNumPages, TPhysAddr* aPageList)
	{
	return ZoneAllocPhysicalRam(&aZoneId, 1, aNumPages, aPageList);
	}


/**
Attempt to allocate discontiguous RAM pages from the specified RAM zones.
The RAM pages will be allocated into the RAM zones in the order that they are specified 
in the aZoneIdList parameter, the RAM zone preferences will be ignored.

Note that this method only repsects the KRamZoneFlagNoAlloc flag and will always attempt
to allocate regardless of whether the other flags are set for the specified RAM zones 
or not.

When the RAM is no longer required it should be freed using Epoc::FreePhysicalRam().

@param 	aZoneIdList	A pointer to an array of RAM zone IDs of the RAM zones to 
					attempt to allocate from.
@param	aZoneIdCount The number of RAM zone IDs pointed to by aZoneIdList.
@param	aNumPages	The number of discontiguous pages required to be allocated 
					from the specified zone.
@param	aPageList	This should be a pointer to a previously allocated array of
					aNumPages TPhysAddr elements.  On a succesful 
					allocation it will receive the physical addresses of each 
					page allocated.
@return	KErrNone if the allocation was successful.
		KErrNoMemory if the requested number of pages can't be allocated from the 
		specified zone.
		KErrArgument if a RAM zone of a specified ID can't be found or if the
		RAM zones have a total number of physical pages which is less than those 
		requested for the allocation.

@pre Calling thread must be in a critical section.
@pre Interrupts must be enabled.
@pre Kernel must be unlocked.
@pre No fast mutex can be held.
@pre Call in a thread context.
@pre Can be used in a device driver.
*/
EXPORT_C TInt Epoc::ZoneAllocPhysicalRam(TUint* aZoneIdList, TUint aZoneIdCount, TInt aNumPages, TPhysAddr* aPageList)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL, "Epoc::ZoneAllocPhysicalRam");
	MmuBase& m = *MmuBase::TheMmu;
	MmuBase::Wait();
	TInt r = m.ZoneAllocPhysicalRam(aZoneIdList, aZoneIdCount, aNumPages, aPageList);
	if (r == KErrNone)
		{
		// For the sake of platform security we have to clear the memory. E.g. the driver
		// could assign it to a chunk visible to user side.
		m.ClearPages(aNumPages, aPageList);

#ifdef BTRACE_KERNEL_MEMORY
		if (BTrace::CheckFilter(BTrace::EKernelMemory))
			{// Only loop round each page if EKernelMemory tracing is enabled
			TPhysAddr* pAddr = aPageList;
			TPhysAddr* pAddrEnd = aPageList + aNumPages;
			while (pAddr < pAddrEnd)
				{
				BTrace8(BTrace::EKernelMemory, BTrace::EKernelMemoryDrvPhysAlloc, KPageSize, *pAddr++);
				Epoc::DriverAllocdPhysRam += KPageSize;
				}
			}
#endif
		}
	MmuBase::Signal();
	return r;
	}

/**
Free a previously-allocated block of physically contiguous RAM.

Specifying one of the following may cause the system to panic: 
a) an invalid physical RAM address.
b) valid physical RAM addresses where some had not been previously allocated.
c) an adrress not aligned to a page boundary.

@param	aPhysAddr	The physical address of the base of the block to be freed.
					This must be the address returned by a previous call to
					Epoc::AllocPhysicalRam(), Epoc::ZoneAllocPhysicalRam(), 
					Epoc::ClaimPhysicalRam() or Epoc::ClaimRamZone().
@param	aSize		The size in bytes of the required block. The specified size
					is rounded up to the page size, since only whole pages of
					physical RAM can be allocated.
@return	KErrNone if the operation was successful.



@pre Calling thread must be in a critical section.
@pre Interrupts must be enabled.
@pre Kernel must be unlocked.
@pre No fast mutex can be held.
@pre Call in a thread context.
@pre Can be used in a device driver.
*/
EXPORT_C TInt Epoc::FreePhysicalRam(TPhysAddr aPhysAddr, TInt aSize)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Epoc::FreePhysicalRam");
	MmuBase& m=*MmuBase::TheMmu;
	MmuBase::Wait();
	TInt r=m.FreePhysicalRam(aPhysAddr,aSize);
#ifdef BTRACE_KERNEL_MEMORY
	if (r == KErrNone)
		{
		TUint size = Kern::RoundToPageSize(aSize);
		BTrace8(BTrace::EKernelMemory, BTrace::EKernelMemoryDrvPhysFree, size, aPhysAddr);
		Epoc::DriverAllocdPhysRam -= size;
		}
#endif
	MmuBase::Signal();
	return r;
	}


/**
Free a number of physical RAM pages that were previously allocated using
Epoc::AllocPhysicalRam() or Epoc::ZoneAllocPhysicalRam().

Specifying one of the following may cause the system to panic: 
a) an invalid physical RAM address.
b) valid physical RAM addresses where some had not been previously allocated.
c) an adrress not aligned to a page boundary.

@param	aNumPages	The number of pages to be freed.
@param	aPhysAddr	An array of aNumPages TPhysAddr elements.  Where each element
					should contain the physical address of each page to be freed.
					This must be the same set of addresses as those returned by a 
					previous call to Epoc::AllocPhysicalRam() or 
					Epoc::ZoneAllocPhysicalRam().
@return	KErrNone if the operation was successful.
  
@pre Calling thread must be in a critical section.
@pre Interrupts must be enabled.
@pre Kernel must be unlocked.
@pre No fast mutex can be held.
@pre Call in a thread context.
@pre Can be used in a device driver.
		
*/
EXPORT_C TInt Epoc::FreePhysicalRam(TInt aNumPages, TPhysAddr* aPageList)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Epoc::FreePhysicalRam");
	MmuBase& m=*MmuBase::TheMmu;
	MmuBase::Wait();
	TInt r=m.FreePhysicalRam(aNumPages, aPageList);
#ifdef BTRACE_KERNEL_MEMORY
	if (r == KErrNone && BTrace::CheckFilter(BTrace::EKernelMemory))
		{// Only loop round each page if EKernelMemory tracing is enabled
		TPhysAddr* pAddr = aPageList;
		TPhysAddr* pAddrEnd = aPageList + aNumPages;
		while (pAddr < pAddrEnd)
			{
			BTrace8(BTrace::EKernelMemory, BTrace::EKernelMemoryDrvPhysFree, KPageSize, *pAddr++);
			Epoc::DriverAllocdPhysRam -= KPageSize;
			}
		}
#endif
	MmuBase::Signal();
	return r;
	}


/**
Allocate a specific block of physically contiguous RAM, specified by physical
base address and size.
If and when the RAM is no longer required it should be freed using
Epoc::FreePhysicalRam()

@param	aPhysAddr	The physical address of the base of the required block.
@param	aSize		The size in bytes of the required block. The specified size
					is rounded up to the page size, since only whole pages of
					physical RAM can be allocated.
@return	KErrNone if the operation was successful.
		KErrArgument if the range of physical addresses specified included some
					which are not valid physical RAM addresses.
		KErrInUse	if the range of physical addresses specified are all valid
					physical RAM addresses but some of them have already been
					allocated for other purposes.
@pre Calling thread must be in a critical section.
@pre Interrupts must be enabled.
@pre Kernel must be unlocked.
@pre No fast mutex can be held.
@pre Call in a thread context.
@pre Can be used in a device driver.
*/
EXPORT_C TInt Epoc::ClaimPhysicalRam(TPhysAddr aPhysAddr, TInt aSize)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Epoc::ClaimPhysicalRam");
	MmuBase& m=*MmuBase::TheMmu;
	MmuBase::Wait();
	TInt r=m.ClaimPhysicalRam(aPhysAddr,aSize);
#ifdef BTRACE_KERNEL_MEMORY
	if(r==KErrNone)
		{
		TUint32 pa=aPhysAddr;
		TUint32 size=aSize;
		m.RoundUpRangeToPageSize(pa,size);
		BTrace8(BTrace::EKernelMemory, BTrace::EKernelMemoryDrvPhysAlloc, size, pa);
		Epoc::DriverAllocdPhysRam += size;
		}
#endif
	MmuBase::Signal();
	return r;
	}


/**
Translate a virtual address to the corresponding physical address.

@param	aLinAddr	The virtual address to be translated.
@return	The physical address corresponding to the given virtual address, or
		KPhysAddrInvalid if the specified virtual address is unmapped.
@pre Interrupts must be enabled.
@pre Kernel must be unlocked.
@pre Call in a thread context.
@pre Can be used in a device driver.
@pre Hold system lock if there is any possibility that the virtual address is
		unmapped, may become unmapped, or may be remapped during the operation.
	This will potentially be the case unless the virtual address refers to a
	hardware chunk or shared chunk under the control of the driver calling this
	function.
*/
EXPORT_C TPhysAddr Epoc::LinearToPhysical(TLinAddr aLinAddr)
	{
//	This precondition is violated by various parts of the system under some conditions,
//	e.g. when __FLUSH_PT_INTO_RAM__ is defined. This function might also be called by
//	a higher-level RTOS for which these conditions are meaningless. Thus, it's been
//	disabled for now.
//	CHECK_PRECONDITIONS(MASK_KERNEL_UNLOCKED|MASK_INTERRUPTS_ENABLED|MASK_NOT_ISR|MASK_NOT_IDFC,"Epoc::LinearToPhysical");
	MmuBase& m=*MmuBase::TheMmu;
	TPhysAddr pa=m.LinearToPhysical(aLinAddr);
	return pa;
	}


EXPORT_C TInt TInternalRamDrive::MaxSize()
	{
	return TheSuperPage().iRamDriveSize+Kern::FreeRamInBytes();
	}


/******************************************************************************
 * Address allocator
 ******************************************************************************/
TLinearSection* TLinearSection::New(TLinAddr aBase, TLinAddr aEnd)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("TLinearSection::New(%08x,%08x)", aBase, aEnd));
	MmuBase& m=*MmuBase::TheMmu;
	TUint npdes=(aEnd-aBase)>>m.iChunkShift;
	TInt nmapw=(npdes+31)>>5;
	TInt memsz=sizeof(TLinearSection)+(nmapw-1)*sizeof(TUint32);
	TLinearSection* p=(TLinearSection*)Kern::Alloc(memsz);
	if (p)
		{
		new(&p->iAllocator) TBitMapAllocator(npdes, ETrue);
		p->iBase=aBase;
		p->iEnd=aEnd;
		}
	__KTRACE_OPT(KMMU,Kern::Printf("TLinearSection at %08x", p));
	return p;
	}

/******************************************************************************
 * Address allocator for HW chunks
 ******************************************************************************/
THwChunkPageTable::THwChunkPageTable(TInt aIndex, TInt aSize, TPde aPdePerm)
	:	THwChunkRegion(aIndex, 0, aPdePerm),
		iAllocator(aSize, ETrue)
	{
	}

THwChunkPageTable* THwChunkPageTable::New(TInt aIndex, TPde aPdePerm)
	{
	__KTRACE_OPT(KMMU, Kern::Printf("THwChunkPageTable::New(%03x,%08x)",aIndex,aPdePerm));
	MmuBase& m=*MmuBase::TheMmu;
	TInt pdepages=m.iChunkSize>>m.iPageShift;
	TInt nmapw=(pdepages+31)>>5;
	TInt memsz=sizeof(THwChunkPageTable)+(nmapw-1)*sizeof(TUint32);
	THwChunkPageTable* p=(THwChunkPageTable*)Kern::Alloc(memsz);
	if (p)
		new (p) THwChunkPageTable(aIndex, pdepages, aPdePerm);
	__KTRACE_OPT(KMMU, Kern::Printf("THwChunkPageTable at %08x",p));
	return p;
	}

THwChunkAddressAllocator::THwChunkAddressAllocator()
	{
	}

THwChunkAddressAllocator* THwChunkAddressAllocator::New(TInt aAlign, TLinearSection* aSection)
	{
	__KTRACE_OPT(KMMU, Kern::Printf("THwChunkAddressAllocator::New(%d,%08x)",aAlign,aSection));
	THwChunkAddressAllocator* p=new THwChunkAddressAllocator;
	if (p)
		{
		p->iAlign=aAlign;
		p->iSection=aSection;
		}
	__KTRACE_OPT(KMMU, Kern::Printf("THwChunkAddressAllocator at %08x",p));
	return p;
	}

THwChunkRegion* THwChunkAddressAllocator::NewRegion(TInt aIndex, TInt aSize, TPde aPdePerm)
	{
	__KTRACE_OPT(KMMU, Kern::Printf("THwChAA::NewRegion(index=%x, size=%x, pde=%08x)",aIndex,aSize,aPdePerm));
	THwChunkRegion* p=new THwChunkRegion(aIndex, aSize, aPdePerm);
	if (p)
		{
		TInt r=InsertInOrder(p, Order);
		__KTRACE_OPT(KMMU, Kern::Printf("p=%08x, insert ret %d",p,r));
		if (r<0)
			delete p, p=NULL;
		}
	__KTRACE_OPT(KMMU, Kern::Printf("THwChAA::NewRegion ret %08x)",p));
	return p;
	}

THwChunkPageTable* THwChunkAddressAllocator::NewPageTable(TInt aIndex, TPde aPdePerm, TInt aInitB, TInt aInitC)
	{
	__KTRACE_OPT(KMMU, Kern::Printf("THwChAA::NewPageTable(index=%x, pde=%08x, iB=%d, iC=%d)",aIndex,aPdePerm,aInitB,aInitC));
	THwChunkPageTable* p=THwChunkPageTable::New(aIndex, aPdePerm);
	if (p)
		{
		TInt r=InsertInOrder(p, Order);
		__KTRACE_OPT(KMMU, Kern::Printf("p=%08x, insert ret %d",p,r));
		if (r<0)
			delete p, p=NULL;
		else
			p->iAllocator.Alloc(aInitB, aInitC);
		}
	__KTRACE_OPT(KMMU, Kern::Printf("THwChAA::NewPageTable ret %08x)",p));
	return p;
	}

TLinAddr THwChunkAddressAllocator::SearchExisting(TInt aNumPages, TInt aPageAlign, TInt aPageOffset, TPde aPdePerm)
	{
	__KTRACE_OPT(KMMU, Kern::Printf("THwChAA::SrchEx np=%03x align=%d offset=%03x pdeperm=%08x",
				aNumPages, aPageAlign, aPageOffset, aPdePerm));
	TInt c=Count();
	if (c==0)
		return 0;	// don't try to access [0] if array empty!
	THwChunkPageTable** pp=(THwChunkPageTable**)&(*this)[0];
	THwChunkPageTable** ppE=pp+c;
	while(pp<ppE)
		{
		THwChunkPageTable* p=*pp++;
		if (p->iRegionSize!=0 || p->iPdePerm!=aPdePerm)
			continue;	// if not page table or PDE permissions wrong, we can't use it
		TInt r=p->iAllocator.AllocAligned(aNumPages, aPageAlign, -aPageOffset, EFalse);
		__KTRACE_OPT(KMMU, Kern::Printf("r=%d", r));
		if (r<0)
			continue;	// not enough space in this page table
		
		// got enough space in existing page table, so use it
		p->iAllocator.Alloc(r, aNumPages);
		MmuBase& m=*MmuBase::TheMmu;
		TLinAddr a = iSection->iBase + (TLinAddr(p->iIndex)<<m.iChunkShift) + (r<<m.iPageShift);
		__KTRACE_OPT(KMMU, Kern::Printf("THwChAA::SrchEx OK, returning %08x", a));
		return a;
		}
	__KTRACE_OPT(KMMU, Kern::Printf("THwChAA::SrchEx not found"));
	return 0;
	}

TLinAddr THwChunkAddressAllocator::Alloc(TInt aSize, TInt aAlign, TInt aOffset, TPde aPdePerm)
	{
	__KTRACE_OPT(KMMU, Kern::Printf("THwChAA::Alloc size=%08x align=%d offset=%08x pdeperm=%08x",
				aSize, aAlign, aOffset, aPdePerm));
	MmuBase& m=*MmuBase::TheMmu;
	TInt npages=(aSize+m.iPageMask)>>m.iPageShift;
	TInt align=Max(aAlign,iAlign);
	if (align>m.iChunkShift)
		return 0;
	TInt aligns=1<<align;
	TInt alignm=aligns-1;
	TInt offset=(aOffset&alignm)>>m.iPageShift;
	TInt pdepages=m.iChunkSize>>m.iPageShift;
	TInt pdepageshift=m.iChunkShift-m.iPageShift;
	MmuBase::WaitHwChunk();
	if (npages<pdepages)
		{
		// for small regions, first try to share an existing page table
		TLinAddr a=SearchExisting(npages, align-m.iPageShift, offset, aPdePerm);
		if (a)
			{
			MmuBase::SignalHwChunk();
			return a;
			}
		}

	// large region or no free space in existing page tables - allocate whole PDEs
	TInt npdes=(npages+offset+pdepages-1)>>pdepageshift;
	__KTRACE_OPT(KMMU, Kern::Printf("Allocate %d PDEs", npdes));
	MmuBase::Wait();
	TInt ix=iSection->iAllocator.AllocConsecutive(npdes, EFalse);
	if (ix>=0)
		iSection->iAllocator.Alloc(ix, npdes);
	MmuBase::Signal();
	TLinAddr a=0;
	if (ix>=0)
		a = iSection->iBase + (TLinAddr(ix)<<m.iChunkShift) + (TLinAddr(offset)<<m.iPageShift);

	// Create bitmaps for each page table and placeholders for section blocks.
	// We only create a bitmap for the first and last PDE and then only if they are not
	// fully occupied by this request
	THwChunkPageTable* first=NULL;
	THwChunkRegion* middle=NULL;
	TInt remain=npages;
	TInt nix=ix;
	if (a && (offset || npages<pdepages))
		{
		// first PDE is bitmap
		TInt first_count = Min(remain, pdepages-offset);
		first=NewPageTable(nix, aPdePerm, offset, first_count);
		++nix;
		remain -= first_count;
		if (!first)
			a=0;
		}
	if (a && remain>=pdepages)
		{
		// next need whole-PDE-block placeholder
		TInt whole_pdes=remain>>pdepageshift;
		middle=NewRegion(nix, whole_pdes, aPdePerm);
		nix+=whole_pdes;
		remain-=(whole_pdes<<pdepageshift);
		if (!middle)
			a=0;
		}
	if (a && remain)
		{
		// need final bitmap section
		if (!NewPageTable(nix, aPdePerm, 0, remain))
			a=0;
		}
	if (!a)
		{
		// alloc failed somewhere - free anything we did create
		if (middle)
			Discard(middle);
		if (first)
			Discard(first);
		if (ix>=0)
			{
			MmuBase::Wait();
			iSection->iAllocator.Free(ix, npdes);
			MmuBase::Signal();
			}
		}
	MmuBase::SignalHwChunk();
	__KTRACE_OPT(KMMU, Kern::Printf("THwChAA::Alloc returns %08x", a));
	return a;
	}

void THwChunkAddressAllocator::Discard(THwChunkRegion* aRegion)
	{
	// remove a region from the array and destroy it
	TInt r=FindInOrder(aRegion, Order);
	if (r>=0)
		Remove(r);
	Kern::Free(aRegion);
	}

TInt THwChunkAddressAllocator::Order(const THwChunkRegion& a1, const THwChunkRegion& a2)
	{
	// order two regions by address
	return a1.iIndex-a2.iIndex;
	}

THwChunkRegion* THwChunkAddressAllocator::Free(TLinAddr aAddr, TInt aSize)
	{
	__KTRACE_OPT(KMMU, Kern::Printf("THwChAA::Free addr=%08x size=%08x", aAddr, aSize));
	__ASSERT_ALWAYS(aAddr>=iSection->iBase && (aAddr+aSize)<=iSection->iEnd,
										MmuBase::Panic(MmuBase::EFreeHwChunkAddrInvalid));
	THwChunkRegion* list=NULL;
	MmuBase& m=*MmuBase::TheMmu;
	TInt ix=(aAddr - iSection->iBase)>>m.iChunkShift;
	TInt remain=(aSize+m.iPageMask)>>m.iPageShift;
	TInt pdepageshift=m.iChunkShift-m.iPageShift;
	TInt offset=(aAddr&m.iChunkMask)>>m.iPageShift;
	THwChunkRegion find(ix, 0, 0);
	MmuBase::WaitHwChunk();
	TInt r=FindInOrder(&find, Order);
	__ASSERT_ALWAYS(r>=0, MmuBase::Panic(MmuBase::EFreeHwChunkAddrInvalid));
	while (remain)
		{
		THwChunkPageTable* p=(THwChunkPageTable*)(*this)[r];
		__ASSERT_ALWAYS(p->iIndex==ix, MmuBase::Panic(MmuBase::EFreeHwChunkIndexInvalid));
		if (p->iRegionSize)
			{
			// multiple-whole-PDE region
			TInt rsz=p->iRegionSize;
			remain-=(rsz<<pdepageshift);
			Remove(r);	// r now indexes following array entry
			ix+=rsz;
			}
		else
			{
			// bitmap region
			TInt n=Min(remain, (1<<pdepageshift)-offset);
			p->iAllocator.Free(offset, n);
			remain-=n;
			++ix;
			if (p->iAllocator.iAvail < p->iAllocator.iSize)
				{
				// bitmap still in use
				offset=0;
				++r;	// r indexes following array entry
				continue;
				}
			Remove(r);	// r now indexes following array entry
			}
		offset=0;
		p->iNext=list;
		list=p;			// chain free region descriptors together
		}
	MmuBase::SignalHwChunk();
	__KTRACE_OPT(KMMU, Kern::Printf("THwChAA::Free returns %08x", list));
	return list;
	}

/********************************************
 * Hardware chunk abstraction
 ********************************************/
THwChunkAddressAllocator* MmuBase::MappingRegion(TUint)
	{
	return iHwChunkAllocator;
	}

TInt MmuBase::AllocateAllPageTables(TLinAddr aLinAddr, TInt aSize, TPde aPdePerm, TInt aMapShift, SPageTableInfo::TAttribs aAttrib)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("AllocateAllPageTables lin=%08x, size=%x, pde=%08x, mapshift=%d attribs=%d",
																aLinAddr, aSize, aPdePerm, aMapShift, aAttrib));
	TInt offset=aLinAddr&iChunkMask;
	TInt remain=aSize;
	TLinAddr a=aLinAddr&~iChunkMask;
	TInt newpts=0;
	for (; remain>0; a+=iChunkSize)
		{
		// don't need page table if a whole PDE mapping is permitted here
		if (aMapShift<iChunkShift || offset || remain<iChunkSize)
			{
			// need to check for a page table at a
			TInt id=PageTableId(a);
			if (id<0)
				{
				// no page table - must allocate one
				id = AllocPageTable();
				if (id<0)
					break;
				// got page table, assign it
				// AssignPageTable(TInt aId, TInt aUsage, TAny* aObject, TLinAddr aAddr, TPde aPdePerm)
				AssignPageTable(id, aAttrib, NULL, a, aPdePerm);
				++newpts;
				}
			}
		remain -= (iChunkSize-offset);
		offset=0;
		}
	if (remain<=0)
		return KErrNone;	// completed OK

	// ran out of memory somewhere - free page tables which were allocated
	for (; newpts; --newpts)
		{
		a-=iChunkSize;
		TInt id=UnassignPageTable(a);
		FreePageTable(id);
		}
	return KErrNoMemory;
	}


/**
Create a hardware chunk object mapping a specified block of physical addresses
with specified access permissions and cache policy.

When the mapping is no longer required, close the chunk using chunk->Close(0);
Note that closing a chunk does not free any RAM pages which were mapped by the
chunk - these must be freed separately using Epoc::FreePhysicalRam().

@param	aChunk	Upon successful completion this parameter receives a pointer to
				the newly created chunk. Upon unsuccessful completion it is
				written with a NULL pointer. The virtual address of the mapping
				can subsequently be discovered using the LinearAddress()
				function on the chunk.
@param	aAddr	The base address of the physical region to be mapped. This will
				be rounded down to a multiple of the hardware page size before
				being used.
@param	aSize	The size of the physical address region to be mapped. This will
				be rounded up to a multiple of the hardware page size before
				being used; the rounding is such that the entire range from
				aAddr to aAddr+aSize-1 inclusive is mapped. For example if
				aAddr=0xB0001FFF, aSize=2 and the hardware page size is 4KB, an
				8KB range of physical addresses from 0xB0001000 to 0xB0002FFF
				inclusive will be mapped.
@param	aMapAttr Mapping attributes required for the mapping. This is formed
				by ORing together values from the TMappingAttributes enumeration
				to specify the access permissions and caching policy.

@pre Calling thread must be in a critical section.
@pre Interrupts must be enabled.
@pre Kernel must be unlocked.
@pre No fast mutex can be held.
@pre Call in a thread context.
@pre Can be used in a device driver.
@see TMappingAttributes
*/
EXPORT_C TInt DPlatChunkHw::New(DPlatChunkHw*& aChunk, TPhysAddr aAddr, TInt aSize, TUint aMapAttr)
	{
	if (aAddr == KPhysAddrInvalid)
		return KErrNotSupported;
	return DoNew(aChunk, aAddr, aSize, aMapAttr);
	}

TInt DPlatChunkHw::DoNew(DPlatChunkHw*& aChunk, TPhysAddr aAddr, TInt aSize, TUint aMapAttr)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"DPlatChunkHw::New");
	__KTRACE_OPT(KMMU,Kern::Printf("DPlatChunkHw::New phys=%08x, size=%x, attribs=%x",aAddr,aSize,aMapAttr));
	if (aSize<=0)
		return KErrArgument;
	MmuBase& m=*MmuBase::TheMmu;
	aChunk=NULL;
	TPhysAddr pa=aAddr!=KPhysAddrInvalid ? aAddr&~m.iPageMask : 0;
	TInt size=((aAddr+aSize+m.iPageMask)&~m.iPageMask)-pa;
	__KTRACE_OPT(KMMU,Kern::Printf("Rounded %08x+%x", pa, size));
	DMemModelChunkHw* pC=new DMemModelChunkHw;
	if (!pC)
		return KErrNoMemory;
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunkHw created at %08x",pC));
	pC->iPhysAddr=aAddr;
	pC->iSize=size;
	TUint mapattr=aMapAttr;
	TPde pdePerm=0;
	TPte ptePerm=0;
	TInt r=m.PdePtePermissions(mapattr, pdePerm, ptePerm);
	if (r==KErrNone)
		{
		pC->iAllocator=m.MappingRegion(mapattr);
		pC->iAttribs=mapattr;	// save actual mapping attributes
		r=pC->AllocateLinearAddress(pdePerm);
		if (r>=0)
			{
			TInt map_shift=r;
			MmuBase::Wait();
			r=m.AllocateAllPageTables(pC->iLinAddr, size, pdePerm, map_shift, SPageTableInfo::EGlobal);
			if (r==KErrNone && aAddr!=KPhysAddrInvalid)
				m.Map(pC->iLinAddr, pa, size, pdePerm, ptePerm, map_shift);
			MmuBase::Signal();
			}
		}
	if (r==KErrNone)
		aChunk=pC;
	else
		pC->Close(NULL);
	return r;
	}

TInt DMemModelChunkHw::AllocateLinearAddress(TPde aPdePerm)
	{
	__KTRACE_OPT(KMMU, Kern::Printf("DMemModelChunkHw::AllocateLinearAddress(%08x)", aPdePerm));
	__KTRACE_OPT(KMMU, Kern::Printf("iAllocator=%08x iPhysAddr=%08x iSize=%08x", iAllocator, iPhysAddr, iSize));
	MmuBase& m=*MmuBase::TheMmu;
	TInt map_shift = (iPhysAddr<0xffffffffu) ? 30 : m.iPageShift;
	for (; map_shift>=m.iPageShift; --map_shift)
		{
		TUint32 map_size = 1<<map_shift;
		TUint32 map_mask = map_size-1;
		if (!(m.iMapSizes & map_size))
			continue;	// map_size is not supported on this hardware
		TPhysAddr base = (iPhysAddr+map_mask) &~ map_mask;	// base rounded up
		TPhysAddr end = (iPhysAddr+iSize)&~map_mask;		// end rounded down
		if ((base-end)<0x80000000u && map_shift>m.iPageShift)
			continue;	// region not big enough to use this mapping size
		__KTRACE_OPT(KMMU, Kern::Printf("Try map size %08x", map_size));
		iLinAddr=iAllocator->Alloc(iSize, map_shift, iPhysAddr, aPdePerm);
		if (iLinAddr)
			break;		// done
		}
	TInt r=iLinAddr ? map_shift : KErrNoMemory;
	__KTRACE_OPT(KMMU, Kern::Printf("iLinAddr=%08x, returning %d", iLinAddr, r));
	return r;
	}

void DMemModelChunkHw::DeallocateLinearAddress()
	{
	__KTRACE_OPT(KMMU, Kern::Printf("DMemModelChunkHw::DeallocateLinearAddress %O", this));
	MmuBase& m=*MmuBase::TheMmu;
	MmuBase::WaitHwChunk();
	THwChunkRegion* rgn=iAllocator->Free(iLinAddr, iSize);
	iLinAddr=0;
	MmuBase::SignalHwChunk();
	TLinAddr base = iAllocator->iSection->iBase;
	TBitMapAllocator& section_allocator = iAllocator->iSection->iAllocator;
	while (rgn)
		{
		MmuBase::Wait();
		if (rgn->iRegionSize)
			{
			// free address range
			__KTRACE_OPT(KMMU, Kern::Printf("Freeing range %03x+%03x", rgn->iIndex, rgn->iRegionSize));
			section_allocator.Free(rgn->iIndex, rgn->iRegionSize);
			
			// Though this is large region, it still can be made up of page tables (not sections).
			// Check each chunk and remove tables in neccessary
			TInt i = 0;
			TLinAddr a = base + (TLinAddr(rgn->iIndex)<<m.iChunkShift);
			for (; i<rgn->iRegionSize ; i++,a+=m.iChunkSize)
				{
				TInt id = m.UnassignPageTable(a);
				if (id>=0)
					m.FreePageTable(id);
				}
			}
		else
			{
			// free address and page table if it exists
			__KTRACE_OPT(KMMU, Kern::Printf("Freeing index %03x", rgn->iIndex));
			section_allocator.Free(rgn->iIndex);
			TLinAddr a = base + (TLinAddr(rgn->iIndex)<<m.iChunkShift);
			TInt id = m.UnassignPageTable(a);
			if (id>=0)
				m.FreePageTable(id);
			}
		MmuBase::Signal();
		THwChunkRegion* free=rgn;
		rgn=rgn->iNext;
		Kern::Free(free);
		}
	}


//
// RamCacheBase
//


RamCacheBase* RamCacheBase::TheRamCache = NULL;


RamCacheBase::RamCacheBase()
	{
	}


void RamCacheBase::Init2()
	{
	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf(">RamCacheBase::Init2"));
	iMmu = MmuBase::TheMmu;
	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf("<RamCacheBase::Init2"));
	}


void RamCacheBase::ReturnToSystem(SPageInfo* aPageInfo)
	{
	__ASSERT_MUTEX(MmuBase::RamAllocatorMutex);
	__ASSERT_SYSTEM_LOCK;
	aPageInfo->SetUnused();
	--iNumberOfFreePages;
	__NK_ASSERT_DEBUG(iNumberOfFreePages>=0);
	// Release system lock before using the RAM allocator.
	NKern::UnlockSystem();
	iMmu->iRamPageAllocator->FreeRamPage(aPageInfo->PhysAddr(), EPageDiscard);
	NKern::LockSystem();
	}


SPageInfo* RamCacheBase::GetPageFromSystem(TUint aBlockedZoneId, TBool aBlockRest)
	{
	__ASSERT_MUTEX(MmuBase::RamAllocatorMutex);
	SPageInfo* pageInfo;
	TPhysAddr pagePhys;
	TInt r = iMmu->iRamPageAllocator->AllocRamPages(&pagePhys,1, EPageDiscard, aBlockedZoneId, aBlockRest);
	if(r==KErrNone)
		{
		NKern::LockSystem();
		pageInfo = SPageInfo::FromPhysAddr(pagePhys);
		pageInfo->Change(SPageInfo::EPagedFree,SPageInfo::EStatePagedDead);
		++iNumberOfFreePages;
		NKern::UnlockSystem();
		}
	else
		pageInfo = NULL;
	return pageInfo;
	}


//
// RamCache
//


void RamCache::Init2()
	{
	__KTRACE_OPT(KBOOT,Kern::Printf(">RamCache::Init2"));
	RamCacheBase::Init2();
	__KTRACE_OPT(KBOOT,Kern::Printf("<RamCache::Init2"));
	}


TInt RamCache::Init3()
	{
	return KErrNone;
	}

void RamCache::RemovePage(SPageInfo& aPageInfo)
	{
	__NK_ASSERT_DEBUG(aPageInfo.Type() == SPageInfo::EPagedCache);
	__NK_ASSERT_DEBUG(aPageInfo.State() == SPageInfo::EStatePagedYoung);
	aPageInfo.iLink.Deque();
	aPageInfo.SetState(SPageInfo::EStatePagedDead);
	}

TBool RamCache::GetFreePages(TInt aNumPages)
	{
	__KTRACE_OPT(KPAGING,Kern::Printf("DP: >GetFreePages %d",aNumPages));
	NKern::LockSystem();

	while(aNumPages>0 && NumberOfFreePages()>=aNumPages)
		{
		// steal a page from cache list and return it to the free pool...
		SPageInfo* pageInfo = SPageInfo::FromLink(iPageList.First()->Deque());
		pageInfo->SetState(SPageInfo::EStatePagedDead);
		SetFree(pageInfo);
		ReturnToSystem(pageInfo);
		--aNumPages;
		}

	NKern::UnlockSystem();
	__KTRACE_OPT(KPAGING,Kern::Printf("DP: <GetFreePages %d",!aNumPages));
	return !aNumPages;
	}


void RamCache::DonateRamCachePage(SPageInfo* aPageInfo)
	{
	SPageInfo::TType type = aPageInfo->Type();
	if(type==SPageInfo::EChunk)
		{
		// Must not donate locked page. An example is DMA transferred memory.
		__NK_ASSERT_DEBUG(!aPageInfo->LockCount());

		aPageInfo->Change(SPageInfo::EPagedCache,SPageInfo::EStatePagedYoung);
		iPageList.Add(&aPageInfo->iLink);
		++iNumberOfFreePages;
		// Update ram allocator counts as this page has changed its type
		DMemModelChunk* chunk = (DMemModelChunk*)aPageInfo->Owner();
		iMmu->iRamPageAllocator->ChangePageType(aPageInfo, chunk->GetPageType(), EPageDiscard);

#ifdef BTRACE_PAGING
		BTraceContext8(BTrace::EPaging, BTrace::EPagingChunkDonatePage, chunk, aPageInfo->Offset());
#endif
		return;
		}
	// allow already donated pages...
	__NK_ASSERT_DEBUG(type==SPageInfo::EPagedCache);
	}


TBool RamCache::ReclaimRamCachePage(SPageInfo* aPageInfo)
	{
	SPageInfo::TType type = aPageInfo->Type();
//	Kern::Printf("DemandPaging::ReclaimRamCachePage %x %d free=%d",aPageInfo,type,iNumberOfFreePages);

	if(type==SPageInfo::EChunk)
		return ETrue; // page already reclaimed

	__NK_ASSERT_DEBUG(type==SPageInfo::EPagedCache);
	__NK_ASSERT_DEBUG(aPageInfo->State()==SPageInfo::EStatePagedYoung);
	// Update ram allocator counts as this page has changed its type
	DMemModelChunk* chunk = (DMemModelChunk*)aPageInfo->Owner();
	iMmu->iRamPageAllocator->ChangePageType(aPageInfo, EPageDiscard, chunk->GetPageType());
	aPageInfo->iLink.Deque();
	--iNumberOfFreePages;
	aPageInfo->Change(SPageInfo::EChunk,SPageInfo::EStateNormal);

#ifdef BTRACE_PAGING
	BTraceContext8(BTrace::EPaging, BTrace::EPagingChunkReclaimPage, chunk, aPageInfo->Offset());
#endif
	return ETrue;
	}


/**
Discard the specified page.
Should only be called on a page if a previous call to IsPageDiscardable()
returned ETrue and the system lock hasn't been released between the calls.

@param aPageInfo The page info of the page to be discarded
@param aBlockedZoneId Not used by this overload.
@param aBlockRest Not used by this overload. 
@return ETrue if page succesfully discarded

@pre System lock held.
@post System lock held.
*/
TBool RamCache::DoDiscardPage(SPageInfo& aPageInfo, TUint aBlockedZoneId, TBool aBlockRest)
	{
	__NK_ASSERT_DEBUG(iNumberOfFreePages > 0);
	RemovePage(aPageInfo);
	SetFree(&aPageInfo);
	ReturnToSystem(&aPageInfo);
	return ETrue;
	}


/**
First stage in discarding a list of pages.

Must ensure that the pages will still be discardable even if system lock is released.
To be used in conjunction with RamCacheBase::DoDiscardPages1().

@param aPageList A NULL terminated list of the pages to be discarded
@return KErrNone on success.

@pre System lock held
@post System lock held
*/
TInt RamCache::DoDiscardPages0(SPageInfo** aPageList)
	{
	__ASSERT_SYSTEM_LOCK;

	SPageInfo* pageInfo;
	while((pageInfo = *aPageList++) != 0)
		{
		RemovePage(*pageInfo);
		}
	return KErrNone;
	}


/**
Final stage in discarding a list of page
Finish discarding the pages previously removed by RamCacheBase::DoDiscardPages0().
This overload doesn't actually need to do anything.

@param aPageList A NULL terminated list of the pages to be discarded
@return KErrNone on success.

@pre System lock held
@post System lock held
*/
TInt RamCache::DoDiscardPages1(SPageInfo** aPageList)
	{
	__ASSERT_SYSTEM_LOCK;
	SPageInfo* pageInfo;
	while((pageInfo = *aPageList++) != 0)
		{
		SetFree(pageInfo);
		ReturnToSystem(pageInfo);
		}
	return KErrNone;
	}


/**
Check whether the specified page can be discarded by the RAM cache.

@param aPageInfo The page info of the page being queried.
@return ETrue when the page can be discarded, EFalse otherwise.
@pre System lock held.
@post System lock held.
*/
TBool RamCache::IsPageDiscardable(SPageInfo& aPageInfo)
	{
	SPageInfo::TType type = aPageInfo.Type();
	SPageInfo::TState state = aPageInfo.State();
	return (type == SPageInfo::EPagedCache && state == SPageInfo::EStatePagedYoung);
	}


/**
@return ETrue when the unmapped page should be freed, EFalse otherwise
*/
TBool RamCache::PageUnmapped(SPageInfo* aPageInfo)
	{
	SPageInfo::TType type = aPageInfo->Type();
//	Kern::Printf("DemandPaging::PageUnmapped %x %d",aPageInfo,type);
	if(type!=SPageInfo::EPagedCache)
		return ETrue;
	SPageInfo::TState state = aPageInfo->State();
	if(state==SPageInfo::EStatePagedYoung)
		{
		// This page will be freed by DChunk::DoDecommit as it was originally 
		// allocated so update page counts in ram allocator
		DMemModelChunk* chunk = (DMemModelChunk*)aPageInfo->Owner();
		iMmu->iRamPageAllocator->ChangePageType(aPageInfo, EPageDiscard, chunk->GetPageType());
		aPageInfo->iLink.Deque();
		--iNumberOfFreePages;
		}
	return ETrue;
	}


void RamCache::Panic(TFault aFault)
	{
	Kern::Fault("RamCache",aFault);
	}

/**
Flush all cache pages.

@pre RAM allocator mutex held
@post RAM allocator mutex held
*/
void RamCache::FlushAll()
	{
	__ASSERT_MUTEX(MmuBase::RamAllocatorMutex);
#ifdef _DEBUG
	// Should always succeed
	__NK_ASSERT_DEBUG(GetFreePages(iNumberOfFreePages));
#else
	GetFreePages(iNumberOfFreePages);
#endif
	}


//
// Demand Paging
//

#ifdef __DEMAND_PAGING__

DemandPaging* DemandPaging::ThePager = 0;
TBool DemandPaging::PseudoRandInitialised = EFalse;
volatile TUint32 DemandPaging::PseudoRandSeed = 0;


void M::DemandPagingInit()
	{
	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf(">M::DemandPagingInit"));
	TInt r = RamCacheBase::TheRamCache->Init3();
	if (r != KErrNone)
		DemandPaging::Panic(DemandPaging::EInitialiseFailed);	

	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf("<M::DemandPagingInit"));
	}


TInt M::DemandPagingFault(TAny* aExceptionInfo)
	{
	DemandPaging* pager = DemandPaging::ThePager;
	if(pager)
		return pager->Fault(aExceptionInfo);
	return KErrAbort;
	}

#ifdef _DEBUG
extern "C" void ASMCheckPagingSafe(TLinAddr aPC, TLinAddr aLR, TLinAddr aStartAddres, TUint aLength)
	{
	if(M::CheckPagingSafe(EFalse, aStartAddres, aLength))
		return;
	Kern::Printf("ASM_ASSERT_PAGING_SAFE FAILED: pc=%x lr=%x",aPC,aLR);
	__NK_ASSERT_ALWAYS(0);
	}

extern "C" void ASMCheckDataPagingSafe(TLinAddr aPC, TLinAddr aLR, TLinAddr aStartAddres, TUint aLength)
	{
	if(M::CheckPagingSafe(ETrue, aStartAddres, aLength))
		return;
	__KTRACE_OPT(KDATAPAGEWARN,Kern::Printf("Data paging: ASM_ASSERT_DATA_PAGING_SAFE FAILED: pc=%x lr=%x",aPC,aLR));
	}
#endif


TBool M::CheckPagingSafe(TBool aDataPaging, TLinAddr aStartAddr, TUint aLength)
	{
	DemandPaging* pager = DemandPaging::ThePager;
	if(!pager || K::Initialising)
		return ETrue;
	
	NThread* nt = NCurrentThread();
	if(!nt)
		return ETrue; // We've not booted properly yet!

	if (!pager->NeedsMutexOrderCheck(aStartAddr, aLength))
		return ETrue;

	TBool dataPagingEnabled = EFalse; // data paging not supported on moving or multiple models

	DThread* thread = _LOFF(nt,DThread,iNThread);
	NFastMutex* fm = NKern::HeldFastMutex();
	if(fm)
		{
		if(!thread->iPagingExcTrap || fm!=&TheScheduler.iLock)
			{
			if (!aDataPaging)
				{
				__KTRACE_OPT2(KPAGING,KPANIC,Kern::Printf("DP: CheckPagingSafe FAILED - FM Held"));
				return EFalse;
				}
			else
				{
				__KTRACE_OPT(KDATAPAGEWARN, Kern::Printf("Data paging: CheckPagingSafe FAILED - FM Held"));
				return !dataPagingEnabled;
				}
			}
		}

	DMutex* m = pager->CheckMutexOrder();
	if (m)
		{
		if (!aDataPaging)
			{
			__KTRACE_OPT2(KPAGING,KPANIC,Kern::Printf("DP: Mutex Order Fault %O",m));
			return EFalse;
			}
		else
			{
			__KTRACE_OPT(KDATAPAGEWARN, Kern::Printf("Data paging: Mutex Order Fault %O",m));
			return !dataPagingEnabled;
			}
		}
	
	return ETrue;
	}


TInt M::LockRegion(TLinAddr aStart,TInt aSize)
	{
	DemandPaging* pager = DemandPaging::ThePager;
	if(pager)
		return pager->LockRegion(aStart,aSize,NULL);
	return KErrNone;
	}


TInt M::UnlockRegion(TLinAddr aStart,TInt aSize)
	{
	DemandPaging* pager = DemandPaging::ThePager;
	if(pager)
		return pager->UnlockRegion(aStart,aSize,NULL);
	return KErrNone;
	}

#else // !__DEMAND_PAGING__

TInt M::LockRegion(TLinAddr /*aStart*/,TInt /*aSize*/)
	{
	return KErrNone;
	}


TInt M::UnlockRegion(TLinAddr /*aStart*/,TInt /*aSize*/)
	{
	return KErrNone;
	}

#endif // __DEMAND_PAGING__




//
// DemandPaging
//

#ifdef __DEMAND_PAGING__


const TUint16 KDefaultYoungOldRatio = 3;
const TUint KDefaultMinPages = 256;
const TUint KDefaultMaxPages = KMaxTUint >> KPageShift;

/*	Need at least 4 mapped pages to guarentee to be able to execute all ARM instructions.
	(Worst case is a THUMB2 STM instruction with both instruction and data stradling page
	boundaries.)
*/
const TUint KMinYoungPages = 4;
const TUint KMinOldPages = 1;

/*	A minimum young/old ratio of 1 means that we need at least twice KMinYoungPages pages...
*/
const TUint KAbsoluteMinPageCount = 2*KMinYoungPages;

__ASSERT_COMPILE(KMinOldPages<=KAbsoluteMinPageCount/2);

class DMissingPagingDevice : public DPagingDevice
	{
	TInt Read(TThreadMessage* /*aReq*/,TLinAddr /*aBuffer*/,TUint /*aOffset*/,TUint /*aSize*/,TInt /*aDrvNumber*/)
		{ DemandPaging::Panic(DemandPaging::EDeviceMissing); return 0; }
	};


TBool DemandPaging::RomPagingRequested()
	{
	return TheRomHeader().iPageableRomSize != 0;
	}


TBool DemandPaging::CodePagingRequested()
	{
	return (TheSuperPage().KernelConfigFlags() & EKernelConfigCodePagingPolicyDefaultPaged) != EKernelConfigCodePagingPolicyNoPaging;
	}


DemandPaging::DemandPaging()
	{
	}


void DemandPaging::Init2()
	{
	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf(">DemandPaging::Init2"));

	RamCacheBase::Init2();

	// initialise live list...
	SDemandPagingConfig config = TheRomHeader().iDemandPagingConfig;

	iMinimumPageCount = KDefaultMinPages;
	if(config.iMinPages)
		iMinimumPageCount = config.iMinPages;
	if(iMinimumPageCount<KAbsoluteMinPageCount)
		iMinimumPageCount = KAbsoluteMinPageCount;
	iInitMinimumPageCount = iMinimumPageCount;

	iMaximumPageCount = KDefaultMaxPages;
	if(config.iMaxPages)
		iMaximumPageCount = config.iMaxPages;
	iInitMaximumPageCount = iMaximumPageCount;

	iYoungOldRatio = KDefaultYoungOldRatio;
	if(config.iYoungOldRatio)
		iYoungOldRatio = config.iYoungOldRatio;
	TInt ratioLimit = (iMinimumPageCount-KMinOldPages)/KMinOldPages;
	if(iYoungOldRatio>ratioLimit)
		iYoungOldRatio = ratioLimit;

	iMinimumPageLimit = (KMinYoungPages * (1 + iYoungOldRatio)) / iYoungOldRatio;
	if(iMinimumPageLimit<KAbsoluteMinPageCount)
		iMinimumPageLimit = KAbsoluteMinPageCount;

	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf(">DemandPaging::InitialiseLiveList min=%d max=%d ratio=%d",iMinimumPageCount,iMaximumPageCount,iYoungOldRatio));

	if(iMaximumPageCount<iMinimumPageCount)
		Panic(EInitialiseBadArgs);

	//
	// This routine doesn't acuire any mutexes because it should be called before the system
	// is fully up and running. I.e. called before another thread can preempt this.
	//

	// Calculate page counts
	iOldCount = iMinimumPageCount/(1+iYoungOldRatio);
	if(iOldCount<KMinOldPages)
		Panic(EInitialiseBadArgs);
	iYoungCount = iMinimumPageCount-iOldCount;
	if(iYoungCount<KMinYoungPages)
		Panic(EInitialiseBadArgs); // Need at least 4 pages mapped to execute an ARM LDM instruction in THUMB2 mode
	iNumberOfFreePages = 0;

	// Allocate RAM pages and put them all on the old list
	iYoungCount = 0;
	iOldCount = 0;
	for(TUint i=0; i<iMinimumPageCount; i++)
		{
		// Allocate a single page
		TPhysAddr pagePhys;
		TInt r = iMmu->iRamPageAllocator->AllocRamPages(&pagePhys,1, EPageDiscard);
		if(r!=0)
			Panic(EInitialiseFailed);
		AddAsFreePage(SPageInfo::FromPhysAddr(pagePhys));
		}

	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf("<DemandPaging::Init2"));
	}


TInt VMHalFunction(TAny*, TInt aFunction, TAny* a1, TAny* a2);

TInt DemandPaging::Init3()
	{
	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf(">DemandPaging::Init3"));
	TInt r;

	// construct iBufferChunk
	iDeviceBufferSize = 2*KPageSize;
	TChunkCreateInfo info;
	info.iType = TChunkCreateInfo::ESharedKernelMultiple;
	info.iMaxSize = iDeviceBufferSize*KMaxPagingDevices;
	info.iMapAttr = EMapAttrCachedMax;
	info.iOwnsMemory = ETrue;
	TUint32 mapAttr;
	r = Kern::ChunkCreate(info,iDeviceBuffersChunk,iDeviceBuffers,mapAttr);
	if(r!=KErrNone)
		return r;

	// Install 'null' paging devices which panic if used...
	DMissingPagingDevice* missingPagingDevice = new DMissingPagingDevice;
	for(TInt i=0; i<KMaxPagingDevices; i++)
		{
		iPagingDevices[i].iInstalled = EFalse;
		iPagingDevices[i].iDevice = missingPagingDevice;
		}

	// Initialise ROM info...
	const TRomHeader& romHeader = TheRomHeader();
	iRomLinearBase = (TLinAddr)&romHeader;
	iRomSize = iMmu->RoundToPageSize(romHeader.iUncompressedSize);
	if(romHeader.iRomPageIndex)
		iRomPageIndex = (SRomPageInfo*)((TInt)&romHeader+romHeader.iRomPageIndex);

	TLinAddr pagedStart = romHeader.iPageableRomSize ? (TLinAddr)&romHeader+romHeader.iPageableRomStart : 0;
	if(pagedStart)
		{
		__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf("ROM=%x+%x PagedStart=%x",iRomLinearBase,iRomSize,pagedStart));
		__NK_ASSERT_ALWAYS(TUint(pagedStart-iRomLinearBase)<TUint(iRomSize));
		iRomPagedLinearBase = pagedStart;
		iRomPagedSize = iRomLinearBase+iRomSize-pagedStart;
		__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf("DemandPaging::Init3, ROM Paged start(0x%x), sixe(0x%x)",iRomPagedLinearBase,iRomPagedSize));

#ifdef __SUPPORT_DEMAND_PAGING_EMULATION__
		// Get physical addresses of ROM pages
		iOriginalRomPageCount = iMmu->RoundToPageSize(iRomSize)>>KPageShift;
		iOriginalRomPages = new TPhysAddr[iOriginalRomPageCount];
		__NK_ASSERT_ALWAYS(iOriginalRomPages);
		TPhysAddr romPhysAddress; 
		iMmu->LinearToPhysical(iRomLinearBase,iRomSize,romPhysAddress,iOriginalRomPages);
#endif
		}

	r = Kern::AddHalEntry(EHalGroupVM, VMHalFunction, 0);
	__NK_ASSERT_ALWAYS(r==KErrNone);

#ifdef __DEMAND_PAGING_BENCHMARKS__
	for (TInt i = 0 ; i < EMaxPagingBm ; ++i)
		ResetBenchmarkData((TPagingBenchmark)i);
#endif

	// Initialisation now complete
	ThePager = this;
	return KErrNone;
	}


DemandPaging::~DemandPaging()
	{
#ifdef __SUPPORT_DEMAND_PAGING_EMULATION__
	delete[] iOriginalRomPages;
#endif
	for (TUint i = 0 ; i < iPagingRequestCount ; ++i)
		delete iPagingRequests[i];
	}


TInt DemandPaging::InstallPagingDevice(DPagingDevice* aDevice)
	{
	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf(">DemandPaging::InstallPagingDevice name='%s' type=%d",aDevice->iName,aDevice->iType));

	if(aDevice->iReadUnitShift>KPageShift)
		Panic(EInvalidPagingDevice);

	TInt i;
	TInt r = KErrNone;
	TBool createRequestObjects = EFalse;
	
	if ((aDevice->iType & DPagingDevice::ERom) && RomPagingRequested())
		{
		r = DoInstallPagingDevice(aDevice, 0);
		if (r != KErrNone)
			goto done;
		K::MemModelAttributes|=EMemModelAttrRomPaging;
		createRequestObjects = ETrue;
		}
	
	if ((aDevice->iType & DPagingDevice::ECode) && CodePagingRequested())
		{
		for (i = 0 ; i < KMaxLocalDrives ; ++i)
			{
			if (aDevice->iDrivesSupported & (1<<i))
				{
				r = DoInstallPagingDevice(aDevice, i + 1);
				if (r != KErrNone)
					goto done;
				}
			}
		K::MemModelAttributes|=EMemModelAttrCodePaging;
		createRequestObjects = ETrue;
		}

	if (createRequestObjects)
		{
		for (i = 0 ; i < KPagingRequestsPerDevice ; ++i)
			{
			r = CreateRequestObject();
			if (r != KErrNone)
				goto done;
			}
		}
	
done:	
	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf("<DemandPaging::InstallPagingDevice returns %d",r));
	return r;
	}

TInt DemandPaging::DoInstallPagingDevice(DPagingDevice* aDevice, TInt aId)
	{
	NKern::LockSystem();
	SPagingDevice* device = &iPagingDevices[aId];
	if((device->iInstalled) && !(aDevice->iType & DPagingDevice::EMediaExtension))
		{
		__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf("**** Attempt to install more than one ROM paging device !!!!!!!! ****"));
		//Panic(EDeviceAlreadyExists);
		NKern::UnlockSystem();
		return KErrNone;
		}	
	
	aDevice->iDeviceId = aId;
	device->iDevice = aDevice;
	device->iInstalled = ETrue;
	NKern::UnlockSystem();
	
	__KTRACE_OPT2(KPAGING,KBOOT,Kern::Printf("DemandPaging::InstallPagingDevice id=%d, device=%08x",aId,device));
	
	return KErrNone;
	}

DemandPaging::DPagingRequest::~DPagingRequest()
	{
	if (iMutex)
		iMutex->Close(NULL);
	}

TInt DemandPaging::CreateRequestObject()
	{
	_LIT(KLitPagingRequest,"PagingRequest-"); 

	TInt index;
	TInt id = (TInt)__e32_atomic_add_ord32(&iNextPagingRequestCount, 1);
	TLinAddr offset = id * iDeviceBufferSize;
	TUint32 physAddr = 0;
	TInt r = Kern::ChunkCommitContiguous(iDeviceBuffersChunk,offset,iDeviceBufferSize, physAddr);
	if(r != KErrNone)
		return r;

	DPagingRequest* req = new DPagingRequest();
	if (!req)
		return KErrNoMemory;

	req->iBuffer = iDeviceBuffers + offset;
	AllocLoadAddress(*req, id);
		
	TBuf<16> mutexName(KLitPagingRequest);
	mutexName.AppendNum(id);
	r = K::MutexCreate(req->iMutex, mutexName, NULL, EFalse, KMutexOrdPageIn);
	if (r!=KErrNone)
		goto done;

	// Ensure there are enough young pages to cope with new request object
	r = ResizeLiveList(iMinimumPageCount, iMaximumPageCount);
	if (r!=KErrNone)
		goto done;

	NKern::LockSystem();
	index = iPagingRequestCount++;
	__NK_ASSERT_ALWAYS(index < KMaxPagingRequests);
	iPagingRequests[index] = req;
	iFreeRequestPool.AddHead(req);
	NKern::UnlockSystem();

done:
	if (r != KErrNone)
		delete req;
	
	return r;
	}

DemandPaging::DPagingRequest* DemandPaging::AcquireRequestObject()
	{
	__ASSERT_SYSTEM_LOCK;	
	__NK_ASSERT_DEBUG(iPagingRequestCount > 0);
	
	DPagingRequest* req = NULL;

	// System lock used to serialise access to our data strucures as we have to hold it anyway when
	// we wait on the mutex

	req = (DPagingRequest*)iFreeRequestPool.GetFirst();
	if (req != NULL)
		__NK_ASSERT_DEBUG(req->iUsageCount == 0);
	else
		{
		// Pick a random request object to wait on
		TUint index = (FastPseudoRand() * TUint64(iPagingRequestCount)) >> 32;
		__NK_ASSERT_DEBUG(index < iPagingRequestCount);
		req = iPagingRequests[index];
		__NK_ASSERT_DEBUG(req->iUsageCount > 0);
		}
	
#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
	++iWaitingCount;
	if (iWaitingCount > iMaxWaitingCount)
		iMaxWaitingCount = iWaitingCount;
#endif

	++req->iUsageCount;
	TInt r = req->iMutex->Wait();
	__NK_ASSERT_ALWAYS(r == KErrNone);

#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
	--iWaitingCount;
	++iPagingCount;
	if (iPagingCount > iMaxPagingCount)
		iMaxPagingCount = iPagingCount;
#endif

	return req;
	}

void DemandPaging::ReleaseRequestObject(DPagingRequest* aReq)
	{
	__ASSERT_SYSTEM_LOCK;

#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
	--iPagingCount;
#endif

	// If there are no threads waiting on the mutex then return it to the free pool
	__NK_ASSERT_DEBUG(aReq->iUsageCount > 0);
	if (--aReq->iUsageCount == 0)
		iFreeRequestPool.AddHead(aReq);

	aReq->iMutex->Signal();
	NKern::LockSystem();
	}

TInt DemandPaging::ReadRomPage(const DPagingRequest* aReq, TLinAddr aRomAddress)
	{
	START_PAGING_BENCHMARK;

	TInt pageSize = KPageSize;
	TInt dataOffset = aRomAddress-iRomLinearBase;
	TInt pageNumber = dataOffset>>KPageShift;
	TInt readUnitShift = RomPagingDevice().iDevice->iReadUnitShift;
	TInt r;
	if(!iRomPageIndex)
		{
		// ROM not broken into pages, so just read it in directly
		START_PAGING_BENCHMARK;
		r = RomPagingDevice().iDevice->Read(const_cast<TThreadMessage*>(&aReq->iMessage),aReq->iLoadAddr,dataOffset>>readUnitShift,pageSize>>readUnitShift,-1/*token for ROM paging*/);
		END_PAGING_BENCHMARK(DemandPaging::ThePager, EPagingBmReadMedia);
		}
	else
		{
		// Work out where data for page is located
		SRomPageInfo* romPageInfo = iRomPageIndex+pageNumber;
		dataOffset = romPageInfo->iDataStart;
		TInt dataSize = romPageInfo->iDataSize;
		if(!dataSize)
			{
			// empty page, fill it with 0xff...
			memset((void*)aReq->iLoadAddr,-1,pageSize);
			r = KErrNone;
			}
		else
			{
			__NK_ASSERT_ALWAYS(romPageInfo->iPagingAttributes&SRomPageInfo::EPageable);

			// Read data for page...
			TThreadMessage* msg= const_cast<TThreadMessage*>(&aReq->iMessage);
			TLinAddr buffer = aReq->iBuffer;
			TUint readStart = dataOffset>>readUnitShift;
			TUint readSize = ((dataOffset+dataSize-1)>>readUnitShift)-readStart+1;
			__NK_ASSERT_DEBUG((readSize<<readUnitShift)<=iDeviceBufferSize);
			START_PAGING_BENCHMARK;
			r = RomPagingDevice().iDevice->Read(msg,buffer,readStart,readSize,-1/*token for ROM paging*/);
			END_PAGING_BENCHMARK(DemandPaging::ThePager, EPagingBmReadMedia);
			if(r==KErrNone)
				{
				// Decompress data...
				TLinAddr data = buffer+dataOffset-(readStart<<readUnitShift);
				r = Decompress(romPageInfo->iCompressionType,aReq->iLoadAddr,data,dataSize);
				if(r>=0)
					{
					__NK_ASSERT_ALWAYS(r==pageSize);
					r = KErrNone;
					}
				}
			}
		}

	END_PAGING_BENCHMARK(this, EPagingBmReadRomPage);
	return r;
	}

TInt ReadFunc(TAny* aArg1, TAny* aArg2, TLinAddr aBuffer, TInt aBlockNumber, TInt aBlockCount)
	{
	START_PAGING_BENCHMARK;
	TInt drive = (TInt)aArg1;
	TThreadMessage* msg= (TThreadMessage*)aArg2;
	DemandPaging::SPagingDevice& device = DemandPaging::ThePager->CodePagingDevice(drive);
	TInt r = device.iDevice->Read(msg, aBuffer, aBlockNumber, aBlockCount, drive);
	END_PAGING_BENCHMARK(DemandPaging::ThePager, EPagingBmReadMedia);
	return r;
	}

TInt DemandPaging::ReadCodePage(const DPagingRequest* aReq, DMmuCodeSegMemory* aCodeSegMemory, TLinAddr aCodeAddress)
	{
	__KTRACE_OPT(KPAGING,Kern::Printf("ReadCodePage buffer = %08x, csm == %08x, addr == %08x", aReq->iLoadAddr, aCodeSegMemory, aCodeAddress));
	
	START_PAGING_BENCHMARK;

	// Get the paging device for this drive
	SPagingDevice& device = CodePagingDevice(aCodeSegMemory->iCodeLocalDrive);

	// Work out which bit of the file to read
	SRamCodeInfo& ri = aCodeSegMemory->iRamInfo;
	TInt codeOffset = aCodeAddress - ri.iCodeRunAddr;
	TInt pageNumber = codeOffset >> KPageShift;
	TBool compressed = aCodeSegMemory->iCompressionType != SRomPageInfo::ENoCompression;
	TInt dataOffset, dataSize;
	if (compressed)
		{
		dataOffset = aCodeSegMemory->iCodePageOffsets[pageNumber];
		dataSize = aCodeSegMemory->iCodePageOffsets[pageNumber + 1] - dataOffset;
		__KTRACE_OPT(KPAGING,Kern::Printf("  compressed, file offset == %x, size == %d", dataOffset, dataSize));
		}
	else
		{
		dataOffset = codeOffset + aCodeSegMemory->iCodeStartInFile;
		dataSize = Min(KPageSize, aCodeSegMemory->iBlockMap.DataLength() - dataOffset);
		__NK_ASSERT_DEBUG(dataSize >= 0);
		__KTRACE_OPT(KPAGING,Kern::Printf("  uncompressed, file offset == %x, size == %d", dataOffset, dataSize));
		}

	TInt bufferStart = aCodeSegMemory->iBlockMap.Read(aReq->iBuffer,
												dataOffset,
												dataSize,
												device.iDevice->iReadUnitShift,
												ReadFunc,
												(TAny*)aCodeSegMemory->iCodeLocalDrive,
												(TAny*)&aReq->iMessage);
	

	TInt r = KErrNone;
	if(bufferStart<0)
		{
		r = bufferStart; // return error
		__NK_ASSERT_DEBUG(0);
		}
	else
		{
		TLinAddr data = aReq->iBuffer + bufferStart;
		if (compressed)
			{
			TInt r = Decompress(aCodeSegMemory->iCompressionType, aReq->iLoadAddr, data, dataSize);
			if(r>=0)
				{
				dataSize = Min(KPageSize, ri.iCodeSize - codeOffset);
				if(r!=dataSize)
					{
					__NK_ASSERT_DEBUG(0);
					r = KErrCorrupt;
					}
				else
					r = KErrNone;
				}
			else
				{
				__NK_ASSERT_DEBUG(0);
				}
			}
		else
			{
			#ifdef BTRACE_PAGING_VERBOSE
			BTraceContext4(BTrace::EPaging,BTrace::EPagingDecompressStart,SRomPageInfo::ENoCompression);
			#endif
			memcpy((TAny*)aReq->iLoadAddr, (TAny*)data, dataSize);
			#ifdef BTRACE_PAGING_VERBOSE
			BTraceContext0(BTrace::EPaging,BTrace::EPagingDecompressEnd);
			#endif
			}
		}

	if(r==KErrNone)
		if (dataSize < KPageSize)
			memset((TAny*)(aReq->iLoadAddr + dataSize), KPageSize - dataSize, 0x03);

	END_PAGING_BENCHMARK(this, EPagingBmReadCodePage);
	
	return KErrNone;
	}


#include "decompress.h"

	
TInt DemandPaging::Decompress(TInt aCompressionType,TLinAddr aDst,TLinAddr aSrc,TUint aSrcSize)
	{
#ifdef BTRACE_PAGING_VERBOSE
	BTraceContext4(BTrace::EPaging,BTrace::EPagingDecompressStart,aCompressionType);
#endif
	TInt r;
	switch(aCompressionType)
		{
	case SRomPageInfo::ENoCompression:
		memcpy((void*)aDst,(void*)aSrc,aSrcSize);
		r = aSrcSize;
		break;

	case SRomPageInfo::EBytePair:
		{
		START_PAGING_BENCHMARK;
		TUint8* srcNext=0;
		r=BytePairDecompress((TUint8*)aDst,KPageSize,(TUint8*)aSrc,aSrcSize,srcNext);
		if (r == KErrNone)
			__NK_ASSERT_ALWAYS((TLinAddr)srcNext == aSrc + aSrcSize);
		END_PAGING_BENCHMARK(this, EPagingBmDecompress);
		}
		break;

	default:
		r = KErrNotSupported;
		break;
		}
#ifdef BTRACE_PAGING_VERBOSE
	BTraceContext0(BTrace::EPaging,BTrace::EPagingDecompressEnd);
#endif
	return r;
	}


void DemandPaging::BalanceAges()
	{
	if(iOldCount*iYoungOldRatio>=iYoungCount)
		return; // We have enough old pages

	// make one young page into an old page...

	__NK_ASSERT_DEBUG(!iYoungList.IsEmpty());
	__NK_ASSERT_DEBUG(iYoungCount);
	SDblQueLink* link = iYoungList.Last()->Deque();
	--iYoungCount;

	SPageInfo* pageInfo = SPageInfo::FromLink(link);
	pageInfo->SetState(SPageInfo::EStatePagedOld);

	iOldList.AddHead(link);
	++iOldCount;

	SetOld(pageInfo);

#ifdef BTRACE_PAGING_VERBOSE
	BTraceContext4(BTrace::EPaging,BTrace::EPagingAged,pageInfo->PhysAddr());
#endif
	}


void DemandPaging::AddAsYoungest(SPageInfo* aPageInfo)
	{
#ifdef _DEBUG
	SPageInfo::TType type = aPageInfo->Type();
	__NK_ASSERT_DEBUG(type==SPageInfo::EPagedROM || type==SPageInfo::EPagedCode || type==SPageInfo::EPagedData || type==SPageInfo::EPagedCache);
#endif
	aPageInfo->SetState(SPageInfo::EStatePagedYoung);
	iYoungList.AddHead(&aPageInfo->iLink);
	++iYoungCount;
	}


void DemandPaging::AddAsFreePage(SPageInfo* aPageInfo)
	{
#ifdef BTRACE_PAGING
	TPhysAddr phys = aPageInfo->PhysAddr();
	BTraceContext4(BTrace::EPaging,BTrace::EPagingPageInFree,phys);
#endif
	aPageInfo->Change(SPageInfo::EPagedFree,SPageInfo::EStatePagedOld);
	iOldList.Add(&aPageInfo->iLink);
	++iOldCount;
	}


void DemandPaging::RemovePage(SPageInfo* aPageInfo)
	{
	switch(aPageInfo->State())
		{
	case SPageInfo::EStatePagedYoung:
		__NK_ASSERT_DEBUG(iYoungCount);
		aPageInfo->iLink.Deque();
		--iYoungCount;
		break;

	case SPageInfo::EStatePagedOld:
		__NK_ASSERT_DEBUG(iOldCount);
		aPageInfo->iLink.Deque();
		--iOldCount;
		break;

	case SPageInfo::EStatePagedLocked:
		break;

	default:
		__NK_ASSERT_DEBUG(0);
		}
	aPageInfo->SetState(SPageInfo::EStatePagedDead);
	}


SPageInfo* DemandPaging::GetOldestPage()
	{
	// remove oldest from list...
	SDblQueLink* link;
	if(iOldCount)
		{
		__NK_ASSERT_DEBUG(!iOldList.IsEmpty());
		link = iOldList.Last()->Deque();
		--iOldCount;
		}
	else
		{
		__NK_ASSERT_DEBUG(iYoungCount);
		__NK_ASSERT_DEBUG(!iYoungList.IsEmpty());
		link = iYoungList.Last()->Deque();
		--iYoungCount;
		}
	SPageInfo* pageInfo = SPageInfo::FromLink(link);
	pageInfo->SetState(SPageInfo::EStatePagedDead);

	// put page in a free state...
	SetFree(pageInfo);
	pageInfo->Change(SPageInfo::EPagedFree,SPageInfo::EStatePagedDead);

	// keep live list balanced...
	BalanceAges();

	return pageInfo;
	}


TBool DemandPaging::GetFreePages(TInt aNumPages)
	{
	__KTRACE_OPT(KPAGING,Kern::Printf("DP: >GetFreePages %d",aNumPages));
	NKern::LockSystem();

	while(aNumPages>0 && NumberOfFreePages()>=aNumPages)
		{
		// steal a page from live page list and return it to the free pool...
		ReturnToSystem(GetOldestPage());
		--aNumPages;
		}

	NKern::UnlockSystem();
	__KTRACE_OPT(KPAGING,Kern::Printf("DP: <GetFreePages %d",!aNumPages));
	return !aNumPages;
	}


void DemandPaging::DonateRamCachePage(SPageInfo* aPageInfo)
	{
	__NK_ASSERT_DEBUG(iMinimumPageCount + iNumberOfFreePages <= iMaximumPageCount);
	SPageInfo::TType type = aPageInfo->Type();
	if(type==SPageInfo::EChunk)
		{
		// Must not donate locked page. An example is DMA transferred memory.
		__NK_ASSERT_DEBUG(!aPageInfo->LockCount());
		
		aPageInfo->Change(SPageInfo::EPagedCache,SPageInfo::EStatePagedYoung);

		// Update ram allocator counts as this page has changed its type
		DMemModelChunk* chunk = (DMemModelChunk*)aPageInfo->Owner();
		iMmu->iRamPageAllocator->ChangePageType(aPageInfo, chunk->GetPageType(), EPageDiscard);

		AddAsYoungest(aPageInfo);
		++iNumberOfFreePages;
		if (iMinimumPageCount + iNumberOfFreePages > iMaximumPageCount)
			ReturnToSystem(GetOldestPage());
		BalanceAges();
		return;
		}
	// allow already donated pages...
	__NK_ASSERT_DEBUG(type==SPageInfo::EPagedCache);
	}


TBool DemandPaging::ReclaimRamCachePage(SPageInfo* aPageInfo)
	{
	SPageInfo::TType type = aPageInfo->Type();
	if(type==SPageInfo::EChunk)
		return ETrue; // page already reclaimed

	__NK_ASSERT_DEBUG(type==SPageInfo::EPagedCache);

	if(!iNumberOfFreePages)
		return EFalse;
	--iNumberOfFreePages;

	RemovePage(aPageInfo);
	aPageInfo->Change(SPageInfo::EChunk,SPageInfo::EStateNormal);

	// Update ram allocator counts as this page has changed its type
	DMemModelChunk* chunk = (DMemModelChunk*)aPageInfo->Owner();
	iMmu->iRamPageAllocator->ChangePageType(aPageInfo, EPageDiscard, chunk->GetPageType());
	return ETrue;
	}


SPageInfo* DemandPaging::AllocateNewPage()
	{
	__ASSERT_SYSTEM_LOCK
	SPageInfo* pageInfo;

	NKern::UnlockSystem();
	MmuBase::Wait();
	NKern::LockSystem();

	// Try getting a free page from our active page list
	if(iOldCount)
		{
		pageInfo = SPageInfo::FromLink(iOldList.Last());
		if(pageInfo->Type()==SPageInfo::EPagedFree)
			{
			pageInfo = GetOldestPage();
			goto done;
			}
		}

	// Try getting a free page from the system pool
	if(iMinimumPageCount+iNumberOfFreePages<iMaximumPageCount)
		{
		NKern::UnlockSystem();
		pageInfo = GetPageFromSystem();
		NKern::LockSystem();
		if(pageInfo)
			goto done;
		}

	// As a last resort, steal one from our list of active pages
	pageInfo = GetOldestPage();

done:
	NKern::UnlockSystem();
	MmuBase::Signal();
	NKern::LockSystem();
	return pageInfo;
	}


void DemandPaging::Rejuvenate(SPageInfo* aPageInfo)
	{
	SPageInfo::TState state = aPageInfo->State();
	if(state==SPageInfo::EStatePagedOld)
		{
		// move page from old list to head of young list...
		__NK_ASSERT_DEBUG(iOldCount);
		aPageInfo->iLink.Deque();
		--iOldCount;
		AddAsYoungest(aPageInfo);
		BalanceAges();
		}
	else if(state==SPageInfo::EStatePagedYoung)
		{
		// page was already young, move it to the start of the list (make it the youngest)
		aPageInfo->iLink.Deque();
		iYoungList.AddHead(&aPageInfo->iLink);
		}
	else
		{
		// leave locked pages alone
		__NK_ASSERT_DEBUG(state==SPageInfo::EStatePagedLocked);
		}
	}


TInt DemandPaging::CheckRealtimeThreadFault(DThread* aThread, TAny* aContext)
	{
	TInt r = KErrNone;
	DThread* client = aThread->iIpcClient;
	
	// If iIpcClient is set then we are accessing the address space of a remote thread.  If we are
	// in an IPC trap, this will contain information the local and remte addresses being accessed.
	// If this is not set then we assume than any fault must be the fault of a bad remote address.
	TIpcExcTrap* ipcTrap = (TIpcExcTrap*)aThread->iExcTrap;
	if (ipcTrap && !ipcTrap->IsTIpcExcTrap())
		ipcTrap = 0;
	if (client && (!ipcTrap || ipcTrap->ExcLocation(aThread, aContext) == TIpcExcTrap::EExcRemote))
		{
		// Kill client thread...
		NKern::UnlockSystem();
		if(K::IllegalFunctionForRealtimeThread(client,"Access to Paged Memory (by other thread)"))
			{
			// Treat memory access as bad...
			r = KErrAbort;
			}
		// else thread is in 'warning only' state so allow paging
		}
	else
		{
		// Kill current thread...
		NKern::UnlockSystem();
		if(K::IllegalFunctionForRealtimeThread(NULL,"Access to Paged Memory"))
			{
			// If current thread is in critical section, then the above kill will be deferred
			// and we will continue executing. We will handle this by returning an error
			// which means that the thread will take an exception (which hopfully is XTRAPed!)
			r = KErrAbort;
			}
		// else thread is in 'warning only' state so allow paging
		}
	
	NKern::LockSystem();
	return r;
	}


TInt DemandPaging::ResizeLiveList(TUint aMinimumPageCount,TUint aMaximumPageCount)
	{
	if(!aMaximumPageCount)
		{
		aMinimumPageCount = iInitMinimumPageCount;
		aMaximumPageCount = iInitMaximumPageCount;
		}

	// Min must not be greater than max...
	if(aMinimumPageCount>aMaximumPageCount)
		return KErrArgument;

	NKern::ThreadEnterCS();
	MmuBase::Wait();

	NKern::LockSystem();

	// Make sure aMinimumPageCount is not less than absolute minimum we can cope with...
	iMinimumPageLimit = ((KMinYoungPages + iNextPagingRequestCount) * (1 + iYoungOldRatio)) / iYoungOldRatio;
	if(iMinimumPageLimit<KAbsoluteMinPageCount)
		iMinimumPageLimit = KAbsoluteMinPageCount;
	if(aMinimumPageCount<iMinimumPageLimit+iReservePageCount)
		aMinimumPageCount = iMinimumPageLimit+iReservePageCount;
	if(aMaximumPageCount<aMinimumPageCount)
		aMaximumPageCount=aMinimumPageCount;

	// Increase iMaximumPageCount?
	TInt extra = aMaximumPageCount-iMaximumPageCount;
	if(extra>0)
		iMaximumPageCount += extra;

	// Reduce iMinimumPageCount?
	TInt spare = iMinimumPageCount-aMinimumPageCount;
	if(spare>0)
		{
		iMinimumPageCount -= spare;
		iNumberOfFreePages += spare;
		}

	// Increase iMinimumPageCount?
	TInt r=KErrNone;
	while(aMinimumPageCount>iMinimumPageCount)
		{
		if(iNumberOfFreePages==0)	// Need more pages?
			{
			// get a page from the system
			NKern::UnlockSystem();
			SPageInfo* pageInfo = GetPageFromSystem();
			NKern::LockSystem();
			if(!pageInfo)
				{
				r=KErrNoMemory;
				break;
				}
			AddAsFreePage(pageInfo);
			}
		++iMinimumPageCount;
		--iNumberOfFreePages;
		NKern::FlashSystem();
		}

	// Reduce iMaximumPageCount?
	while(iMaximumPageCount>aMaximumPageCount)
		{
		if (iMinimumPageCount+iNumberOfFreePages==iMaximumPageCount)	// Need to free pages?
			{
			ReturnToSystem(GetOldestPage());
			}
		--iMaximumPageCount;
		NKern::FlashSystem();
		}

#ifdef BTRACE_KERNEL_MEMORY
	BTrace4(BTrace::EKernelMemory,BTrace::EKernelMemoryDemandPagingCache,ThePager->iMinimumPageCount << KPageShift);
#endif

	__NK_ASSERT_DEBUG(iMinimumPageCount + iNumberOfFreePages <= iMaximumPageCount);

	NKern::UnlockSystem();

	MmuBase::Signal();
	NKern::ThreadLeaveCS();

	return r;
	}


TInt VMHalFunction(TAny*, TInt aFunction, TAny* a1, TAny* a2)
	{
	DemandPaging* pager = DemandPaging::ThePager;
	switch(aFunction)
		{
	case EVMHalFlushCache:
		if(!TheCurrentThread->HasCapability(ECapabilityWriteDeviceData,__PLATSEC_DIAGNOSTIC_STRING("Checked by VMHalFunction(EVMHalFlushCache)")))
			K::UnlockedPlatformSecurityPanic();
		pager->FlushAll();
		return KErrNone;

	case EVMHalSetCacheSize:
		{
		if(!TheCurrentThread->HasCapability(ECapabilityWriteDeviceData,__PLATSEC_DIAGNOSTIC_STRING("Checked by VMHalFunction(EVMHalSetCacheSize)")))
			K::UnlockedPlatformSecurityPanic();
		TUint min = (TUint)a1>>KPageShift;
		if((TUint)a1&KPageMask)
			++min;
		TUint max = (TUint)a2>>KPageShift;
		if((TUint)a2&KPageMask)
			++max;
		return pager->ResizeLiveList(min,max);
		}

	case EVMHalGetCacheSize:
		{
		SVMCacheInfo info;
		NKern::LockSystem(); // lock system to ensure consistent set of values are read...
		info.iMinSize = pager->iMinimumPageCount<<KPageShift;
		info.iMaxSize = pager->iMaximumPageCount<<KPageShift;
		info.iCurrentSize = (pager->iMinimumPageCount+pager->iNumberOfFreePages)<<KPageShift;
		info.iMaxFreeSize = pager->iNumberOfFreePages<<KPageShift;
		NKern::UnlockSystem();
		kumemput32(a1,&info,sizeof(info));
		}
		return KErrNone;

	case EVMHalGetEventInfo:
		{
		SVMEventInfo info;
		NKern::LockSystem(); // lock system to ensure consistent set of values are read...
		info = pager->iEventInfo;
		NKern::UnlockSystem();
		Kern::InfoCopy(*(TDes8*)a1,(TUint8*)&info,sizeof(info));
		}
		return KErrNone;

	case EVMHalResetEventInfo:
		NKern::LockSystem();
		memclr(&pager->iEventInfo, sizeof(pager->iEventInfo));
		NKern::UnlockSystem();
		return KErrNone;

#ifdef __SUPPORT_DEMAND_PAGING_EMULATION__
	case EVMHalGetOriginalRomPages:
		*(TPhysAddr**)a1 = pager->iOriginalRomPages;
		*(TInt*)a2 = pager->iOriginalRomPageCount;
		return KErrNone;
#endif

	case EVMPageState:
		return pager->PageState((TLinAddr)a1);

#ifdef __CONCURRENT_PAGING_INSTRUMENTATION__
	case EVMHalGetConcurrencyInfo:
		{
		NKern::LockSystem();
		SPagingConcurrencyInfo info = { pager->iMaxWaitingCount, pager->iMaxPagingCount };
		NKern::UnlockSystem();
		kumemput32(a1,&info,sizeof(info));
		}
		return KErrNone;
		
	case EVMHalResetConcurrencyInfo:
		NKern::LockSystem();
		pager->iMaxWaitingCount = 0;
		pager->iMaxPagingCount = 0;
		NKern::UnlockSystem();
		return KErrNone;
#endif

#ifdef __DEMAND_PAGING_BENCHMARKS__
	case EVMHalGetPagingBenchmark:
		{
		TUint index = (TInt) a1;
		if (index >= EMaxPagingBm)
			return KErrNotFound;
		NKern::LockSystem();
		SPagingBenchmarkInfo info = pager->iBenchmarkInfo[index];
		NKern::UnlockSystem();
		kumemput32(a2,&info,sizeof(info));
		}		
		return KErrNone;
		
	case EVMHalResetPagingBenchmark:
		{
		TUint index = (TInt) a1;
		if (index >= EMaxPagingBm)
			return KErrNotFound;
		NKern::LockSystem();
		pager->ResetBenchmarkData((TPagingBenchmark)index);
		NKern::UnlockSystem();
		}
		return KErrNone;
#endif

	default:
		return KErrNotSupported;
		}
	}

void DemandPaging::Panic(TFault aFault)
	{
	Kern::Fault("DEMAND-PAGING",aFault);
	}


DMutex* DemandPaging::CheckMutexOrder()
	{
#ifdef _DEBUG
	SDblQue& ml = TheCurrentThread->iMutexList;
	if(ml.IsEmpty())
		return NULL;
	DMutex* mm = _LOFF(ml.First(), DMutex, iOrderLink);
	if (KMutexOrdPageIn >= mm->iOrder)
		return mm;
#endif
	return NULL;
	}


TBool DemandPaging::ReservePage()
	{
	__ASSERT_SYSTEM_LOCK;
	__ASSERT_CRITICAL;

	NKern::UnlockSystem();
	MmuBase::Wait();
	NKern::LockSystem();

	__NK_ASSERT_DEBUG(iMinimumPageCount >= iMinimumPageLimit + iReservePageCount);
	while (iMinimumPageCount == iMinimumPageLimit + iReservePageCount &&
		   iNumberOfFreePages == 0)
		{
		NKern::UnlockSystem();
		SPageInfo* pageInfo = GetPageFromSystem();
		if(!pageInfo)
			{
			MmuBase::Signal();
			NKern::LockSystem();
			return EFalse;
			}
		NKern::LockSystem();
		AddAsFreePage(pageInfo);
		}
	if (iMinimumPageCount == iMinimumPageLimit + iReservePageCount)
		{	
		++iMinimumPageCount;
		--iNumberOfFreePages;
		if (iMinimumPageCount > iMaximumPageCount)
			iMaximumPageCount = iMinimumPageCount;
		}
	++iReservePageCount;
	__NK_ASSERT_DEBUG(iMinimumPageCount >= iMinimumPageLimit + iReservePageCount);
	__NK_ASSERT_DEBUG(iMinimumPageCount + iNumberOfFreePages <= iMaximumPageCount);

	NKern::UnlockSystem();
	MmuBase::Signal();
	NKern::LockSystem();
	return ETrue;
	}


TInt DemandPaging::LockRegion(TLinAddr aStart,TInt aSize,DProcess* aProcess)
	{
	__KTRACE_OPT(KPAGING,Kern::Printf("DP: LockRegion(%08x,%x)",aStart,aSize));
	NKern::ThreadEnterCS();

	// calculate the number of pages required to lock aSize bytes
	TUint32 mask=KPageMask;
	TUint32 offset=aStart&mask;
	TInt numPages = (aSize+offset+mask)>>KPageShift;

	// Lock pages...
	TInt r=KErrNone;
	TLinAddr page = aStart;

	NKern::LockSystem();
	while(--numPages>=0)
		{
		if (!ReservePage())
			break;
		TPhysAddr phys;
		r = LockPage(page,aProcess,phys);
		NKern::FlashSystem();
		if(r!=KErrNone)
			break;
		page += KPageSize;
		}

	NKern::UnlockSystem();

	// If error, unlock whatever we managed to lock...
	if(r!=KErrNone)
		{
		while((page-=KPageSize)>=aStart)
			{
			NKern::LockSystem();
			UnlockPage(aStart,aProcess,KPhysAddrInvalid);
			--iReservePageCount;
			NKern::UnlockSystem();
			}
		}

	NKern::ThreadLeaveCS();
	__KTRACE_OPT(KPAGING,Kern::Printf("DP: LockRegion returns %d",r));
	return r;
	}


TInt DemandPaging::UnlockRegion(TLinAddr aStart,TInt aSize,DProcess* aProcess)
	{
	__KTRACE_OPT(KPAGING,Kern::Printf("DP: UnlockRegion(%08x,%x)",aStart,aSize));
	TUint32 mask=KPageMask;
	TUint32 offset=aStart&mask;
	TInt numPages = (aSize+offset+mask)>>KPageShift;
	NKern::LockSystem();
	__NK_ASSERT_DEBUG(iReservePageCount >= (TUint)numPages);
	while(--numPages>=0)
		{
		UnlockPage(aStart,aProcess,KPhysAddrInvalid);
		--iReservePageCount;		
		NKern::FlashSystem();
		aStart += KPageSize;
		}
	NKern::UnlockSystem();
	return KErrNone;
	}


void DemandPaging::FlushAll()
	{
	NKern::ThreadEnterCS();
	MmuBase::Wait();
	// look at all RAM pages in the system, and unmap all those used for paging
	const TUint32* piMap = (TUint32*)KPageInfoMap;
	const TUint32* piMapEnd = piMap+(KNumPageInfoPages>>5);
	SPageInfo* pi = (SPageInfo*)KPageInfoLinearBase;
	NKern::LockSystem();
	do
		{
		SPageInfo* piNext = pi+(KPageInfosPerPage<<5);
		for(TUint32 piFlags=*piMap++; piFlags; piFlags>>=1)
			{
			if(!(piFlags&1))
				{
				pi += KPageInfosPerPage;
				continue;
				}
			SPageInfo* piEnd = pi+KPageInfosPerPage;
			do
				{
				SPageInfo::TState state = pi->State();
				if(state==SPageInfo::EStatePagedYoung || state==SPageInfo::EStatePagedOld)
					{
					RemovePage(pi);
					SetFree(pi);
					AddAsFreePage(pi);
					NKern::FlashSystem();
					}
				++pi;
				const TUint KFlashCount = 64; // flash every 64 page infos (must be a power-of-2)
				__ASSERT_COMPILE((TUint)KPageInfosPerPage >= KFlashCount);
				if(((TUint)pi&((KFlashCount-1)<<KPageInfoShift))==0)
					NKern::FlashSystem();
				}
			while(pi<piEnd);
			}
		pi = piNext;
		}
	while(piMap<piMapEnd);
	NKern::UnlockSystem();

	// reduce live page list to a minimum
	while(GetFreePages(1)) {}; 

	MmuBase::Signal();
	NKern::ThreadLeaveCS();
	}


TInt DemandPaging::LockPage(TLinAddr aPage, DProcess *aProcess, TPhysAddr& aPhysAddr)
	{
	__KTRACE_OPT(KPAGING,Kern::Printf("DP: LockPage() %08x",aPage));
	__ASSERT_SYSTEM_LOCK

	aPhysAddr = KPhysAddrInvalid;

	TInt r = EnsurePagePresent(aPage,aProcess);
	if (r != KErrNone)
		return KErrArgument; // page doesn't exist

	// get info about page to be locked...
	TPhysAddr phys = LinearToPhysical(aPage,aProcess);
retry:
	__NK_ASSERT_DEBUG(phys!=KPhysAddrInvalid);

	SPageInfo* pageInfo = SPageInfo::SafeFromPhysAddr(phys);
	if(!pageInfo)
		return KErrNotFound;

	// lock it...
	SPageInfo::TType type = pageInfo->Type();
	if(type==SPageInfo::EShadow)
		{
		// get the page which is being shadowed and lock that
		phys = (TPhysAddr)pageInfo->Owner();
		goto retry;
		}

	switch(pageInfo->State())
		{
	case SPageInfo::EStatePagedLocked:
		// already locked, so just increment lock count...
		++pageInfo->PagedLock();
		break;

	case SPageInfo::EStatePagedYoung:
		{
		if(type!=SPageInfo::EPagedROM && type !=SPageInfo::EPagedCode)
			{
			// not implemented yet
			__NK_ASSERT_ALWAYS(0);
			}

		// remove page to be locked from live list...
		RemovePage(pageInfo);

		// change to locked state...
		pageInfo->SetState(SPageInfo::EStatePagedLocked);
		pageInfo->PagedLock() = 1; // Start with lock count of one

		// open reference on memory...
		if(type==SPageInfo::EPagedCode)
			{
			DMemModelCodeSegMemory* codeSegMemory = (DMemModelCodeSegMemory*)pageInfo->Owner();
			if(codeSegMemory->Open()!=KErrNone)
				{
				__NK_ASSERT_DEBUG(0);
				}
			}
		}
		
		break;

	case SPageInfo::EStatePagedOld:
		// can't happen because we forced the page to be accessible earlier
		__NK_ASSERT_ALWAYS(0);
		return KErrCorrupt;

	default:
		return KErrNotFound;
		}

	aPhysAddr = phys;

#ifdef BTRACE_PAGING
	BTraceContext8(BTrace::EPaging,BTrace::EPagingPageLock,phys,pageInfo->PagedLock());
#endif
	return KErrNone;
	}


TInt DemandPaging::UnlockPage(TLinAddr aPage, DProcess* aProcess, TPhysAddr aPhysAddr)
	{
	__KTRACE_OPT(KPAGING,Kern::Printf("DP: UnlockPage() %08x",aPage));
	__ASSERT_SYSTEM_LOCK;
	__ASSERT_CRITICAL;

	// Get info about page to be unlocked
	TPhysAddr phys = LinearToPhysical(aPage,aProcess);
	if(phys==KPhysAddrInvalid)
		{
		phys = aPhysAddr;
		if(phys==KPhysAddrInvalid)
			return KErrNotFound;
		}
retry:
	SPageInfo* pageInfo = SPageInfo::SafeFromPhysAddr(phys);
	if(!pageInfo)
		return KErrNotFound;

	SPageInfo::TType type = pageInfo->Type();
	if(type==SPageInfo::EShadow)
		{
		// Get the page which is being shadowed and unlock that
		phys = (TPhysAddr)pageInfo->Owner();
		goto retry;
		}

	__NK_ASSERT_DEBUG(phys==aPhysAddr || aPhysAddr==KPhysAddrInvalid);

	// Unlock it...
	switch(pageInfo->State())
		{
	case SPageInfo::EStatePagedLocked:
#ifdef BTRACE_PAGING
		BTraceContext8(BTrace::EPaging,BTrace::EPagingPageUnlock,phys,pageInfo->PagedLock());
#endif
		if(!(--pageInfo->PagedLock()))
			{
			// get pointer to memory...
			DMemModelCodeSegMemory* codeSegMemory = 0;
			if(type==SPageInfo::EPagedCode)
				codeSegMemory = (DMemModelCodeSegMemory*)pageInfo->Owner();

			// put page back on live list...
			AddAsYoungest(pageInfo);
			BalanceAges();

			// close reference on memory...
			if(codeSegMemory)
				{
				NKern::UnlockSystem();
				codeSegMemory->Close();
				NKern::LockSystem();
				}
			}
		break;

	default:
		return KErrNotFound;
		}

	return KErrNone;
	}



TInt DemandPaging::ReserveAlloc(TInt aSize, DDemandPagingLock& aLock)
	{
	__NK_ASSERT_DEBUG(aLock.iPages == NULL);
	
	// calculate the number of pages required to lock aSize bytes
	TInt numPages = ((aSize-1+KPageMask)>>KPageShift)+1;

	__KTRACE_OPT(KPAGING,Kern::Printf("DP: ReserveAlloc() pages %d",numPages));
	
	NKern::ThreadEnterCS();

	aLock.iPages = (TPhysAddr*)Kern::Alloc(numPages*sizeof(TPhysAddr));
	if(!aLock.iPages)
		{
		NKern::ThreadLeaveCS();
		return KErrNoMemory;
		}
	
	MmuBase::Wait();
	NKern::LockSystem();

	// reserve pages, adding more if necessary
	while (aLock.iReservedPageCount < numPages)
		{
		if (!ReservePage())
			break;
		++aLock.iReservedPageCount;
		}

	NKern::UnlockSystem();
	MmuBase::Signal();

	TBool enoughPages = aLock.iReservedPageCount == numPages;
	if(!enoughPages)
		ReserveFree(aLock);

	NKern::ThreadLeaveCS();
	return enoughPages ? KErrNone : KErrNoMemory;
	}



void DemandPaging::ReserveFree(DDemandPagingLock& aLock)
	{
	NKern::ThreadEnterCS();

	// make sure pages aren't still locked
	ReserveUnlock(aLock);

	NKern::LockSystem();
	__NK_ASSERT_DEBUG(iReservePageCount >= (TUint)aLock.iReservedPageCount);
	iReservePageCount -= aLock.iReservedPageCount;
	aLock.iReservedPageCount = 0;
	NKern::UnlockSystem();

	// free page array...
	Kern::Free(aLock.iPages);
	aLock.iPages = 0;

	NKern::ThreadLeaveCS();
	}



TBool DemandPaging::ReserveLock(DThread* aThread, TLinAddr aStart,TInt aSize, DDemandPagingLock& aLock)
	{
	if(aLock.iLockedPageCount)
		Panic(ELockTwice);

	// calculate the number of pages that need to be locked...
	TUint32 mask=KPageMask;
	TUint32 offset=aStart&mask;
	TInt numPages = (aSize+offset+mask)>>KPageShift;
	if(numPages>aLock.iReservedPageCount)
		Panic(ELockTooBig);

	NKern::LockSystem();

	// lock the pages
	TBool locked = EFalse; // becomes true if any pages were locked
	DProcess* process = aThread->iOwningProcess;
	TLinAddr page=aStart;
	TInt count=numPages;
	TPhysAddr* physPages = aLock.iPages;
	while(--count>=0)
		{
		if(LockPage(page,process,*physPages)==KErrNone)
			locked = ETrue;
		NKern::FlashSystem();
		page += KPageSize;
		++physPages;
		}

	// if any pages were locked, save the lock info...
	if(locked)
		{
		if(aLock.iLockedPageCount)
			Panic(ELockTwice);
		aLock.iLockedStart = aStart;
		aLock.iLockedPageCount = numPages;
		aLock.iProcess = process;
		aLock.iProcess->Open();
		}

	NKern::UnlockSystem();
	return locked;
	}



void DemandPaging::ReserveUnlock(DDemandPagingLock& aLock)
	{
	NKern::ThreadEnterCS();

	DProcess* process = NULL;
	NKern::LockSystem();
	TInt numPages = aLock.iLockedPageCount;
	TLinAddr page = aLock.iLockedStart;
	TPhysAddr* physPages = aLock.iPages;
	while(--numPages>=0)
		{
		UnlockPage(page, aLock.iProcess,*physPages);
		NKern::FlashSystem();
		page += KPageSize;
		++physPages;
		}
	process = aLock.iProcess;
	aLock.iProcess = NULL;
	aLock.iLockedPageCount = 0;
	NKern::UnlockSystem();
	if (process)
		process->Close(NULL);

	NKern::ThreadLeaveCS();
	}

/**
Check whether the specified page can be discarded by the RAM cache.

@param aPageInfo The page info of the page being queried.
@return ETrue when the page can be discarded, EFalse otherwise.
@pre System lock held.
@post System lock held.
*/
TBool DemandPaging::IsPageDiscardable(SPageInfo& aPageInfo)
	{
	 // on live list?
	SPageInfo::TState state = aPageInfo.State();
	return (state == SPageInfo::EStatePagedYoung || state == SPageInfo::EStatePagedOld);
	}


/**
Discard the specified page.
Should only be called on a page if a previous call to IsPageDiscardable()
returned ETrue and the system lock hasn't been released between the calls.

@param aPageInfo The page info of the page to be discarded
@param aBlockZoneId The ID of the RAM zone that shouldn't be allocated into.
@param aBlockRest Set to ETrue to stop allocation as soon as aBlockedZoneId is reached 
in preference ordering.  EFalse otherwise.
@return ETrue if the page could be discarded, EFalse otherwise.

@pre System lock held.
@post System lock held.
*/
TBool DemandPaging::DoDiscardPage(SPageInfo& aPageInfo, TUint aBlockedZoneId, TBool aBlockRest)
	{
	__ASSERT_SYSTEM_LOCK;
	// Ensure that we don't reduce the cache beyond its minimum.
	if (iNumberOfFreePages == 0)
		{
		NKern::UnlockSystem();
		SPageInfo* newPage = GetPageFromSystem(aBlockedZoneId, aBlockRest);
		NKern::LockSystem();
		if (newPage == NULL)
			{// couldn't allocate a new page
			return EFalse;
			}
		if (IsPageDiscardable(aPageInfo))
			{// page can still be discarded so use new page 
			// and discard old one
			AddAsFreePage(newPage);
			RemovePage(&aPageInfo);
			SetFree(&aPageInfo);
			ReturnToSystem(&aPageInfo);
			BalanceAges();
			return ETrue;
			}
		else
			{// page no longer discardable so no longer require new page
			ReturnToSystem(newPage);
			return EFalse;
			}
		}

	// Discard the page
	RemovePage(&aPageInfo);
	SetFree(&aPageInfo);
	ReturnToSystem(&aPageInfo);
	BalanceAges();
	
	return ETrue;
	}


/**
First stage in discarding a list of pages.

Must ensure that the pages will still be discardable even if system lock is released.
To be used in conjunction with RamCacheBase::DoDiscardPages1().

@param aPageList A NULL terminated list of the pages to be discarded
@return KErrNone on success.

@pre System lock held
@post System lock held
*/
TInt DemandPaging::DoDiscardPages0(SPageInfo** aPageList)
	{
	__ASSERT_SYSTEM_LOCK;

	SPageInfo* pageInfo;
	while((pageInfo = *aPageList++) != 0)
		{
		RemovePage(pageInfo);
		}
	return KErrNone;
	}


/**
Final stage in discarding a list of page
Finish discarding the pages previously removed by RamCacheBase::DoDiscardPages0().

@param aPageList A NULL terminated list of the pages to be discarded
@return KErrNone on success.

@pre System lock held
@post System lock held
*/
TInt DemandPaging::DoDiscardPages1(SPageInfo** aPageList)
	{
	__ASSERT_SYSTEM_LOCK;

	SPageInfo* pageInfo;
	while((pageInfo = *aPageList++)!=0)
		{
		SetFree(pageInfo);
		ReturnToSystem(pageInfo);
		BalanceAges();
		}
	return KErrNone;
	}


TBool DemandPaging::MayBePaged(TLinAddr aStartAddr, TUint aLength)
	{
	TLinAddr endAddr = aStartAddr + aLength;
	TBool rangeTouchesPagedRom =
		TUint(aStartAddr - iRomPagedLinearBase) < iRomSize  ||
		TUint(endAddr - iRomPagedLinearBase) < iRomSize;
	TBool rangeTouchesCodeArea =
		TUint(aStartAddr - iCodeLinearBase) < iCodeSize  ||
		TUint(endAddr - iCodeLinearBase) < iCodeSize;
	return rangeTouchesPagedRom || rangeTouchesCodeArea;
	}


#ifdef __DEMAND_PAGING_BENCHMARKS__

void DemandPaging::ResetBenchmarkData(TPagingBenchmark aBm)
	{
	SPagingBenchmarkInfo& info = iBenchmarkInfo[aBm];
	info.iCount = 0;
	info.iTotalTime = 0;
	info.iMaxTime = 0;
	info.iMinTime = KMaxTInt;
	}

void DemandPaging::RecordBenchmarkData(TPagingBenchmark aBm, TUint32 aStartTime, TUint32 aEndTime)
	{
	SPagingBenchmarkInfo& info = iBenchmarkInfo[aBm];
	++info.iCount;
#if !defined(HIGH_RES_TIMER) || defined(HIGH_RES_TIMER_COUNTS_UP)
	TInt64 elapsed = aEndTime - aStartTime;
#else
	TInt64 elapsed = aStartTime - aEndTime;
#endif
	info.iTotalTime += elapsed;
	if (elapsed > info.iMaxTime)
		info.iMaxTime = elapsed;
	if (elapsed < info.iMinTime)
		info.iMinTime = elapsed;
	}
	
#endif


//
// DDemandPagingLock
//

EXPORT_C DDemandPagingLock::DDemandPagingLock()
	: iThePager(DemandPaging::ThePager), iReservedPageCount(0), iLockedPageCount(0), iPages(0)
	{
	}


EXPORT_C TInt DDemandPagingLock::Alloc(TInt aSize)
	{	
	if (iThePager)
		return iThePager->ReserveAlloc(aSize,*this);
	else
		return KErrNone;
	}


EXPORT_C void DDemandPagingLock::DoUnlock()
	{
	if (iThePager)
		iThePager->ReserveUnlock(*this);
	}


EXPORT_C void DDemandPagingLock::Free()
	{
	if (iThePager)
		iThePager->ReserveFree(*this);
	}


EXPORT_C TInt Kern::InstallPagingDevice(DPagingDevice* aDevice)
	{
	if (DemandPaging::ThePager)
		return DemandPaging::ThePager->InstallPagingDevice(aDevice);
	else
		return KErrNotSupported;
	}


#else  // !__DEMAND_PAGING__

EXPORT_C DDemandPagingLock::DDemandPagingLock()
	: iLockedPageCount(0)
	{
	}

EXPORT_C TInt DDemandPagingLock::Alloc(TInt /*aSize*/)
	{
	return KErrNone;
	}

EXPORT_C TBool DDemandPagingLock::Lock(DThread* /*aThread*/, TLinAddr /*aStart*/, TInt /*aSize*/)
	{
	return EFalse;
	}

EXPORT_C void DDemandPagingLock::DoUnlock()
	{
	}

EXPORT_C void DDemandPagingLock::Free()
	{
	}

EXPORT_C TInt Kern::InstallPagingDevice(DPagingDevice* aDevice)
	{
	return KErrNotSupported;
	}

#endif // __DEMAND_PAGING__


DMmuCodeSegMemory::DMmuCodeSegMemory(DEpocCodeSeg* aCodeSeg)
	: DEpocCodeSegMemory(aCodeSeg), iCodeAllocBase(KMinTInt)
	{
	}

//#define __DUMP_BLOCKMAP_INFO
DMmuCodeSegMemory::~DMmuCodeSegMemory()
	{
#ifdef __DEMAND_PAGING__
	Kern::Free(iCodeRelocTable);
	Kern::Free(iCodePageOffsets);
	Kern::Free(iDataSectionMemory);
#endif
	}

#ifdef __DEMAND_PAGING__

/**
Read and process the block map and related data.
*/
TInt DMmuCodeSegMemory::ReadBlockMap(const TCodeSegCreateInfo& aInfo)
	{
	__KTRACE_OPT(KPAGING,Kern::Printf("DP: Reading block map for %C", iCodeSeg));

	if (aInfo.iCodeBlockMapEntriesSize <= 0)
		return KErrArgument;  // no block map provided
	
	// Get compression data
	switch (aInfo.iCompressionType)
		{
		case KFormatNotCompressed:
			iCompressionType = SRomPageInfo::ENoCompression;
			break;

		case KUidCompressionBytePair:
			{
			iCompressionType = SRomPageInfo::EBytePair;
			if (!aInfo.iCodePageOffsets)
				return KErrArgument;
			TInt size = sizeof(TInt32) * (iPageCount + 1);
			iCodePageOffsets = (TInt32*)Kern::Alloc(size);
			if (!iCodePageOffsets)
				return KErrNoMemory;
			kumemget32(iCodePageOffsets, aInfo.iCodePageOffsets, size);

#ifdef __DUMP_BLOCKMAP_INFO
			Kern::Printf("CodePageOffsets:");
			for (TInt i = 0 ; i < iPageCount + 1 ; ++i)
				Kern::Printf("  %08x", iCodePageOffsets[i]);
#endif

			TInt last = 0;
			for (TInt j = 0 ; j < iPageCount + 1 ; ++j)
				{
				if (iCodePageOffsets[j] < last ||
					iCodePageOffsets[j] > (aInfo.iCodeLengthInFile + aInfo.iCodeStartInFile))
					{
					__NK_ASSERT_DEBUG(0);
					return KErrCorrupt;
					}
				last = iCodePageOffsets[j];
				}
			}
			break;

		default:
			return KErrNotSupported;
		}		

	// Copy block map data itself...

#ifdef __DUMP_BLOCKMAP_INFO
	Kern::Printf("Original block map");
	Kern::Printf("  block granularity: %d", aInfo.iCodeBlockMapCommon.iBlockGranularity);
	Kern::Printf("  block start offset: %x", aInfo.iCodeBlockMapCommon.iBlockStartOffset);
	Kern::Printf("  start block address: %016lx", aInfo.iCodeBlockMapCommon.iStartBlockAddress);
	Kern::Printf("  local drive number: %d", aInfo.iCodeBlockMapCommon.iLocalDriveNumber);
	Kern::Printf("  entry size: %d", aInfo.iCodeBlockMapEntriesSize);
#endif

	// Find relevant paging device
	iCodeLocalDrive = aInfo.iCodeBlockMapCommon.iLocalDriveNumber;
	if (TUint(iCodeLocalDrive) >= (TUint)KMaxLocalDrives)
		{
		__KTRACE_OPT(KPAGING,Kern::Printf("Bad local drive number"));
		return KErrArgument;
		}
	DemandPaging* pager = DemandPaging::ThePager;
	
	if (!pager->CodePagingDevice(iCodeLocalDrive).iInstalled)
		{
		__KTRACE_OPT(KPAGING,Kern::Printf("No paging device installed for drive"));
		return KErrNotSupported;
		}
	DPagingDevice* device = pager->CodePagingDevice(iCodeLocalDrive).iDevice;

	// Set code start offset
	iCodeStartInFile = aInfo.iCodeStartInFile;
	if (iCodeStartInFile < 0)
		{
		__KTRACE_OPT(KPAGING,Kern::Printf("Bad code start offset"));
		return KErrArgument;
		}
	
	// Allocate buffer for block map and copy from user-side
	TBlockMapEntryBase* buffer = (TBlockMapEntryBase*)Kern::Alloc(aInfo.iCodeBlockMapEntriesSize);
	if (!buffer)
		return KErrNoMemory;
	kumemget32(buffer, aInfo.iCodeBlockMapEntries, aInfo.iCodeBlockMapEntriesSize);
	
#ifdef __DUMP_BLOCKMAP_INFO
	Kern::Printf("  entries:");
	for (TInt k = 0 ; k < aInfo.iCodeBlockMapEntriesSize / sizeof(TBlockMapEntryBase) ; ++k)
		Kern::Printf("    %d: %d blocks at %08x", k, buffer[k].iNumberOfBlocks, buffer[k].iStartBlock);
#endif

	// Initialise block map
	TInt r = iBlockMap.Initialise(aInfo.iCodeBlockMapCommon,
								  buffer,
								  aInfo.iCodeBlockMapEntriesSize,
								  device->iReadUnitShift,
								  iCodeStartInFile + aInfo.iCodeLengthInFile);
	if (r != KErrNone)
		{
		Kern::Free(buffer);
		return r;
		}

#if defined(__DUMP_BLOCKMAP_INFO) && defined(_DEBUG)
	iBlockMap.Dump();
#endif
	
	return KErrNone;
	}

/**
Read code relocation table and import fixup table from user side.
*/
TInt DMmuCodeSegMemory::ReadFixupTables(const TCodeSegCreateInfo& aInfo)
	{
	__KTRACE_OPT(KPAGING,Kern::Printf("DP: Reading fixup tables for %C", iCodeSeg));
	
	iCodeRelocTableSize = aInfo.iCodeRelocTableSize;
	iImportFixupTableSize = aInfo.iImportFixupTableSize;
	iCodeDelta = aInfo.iCodeDelta;
	iDataDelta = aInfo.iDataDelta;
	
	// round sizes to four-byte boundaris...
	TInt relocSize = (iCodeRelocTableSize + 3) & ~3;
	TInt fixupSize = (iImportFixupTableSize + 3) & ~3;

	// copy relocs and fixups...
	iCodeRelocTable = (TUint8*)Kern::Alloc(relocSize+fixupSize);
	if (!iCodeRelocTable)
		return KErrNoMemory;
	iImportFixupTable = iCodeRelocTable + relocSize;
	kumemget32(iCodeRelocTable, aInfo.iCodeRelocTable, relocSize);
	kumemget32(iImportFixupTable, aInfo.iImportFixupTable, fixupSize);
	
	return KErrNone;
	}

#endif


TInt DMmuCodeSegMemory::Create(TCodeSegCreateInfo& aInfo)
	{
	TInt r = KErrNone;	
	if (!aInfo.iUseCodePaging)
		iPageCount=(iRamInfo.iCodeSize+iRamInfo.iDataSize+KPageMask)>>KPageShift;
	else
		{
#ifdef __DEMAND_PAGING__
		iDataSectionMemory = Kern::Alloc(iRamInfo.iDataSize);
		if (!iDataSectionMemory)
			return KErrNoMemory;

		iPageCount=(iRamInfo.iCodeSize+KPageMask)>>KPageShift;
		iDataPageCount=(iRamInfo.iDataSize+KPageMask)>>KPageShift;

		r = ReadBlockMap(aInfo);
		if (r != KErrNone)
			return r;

		iIsDemandPaged = ETrue;
		iCodeSeg->iAttr |= ECodeSegAttCodePaged;
#endif
		}

	iCodeSeg->iSize = (iPageCount+iDataPageCount)<<KPageShift;
	return r;		
	}


TInt DMmuCodeSegMemory::Loaded(TCodeSegCreateInfo& aInfo)
	{
#ifdef __DEMAND_PAGING__
	if(iIsDemandPaged)
		{
		TInt r = ReadFixupTables(aInfo);
		if (r != KErrNone)
			return r;
		}
	TAny* dataSection = iDataSectionMemory;
	if(dataSection)
		{
		UNLOCK_USER_MEMORY();
		memcpy(dataSection,(TAny*)iRamInfo.iDataLoadAddr,iRamInfo.iDataSize);
		LOCK_USER_MEMORY();
		iRamInfo.iDataLoadAddr = (TLinAddr)dataSection;
		}
#endif
	return KErrNone;
	}


void DMmuCodeSegMemory::ApplyCodeFixups(TUint32* aBuffer, TLinAddr aDestAddress)
	{
	__NK_ASSERT_DEBUG(iRamInfo.iCodeRunAddr==iRamInfo.iCodeLoadAddr); // code doesn't work if this isn't true

	START_PAGING_BENCHMARK;
	
	TUint offset = aDestAddress - iRamInfo.iCodeRunAddr;
	__ASSERT_ALWAYS(offset < (TUint)(iRamInfo.iCodeSize + iRamInfo.iDataSize), K::Fault(K::ECodeSegBadFixupAddress));

	// Index tables are only valid for pages containg code
	if (offset >= (TUint)iRamInfo.iCodeSize)
		return;

	UNLOCK_USER_MEMORY();

	TInt page = offset >> KPageShift;

	// Relocate code
	
	if (iCodeRelocTableSize > 0)
		{
		TUint32* codeRelocTable32 = (TUint32*)iCodeRelocTable;
		TUint startOffset = codeRelocTable32[page];
		TUint endOffset = codeRelocTable32[page + 1];
		
		__KTRACE_OPT(KPAGING, Kern::Printf("Performing code relocation: start == %x, end == %x", startOffset, endOffset));
		__ASSERT_ALWAYS(startOffset <= endOffset && endOffset <= (TUint)iCodeRelocTableSize,
						K::Fault(K::ECodeSegBadFixupTables));
		
		TUint8* codeRelocTable8 = (TUint8*)codeRelocTable32;
		const TUint16* ptr = (const TUint16*)(codeRelocTable8 + startOffset);
		const TUint16* end = (const TUint16*)(codeRelocTable8 + endOffset);

		const TUint32 codeDelta = iCodeDelta;
		const TUint32 dataDelta = iDataDelta;

		while (ptr < end)
			{
			TUint16 entry = *ptr++;

			// address of word to fix up is sum of page start and 12-bit offset
			TUint32* addr = (TUint32*)((TUint8*)aBuffer + (entry & 0x0fff));
			
			TUint32 word = *addr;
#ifdef _DEBUG
			TInt type = entry & 0xf000;
			__NK_ASSERT_DEBUG(type == KTextRelocType || type == KDataRelocType);
#endif
			if (entry < KDataRelocType /* => type == KTextRelocType */)
				word += codeDelta;
			else
				word += dataDelta;
			*addr = word;
			}
		}
		
	// Fixup imports
			
	if (iImportFixupTableSize > 0)
		{
		TUint32* importFixupTable32 = (TUint32*)iImportFixupTable;
		TUint startOffset = importFixupTable32[page];
		TUint endOffset = importFixupTable32[page + 1];
		
		__KTRACE_OPT(KPAGING, Kern::Printf("Performing import fixup: start == %x, end == %x", startOffset, endOffset));
		__ASSERT_ALWAYS(startOffset <= endOffset && endOffset <= (TUint)iImportFixupTableSize,
						K::Fault(K::ECodeSegBadFixupTables));
		
		TUint8* importFixupTable8 = (TUint8*)importFixupTable32;
		const TUint16* ptr = (const TUint16*)(importFixupTable8 + startOffset);
		const TUint16* end = (const TUint16*)(importFixupTable8 + endOffset);

		while (ptr < end)
			{
			TUint16 offset = *ptr++;
		
			// get word to write into that address
			// (don't read as a single TUint32 because may not be word-aligned)
			TUint32 wordLow = *ptr++;
			TUint32 wordHigh = *ptr++;
			TUint32 word = (wordHigh << 16) | wordLow;

			__KTRACE_OPT(KPAGING, Kern::Printf("DP: Fixup %08x=%08x", iRamInfo.iCodeRunAddr+(page<<KPageShift)+offset, word));
			*(TUint32*)((TLinAddr)aBuffer+offset) = word;
			}
		}
	
	LOCK_USER_MEMORY();

	END_PAGING_BENCHMARK(DemandPaging::ThePager, EPagingBmFixupCodePage);
	}


TInt DMmuCodeSegMemory::ApplyCodeFixupsOnLoad(TUint32* aBuffer, TLinAddr aDestAddress)
	{
#ifdef __DEMAND_PAGING__
	TInt r=DemandPaging::ThePager->LockRegion((TLinAddr)aBuffer,KPageSize,&Kern::CurrentProcess());
	if(r!=KErrNone)
		return r;
#endif
	ApplyCodeFixups(aBuffer,aDestAddress);
	UNLOCK_USER_MEMORY();
	CacheMaintenance::CodeChanged((TLinAddr)aBuffer, KPageSize);
	LOCK_USER_MEMORY();
#ifdef __DEMAND_PAGING__
	DemandPaging::ThePager->UnlockRegion((TLinAddr)aBuffer,KPageSize,&Kern::CurrentProcess());
#endif
	return KErrNone;
	}


#ifdef __DEMAND_PAGING__

TInt M::CreateVirtualPinObject(TVirtualPinObject*& aPinObject)
	{
	aPinObject = (TVirtualPinObject*) new DDemandPagingLock;
	return aPinObject != NULL ? KErrNone : KErrNoMemory;
	}

TInt M::PinVirtualMemory(TVirtualPinObject* aPinObject, TLinAddr aStart, TUint aSize, DThread* aThread)
	{
	if (!DemandPaging::ThePager)
		return KErrNone;
	
	if (!DemandPaging::ThePager->MayBePaged(aStart, aSize))
		return KErrNone;

	DDemandPagingLock* lock = (DDemandPagingLock*)aPinObject;
	TInt r = lock->Alloc(aSize);
	if (r != KErrNone)
		return r;
	lock->Lock(aThread, aStart, aSize);
	return KErrNone;
	}

TInt M::CreateAndPinVirtualMemory(TVirtualPinObject*& aPinObject, TLinAddr aStart, TUint aSize)
	{
	aPinObject = 0;

	if (!DemandPaging::ThePager)
		return KErrNone;
	if (!DemandPaging::ThePager->MayBePaged(aStart, aSize))
		return KErrNone;

	TInt r = CreateVirtualPinObject(aPinObject);
	if (r != KErrNone)
		return r;

	DDemandPagingLock* lock = (DDemandPagingLock*)aPinObject;
	r = lock->Alloc(aSize);
	if (r != KErrNone)
		return r;
	lock->Lock(TheCurrentThread, aStart, aSize);
	return KErrNone;
	}

void M::UnpinVirtualMemory(TVirtualPinObject* aPinObject)
	{
	DDemandPagingLock* lock = (DDemandPagingLock*)aPinObject;
	if (lock)
		lock->Free();
	}
	
void M::DestroyVirtualPinObject(TVirtualPinObject*& aPinObject)
	{
	DDemandPagingLock* lock = (DDemandPagingLock*)__e32_atomic_swp_ord_ptr(&aPinObject, 0);
	if (lock)
		lock->AsyncDelete();
	}

#else

class TVirtualPinObject
	{	
	};

TInt M::CreateVirtualPinObject(TVirtualPinObject*& aPinObject)
	{
	aPinObject = new TVirtualPinObject;
	return aPinObject != NULL ? KErrNone : KErrNoMemory;
	}

TInt M::PinVirtualMemory(TVirtualPinObject* aPinObject, TLinAddr, TUint, DThread*)
	{
	__ASSERT_DEBUG(aPinObject, K::Fault(K::EVirtualPinObjectBad));
	(void)aPinObject;
	return KErrNone;
	}

TInt M::CreateAndPinVirtualMemory(TVirtualPinObject*& aPinObject, TLinAddr, TUint)
	{
	aPinObject = 0;
	return KErrNone;
	}

void M::UnpinVirtualMemory(TVirtualPinObject* aPinObject)
	{
	__ASSERT_DEBUG(aPinObject, K::Fault(K::EVirtualPinObjectBad));
	(void)aPinObject;
	}

void M::DestroyVirtualPinObject(TVirtualPinObject*& aPinObject)
	{
	TVirtualPinObject* object = (TVirtualPinObject*)__e32_atomic_swp_ord_ptr(&aPinObject, 0);
	if (object)
		Kern::AsyncFree(object);
	}

#endif

TInt M::CreatePhysicalPinObject(TPhysicalPinObject*& aPinObject)
	{
	return KErrNotSupported;
	}

TInt M::PinPhysicalMemory(TPhysicalPinObject*, TLinAddr, TUint, TBool, TUint32&, TUint32*, TUint32&, TUint&, DThread*)
	{
	K::Fault(K::EPhysicalPinObjectBad);
	return KErrNone;
	}

void M::UnpinPhysicalMemory(TPhysicalPinObject* aPinObject)
	{
	K::Fault(K::EPhysicalPinObjectBad);
	}

void M::DestroyPhysicalPinObject(TPhysicalPinObject*& aPinObject)
	{
	K::Fault(K::EPhysicalPinObjectBad);
	}


//
// Kernel map and pin (Not supported on the moving or multiple memory models).
//

TInt M::CreateKernelMapObject(TKernelMapObject*&, TUint)
	{
	return KErrNotSupported;
	}


TInt M::MapAndPinMemory(TKernelMapObject*, DThread*, TLinAddr, TUint, TUint, TLinAddr&, TPhysAddr*)
	{
	return KErrNotSupported;
	}


void M::UnmapAndUnpinMemory(TKernelMapObject*)
	{
	}


void M::DestroyKernelMapObject(TKernelMapObject*&)
	{
	}


// Misc DPagingDevice methods

EXPORT_C NFastMutex* DPagingDevice::NotificationLock()
	{
	// use the system lock
	return &TheScheduler.iLock;
	}

EXPORT_C void DPagingDevice::NotifyIdle()
	{
	// Not used on this memory model
	}

EXPORT_C void DPagingDevice::NotifyBusy()
	{
	// Not used on this memory model
	}

EXPORT_C TInt Cache::SyncPhysicalMemoryBeforeDmaWrite(TPhysAddr* , TUint , TUint , TUint , TUint32 )
	{
	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"Cache::SyncPhysicalMemoryBeforeDmaWrite");
	return KErrNotSupported;
	}

EXPORT_C TInt Cache::SyncPhysicalMemoryBeforeDmaRead(TPhysAddr* , TUint , TUint , TUint , TUint32 )
	{
	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"Cache::SyncPhysicalMemoryBeforeDmaRead");
	return KErrNotSupported;
	}
EXPORT_C TInt Cache::SyncPhysicalMemoryAfterDmaRead(TPhysAddr* , TUint , TUint , TUint , TUint32 )
	{
	CHECK_PRECONDITIONS(MASK_THREAD_STANDARD,"Cache::SyncPhysicalMemoryAfterDmaRead");
	return KErrNotSupported;
	}

//
//	Page moving methods
//

/*
 * Move a page from aOld to aNew safely, updating any references to the page
 * stored elsewhere (such as page table entries). The destination page must
 * already be allocated. If the move is successful, the source page will be
 * freed and returned to the allocator.
 *
 * @pre RAM alloc mutex must be held.
 * @pre Calling thread must be in a critical section.
 * @pre Interrupts must be enabled.
 * @pre Kernel must be unlocked.
 * @pre No fast mutex can be held.
 * @pre Call in a thread context.
 */
TInt MmuBase::MovePage(TPhysAddr aOld, TPhysAddr& aNew, TUint aBlockZoneId, TBool aBlockRest)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL, "Defrag::DoMovePage");
	__ASSERT_WITH_MESSAGE_MUTEX(MmuBase::RamAllocatorMutex, "Ram allocator mutex must be held", "Defrag::DoMovePage");
	__KTRACE_OPT(KMMU,Kern::Printf("MmuBase::MovePage() old=%08x",aOld));
	TInt r = KErrNotSupported;
#if defined(__CPU_X86) && defined(__MEMMODEL_MULTIPLE__)
	return r;
#endif
	aNew = KPhysAddrInvalid;
	NKern::LockSystem();
	SPageInfo* pi = SPageInfo::SafeFromPhysAddr(aOld);
	if (!pi)
		{
		__KTRACE_OPT(KMMU,Kern::Printf("MmuBase::MovePage() fails: page has no PageInfo"));
		r = KErrArgument;
		goto fail;
		}
	if (pi->LockCount())
		{
		__KTRACE_OPT(KMMU,Kern::Printf("MmuBase::MovePage() fails: page is locked"));
		goto fail;
		}
	
	switch(pi->Type())
		{
	case SPageInfo::EUnused:
		// Nothing to do - we allow this, though, in case the caller wasn't
		// actually checking the free bitmap.
		r = KErrNotFound;
		__KTRACE_OPT(KMMU,Kern::Printf("MmuBase::MovePage(): page unused"));
		break;

	case SPageInfo::EChunk:
		{
		// It's a chunk - we need to investigate what it's used for.
		DChunk* chunk = (DChunk*)pi->Owner();
		TInt offset = pi->Offset()<<KPageShift;

		switch(chunk->iChunkType)
			{
		case EKernelData:
		case EKernelMessage:
			// The kernel data/bss/heap chunk pages are not moved as DMA may be accessing them.
			__KTRACE_OPT(KMMU, Kern::Printf("MmuBase::MovePage() fails: kernel data"));
			goto fail;

		case EKernelStack:
			// The kernel thread stack chunk.
			r = MoveKernelStackPage(chunk, offset, aOld, aNew, aBlockZoneId, aBlockRest);
			__KTRACE_OPT(KMMU,if (r!=KErrNone) Kern::Printf("MmuBase::MovePage() fails: k stack r%d",r));
			__NK_ASSERT_DEBUG(NKern::HeldFastMutex()==0);
 			goto released;

		case EKernelCode:
		case EDll:
			// The kernel code chunk, or a global user code chunk.
			r = MoveCodeChunkPage(chunk, offset, aOld, aNew, aBlockZoneId, aBlockRest);
			__KTRACE_OPT(KMMU,if (r!=KErrNone) Kern::Printf("MmuBase::MovePage() fails: code chk r%d",r));
			__NK_ASSERT_DEBUG(NKern::HeldFastMutex()==0);
			goto released;

		case ERamDrive:
		case EUserData:
		case EDllData:
		case EUserSelfModCode:
			// A data chunk of some description.
			r = MoveDataChunkPage(chunk, offset, aOld, aNew, aBlockZoneId, aBlockRest);
			__KTRACE_OPT(KMMU,if (r!=KErrNone) Kern::Printf("MmuBase::MovePage() fails: data chk r%d",r));
			__NK_ASSERT_DEBUG(NKern::HeldFastMutex()==0);
			goto released;

		case ESharedKernelSingle:
		case ESharedKernelMultiple:
		case ESharedIo:
		case ESharedKernelMirror:
			// These chunk types cannot be moved
			r = KErrNotSupported;
			__KTRACE_OPT(KMMU,if (r!=KErrNone) Kern::Printf("MmuBase::MovePage() fails: shared r%d",r));
			break;

		case EUserCode:
		default:
			// Unknown page type, or EUserCode.
			// EUserCode is not used in moving model, and on multiple model
			// it never owns any pages so shouldn't be found via SPageInfo
			__KTRACE_OPT(KMMU,Kern::Printf("Defrag::DoMovePage fails: unknown chunk type %d",chunk->iChunkType));
			Panic(EDefragUnknownChunkType);
			}
		}
		break;

	case SPageInfo::ECodeSegMemory:
		// It's a code segment memory section (multiple model only)
		r = MoveCodeSegMemoryPage((DMemModelCodeSegMemory*)pi->Owner(), pi->Offset()<<KPageShift, aOld, aNew, aBlockZoneId, aBlockRest);
		__KTRACE_OPT(KMMU,if (r!=KErrNone) Kern::Printf("MmuBase::MovePage() fails: codeseg r%d",r));
		__NK_ASSERT_DEBUG(NKern::HeldFastMutex()==0);
		goto released;

	case SPageInfo::EPagedROM:
	case SPageInfo::EPagedCode:
	case SPageInfo::EPagedData:
	case SPageInfo::EPagedCache:
	case SPageInfo::EPagedFree:
		{// DP or RamCache page so attempt to discard it. Added for testing purposes only
		//  In normal use ClearDiscardableFromZone will have already removed RAM cache pages
		r = KErrInUse;
		MmuBase& mmu = *MmuBase::TheMmu;
		RamCacheBase& ramCache = *(mmu.iRamCache);
		if (ramCache.IsPageDiscardable(*pi))
			{
			if (ramCache.DoDiscardPage(*pi, KRamZoneInvalidId, EFalse))
				{// Sucessfully discarded the page.
				r = KErrNone;
				}
			}
		__KTRACE_OPT(KMMU,if (r!=KErrNone) Kern::Printf("MmuBase::MovePage() fails: paged r%d",r));
		goto fail; // Goto fail to release the system lock.	
		}

		
	case SPageInfo::EPageTable:
	case SPageInfo::EPageDir:
	case SPageInfo::EPtInfo:
	case SPageInfo::EInvalid:
	case SPageInfo::EFixed:
	case SPageInfo::EShadow:
		// These page types cannot be moved (or don't need to be moved)
		r = KErrNotSupported;
		__KTRACE_OPT(KMMU,if (r!=KErrNone) Kern::Printf("MmuBase::MovePage() fails: PT etc r%d",r));
		break;

	default:
		// Unknown page type
		__KTRACE_OPT(KMMU,Kern::Printf("MmuBase::MovePage() fails: unknown page type %d",pi->Type()));
		Panic(EDefragUnknownPageType);
		}

fail:
	NKern::UnlockSystem();
released:
	__KTRACE_OPT(KMMU,Kern::Printf("MmuBase::MovePage() returns %d",r));
	return r;
	}


TInt MmuBase::DiscardPage(TPhysAddr aAddr, TUint aBlockZoneId, TBool aBlockRest)
	{
	TInt r = KErrInUse;
	NKern::LockSystem();
	SPageInfo* pageInfo = SPageInfo::SafeFromPhysAddr(aAddr);
	if (pageInfo != NULL)
		{// Allocatable page at this address so is it a discardable one?
		if (iRamCache->IsPageDiscardable(*pageInfo))
			{
			// Discard this page and return it to the ram allocator
			if (!iRamCache->DoDiscardPage(*pageInfo, aBlockZoneId, aBlockRest))
				{// Couldn't discard the page.
				if (aBlockRest)
					{
					__KTRACE_OPT(KMMU, Kern::Printf("ClearDiscardableFromZone: page discard fail addr %x", aAddr));
					NKern::UnlockSystem();
					return KErrNoMemory;
					}
				}
			else
				{// Page discarded successfully.
				r = KErrNone;
				}
			}
		}
	NKern::UnlockSystem();
	return r;
	}

TUint MmuBase::NumberOfFreeDpPages()
	{
	TUint free = 0;
	if(iRamCache)
		{
		free = iRamCache->NumberOfFreePages();
		}
	return free;
	}


EXPORT_C TInt Epoc::MovePhysicalPage(TPhysAddr aOld, TPhysAddr& aNew, TRamDefragPageToMove aPageToMove)
	{
	CHECK_PRECONDITIONS(MASK_THREAD_CRITICAL,"Epoc::MovePhysicalPage");
	__KTRACE_OPT(KMMU,Kern::Printf("Epoc::MovePhysicalPage() old=%08x pageToMove=%d",aOld,aPageToMove));

	switch(aPageToMove)
		{
		case ERamDefragPage_Physical:
			break;
		default:
			return KErrNotSupported;
		}

	MmuBase::Wait();
	TInt r=M::MovePage(aOld,aNew,KRamZoneInvalidId,0);
	if (r!=KErrNone)
		aNew = KPhysAddrInvalid;
	MmuBase::Signal();
	__KTRACE_OPT(KMMU,Kern::Printf("Epoc::MovePhysicalPage() returns %d",r));
	return r;
	}


TInt M::RamDefragFault(TAny* aExceptionInfo)
	{
	// If the mmu has been initialised then let it try processing the fault.
	if(MmuBase::TheMmu)
		return MmuBase::TheMmu->RamDefragFault(aExceptionInfo);
	return KErrAbort;
	}


void M::RamZoneClaimed(SZone* aZone)
	{
	// Lock each page.  OK to traverse SPageInfo array as we know no unknown
	// pages are in the zone.
	SPageInfo* pageInfo = SPageInfo::FromPhysAddr(aZone->iPhysBase);
	SPageInfo* pageInfoEnd = pageInfo + aZone->iPhysPages;
	for (; pageInfo < pageInfoEnd; ++pageInfo)
		{
		NKern::LockSystem();
		__NK_ASSERT_DEBUG(pageInfo->Type()==SPageInfo::EUnused);
		pageInfo->Lock();
		NKern::UnlockSystem();
		}
	// For the sake of platform security we have to clear the memory. E.g. the driver
	// could assign it to a chunk visible to user side.  Set LSB so ClearPages
	// knows this is a contiguous memory region.
	Mmu::Get().ClearPages(aZone->iPhysPages, (TPhysAddr*)(aZone->iPhysBase|1));
	}
