// Copyright (c) 1994-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\moving\mchunk.cpp
// 
//

#include "memmodel.h"
#include "cache_maintenance.h"
#include <mmubase.inl>
#include <ramalloc.h>

DMemModelChunk::DMemModelChunk()
	{
	}

void DMemModelChunk::Destruct()
	{
	__KTRACE_OPT(KTHREAD,Kern::Printf("DMemModelChunk destruct %O",this));
	Mmu& m = Mmu::Get();
	TInt nPdes=iMaxSize>>m.iChunkShift;
	if (nPdes<=32 || iPdeBitMap!=NULL)
		{
		if ((iAttributes & EDisconnected) && iPageBitMap!=NULL)
			Decommit(0,iMaxSize);
		else if (iAttributes & EDoubleEnded)
			AdjustDoubleEnded(0,0);
		else
			Adjust(0);
		}

	if ((iAttributes&EFixedAddress) && iHomeRegionBase>=m.iKernelSection->iBase)
		{
		Mmu::Wait();
		__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::~DMemModelChunk remove region"));
		if (TLinAddr(iBase)==iHomeBase)
			iBase=NULL;
		DeallocateHomeAddress();	// unlink from home section queue
		iHomeRegionBase=0;
		iHomeBase=0;
		Mmu::Signal();
		}
	if ((iMaxSize>>m.iChunkShift) > 32)
		{
		TAny* pM = __e32_atomic_swp_ord_ptr(&iPdeBitMap, 0);
		Kern::Free(pM);
		}
	TBitMapAllocator* pM = (TBitMapAllocator*)__e32_atomic_swp_ord_ptr(&iPageBitMap, 0);
	delete pM;
	pM = (TBitMapAllocator*)__e32_atomic_swp_ord_ptr(&iPermanentPageBitMap, 0);
	delete pM;

	TDfc* dfc = (TDfc*)__e32_atomic_swp_ord_ptr(&iDestroyedDfc, 0);
	if(dfc)
		dfc->Enque();

	__KTRACE_OPT(KMEMTRACE, {Mmu::Wait(); Kern::Printf("MT:D %d %x %O",NTickCount(),this,this);Mmu::Signal();});
#ifdef BTRACE_CHUNKS
	BTraceContext4(BTrace::EChunks,BTrace::EChunkDestroyed,this);
#endif
	}

TInt DMemModelChunk::Close(TAny* aPtr)
	{
	if (aPtr)
		{
		DMemModelProcess* pP=(DMemModelProcess*)aPtr;
		pP->RemoveChunk(this);
		}
	TInt r=Dec();
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::Close %d %O",r,this));
	__NK_ASSERT_DEBUG(r > 0); // Should never be negative.
	if (r==1)
		{
		K::ObjDelete(this);
		return EObjectDeleted;
		}
	return 0;
	}


TUint8* DMemModelChunk::Base(DProcess* aProcess)
	{
	return iBase;
	}


TInt DMemModelChunk::DoCreate(SChunkCreateInfo& aInfo)
	{
	__ASSERT_COMPILE(!(EMMChunkAttributesMask & EChunkAttributesMask));

	if (aInfo.iMaxSize<=0)
		return KErrArgument;
	Mmu& m=Mmu::Get();
	TInt nPdes=(aInfo.iMaxSize+m.iChunkMask)>>m.iChunkShift;
	iMaxSize=nPdes<<m.iChunkShift;
	iMapAttr = aInfo.iMapAttr;
	SetupPermissions();
	if (nPdes>32)
		{
		TInt words=(nPdes+31)>>5;
		iPdeBitMap=(TUint32*)Kern::Alloc(words*sizeof(TUint32));
		if (!iPdeBitMap)
			return KErrNoMemory;
		memclr(iPdeBitMap, words*sizeof(TUint32));
		}
	else
		iPdeBitMap=NULL;

	TInt maxpages=iMaxSize>>m.iPageShift;
	if (iAttributes & EDisconnected)
		{
		TBitMapAllocator* pM=TBitMapAllocator::New(maxpages,ETrue);
		if (!pM)
			return KErrNoMemory;
		iPageBitMap=pM;
		__KTRACE_OPT(KMMU,Kern::Printf("PageBitMap at %08x, MaxPages %d",pM,maxpages));
		}
	if(iChunkType==ESharedKernelSingle || iChunkType==ESharedKernelMultiple)
		{
		TBitMapAllocator* pM=TBitMapAllocator::New(maxpages,ETrue);
		if (!pM)
			return KErrNoMemory;
		iPermanentPageBitMap = pM;
		}
	__KTRACE_OPT(KMEMTRACE, {Mmu::Wait();Kern::Printf("MT:C %d %x %O",NTickCount(),this,this);Mmu::Signal();});
#ifdef BTRACE_CHUNKS
	TKName nameBuf;
	Name(nameBuf);
	BTraceContextN(BTrace::EChunks,BTrace::EChunkCreated,this,iMaxSize,nameBuf.Ptr(),nameBuf.Size());
	if(iOwningProcess)
		BTrace8(BTrace::EChunks,BTrace::EChunkOwner,this,iOwningProcess);
	BTraceContext12(BTrace::EChunks,BTrace::EChunkInfo,this,iChunkType,iAttributes);
#endif
	return KErrNone;
	}

void DMemModelChunk::ClaimInitialPages()
	{
	__KTRACE_OPT(KMMU,Kern::Printf("Chunk %O ClaimInitialPages()",this));
	Mmu& m=Mmu::Get();
	TInt offset=0;
	TUint32 ccp=K::CompressKHeapPtr(this);
	NKern::LockSystem();
	while(offset<iSize)
		{
		TInt ptid=m.GetPageTableId(TLinAddr(iBase)+offset);
		__ASSERT_ALWAYS(ptid>=0,MM::Panic(MM::EClaimInitialPagesBadPageTable));
		__KTRACE_OPT(KMMU,Kern::Printf("Offset %x PTID=%d",offset,ptid));
		AddPde(offset);
		SPageTableInfo& ptinfo = m.PtInfo(ptid);
		ptinfo.SetChunk(ccp,offset>>m.iChunkShift);
		TPte* pPte=(TPte*)m.PageTableLinAddr(ptid);
		TInt i;
		TInt np = 0;
		TInt flashCount = MM::MaxPagesInOneGo;
		for (i=0; i<m.iChunkSize>>m.iPageShift; ++i, offset+=m.iPageSize)
			{
			if(--flashCount<=0)
				{
				flashCount = MM::MaxPagesInOneGo;
				NKern::FlashSystem();
				}
			TPte pte=pPte[i];
			if (m.PteIsPresent(pte))
				{
				++np;
				TPhysAddr phys=m.PtePhysAddr(pte, i);
				__KTRACE_OPT(KMMU,Kern::Printf("Offset %x phys %08x",offset,phys));
				SPageInfo* pi = SPageInfo::SafeFromPhysAddr(phys);
				if (pi)
					{
					pi->SetChunk(this,offset>>m.iPageShift);
#ifdef BTRACE_KERNEL_MEMORY
					--Epoc::KernelMiscPages; // page now owned by chunk, and is not 'miscelaneous'
#endif
					}
				}
			}
		ptinfo.iCount = np;
		__KTRACE_OPT(KMMU,Kern::Printf("Offset %x PTID %d NP %d", offset, ptid, np));
		}
	NKern::UnlockSystem();
	__KTRACE_OPT(KMMU,Kern::Printf("nPdes=%d, Pdes=%08x, HomePdes=%08x",iNumPdes,iPdes,iHomePdes));
	}

