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

#include <memmodel.h>
#include "mmu/mm.h"
#include "mmboot.h"


DMemModelChunk::DMemModelChunk()
	{
	}


DMemModelChunk::~DMemModelChunk()
	{
	__KTRACE_OPT(KTHREAD,Kern::Printf("DMemModelChunk destruct %O",this));

	MM::MappingDestroy(iKernelMapping);
	MM::MemoryDestroy(iMemoryObject);

	delete iPageBitMap;
	delete iPermanentPageBitMap;

	TDfc* dfc = iDestroyedDfc;
	if(dfc)
		dfc->QueueOnIdle();

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


TInt DMemModelChunk::Close(TAny* aPtr)
	{
	if (aPtr)
		{
		DMemModelProcess* pP=(DMemModelProcess*)aPtr;
		__NK_ASSERT_DEBUG(!iOwningProcess || iOwningProcess==pP);
		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;
	}


void DMemModelChunk::SetPaging(TUint aCreateAtt)
	{
	// Only user data chunks should be able to be data paged, i.e. only those 
	// that can be created via the RChunk create methods.
	if ((iChunkType != EUserData && iChunkType != EUserSelfModCode) ||
		!(K::MemModelAttributes & EMemModelAttrDataPaging))	// Data paging device installed?
		{
		return;
		}
	// Pageable chunks must own their memory.
	__NK_ASSERT_DEBUG(!(iAttributes & EMemoryNotOwned));

	// Set the data paging attributes
	TUint dataPolicy = TheSuperPage().KernelConfigFlags() & EKernelConfigDataPagingPolicyMask;
	if (dataPolicy == EKernelConfigDataPagingPolicyNoPaging)
		{
		return;
		}
	if (dataPolicy == EKernelConfigDataPagingPolicyAlwaysPage)
		{
		iAttributes |= EDataPaged;
		return;
		}
	TUint pagingAtt = aCreateAtt & TChunkCreate::EPagingMask;
	if (pagingAtt == TChunkCreate::EPaged)
		{
		iAttributes |= EDataPaged;
		return;
		}
	if (pagingAtt == TChunkCreate::EUnpaged)
		{
		return;
		}
	// No data paging attribute specified for this chunk so use the process's
	__NK_ASSERT_DEBUG(pagingAtt == TChunkCreate::EPagingUnspec);
	DProcess* currentProcess = TheCurrentThread->iOwningProcess;
	if (currentProcess->iAttributes & DProcess::EDataPaged)
		{
		iAttributes |= EDataPaged;
		}
	}


TInt DMemModelChunk::DoCreate(SChunkCreateInfo& aInfo)
	{
	__ASSERT_COMPILE(!(EMMChunkAttributesMask & EChunkAttributesMask));
	__KTRACE_OPT(KMMU,Kern::Printf("Chunk %O DoCreate att=%08x",this,iAttributes));
	if (aInfo.iMaxSize<=0)
		return KErrArgument;

	iMaxSize = MM::RoundToPageSize(aInfo.iMaxSize);

	TInt maxpages=iMaxSize>>KPageShift;
	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;
		}

	TMemoryAttributes attr = EMemoryAttributeStandard;
	TBool mapInKernel = false;
	TBool nowipe = false;
	TBool executable = false;
	TBool movable = false;
	TInt r;

	switch(iChunkType)
		{
	case EUserSelfModCode:
		executable = true;
		movable = true;
		break;

	case EUserData:
	case ERamDrive:
		movable = true;
		break;

	case EKernelMessage:
	case ESharedKernelSingle:
	case ESharedKernelMultiple:
	case ESharedIo:
		mapInKernel = true;
		r = MM::MemoryAttributes(attr,*(TMappingAttributes2*)&aInfo.iMapAttr);
		if(r!=KErrNone)
			return r;
		break;

	case EKernelData:
		nowipe = true;
		break;

	case EDllData:
		__NK_ASSERT_DEBUG(0); // invalid chunk type
	case EKernelStack:
		__NK_ASSERT_DEBUG(0); // invalid chunk type
	case EDll: // global code
		__NK_ASSERT_DEBUG(0); // invalid chunk type
	case EKernelCode:
		__NK_ASSERT_DEBUG(0); // invalid chunk type
	case EUserCode: // local code
		__NK_ASSERT_DEBUG(0); // invalid chunk type
	case ESharedKernelMirror:
		__NK_ASSERT_DEBUG(0); // invalid chunk type
	default:
		__NK_ASSERT_DEBUG(0); // invalid chunk type
		return KErrArgument;
		}

	// calculate memory type...
	TMemoryObjectType memoryType = EMemoryObjectUnpaged;
	if (iAttributes & EMemoryNotOwned)
		{
		if (memoryType != EMemoryObjectUnpaged)
			return KErrArgument;
		memoryType = EMemoryObjectHardware;
		}
	if (iAttributes & EDataPaged)
		{
		if (memoryType != EMemoryObjectUnpaged)
			return KErrArgument;
		memoryType = EMemoryObjectPaged;
		}
	if (iAttributes & ECache)
		{
		if (memoryType != EMemoryObjectUnpaged)
			return KErrArgument;
		memoryType = EMemoryObjectDiscardable;
		}
	if (memoryType == EMemoryObjectUnpaged)
		{
		if (movable)
			memoryType = EMemoryObjectMovable;
		}

	// calculate memory flags...
	TMemoryCreateFlags flags = nowipe ? EMemoryCreateNoWipe : EMemoryCreateDefault;
	flags = (TMemoryCreateFlags)(flags|EMemoryCreateUseCustomWipeByte|(iClearByte<<EMemoryCreateWipeByteShift));
	if(executable)
		flags = (TMemoryCreateFlags)(flags|EMemoryCreateAllowExecution);

	r = MM::MemoryNew(iMemoryObject,memoryType,MM::BytesToPages(iMaxSize),flags,attr);
	if(r!=KErrNone)
		return r;

	if(mapInKernel)
		{
		TInt r = MM::MappingNew(iKernelMapping, iMemoryObject, ESupervisorReadWrite, KKernelOsAsid);
		if(r!=KErrNone)
			return r; // Note, iMemoryObject will get cleaned-up when chunk is destroyed
		const TMappingAttributes2& lma = MM::LegacyMappingAttributes(attr,EUserReadWrite);
		*(TMappingAttributes2*)&iMapAttr = lma;
		}

#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
#ifdef BTRACE_FLEXIBLE_MEM_MODEL
	BTrace8(BTrace::EFlexibleMemModel,BTrace::EMemoryObjectIsChunk,iMemoryObject,this);
#endif
	return KErrNone;
	}


void DMemModelChunk::SetFixedAddress(TLinAddr aAddr, TInt aInitialSize)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk %O SetFixedAddress %08x size %08x",this,aAddr,aInitialSize));
	iFixedBase = aAddr;
	iSize = MM::RoundToPageSize(aInitialSize);
	if(iSize)
		MM::MemoryClaimInitialPages(iMemoryObject,iFixedBase,iSize,ESupervisorReadWrite);
	}


