FCL/sf/os/kernelhwsrv: comparison kernel/eka/memmodel/epoc/flexible/mmu/mmanager.cpp

equal deleted inserted replaced

-:73ea206103e6
+:43365a9b78a3
 TInt DMemoryManager::MovePage(	DMemoryObject* aMemory, SPageInfo* aOldPageInfo,
 								TPhysAddr& aNewPage, TUint aBlockZoneId, TBool aBlockRest)
 	{
+	MmuLock::Unlock();
 	return KErrNotSupported;
 	}
 TInt DMemoryManager::MoveAndAllocPage(DMemoryObject*, SPageInfo*, TZonePageType)
 	{
+	__NK_ASSERT_DEBUG(0);	// This should only be invoked on managers that can move or discard pages.
 	return KErrNotSupported;
 	}
 TZonePageType DMemoryManager::PageType()
 TInt DMovableMemoryManager::MovePage(	DMemoryObject* aMemory, SPageInfo* aOldPageInfo,
 										TPhysAddr& aNewPage, TUint aBlockZoneId, TBool aBlockRest)
 	{
 	__NK_ASSERT_DEBUG(RamAllocLock::IsHeld());
+	__NK_ASSERT_DEBUG(MmuLock::IsHeld());
-	// Allocate the new page to move to, ensuring that we use the page type of the
+	TInt r = KErrInUse;
-	// manager assigned to this page.
-	TPhysAddr newPage;
-	Mmu& m = TheMmu;
-	TInt r = m.AllocRam(&newPage, 1, aMemory->RamAllocFlags(), aMemory->iManager->PageType(),
-						aBlockZoneId, aBlockRest);
-	if (r != KErrNone)
-		{// Failed to allocate a new page to move the page to so can't continue.
-		return r;
-		}
-	r = KErrInUse;
-	MmuLock::Lock();
 	TUint index = aOldPageInfo->Index();
 	TRACE(	("DMovableMemoryManager::MovePage(0x%08x,0x%08x,?,0x%08x,%d) index=0x%x",
 			aMemory,aOldPageInfo,aBlockZoneId,aBlockRest,index));
 	__NK_ASSERT_DEBUG(aMemory==aOldPageInfo->Owner());
 	RPageArray::TIter pageIter;
 	TPhysAddr* const movingPageArrayPtr = aMemory->iPages.MovePageStart(index, pageIter);
 	if (!movingPageArrayPtr)
 		{// Can't move the page another operation is being performed on it.
 		MmuLock::Unlock();
-		TheMmu.FreeRam(&newPage, 1, aMemory->iManager->PageType());
 		return r;
 		}
 	__NK_ASSERT_DEBUG(RPageArray::IsPresent(*movingPageArrayPtr));
 	TPhysAddr oldPageEntry = *movingPageArrayPtr;
 	TPhysAddr oldPage = oldPageEntry & ~KPageMask;
 		{// The address of page array entry and the page info should match except
 		// when the page is being shadowed.
 		__NK_ASSERT_DEBUG(SPageInfo::FromPhysAddr(oldPage)->Type() == SPageInfo::EShadow);
 		}
 #endif
+	// Set the modifier so we can detect if the page state is updated.
+	aOldPageInfo->SetModifier(&pageIter);
+	MmuLock::Unlock();
+	// Allocate the new page to move to, ensuring that we use the page type of the
+	// manager assigned to this page.
+	TPhysAddr newPage;
+	Mmu& m = TheMmu;
+	TInt allocRet = m.AllocRam(&newPage, 1, aMemory->RamAllocFlags(), aMemory->iManager->PageType(),
+						aBlockZoneId, aBlockRest);
+	if (allocRet != KErrNone)
+		{
+		MmuLock::Lock();
+		aMemory->iPages.MovePageEnd(*movingPageArrayPtr, index);
+		MmuLock::Unlock();
+		return allocRet;
+		}
 	__NK_ASSERT_DEBUG((newPage & KPageMask) == 0);
 	__NK_ASSERT_DEBUG(newPage != oldPage);
-	// Set the modifier so we can detect if the page state is updated.
+	MmuLock::Lock();
-	aOldPageInfo->SetModifier(&pageIter);
+	if (aOldPageInfo->CheckModified(&pageIter) ||
+		oldPageEntry != *movingPageArrayPtr)
-	// Restrict the page ready for moving.
+		{// The page was modified or freed.
+		aMemory->iPages.MovePageEnd(*movingPageArrayPtr, index);
+		MmuLock::Unlock();
+		m.FreeRam(&newPage, 1, aMemory->iManager->PageType());
+		return r;
+		}
+	MmuLock::Unlock();
+	// This page's contents may be changed so restrict the page to no access
+	// so we can detect any access to it while we are moving it.
 	// Read only memory objects don't need to be restricted but we still need
 	// to discover any physically pinned mappings.
 	TBool pageRestrictedNA = !aMemory->IsReadOnly();
 	TRestrictPagesType restrictType = 	pageRestrictedNA ?
 										ERestrictPagesNoAccessForMoving :
 										ERestrictPagesForMovingFlag;
-	// This page's contents may be changed so restrict the page to no access
-	// so we can detect any access to it while we are moving it.
-	MmuLock::Unlock();
 	// This will clear the memory objects mapping added flag so we can detect any new mappings.
 	aMemory->RestrictPages(pageIter, restrictType);
 	const TUint KOldMappingSlot = 0;
 	const TUint KNewMappingSlot = 1;
 	// Verify that page restricting wasn't interrupted, if it was then the page
 	// can't be moved so remap it.
 	// If the page array entry (*movingPageArrayPtr) has been modified then a pinning
 	// veto'd the preparation.
 	MmuLock::Lock();
-	if (aOldPageInfo->CheckModified(&pageIter) || oldPageEntry != *movingPageArrayPtr)
+	if (aOldPageInfo->CheckModified(&pageIter) ||
+		oldPageEntry != *movingPageArrayPtr)
 		{// Page is pinned or has been modified by another operation.
 		MmuLock::Unlock();
 		TheMmu.FreeRam(&newPage, 1, aMemory->iManager->PageType());
 		goto remap;
 		}
 #ifndef _DEBUG
 	TheMmu.UnmapTemp(KOldMappingSlot);
 #endif
 	MmuLock::Lock();
-	if (!aOldPageInfo->CheckModified(&pageIter) && oldPageEntry == *movingPageArrayPtr &&
+	if (!aOldPageInfo->CheckModified(&pageIter) &&
+		oldPageEntry == *movingPageArrayPtr &&
 		!aMemory->MappingAddedFlag())
 		{
 		// The page has been copied without anyone modifying it so set the page
 		// array entry to new physical address and map the page.
 		RPageArray::PageMoveNewAddr(*movingPageArrayPtr, newPage);
 #else
 		}
 #endif
 	// indicate we've stopped moving memory now...
 	MmuLock::Lock();
-	RPageArray::MovePageEnd(*movingPageArrayPtr);
+	aMemory->iPages.MovePageEnd(*movingPageArrayPtr, index);
 	MmuLock::Unlock();
 	return r;
 	}
 			// page successfully unmapped...
 			aPageInfo->SetReadOnly(); // page not mapped, so must be read-only
 			// attempt to clean the page if it is dirty...
 			if (aPageInfo->IsDirty())
+				{
+				//Kern::Printf("WDP: Cleaning single page in StealPage");
 				aMemory->iManager->CleanPages(1, &aPageInfo, EFalse);
+				}
 			if(aPageInfo)
 				{
 				// page successfully stolen...
 				__NK_ASSERT_DEBUG((*p^page)<(TUint)KPageSize); // sanity check, page should still be allocated to us
 	MmuLock::Lock();
 	page = *p;
 	if(aPageInfo->CheckModified(&pageList) || page!=originalPage/*page state changed*/)
-		{
-		// page state was changed by someone else...
 		r = KErrInUse;
-		}
 	else
 		{
 		// nobody else has modified page state, so restrictions successfully applied...
 		*p = (page&~RPageArray::EStateMask)|RPageArray::ECommitted; // restore state
 		aPageInfo->SetReadOnly();
 TInt DPagedMemoryManager::DoPin(DMemoryObject* aMemory, TUint aIndex, TUint aCount, DMemoryMappingBase* aMapping, TPinArgs& aPinArgs)
 	{
 	TRACE(("DPagedMemoryManager::DoPin(0x%08x,0x%08x,0x%08x,0x%08x)",aMemory, aIndex, aCount, aMapping));
 	__ASSERT_CRITICAL;
 	__NK_ASSERT_DEBUG(aPinArgs.HaveSufficientPages(aCount));
+	__NK_ASSERT_DEBUG(aMapping->IsPinned());
+	__NK_ASSERT_DEBUG(!aMapping->PagesPinned());
 	// check and allocate page array entries...
 	RPageArray::TIter pageList;
 	TInt r = aMemory->iPages.AddStart(aIndex,aCount,pageList,true);
 	if(r!=KErrNone)

changeset 201	43365a9b78a3
parent 152	657f875b013e