void DMemModelChunk::SetFixedAddress(TLinAddr aAddr, TInt aInitialSize)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk %O SetFixedAddress %08X size %08X",this,aAddr,aInitialSize));
	iHomeRegionOffset=0;
	iHomeRegionBase=aAddr;
	iHomeBase=aAddr;
	iBase=(TUint8*)aAddr;
	iHomeRegionSize=iMaxSize;
	iAttributes|=EFixedAddress;
	iSize=Mmu::RoundToPageSize(aInitialSize);
	ClaimInitialPages();
	}

TInt DMemModelChunk::Reserve(TInt aInitialSize)
//
// Reserve home section address space for a chunk
//
	{
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk %O Reserve() size %08x",this,aInitialSize));
	iHomeRegionOffset=0;
	if (!K::Initialising)
		Mmu::Wait();
	iHomeRegionBase=AllocateHomeAddress(iMaxSize);
	if (!K::Initialising)
		Mmu::Signal();
	iHomeBase=iHomeRegionBase;
	iBase=(TUint8*)iHomeRegionBase;
	if (iHomeRegionBase==0)
		return KErrNoMemory;
	iSize=Mmu::RoundToPageSize(aInitialSize);
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk %O address %08x",this,iHomeRegionBase));
	ClaimInitialPages();
	return KErrNone;
	}

TInt DMemModelChunk::Adjust(TInt aNewSize)
//
// Adjust a standard chunk.
//
	{

	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::Adjust %08x",aNewSize));
	if (iAttributes & (EDoubleEnded|EDisconnected))
		return KErrGeneral;
	if (aNewSize<0 || aNewSize>iMaxSize)
		return KErrArgument;

	TInt r=KErrNone;
	TInt newSize=Mmu::RoundToPageSize(aNewSize);
	if (newSize!=iSize)
		{
		Mmu::Wait();
		if (newSize>iSize)
			{
			__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::Adjust growing"));
			r=DoCommit(iSize,newSize-iSize);
			}
		else if (newSize<iSize)
			{
			__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::Adjust shrinking"));
			DoDecommit(newSize,iSize-newSize);
			}
		Mmu::Signal();
		}
	__COND_DEBUG_EVENT(r==KErrNone, EEventUpdateChunk, this);
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk %O adjusted to %x base %08x home %08x",this,iSize,iBase,iHomeRegionBase));
	return r;
	}

TInt DMemModelChunk::ExpandHomeRegion(TInt aOffset, TInt aSize)
	{
	// Ensure that the chunk's home region is big enough to accommodate extra RAM being committed
	__KTRACE_OPT(KMMU,Kern::Printf("Chunk %O ExpandHomeRegion(%x,%x)",this,aOffset,aSize));
	Mmu& m = Mmu::Get();
	TBool lowerLimitOk=(aOffset>=iHomeRegionOffset && aOffset<=iHomeRegionOffset+iHomeRegionSize);
	TBool upperLimitOk=(aOffset+aSize>=iHomeRegionOffset && aOffset+aSize<=iHomeRegionOffset+iHomeRegionSize);
	if (lowerLimitOk && upperLimitOk)
		return KErrNone;	// no change required
	TInt newLowerLimit;
	TInt newUpperLimit;
	if (iHomeRegionSize)
		{
		newLowerLimit=Min(iHomeRegionOffset,aOffset);
		newUpperLimit=Max(iHomeRegionOffset+iHomeRegionSize,aOffset+aSize);
		}
	else
		{
		newLowerLimit=aOffset;
		newUpperLimit=aOffset+aSize;
		}
	newLowerLimit &= ~m.iChunkMask;
	newUpperLimit = (newUpperLimit+m.iChunkMask)&~m.iChunkMask;
	TInt newHomeRegionSize=newUpperLimit-newLowerLimit;
	__KTRACE_OPT(KMMU,Kern::Printf("newLowerLimit=%x, newUpperLimit=%x",newLowerLimit,newUpperLimit));
	if (newHomeRegionSize>iMaxSize)
		return KErrArgument;
	TLinAddr newHomeRegionBase;
	if (iHomeRegionSize==0)
		newHomeRegionBase=AllocateHomeAddress(newHomeRegionSize);
	else
		newHomeRegionBase=ReallocateHomeAddress(newHomeRegionSize);
	__KTRACE_OPT(KMMU,Kern::Printf("newHomeRegionBase=%08x",newHomeRegionBase));
	if (newHomeRegionBase==0)
		return KErrNoMemory;
	TInt deltaOffset=iHomeRegionOffset-newLowerLimit;
	TLinAddr newHomeBase=newHomeRegionBase-newLowerLimit;
	TLinAddr translatedHomeBase=newHomeRegionBase+deltaOffset;

	// lock the kernel while we change the chunk's home region
	// Note: The new home region always contains the original home region, so
	// if we reach here, it must be strictly larger.
	NKern::LockSystem();
	if (iNumPdes && iHomeRegionBase!=translatedHomeBase)
		{
		TLinAddr oldBase=TLinAddr(iBase);
		if (oldBase==iHomeBase)
			{
			// chunk is currently at home, so must move it
			// Note: this operation must cope with overlapping initial and final regions
			m.GenericFlush(Mmu::EFlushDMove);		// preemption could occur here...
			if (TLinAddr(iBase)==iHomeBase)	// ...so need to check chunk is still at home address
				{
				m.MoveChunk(iHomeRegionBase,translatedHomeBase,iNumPdes);
				iBase=(TUint8*)newHomeBase;
				MoveCurrentPdes(iHomeRegionBase,translatedHomeBase);
				MoveHomePdes(iHomeRegionBase,translatedHomeBase);
				}
			}
		else
			{
			MoveHomePdes(iHomeRegionBase,translatedHomeBase);
			}
		__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::ExpandHomeRegion moved home base from %08x to %08x",
							iHomeRegionBase,newHomeRegionBase));
		}
	if (!iBase)
		iBase=(TUint8*)newHomeBase;
	iHomeRegionBase=newHomeRegionBase;
	iHomeRegionOffset=newLowerLimit;
	iHomeBase=newHomeBase;
	__KTRACE_OPT(KMMU,Kern::Printf("Final iHomeRegionBase=%08x, iHomeRegionOffset=%08x",iHomeRegionBase,iHomeRegionOffset));
	__KTRACE_OPT(KMMU,Kern::Printf("Final iHomeRegionSize=%08x, iBase=%08x, iHomeBase=%08x",iHomeRegionSize,iBase,iHomeBase));
	__KTRACE_OPT(KMMU,Kern::Printf("nPdes=%d, Pdes=%08x, HomePdes=%08x",iNumPdes,iPdes,iHomePdes));
	NKern::UnlockSystem();
	return KErrNone;
	}