TInt DMemModelChunk::SetAttributes(SChunkCreateInfo& aInfo)
	{
	switch(iChunkType)
		{
		case EKernelData:
		case EKernelMessage:
			iAttributes = EPrivate;
			break;
		case ERamDrive:
			iAttributes = EPrivate;
			break;
		case EUserData:
			if (aInfo.iGlobal)
				iAttributes = EPublic;
			else
				iAttributes = EPrivate;
			break;
		case EUserSelfModCode:
			if (aInfo.iGlobal)
				iAttributes = EPublic|ECode;
			else
				iAttributes = EPrivate|ECode;
			break;
		case ESharedKernelSingle:
		case ESharedKernelMultiple:
		case ESharedIo:
			iAttributes = EPublic;
			break;
		case EDllData:
			__NK_ASSERT_DEBUG(0); // invalid chunk type
		case EKernelStack:
			__NK_ASSERT_DEBUG(0); // invalid chunk type
		case EDll: // global code
			__NK_ASSERT_DEBUG(0); // invalid chunk type
		case EKernelCode:
			__NK_ASSERT_DEBUG(0); // invalid chunk type
		case EUserCode: // local code
			__NK_ASSERT_DEBUG(0); // invalid chunk type
		case ESharedKernelMirror:
			__NK_ASSERT_DEBUG(0); // invalid chunk type
		default:
			FAULT();
		}
	return KErrNone;
	}


TInt DMemModelChunk::Adjust(TInt aNewSize)
	{
	__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=MM::RoundToPageSize(aNewSize);
	if (newSize!=iSize)
		{
		MM::MemoryLock(iMemoryObject);
		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);
			}
		MM::MemoryUnlock(iMemoryObject);
		}
	__COND_DEBUG_EVENT(r==KErrNone, EEventUpdateChunk, this);
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk %O adjusted to %x",this,iSize));
	return r;
	}


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 start = aOffset>>KPageShift;
	TInt size = ((aOffset+aSize-1)>>KPageShift)-start+1;
	if(iPermanentPageBitMap->NotAllocated(start,size))
		return KErrNotFound;
	aKernelAddress = MM::MappingBase(iKernelMapping)+aOffset;
	return KErrNone;
	}


