--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kernel/eka/memmodel/epoc/flexible/mchunk.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,688 @@
+// 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);
+ }
+