TInt DMemModelChunk::Address(TInt aOffset, TInt aSize, TLinAddr& aKernelAddress)
	{
	if(!iPermanentPageBitMap)
		return KErrAccessDenied;
	if(TUint(aOffset)>=TUint(iMaxSize))
		return KErrArgument;
	if(TUint(aOffset+aSize)>TUint(iMaxSize))
		return KErrArgument;
	if(aSize<=0)
		return KErrArgument;
	TInt pageShift = Mmu::Get().iPageShift;
	TInt start = aOffset>>pageShift;
	TInt size = ((aOffset+aSize-1)>>pageShift)-start+1;
	if(iPermanentPageBitMap->NotAllocated(start,size))
		return KErrNotFound;
	aKernelAddress = (TLinAddr)iBase+aOffset;
	return KErrNone;
	}

TInt DMemModelChunk::PhysicalAddress(TInt aOffset, TInt aSize, TLinAddr& aKernelAddress, TUint32& aPhysicalAddress, TUint32* aPhysicalPageList)
	{
	TInt r=Address(aOffset,aSize,aKernelAddress);
	if(r!=KErrNone)
		return r;

	return Mmu::Get().LinearToPhysical(aKernelAddress,aSize,aPhysicalAddress,aPhysicalPageList);
	}

void DMemModelChunk::Substitute(TInt aOffset, TPhysAddr aOldAddr, TPhysAddr aNewAddr)
	{
	// Substitute the page mapping at aOffset with aNewAddr.
	// Called with the system lock held.
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::Substitute %x %08x %08x",aOffset,aOldAddr,aNewAddr));
	Mmu& m = Mmu::Get();
	
	TLinAddr addr=(TLinAddr)iBase+aOffset;
	TInt ptid=m.GetPageTableId(addr);
	if(ptid<0)
		MM::Panic(MM::EChunkRemapNoPageTable);

	m.RemapPage(ptid, addr, aOldAddr, aNewAddr, iPtePermissions, iOwningProcess);
	if(iChunkType==EKernelCode || iChunkType==EDll || iChunkType==EUserSelfModCode)
		m.SyncCodeMappings();
	}

/**
Get the movability type of the chunk's pages
@return How movable the chunk's pages are
*/
TZonePageType DMemModelChunk::GetPageType()
	{
	// Shared chunks have their physical addresses available
	if (iChunkType == ESharedKernelSingle ||
		iChunkType == ESharedKernelMultiple || 
		iChunkType == ESharedIo ||
		iChunkType == ESharedKernelMirror ||
		iChunkType == EKernelMessage ||
		iChunkType == EKernelData)	// Don't move kernel heap pages as DMA may be accessing them.
		{
		return EPageFixed;
		}
	// All other types of chunk are movable
	return EPageMovable;
	}