TInt DMemModelChunk::PhysicalAddress(TInt aOffset, TInt aSize, TLinAddr& aKernelAddress, TUint32& aPhysicalAddress, TUint32* aPhysicalPageList)
	{
	if(aSize<=0)
		return KErrArgument;
	TInt r = Address(aOffset,aSize,aKernelAddress);
	if(r!=KErrNone)
		return r;
	TInt index = aOffset>>KPageShift;
	TInt count = ((aOffset+aSize-1)>>KPageShift)-index+1;
	r = MM::MemoryPhysAddr(iMemoryObject,index,count,aPhysicalAddress,aPhysicalPageList);
	if(r==KErrNone)
		aPhysicalAddress += aOffset&KPageMask;
	return r;
	}


TInt DMemModelChunk::DoCommit(TInt aOffset, TInt aSize, TCommitType aCommitType, TUint32* aExtraArg)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::DoCommit %x+%x type=%d extra=%08x",aOffset,aSize,aCommitType,aExtraArg));

	__NK_ASSERT_DEBUG(((aOffset|aSize)&KPageMask)==0);

	TInt r = KErrArgument;
	switch(aCommitType)
		{
	case DChunk::ECommitDiscontiguous:
		r = MM::MemoryAlloc(iMemoryObject, MM::BytesToPages(aOffset), MM::BytesToPages(aSize));
		break;

	case DChunk::ECommitDiscontiguousPhysical:
		r = MM::MemoryAddPages(iMemoryObject, MM::BytesToPages(aOffset), MM::BytesToPages(aSize), (TPhysAddr*)aExtraArg);
		break;

	case DChunk::ECommitContiguous:
		r = MM::MemoryAllocContiguous(iMemoryObject, MM::BytesToPages(aOffset), MM::BytesToPages(aSize), 0, *(TPhysAddr*)aExtraArg);
		break;

	case DChunk::ECommitContiguousPhysical:
		r = MM::MemoryAddContiguous(iMemoryObject, MM::BytesToPages(aOffset), MM::BytesToPages(aSize), (TPhysAddr)aExtraArg);
		break;

	case DChunk::ECommitVirtual:
	default:
		__NK_ASSERT_DEBUG(0); // Invalid commit type
		r = KErrNotSupported;
		break;
		}

	if(r==KErrNone)
		{
		iSize += aSize;
		if(iPermanentPageBitMap)
			iPermanentPageBitMap->Alloc(aOffset>>KPageShift,aSize>>KPageShift);
#ifdef BTRACE_CHUNKS
		TInt subcategory = (aCommitType & DChunk::ECommitPhysicalMask) ? BTrace::EChunkMemoryAdded : BTrace::EChunkMemoryAllocated;
		BTraceContext12(BTrace::EChunks,subcategory,this,aOffset,aSize);
#endif
		}

	return r;
	}


void DMemModelChunk::DoDecommit(TInt aOffset, TInt aSize)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::DoDecommit %x+%x",aOffset,aSize));

	__NK_ASSERT_DEBUG(((aOffset|aSize)&KPageMask)==0);

	TUint index = MM::BytesToPages(aOffset);
	TUint count = MM::BytesToPages(aSize);
	iSize -= count*KPageSize;
	if(iAttributes&EMemoryNotOwned)
		MM::MemoryRemovePages(iMemoryObject, index, count, 0);
	else
		MM::MemoryFree(iMemoryObject, index, count);

#ifdef BTRACE_CHUNKS
	if (count != 0)
		{
		TInt subcategory = (iAttributes & EMemoryNotOwned) ? BTrace::EChunkMemoryRemoved : BTrace::EChunkMemoryDeallocated;
		BTraceContext12(BTrace::EChunks,subcategory,this,aOffset,count*KPageSize);
		}
#endif
	}


TInt DMemModelChunk::AdjustDoubleEnded(TInt aBottom, TInt aTop)
	{
	__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;

	aBottom &= ~KPageMask;
	aTop = MM::RoundToPageSize(aTop);
	TInt newSize=aTop-aBottom;
	if (newSize>iMaxSize)
		return KErrArgument;

	MM::MemoryLock(iMemoryObject);
	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);
		}
	MM::MemoryUnlock(iMemoryObject);
	__COND_DEBUG_EVENT(r==KErrNone, EEventUpdateChunk, this);
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk %O adjusted to %x+%x",this,iStartPos,iSize));
	return r;
	}


TInt DMemModelChunk::CheckRegion(TInt& aOffset, TInt& aSize)
	{
	if((iAttributes & (EDoubleEnded|EDisconnected))!=EDisconnected)
		return KErrGeneral;
	if(aOffset<0 || aSize<0)
		return KErrArgument;
	if(aSize==0)
		return KErrNone;

	TUint end = MM::RoundToPageSize(aOffset+aSize);
	if(end>TUint(iMaxSize))
		return KErrArgument;
	aOffset &= ~KPageMask;
	aSize = end-aOffset;
	if(end<=TUint(aOffset))
		return KErrArgument;

	return 1;
	}


