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

		r=m.AllocContiguousRam(numPages<<m.iPageShift, nextPage, GetPageType(), 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.