TInt DMemModelChunk::DoCommit(TInt aOffset, TInt aSize, TCommitType aCommitType, TUint32* aExtraArg)
	{
	// Commit more RAM to a chunk at a specified offset
	// enter and leave with system unlocked
	// must hold RamAlloc mutex before calling this function
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::DoCommit %x+%x type=%d extra=%08x",aOffset,aSize,aCommitType,aExtraArg));
	TInt offset=aOffset;
	TInt endOffset=offset+aSize;
	TInt newPtId=-1;
	Mmu& m = Mmu::Get();
	DRamAllocator& a = *m.iRamPageAllocator;
	TInt r=KErrNone;
	TPhysAddr pageList[KMaxPages];
	TPhysAddr* pPageList=0;
	TPhysAddr nextPage=0;
	TUint32 ccp=K::CompressKHeapPtr(this);
	SPageInfo::TType type = SPageInfo::EChunk;

	if (iHomeRegionSize==0 || (iAttributes&EFixedAddress)==0)
		{
		r=ExpandHomeRegion(aOffset,aSize);
		if (r!=KErrNone)
			return r;
		}

	// Set flag to indicate if RAM should be cleared before being committed.
	// Note, EDll, EUserCode are covered in the code segment, in order not to clear
	// the region overwritten by the loader
	TBool clearRam =	iChunkType==EUserData
					 || iChunkType==EDllData
					 || iChunkType==EUserSelfModCode
					 || iChunkType==ESharedKernelSingle
					 || iChunkType==ESharedKernelMultiple
					 || iChunkType==ESharedIo
                     || iChunkType==ERamDrive;


	TBool ownsMemory = !(iAttributes&EMemoryNotOwned);
	TBool physicalCommit = aCommitType&DChunk::ECommitPhysicalMask;
	if(ownsMemory)
		{
		if(physicalCommit)
			return KErrNotSupported;
		}
	else
		{
		if(!physicalCommit)
			return KErrNotSupported;
		type = SPageInfo::EInvalid;	// to indicate page info not to be updated
		}

	switch(aCommitType)
		{
	case DChunk::ECommitDiscontiguous:
		// No setup to do
		break;

	case DChunk::ECommitContiguous:
		{
		// Allocate a block of contiguous RAM from the free pool
		TInt numPages=(endOffset-offset)>>m.iPageShift;
		__NK_ASSERT_DEBUG(EPageFixed == GetPageType());
		r=m.AllocContiguousRam(numPages<<m.iPageShift, nextPage, 0);
		if (r!=KErrNone)
			return r;
		if(clearRam)
			m.ClearPages(numPages, (TPhysAddr*)(nextPage|1), iClearByte);  // clear RAM if required
		*aExtraArg = nextPage;	// store physical address of RAM as return argument
		}
		break;

	case DChunk::ECommitDiscontiguousPhysical:
		{
		pPageList = aExtraArg;				// use pages given given to us

		// Check address of pages are multiples of page size...
		TInt numPages=(endOffset-offset)>>m.iPageShift;
		TUint32* ptr = aExtraArg;
		TUint32* endPtr = aExtraArg+numPages;
		if(ptr>=endPtr)
			return KErrNone;				// Zero size commit is OK
		TPhysAddr pageBits = 0;
		do
			pageBits |= *ptr++;
		while(ptr<endPtr);
		if(pageBits&(m.iPageSize-1))
			return KErrArgument;			// all addresses must be multiple of page size
		}
		break;

	case DChunk::ECommitContiguousPhysical:
		nextPage = (TPhysAddr)aExtraArg;	// we have been given the physical address to use
		if(nextPage&(m.iPageSize-1))
			return KErrArgument;			// address must be multiple of page size
		break;

#ifdef __MARM__
	case DChunk::ECommitVirtual:
		break;
#endif

	default:
		return KErrNotSupported;
		}

	// Commit memory a bit at a time (so system lock is only needs to be held for limited time)
	while(offset<endOffset)
		{
		TInt np=(endOffset-offset)>>m.iPageShift;	// pages remaining to satisfy request
		TInt npEnd=(m.iChunkSize-(offset&m.iChunkMask))>>m.iPageShift;	// number of pages to end of page table
		if (np>npEnd)
			np=npEnd;								// limit to single page table
		if (np>MM::MaxPagesInOneGo)
			np=MM::MaxPagesInOneGo;					// limit
		NKern::LockSystem();						// lock the system while we look at the page directory
		TLinAddr addr=(TLinAddr)iBase+offset;		// current address
		TInt ptid=m.GetPageTableId(addr);			// get page table ID if a page table is already assigned here
		NKern::UnlockSystem();						// we can now unlock the system
		newPtId=-1;
		if (ptid<0)
			{
			// need to allocate a new page table
			newPtId=m.AllocPageTable();
			if (newPtId<0)
				{
				// out of memory, so break out and revert
				r=KErrNoMemory;
				break;
				}
			ptid=newPtId;
			}

		if(aCommitType==DChunk::ECommitDiscontiguous)
			{
			pPageList = pageList;
			r=m.AllocRamPages(pPageList,np, GetPageType());	// try to allocate pages
			if (r!=KErrNone)
				break;							// if we fail, break out and revert
			if(clearRam)
				m.ClearPages(np, pPageList, iClearByte);	// clear RAM if required
			}

		// lock the system while we change the MMU mappings
		NKern::LockSystem();
		TInt commitSize = np<<m.iPageShift;
		iSize += commitSize;					// update committed size
		if (aCommitType==DChunk::ECommitVirtual)
			m.MapVirtual(ptid, np);
		else if(pPageList)
			{
			m.MapRamPages(ptid, type, this, offset, pPageList, np, iPtePermissions);
			pPageList += np;
			}
		else
			{
			m.MapPhysicalPages(ptid, type, this, offset, nextPage, np, iPtePermissions);
			nextPage += commitSize;
			}
		NKern::UnlockSystem();

		NKern::LockSystem();
		if (newPtId>=0)
			{
			// We have allocated a new page table, now we must assign it and update PDE info
			SPageTableInfo& pti=m.PtInfo(ptid);
			pti.SetChunk(ccp, offset>>m.iChunkShift);
			TLinAddr addr=(TLinAddr)iBase+offset;	// current address
			m.DoAssignPageTable(ptid, addr, iPdePermissions[iChunkState]);
			AddPde(offset);						// update PDE info
			}
		__KTRACE_OPT(KMMU,Kern::Printf("nPdes=%d, Pdes=%08x, HomePdes=%08x",iNumPdes,iPdes,iHomePdes));
		NKern::UnlockSystem();
		__KTRACE_OPT(KMEMTRACE,Kern::Printf("MT:A %d %x %x %O",NTickCount(),this,iSize,this));
#ifdef BTRACE_CHUNKS
		BTraceContext12(BTrace::EChunks,ownsMemory?BTrace::EChunkMemoryAllocated:BTrace::EChunkMemoryAdded,this,offset,commitSize);
#endif

		offset += commitSize;				// update offset
		}

	if (r==KErrNone)
		{
		if(iPermanentPageBitMap)
			iPermanentPageBitMap->Alloc(aOffset>>m.iPageShift,aSize>>m.iPageShift);
		}
	else
		{
		// we ran out of memory somewhere
		// first check if we have an unassigned page table
		if (newPtId>=0)
			m.FreePageTable(newPtId);			// free the unassigned page table

		// now free any memory we succeeded in allocating and return the chunk to its initial state
		DChunk::TDecommitType decommitType = aCommitType==DChunk::ECommitVirtual ?
			DChunk::EDecommitVirtual : DChunk::EDecommitNormal;
		DoDecommit(aOffset,offset-aOffset,decommitType);

		if(aCommitType==DChunk::ECommitContiguous)
			{
			// Free the pages we allocated but didn't get around to commiting
			TPhysAddr last = nextPage + ((endOffset-offset)>>m.iPageShift<<m.iPageShift);
			while(nextPage<last)
				{
				a.FreeRamPage(nextPage, GetPageType());
				nextPage += m.iPageSize;
				}
			*aExtraArg = KPhysAddrInvalid;	// return invalid physical address
			}

		m.iAllocFailed=ETrue;
		}
	return r;
	}