TInt DMemModelChunk::Commit(TInt aOffset, TInt aSize, TCommitType aCommitType, TUint32* aExtraArg)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::Commit %x+%x type=%d extra=%08x",aOffset,aSize,aCommitType,aExtraArg));

	TInt r = CheckRegion(aOffset,aSize);
	if(r<=0)
		return r;

	MM::MemoryLock(iMemoryObject);
	TInt i=aOffset>>KPageShift;
	TInt n=aSize>>KPageShift;
	if (iPageBitMap->NotFree(i,n))
		r=KErrAlreadyExists;
	else
		{
		r=DoCommit(aOffset,aSize,aCommitType,aExtraArg);
		if (r==KErrNone)
			iPageBitMap->Alloc(i,n);
		}
	MM::MemoryUnlock(iMemoryObject);
	__COND_DEBUG_EVENT(r==KErrNone, EEventUpdateChunk, this);
	return r;
	}


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

	// the flexible memory model doesn't implement aGuard and aAlign...
	__NK_ASSERT_DEBUG(aGuard==0);
	(void)aGuard;
	__NK_ASSERT_DEBUG(aAlign==0);
	(void)aAlign;

	TInt dummyOffset = 0;
	TInt r = CheckRegion(dummyOffset,aSize);
	if(r<=0)
		return r;

	MM::MemoryLock(iMemoryObject);
	TInt n=aSize>>KPageShift;
	TInt i=iPageBitMap->AllocConsecutive(n, EFalse);		// allocate the offset
	if (i<0)
		r=KErrNoMemory;		// run out of reserved space for this chunk
	else
		{
		TInt offset=i<<KPageShift;
		__KTRACE_OPT(KMMU,Kern::Printf("Offset %x allocated",offset));
		r=DoCommit(offset,aSize);
		if (r==KErrNone)
			{
			iPageBitMap->Alloc(i,n);
			r=offset;		// if operation successful, return allocated offset
			}
		}
	MM::MemoryUnlock(iMemoryObject);
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::Allocate returns %x",r));
	__COND_DEBUG_EVENT(r==KErrNone, EEventUpdateChunk, this);
	return r;
	}


TInt DMemModelChunk::Decommit(TInt aOffset, TInt aSize)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::Decommit %x+%x",aOffset,aSize));
	TInt r = CheckRegion(aOffset,aSize);
	if(r<=0)
		return r;

	MM::MemoryLock(iMemoryObject);

	TInt i=aOffset>>KPageShift;
	TInt n=aSize>>KPageShift;
	__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);

	MM::MemoryUnlock(iMemoryObject);

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


TInt DMemModelChunk::Unlock(TInt aOffset, TInt aSize)
	{
	__KTRACE_OPT(KMMU,Kern::Printf("DMemModelChunk::Unlock %x+%x",aOffset,aSize));
	if(!(iAttributes&ECache))
		return KErrGeneral;
	TInt r = CheckRegion(aOffset,aSize);
	if(r<=0)
		return r;

	MM::MemoryLock(iMemoryObject);

	TInt i=aOffset>>KPageShift;
	TInt n=aSize>>KPageShift;
	if(iPageBitMap->NotAllocated(i,n))
		r = KErrNotFound;
	else
		r = MM::MemoryAllowDiscard(iMemoryObject,i,n);

	MM::MemoryUnlock(iMemoryObject);

	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;
	TInt r = CheckRegion(aOffset,aSize);
	if(r<=0)
		return r;

	r = MM::MemoryDisallowDiscard(iMemoryObject, MM::BytesToPages(aOffset), MM::BytesToPages(aSize));
	if(r!=KErrNone)
		Decommit(aOffset,aSize);

	return r;
	}


TInt DMemModelChunk::CheckAccess()
	{
	if(iOwningProcess && iOwningProcess!=TheCurrentThread->iOwningProcess)
		return KErrAccessDenied;
	return KErrNone;
	}


void DMemModelChunk::BTracePrime(TInt aCategory)
	{
	DChunk::BTracePrime(aCategory);
#ifdef BTRACE_FLEXIBLE_MEM_MODEL
	if (aCategory == BTrace::EFlexibleMemModel || aCategory == -1)
		{
		if (iMemoryObject)
			{
			MM::MemoryBTracePrime(iMemoryObject);
			BTrace8(BTrace::EFlexibleMemModel,BTrace::EMemoryObjectIsChunk,iMemoryObject,this);
			}
		}
#endif
	}


void DMemModelChunk::Substitute(TInt /*aOffset*/, TPhysAddr /*aOldAddr*/, TPhysAddr /*aNewAddr*/)
	{
	MM::Panic(MM::EUnsupportedOperation);
	}