void DMemModelChunk::DoDecommit(TInt aOffset, TInt aSize, TDecommitType aDecommitType)
	{
	// Decommit RAM from a chunk at a specified offset
	// enter and leave with kernel unlocked
	// must hold RamAlloc mutex before calling this function
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::DoDecommit %x+%x",aOffset,aSize));
	if (iHomeRegionBase==0)
		return;
	
	TBool ownsMemory = !(iAttributes&EMemoryNotOwned);
	if (!ownsMemory)
		{
		// Physical memory not owned by the chunk also has to be evicted from cache(s).
		// We cannot just purge, as it can still be in use by the driver. Therefore, we'll flush it.
		// Purging physical memory from cache(s) that is owned by the chunk is done below.
		CacheMaintenance::MemoryToPreserveAndReuse((TLinAddr)(iBase+aOffset), aSize, iMapAttr);			
		}
	
	TInt offset=aOffset;
	TInt endOffset=offset+aSize;
	Mmu& m = Mmu::Get();
	DRamAllocator& a = *m.iRamPageAllocator;
	TPhysAddr pageList[KMaxPages];
#ifdef __CPU_WRITE_BACK_CACHE
	TInt size_reduction = Min(aSize,iSize);
	TBool selectiveFlush=((TUint)size_reduction<=(CacheMaintenance::SyncAllPerformanceThresholdPages()<<KPageShift));
#endif
	while(offset<endOffset)
		{
		TInt np=(endOffset-offset)>>m.iPageShift;		// number of pages remaining to decommit
		TInt pdeEnd=(offset+m.iChunkSize)&~m.iChunkMask;
		TInt npEnd=(pdeEnd-offset)>>m.iPageShift;		// number of pages to end of page table
		if (np>npEnd)
			np=npEnd;									// limit to single page table
		if (np>MM::MaxPagesInOneGo)
			np=MM::MaxPagesInOneGo;						// limit
		NKern::LockSystem();							// lock the system while we look at the page directory
		TUint8* base=iBase;								// save base address
		TLinAddr addr=(TLinAddr)base+offset;			// current address
		TInt ptid=m.GetPageTableId(addr);				// get page table ID if a page table is already assigned here
		if (ptid>=0)
			{
			TInt nPtes=0;
			TInt nFree=0;

			// Unmap the pages, clear the PTEs and place the physical addresses of the now-free RAM pages in
			// pageList. Return nPtes=number of pages placed in list, remain=number of PTEs remaining in page table
			// This also invalidates any TLB entries for the unmapped pages.
			// NB for WriteBack cache, we must also invalidate any cached entries for these pages - this might be done
			// by invalidating entry-by-entry or by a complete cache flush at the end.
			// NB For split TLB, ITLB may not be invalidated. In that case it will be invalidated by
			// Mmu::SyncCodeMappings() at the end of the function.
			TInt remain;
			if (aDecommitType == EDecommitVirtual)
				remain=m.UnmapVirtual(ptid,addr,np,pageList,ownsMemory,nPtes,nFree,iOwningProcess);
			else
				remain=m.UnmapPages(ptid,addr,np,pageList,ownsMemory,nPtes,nFree,iOwningProcess);
			TInt decommitSize=nPtes<<m.iPageShift;
			iSize-=decommitSize;				// reduce the committed size

			// if page table is now completely empty, unassign it and update chunk PDE info
			remain &= KUnmapPagesCountMask;
			if (remain==0)
				{
				m.DoUnassignPageTable(addr);
				RemovePde(offset);
				NKern::UnlockSystem();
				m.FreePageTable(ptid);
				NKern::LockSystem();
				}
			__KTRACE_OPT(KMMU,Kern::Printf("nPdes=%d, Pdes=%08x, HomePdes=%08x",iNumPdes,iPdes,iHomePdes));
#ifdef __CPU_WRITE_BACK_CACHE
			if (selectiveFlush)
				{
				TInt n=np;
				while(n && iBase==base)	// reschedule may move base, but then cache will have been flushed so we can stop purging L1
					{
					CacheMaintenance::PageToReuseVirtualCache(addr);
					addr+=m.iPageSize;
					--n;
					NKern::FlashSystem();
					}
				Mmu::Get().CacheMaintenanceOnDecommit(pageList, nFree);	//On ARMv5, this deals with L2 cache only
				}
#endif
			NKern::UnlockSystem();				// we can now unlock the system
			__KTRACE_OPT(KMEMTRACE,Kern::Printf("MT:A %d %x %x %O",NTickCount(),this,iSize,this));
#ifdef BTRACE_CHUNKS
			if(nFree)
				BTraceContext12(BTrace::EChunks,ownsMemory?BTrace::EChunkMemoryDeallocated:BTrace::EChunkMemoryRemoved,this,offset,nFree<<m.iPageShift);
#endif

			// We can now return the decommitted pages to the free page list
			if (nFree)
				a.FreeRamPages(pageList,nFree, GetPageType());

			offset+=(np<<m.iPageShift);
			}
		else
			{
			NKern::UnlockSystem();
			__KTRACE_OPT(KMMU,Kern::Printf("No page table at %08x",addr));
			if ((iAttributes&EDisconnected)==0)
				MM::Panic(MM::EChunkDecommitNoPageTable);
			offset=pdeEnd;	// disconnected chunk - step on to next PDE
			}
		}
	if (iSize==0 && (iAttributes&EFixedAddress)==0)
		{
		__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::DoDecommit remove region"));
		NKern::LockSystem();
		if (TLinAddr(iBase)==iHomeBase)
			iBase=NULL;
		DeallocateHomeAddress();
		NKern::UnlockSystem();
		}
#ifdef __CPU_WRITE_BACK_CACHE
	if (!selectiveFlush)
		{
		NKern::LockSystem();
		m.GenericFlush((TUint)Mmu::EFlushDDecommit); 	//Flush virtual DCache
		CacheMaintenance::SyncPhysicalCache_All();
		NKern::UnlockSystem();
		}
#endif
	if (iAttributes & ECode)
		m.SyncCodeMappings();		// flush ITLB if necessary
	}


TInt DMemModelChunk::AdjustDoubleEnded(TInt aBottom, TInt aTop)
//
// Adjust a double-ended chunk.
//
	{

	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::AdjustDoubleEnded %x-%x",aBottom,aTop));
	if ((iAttributes & (EDoubleEnded|EDisconnected))!=EDoubleEnded)
		return KErrGeneral;
	if (aTop<0 || aBottom<0 || aTop<aBottom || aTop>iMaxSize)
		return KErrArgument;
	Mmu& m = Mmu::Get();
	aBottom &= ~m.iPageMask;
	aTop=(aTop+m.iPageMask)&~m.iPageMask;
	TInt newSize=aTop-aBottom;
	if (newSize>iMaxSize)
		return KErrArgument;

	Mmu::Wait();
	TInt initBottom=iStartPos;
	TInt initTop=iStartPos+iSize;
	TInt nBottom=Max(aBottom,iStartPos);	// intersection bottom
	TInt nTop=Min(aTop,iStartPos+iSize);	// intersection top
	TInt r=KErrNone;
	if (nBottom<nTop)
		{
		__KTRACE_OPT(KMMU,Kern::Printf("Initial and final regions intersect"));
		if (initBottom<nBottom)
			{
			iStartPos=aBottom;
			DoDecommit(initBottom,nBottom-initBottom);
			}
		if (initTop>nTop)
			DoDecommit(nTop,initTop-nTop);	// this changes iSize
		if (aBottom<nBottom)
			{
			r=DoCommit(aBottom,nBottom-aBottom);
			if (r==KErrNone)
				{
				if (aTop>nTop)
					r=DoCommit(nTop,aTop-nTop);
				if (r==KErrNone)
					iStartPos=aBottom;
				else
					DoDecommit(aBottom,nBottom-aBottom);
				}
			}
		else if (aTop>nTop)
			r=DoCommit(nTop,aTop-nTop);
		}
	else
		{
		__KTRACE_OPT(KMMU,Kern::Printf("Initial and final regions disjoint"));
		if (iSize)
			DoDecommit(initBottom,iSize);
		iStartPos=aBottom;
		if (newSize)
			r=DoCommit(iStartPos,newSize);
		}
	Mmu::Signal();
	__COND_DEBUG_EVENT(r==KErrNone, EEventUpdateChunk, this);
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk %O adjusted to %x+%x base %08x home %08x",this,iStartPos,iSize,iBase,iHomeRegionBase));
	return r;
	}

TInt DMemModelChunk::Commit(TInt aOffset, TInt aSize, TCommitType aCommitType, TUint32* aExtraArg)
//
// Commit to a disconnected chunk.
//
	{
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::Commit %x+%x type=%d extra=%08x",aOffset,aSize,aCommitType,aExtraArg));
	if ((iAttributes & (EDoubleEnded|EDisconnected))!=EDisconnected)
		return KErrGeneral;
	if (aOffset<0 || aSize<0)
		return KErrArgument;
	if (aSize==0)
		return KErrNone;
	Mmu& m = Mmu::Get();
	aSize+=(aOffset & m.iPageMask);
	aOffset &= ~m.iPageMask;
	aSize=(aSize+m.iPageMask)&~m.iPageMask;
	if ((aOffset+aSize)>iMaxSize)
		return KErrArgument;

	Mmu::Wait();
	TInt r=KErrNone;
	TInt i=aOffset>>m.iPageShift;
	TInt n=aSize>>m.iPageShift;
	if (iPageBitMap->NotFree(i,n))
		r=KErrAlreadyExists;
	else
		{
		r=DoCommit(aOffset,aSize,aCommitType,aExtraArg);
		if (r==KErrNone)
			iPageBitMap->Alloc(i,n);
		}
	Mmu::Signal();
	__COND_DEBUG_EVENT(r==KErrNone, EEventUpdateChunk, this);
	return r;
	}

TInt DMemModelChunk::Allocate(TInt aSize, TInt aGuard, TInt aAlign)
//
// Allocate offset and commit to a disconnected chunk.
//
	{
	TInt r = DoAllocate(aSize, aGuard, aAlign, ETrue);
	__COND_DEBUG_EVENT(r==KErrNone, EEventUpdateChunk, this);
	return r;
	}

TInt DMemModelChunk::FindFree(TInt aSize, TInt aGuard, TInt aAlign)
//
// Find free offset but don't commit any memory.
//
	{
	return DoAllocate(aSize, aGuard, aAlign, EFalse);
	}

TInt DMemModelChunk::DoAllocate(TInt aSize, TInt aGuard, TInt aAlign, TBool aCommit)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::DoAllocate %x %x %d",aSize,aGuard,aAlign));

	// Only allow this to be called on disconnected chunks and not disconnected 
	// cache chunks as when guards pages exist the bit map can't be used to determine
	// the size of disconnected cache chunks as is required by Decommit().
	if ((iAttributes & (EDoubleEnded|EDisconnected|ECache))!=EDisconnected)
		return KErrGeneral;

	if (aSize<=0 || aGuard<0)
		return KErrArgument;
	Mmu& m = Mmu::Get();
	aAlign=Max(aAlign-m.iPageShift,0);
	aSize=(aSize+m.iPageMask)&~m.iPageMask;
	aGuard=(aGuard+m.iPageMask)&~m.iPageMask;
	if ((aSize+aGuard)>iMaxSize)
		return KErrArgument;

	Mmu::Wait();
	TInt r=KErrNone;
	TInt n=(aSize+aGuard)>>m.iPageShift;
	TInt i=iPageBitMap->AllocAligned(n,aAlign,0,EFalse);	// allocate the offset
	if (i<0)
		r=KErrNoMemory;		// run out of reserved space for this chunk
	else
		{
		TInt offset=i<<m.iPageShift;
		__KTRACE_OPT(KMMU,Kern::Printf("Offset %x allocated",offset));
		if (aCommit)
			{
			r=DoCommit(offset+aGuard,aSize,ECommitDiscontiguous);
			if (r==KErrNone)
				iPageBitMap->Alloc(i,n);
			}
		if (r==KErrNone)
			r=offset;		// if operation successful, return allocated offset
		}
	Mmu::Signal();
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::DoAllocate returns %x",r));
	return r;
	}

TInt DMemModelChunk::Decommit(TInt aOffset, TInt aSize)
//
// Decommit from a disconnected chunk.
//
	{
	return Decommit(aOffset, aSize, EDecommitNormal);
	}

TInt DMemModelChunk::Decommit(TInt aOffset, TInt aSize, TDecommitType aDecommitType)
//
// Decommit from a disconnected chunk.
//
	{
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::Decommit %x+%x",aOffset,aSize));
	if ((iAttributes & (EDoubleEnded|EDisconnected))!=EDisconnected)
		return KErrGeneral;
	if (aOffset<0 || aSize<0)
		return KErrArgument;
	if (aSize==0)
		return KErrNone;
	Mmu& m = Mmu::Get();
	aSize+=(aOffset & m.iPageMask);
	aOffset &= ~m.iPageMask;
	aSize=(aSize+m.iPageMask)&~m.iPageMask;
	if ((aOffset+aSize)>iMaxSize)
		return KErrArgument;

	Mmu::Wait();

	// limit the range to the home region range
	TInt end = aOffset+aSize;
	if (aOffset<iHomeRegionOffset)
		aOffset=iHomeRegionOffset;
	if (end>iHomeRegionOffset+iHomeRegionSize)
		end=iHomeRegionOffset+iHomeRegionSize;
	aSize = end-aOffset;
	if(aSize<0)
		aSize=0;
	__KTRACE_OPT(KMMU,Kern::Printf("Rounded and Clipped range %x+%x",aOffset,aSize));

	if (aSize)
		{
		TInt i=aOffset>>m.iPageShift;
		TInt n=aSize>>m.iPageShift;
		__KTRACE_OPT(KMMU,Kern::Printf("Calling SelectiveFree(%d,%d)",i,n));
		TUint oldAvail = iPageBitMap->iAvail;
		TUint oldSize = iSize;

		// Free those positions which are still commited and also any guard pages, 
		// i.e. pages that are reserved in this chunk but which are not commited.
		iPageBitMap->SelectiveFree(i,n);
		DoDecommit(aOffset,aSize,aDecommitType);

		if (iAttributes & ECache)
			{// If this is the file server cache chunk then adjust the size based 
			// on the bit map size because:-
			//	- 	Unlocked and reclaimed pages will be unmapped without updating
			// 		iSize or the bit map. 
			//	-	DoDecommit() only decommits the mapped pages.
			// For all other chunks what is mapped is what is committed to the 
			// chunk so iSize is accurate.
			TUint actualFreedPages = iPageBitMap->iAvail - oldAvail;
			iSize = oldSize - (actualFreedPages << KPageShift);
			}
		}

	Mmu::Signal();
	__DEBUG_EVENT(EEventUpdateChunk, this);
	return KErrNone;
	}

TInt DMemModelChunk::Unlock(TInt aOffset, TInt aSize)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::Unlock %x+%x",aOffset,aSize));
	if (!(iAttributes&ECache))
		return KErrGeneral;
	if ((iAttributes & (EDoubleEnded|EDisconnected))!=EDisconnected)
		return KErrGeneral;

	// Mark this as the file server cache chunk.  This is safe as it is only the 
	// file server that can invoke this function.
	iAttributes |= ECache;

	if (aOffset<0 || aSize<0)
		return KErrArgument;
	if (aSize==0)
		return KErrNone;
	Mmu& m = Mmu::Get();
	aSize+=(aOffset & m.iPageMask);
	aOffset &= ~m.iPageMask;
	aSize=(aSize+m.iPageMask)&~m.iPageMask;
	if ((aOffset+aSize)>iMaxSize)
		return KErrArgument;

	Mmu::Wait();
	TInt r=KErrNone;
	TInt i=aOffset>>m.iPageShift;
	TInt n=aSize>>m.iPageShift;
	if (iPageBitMap->NotAllocated(i,n))
		r=KErrNotFound;
	else
		{
#ifdef BTRACE_CHUNKS
		TUint oldFree = m.FreeRamInBytes();
#endif
		r=Mmu::Get().UnlockRamCachePages(iBase,i,n);
#ifdef BTRACE_CHUNKS
		if(r==KErrNone)
			{
			TUint unlocked = m.FreeRamInBytes()-oldFree; // size of memory unlocked
			if(unlocked)
				BTraceContext12(BTrace::EChunks,BTrace::EChunkMemoryDeallocated,this,aOffset,unlocked);
			}
#endif
		}
	Mmu::Signal();
	__COND_DEBUG_EVENT(r==KErrNone, EEventUpdateChunk, this);
	return r;
	}

TInt DMemModelChunk::Lock(TInt aOffset, TInt aSize)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::Lock %x+%x",aOffset,aSize));
	if (!(iAttributes&ECache))
		return KErrGeneral;
	if ((iAttributes & (EDoubleEnded|EDisconnected))!=EDisconnected)
		return KErrGeneral;
	if (aOffset<0 || aSize<0)
		return KErrArgument;
	if (aSize==0)
		return KErrNone;
	Mmu& m = Mmu::Get();
	aSize+=(aOffset & m.iPageMask);
	aOffset &= ~m.iPageMask;
	aSize=(aSize+m.iPageMask)&~m.iPageMask;
	if ((aOffset+aSize)>iMaxSize)
		return KErrArgument;

	Mmu::Wait();
	TInt r=KErrNone;
	TInt i=aOffset>>m.iPageShift;
	TInt n=aSize>>m.iPageShift;
	if (iPageBitMap->NotAllocated(i,n))
		r=KErrNotFound;
	else
		{
#ifdef BTRACE_CHUNKS
		TUint oldFree = m.FreeRamInBytes();
#endif
		r=Mmu::Get().LockRamCachePages(iBase,i,n);
#ifdef BTRACE_CHUNKS
		if(r==KErrNone)
			{
			TUint locked = oldFree-m.FreeRamInBytes();
			if(locked)
				BTraceContext12(BTrace::EChunks,BTrace::EChunkMemoryAllocated,this,aOffset,locked);
			}
#endif
		}
	if(r!=KErrNone)
		{
		// decommit memory on error...
		__KTRACE_OPT(KMMU,Kern::Printf("Calling SelectiveFree(%d,%d)",i,n));
		TUint oldAvail = iPageBitMap->iAvail;
		iPageBitMap->SelectiveFree(i,n);	// free those positions which are actually allocated
		TUint oldSize = iSize;

		DoDecommit(aOffset,aSize);

		// Use the bit map to adjust the size of the chunk as unlocked and reclaimed pages
		// will have been unmapped but not removed from the bit map as DoDecommit() only 
		// decommits the mapped pages.
		TUint actualFreedPages = iPageBitMap->iAvail - oldAvail;
		iSize = oldSize - (actualFreedPages << KPageShift);
		}

	Mmu::Signal();
	__COND_DEBUG_EVENT(r==KErrNone, EEventUpdateChunk, this);
	return r;
	}

#ifndef __SCHEDULER_MACHINE_CODED__
// System locked in this function for a time proportional to chunk size.
// This is unavoidable since the chunk state must always be well defined
// whenever the system is unlocked.
TUint32 DMemModelChunk::ApplyTopLevelPermissions(TChunkState aChunkState)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("ApplyTopLevelPermissions ChunkState=%d",aChunkState));
	if (!(iAttributes&EFixedAccess))
		{
		iChunkState=aChunkState;
		if (iSize)
			{
			Mmu& m = Mmu::Get();
			TLinAddr base=(TLinAddr)iBase;
			TInt size=iSize;
			TUint32 mask=m.iChunkMask;
			if (iAttributes & EDoubleEnded)
				{
				base+=(iStartPos & ~mask);
				size=((iStartPos&mask)+size+mask)&~mask;
				}
			m.ApplyTopLevelPermissions(base,size,iPdePermissions[aChunkState]);
			}
		return (iAttributes&ECode)?Mmu::EFlushDPermChg|Mmu::EFlushIPermChg:Mmu::EFlushDPermChg;
		}
	return 0;
	}

// System locked in this function for a time proportional to chunk size.
// This is unavoidable since the chunk state must always be well defined
// whenever the system is unlocked.
TUint32 DMemModelChunk::MoveToRunAddress(TLinAddr aLinearAddr, TChunkState aChunkState)
	{
	iChunkState=aChunkState;
	if (iSize)
		{
		TLinAddr base=(TLinAddr)iBase;
		TLinAddr dest=aLinearAddr;
		TInt size=iSize;
		if (iAttributes & EDoubleEnded)
			{
			Mmu& m = Mmu::Get();
			TUint32 mask=m.iChunkMask;
			base+=(iStartPos & ~mask);
			dest+=(iStartPos & ~mask);
			size=((iStartPos&mask)+size+mask)&~mask;
			}
		m.MoveChunk(base,size,dest,iPdePermissions[aChunkState]);
		}
	MoveCurrentPdes((TLinAddr)iBase,aLinearAddr);
	iBase=(TUint8 *)aLinearAddr;
	return Mmu::EFlushDMove;	// chunk can't contain code
	}

// System locked in this function for a time proportional to chunk size.
// This is unavoidable since the chunk state must always be well defined
// whenever the system is unlocked.
TUint32 DMemModelChunk::MoveToHomeSection()
	{
	iChunkState=ENotRunning;
	if (iSize)
		{
		TLinAddr base=TLinAddr(iBase);
		TLinAddr home=iHomeRegionBase;
		TInt size=iSize;
		if (iAttributes & EDoubleEnded)
			{
			Mmu& m = Mmu::Get();
			TUint32 mask=m.iChunkMask;
			base+=(iStartPos & ~mask);
			home+=(iStartPos & ~mask);
			size=((iStartPos&mask)+size+mask)&~mask;
			}
		m.MoveChunk(base,size,home,iPdePermissions[0]);
		}
	iBase=(TUint8 *)iHomeRegionBase;
	iHomePdes=iPdes;
	return Mmu::EFlushDMove;	// chunk can't contain code
	}
#endif

TLinAddr DMemModelChunk::AllocateHomeAddress(TInt aSize)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::AllocateHomeAddress size %08x",aSize));
	Mmu& m = Mmu::Get();
	TLinearSection* s = m.iKernelSection;
	TUint required;
	if (iAttributes&EFixedAddress)
		required=Mmu::RoundToChunkSize(iMaxSize);
	else
		required=Mmu::RoundToChunkSize(aSize);
	required >>= m.iChunkShift;
	TInt r = s->iAllocator.AllocConsecutive(required, EFalse);
	if (r<0)
		return 0;
	s->iAllocator.Alloc(r, required);
	TLinAddr addr = s->iBase + (r<<m.iChunkShift);
	__KTRACE_OPT(KMMU,Kern::Printf("Address %08x allocated",addr));
	iHomeRegionSize = required << m.iChunkShift;
	return addr;
	}

void DMemModelChunk::DeallocateHomeAddress()
	{
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::DeallocateHomeAddress %08x+%x", iHomeRegionBase, iHomeRegionSize));
	if (iHomeRegionSize)
		{
		Mmu& m = Mmu::Get();
		TLinearSection* s = m.iKernelSection;
		TInt first = (TInt)((iHomeRegionBase - s->iBase)>>m.iChunkShift);
		TInt count = (TInt)(iHomeRegionSize >> m.iChunkShift);
		s->iAllocator.Free(first, count);
		iHomeRegionBase=0;
		iHomeRegionSize=0;
		}
	}

TLinAddr DMemModelChunk::ReallocateHomeAddress(TInt aNewSize)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::ReallocateHomeAddress(%08x) for chunk %O",aNewSize,this));

	// can never be called for a fixed address chunk
	__ASSERT_ALWAYS((iAttributes&(EFixedAddress))==0,MM::Panic(MM::EFixedChunkMoving));

	Mmu& m = Mmu::Get();
	TLinearSection* s = m.iKernelSection;
	TUint required=Mmu::RoundToChunkSize(aNewSize);
	TInt next = (TInt)((iHomeRegionBase + iHomeRegionSize - s->iBase)>>m.iChunkShift);
	TInt count = (TInt)((required - iHomeRegionSize) >> m.iChunkShift);
	if (!s->iAllocator.NotFree(next, count))
		{
		// we can expand in place
		s->iAllocator.Alloc(next, count);
		iHomeRegionSize = required;
		return iHomeRegionBase;
		}
	TUint oldHomeSize = iHomeRegionSize;
	TLinAddr addr = AllocateHomeAddress(required);	// try to get a new home address
	if (addr && oldHomeSize)
		{
		// succeeded - free old region
		next = (TInt)((iHomeRegionBase - s->iBase)>>m.iChunkShift);
		count = (TInt)(oldHomeSize >> m.iChunkShift);
		s->iAllocator.Free(next, count);
		}
	// if it fails, keep our current home region
	return addr;
	}

TInt DMemModelChunk::CheckAccess()
	{
	DProcess* pP=TheCurrentThread->iOwningProcess;
	if (iAttributes&EPrivate)
		{
		if (iOwningProcess && iOwningProcess!=pP && pP!=K::TheKernelProcess)
			return KErrAccessDenied;
		}
	return KErrNone;
	}

TInt DMemModelChunkHw::Close(TAny*)
	{
	__KTRACE_OPT(KOBJECT,Kern::Printf("DMemModelChunkHw::Close %d %O",AccessCount(),this));
	TInt r=Dec();
	if (r==1)
		{
		if (iLinAddr)
			{
			// Physical memory has to be evicted from cache(s).
			// Must be preserved as well, as it can still be in use by the driver.
			CacheMaintenance::MemoryToPreserveAndReuse(iLinAddr, iSize, iAttribs);			

			MmuBase& m=*MmuBase::TheMmu;
			MmuBase::Wait();
			m.Unmap(iLinAddr,iSize);
			MmuBase::Signal();
			DeallocateLinearAddress();
			}
		K::ObjDelete(this);
		}
	return r;
	}

void DMemModelChunk::BTracePrime(TInt aCategory)
	{
	DChunk::BTracePrime(aCategory);
	
#ifdef BTRACE_CHUNKS
	if (aCategory == BTrace::EChunks || aCategory == -1)
		{
		MmuBase::Wait();

		TBool memoryOwned = !(iAttributes&EMemoryNotOwned);
		Mmu& m=Mmu::Get();
		TInt committedBase = -1;

		// look at each page table in this chunk...
		TUint chunkEndIndex = iMaxSize>>KChunkShift;
		NKern::LockSystem();
		for(TUint chunkIndex=0; chunkIndex<chunkEndIndex; ++chunkIndex)
			{
			TLinAddr addr=(TLinAddr)iBase+chunkIndex*KChunkSize;		// current address
			TInt ptid = m.GetPageTableId(addr);
			if(ptid<0)
				{
				// no page table...
				if(committedBase!=-1)
					{
					NKern::FlashSystem();
					TUint committedEnd = chunkIndex*KChunkSize;
					BTrace12(BTrace::EChunks, memoryOwned?BTrace::EChunkMemoryAllocated:BTrace::EChunkMemoryAdded,this,committedBase,committedEnd-committedBase);
					committedBase = -1;
					}
				continue;
				}
			TPte* pPte=(TPte*)m.PageTableLinAddr(ptid);

			// look at each page in page table...
			for(TUint pageIndex=0; pageIndex<KChunkSize/KPageSize; ++pageIndex)
				{
				TBool committed = false;
				TPhysAddr phys = m.PtePhysAddr(pPte[pageIndex], pageIndex);
				if(phys!=KPhysAddrInvalid)
					{
					// we have a page...
					if(!memoryOwned)
						committed = true;
					else
						{
						// make sure we own the page...
						SPageInfo* pi = SPageInfo::SafeFromPhysAddr(phys);
						if(pi && pi->Type()==SPageInfo::EChunk && pi->Owner()==this)
							committed = true;
						}
					}

				if(committed)
					{
					if(committedBase==-1)
						committedBase = chunkIndex*KChunkSize+pageIndex*KPageSize; // start of new region
					}
				else
					{
					if(committedBase!=-1)
						{
						// generate trace for region...
						NKern::FlashSystem();
						TUint committedEnd = chunkIndex*KChunkSize+pageIndex*KPageSize;
						BTrace12(BTrace::EChunks, memoryOwned?BTrace::EChunkMemoryAllocated:BTrace::EChunkMemoryAdded,this,committedBase,committedEnd-committedBase);
						committedBase = -1;
						}
					}

				if((pageIndex&15)==0)
					NKern::FlashSystem();
				}
			}
		NKern::UnlockSystem();

		if(committedBase!=-1)
			{
			TUint committedEnd = chunkEndIndex*KChunkSize;
			BTrace12(BTrace::EChunks, memoryOwned?BTrace::EChunkMemoryAllocated:BTrace::EChunkMemoryAdded,this,committedBase,committedEnd-committedBase);
			}

		MmuBase::Signal();
		}
#endif
	}