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

equal deleted inserted replaced

-:e880629062dd
+:e4a7b1cbe40c
 						EMemModelAttrVA|EMemModelAttrProcessProt|EMemModelAttrSameVA|EMemModelAttrSvKernProt|
 						EMemModelAttrIPCKernProt|EMemModelAttrRamCodeProt;
 	}
-#if 0
+#ifdef FMM_VERIFY_RAM
+// Attempt to write to each unused RAM page and verify the contents.
 void Mmu::VerifyRam()
 	{
 	Kern::Printf("Mmu::VerifyRam() pass 1");
 	RamAllocLock::Lock();
 					TInt r = iRamPageAllocator->MarkPageAllocated(pa, EPageFixed);
 					// allow KErrAlreadyExists since it's possible that a page is doubly mapped
 					__ASSERT_ALWAYS(r==KErrNone || r==KErrAlreadyExists, Panic(EBadMappedPageAfterBoot));
 					if(pi->Type()==SPageInfo::EUnused)
 						pi->SetFixed();
+#ifdef BTRACE_KERNEL_MEMORY
+					if(r == KErrNone)
+						++Epoc::KernelMiscPages;
+#endif
 					}
 				}
 			}
 		__KTRACE_OPT(KBOOT,Kern::Printf("Addr: %08x #PTEs=%d",(i<<KChunkShift),np));
 		if(pt)
 	iPhysMemSyncTemp.Alloc(1);
 	r = K::MutexCreate(iPhysMemSyncMutex, KLitPhysMemSync, NULL, EFalse, KMutexOrdSyncPhysMem);
 	if(r!=KErrNone)
 		Panic(EPhysMemSyncMutexCreateFailed);
-//	VerifyRam();
+#ifdef FMM_VERIFY_RAM
+	VerifyRam();
+#endif
 	}
 void Mmu::Init2FinalCommon()
 	{
 	__KTRACE_OPT2(KBOOT,KMMU,Kern::Printf("Mmu::Init2FinalCommon"));
-	// hack, reduce free memory to <2GB...
+	// Reduce free memory to <2GB...
 	while(FreeRamInPages()>=0x80000000/KPageSize)
 		{
 		TPhysAddr dummyPage;
 		TInt r = iRamPageAllocator->AllocRamPages(&dummyPage,1, EPageFixed);
 		__NK_ASSERT_ALWAYS(r==KErrNone);
 		}
-	// hack, reduce total RAM to <2GB...
+	// Reduce total RAM to <2GB...
 	if(TheSuperPage().iTotalRamSize<0)
 		TheSuperPage().iTotalRamSize = 0x80000000-KPageSize;
 	// Save current free RAM size - there can never be more free RAM than this
 	TUint maxFreePages = FreeRamInPages();
 	if (!iDefrag)
 		Panic(EDefragAllocFailed);
 	iDefrag->Init3(TheMmu.iRamPageAllocator);
 	}
+void Mmu::BTracePrime(TUint aCategory)
+	{
+	(void)aCategory;
+#ifdef BTRACE_RAM_ALLOCATOR
+	// Must check for -1 as that is the default value of aCategory for
+	// BTrace::Prime() which is intended to prime all categories that are
+	// currently enabled via a single invocation of BTrace::Prime().
+	if(aCategory==BTrace::ERamAllocator || (TInt)aCategory == -1)
+		{
+		NKern::ThreadEnterCS();
+		RamAllocLock::Lock();
+		iRamPageAllocator->DoBTracePrime();
+		RamAllocLock::Unlock();
+		NKern::ThreadLeaveCS();
+		}
+#endif
+	}
 //
 // Utils
 //
 void Mmu::Panic(TPanic aPanic)
 TInt Mmu::ZoneAllocPhysicalRam(TUint* aZoneIdList, TUint aZoneIdCount, TInt aBytes, TPhysAddr& aPhysAddr, TInt aAlign)
 	{
 	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::ZoneAllocPhysicalRam(?,%d,%d,?,%d)", aZoneIdCount, aBytes, aPhysAddr, aAlign));
 	__NK_ASSERT_DEBUG(RamAllocLock::IsHeld());
-	TInt r = iRamPageAllocator->ZoneAllocContiguousRam(aZoneIdList, aZoneIdCount, aBytes, aPhysAddr, EPageFixed, aAlign);
+	TInt r = iRamPageAllocator->ZoneAllocContiguousRam(aZoneIdList, aZoneIdCount, aBytes, aPhysAddr, aAlign);
 	if(r!=KErrNone)
 		iRamAllocFailed = ETrue;
 	else
 		{
 		TUint pages = MM::RoundToPageCount(aBytes);
 	else
 		{
 		PagesAllocated(aPageList, aNumPages, (Mmu::TRamAllocFlags)EMemAttStronglyOrdered);
 		// update page infos...
-		TUint flash = 0;
+		SetAllocPhysRam(aPageList, aNumPages);
-		TPhysAddr* pageEnd = aPageList + aNumPages;
-		MmuLock::Lock();
-		TPhysAddr* page = aPageList;
-		while (page < pageEnd)
-			{
-			MmuLock::Flash(flash,KMaxPageInfoUpdatesInOneGo/2);
-			TPhysAddr pagePhys = *page++;
-			__NK_ASSERT_DEBUG(pagePhys != KPhysAddrInvalid);
-			SPageInfo::FromPhysAddr(pagePhys)->SetPhysAlloc();
-			}
-		MmuLock::Unlock();
 		}
 	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::ZoneAllocPhysicalRam returns %d",r));
 	return r;
 	}
 	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::AllocRam returns %d",r));
 	return r;
 	}
+/**
+Mark a page as being allocated to a particular page type.
+NOTE - This page should not be used until PagesAllocated() has been invoked on it.
+@param aPhysAddr		The physical address of the page to mark as allocated.
+@param aZonePageType	The type of the page to mark as allocated.
+*/
+void Mmu::MarkPageAllocated(TPhysAddr aPhysAddr, TZonePageType aZonePageType)
+	{
+	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::MarkPageAllocated(0x%x, %d)", aPhysAddr, aZonePageType));
+	__NK_ASSERT_DEBUG(RamAllocLock::IsHeld());
+	iRamPageAllocator->MarkPageAllocated(aPhysAddr, aZonePageType);
+	}
 void Mmu::FreeRam(TPhysAddr* aPages, TUint aCount, TZonePageType aZonePageType)
 	{
 	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::FreeRam(?,%d)",aCount));
 	__NK_ASSERT_DEBUG(RamAllocLock::IsHeld());
 		TPhysAddr pagePhys = *pages++;
 		__NK_ASSERT_DEBUG(pagePhys!=KPhysAddrInvalid);
 		SPageInfo* pi = SPageInfo::FromPhysAddr(pagePhys);
 		PageFreed(pi);
-		// If this is an old page of a page being moved that was previously pinned
+		switch (ThePager.PageFreed(pi))
-		// then make sure it is freed as discardable otherwise despite DPager::DonatePages()
+			{
-		// having marked it as discardable it would be freed as movable.
+			case KErrNone:
-		__NK_ASSERT_DEBUG(pi->PagedState() != SPageInfo::EPagedPinnedMoved || aCount == 1);
+				--aCount; // pager has dealt with this page, so one less for us
-		if (pi->PagedState() == SPageInfo::EPagedPinnedMoved)
+				break;
-			aZonePageType = EPageDiscard;
+			case KErrCompletion:
+				// This was a pager controlled page but it is no longer required.
-		if(ThePager.PageFreed(pi)==KErrNone)
+				__NK_ASSERT_DEBUG(aZonePageType == EPageMovable || aZonePageType == EPageDiscard);
-			--aCount; // pager has dealt with this page, so one less for us
+				__NK_ASSERT_DEBUG(pi->PagedState() == SPageInfo::EUnpaged);
-		else
+				if (aZonePageType == EPageMovable)
-			{
+					{// This page was donated to the pager so have to free it here
-			// All paged pages should have been dealt with by the pager above.
+					// as aZonePageType is incorrect for this page but aPages may
-			__NK_ASSERT_DEBUG(pi->PagedState() == SPageInfo::EUnpaged);
+					// contain a mixture of movable and discardable pages.
-			*pagesOut++ = pagePhys; // store page address for freeing later
+					MmuLock::Unlock();
+					iRamPageAllocator->FreeRamPages(&pagePhys, 1, EPageDiscard);
+					aCount--; // We've freed this page here so one less to free later
+					flash = 0;	// reset flash count as we released the mmulock.
+					MmuLock::Lock();
+					break;
+					}
+				// fall through..
+			default:
+				// Free this page..
+				__NK_ASSERT_DEBUG(pi->PagedState() == SPageInfo::EUnpaged);
+				*pagesOut++ = pagePhys; // store page address for freeing later
 			}
 		}
 	MmuLock::Unlock();
 	iRamPageAllocator->FreeRamPages(aPages, aCount, aZonePageType);
 	if(K::CheckForSimulatedAllocFail())
 		{
 		__KTRACE_OPT(KMMU,Kern::Printf("Mmu::AllocContiguousRam returns simulated OOM %d",KErrNoMemory));
 		return KErrNoMemory;
 		}
-	// Only the page sets EAllocNoPagerReclaim and it shouldn't allocate contiguous ram.
+	// Only the pager sets EAllocNoPagerReclaim and it shouldn't allocate contiguous ram.
 	__NK_ASSERT_DEBUG(!(aFlags&EAllocNoPagerReclaim));
 #endif
-	TInt r = iRamPageAllocator->AllocContiguousRam(aCount, aPhysAddr, EPageFixed, aAlign+KPageShift);
+	TInt r = iRamPageAllocator->AllocContiguousRam(aCount, aPhysAddr, aAlign+KPageShift);
-	if(r==KErrNoMemory && aCount > KMaxFreeableContiguousPages)
-		{
-		// flush paging cache and retry...
-		ThePager.FlushAll();
-		r = iRamPageAllocator->AllocContiguousRam(aCount, aPhysAddr, EPageFixed, aAlign+KPageShift);
-		}
 	if(r!=KErrNone)
 		iRamAllocFailed = ETrue;
 	else
 		PagesAllocated((TPhysAddr*)(aPhysAddr|1), aCount, aFlags);
-	__KTRACE_OPT(KMMU,Kern::Printf("AllocContiguouseRam returns %d and aPhysAddr=0x%08x",r,aPhysAddr));
+	__KTRACE_OPT(KMMU,Kern::Printf("AllocContiguousRam returns %d and aPhysAddr=0x%08x",r,aPhysAddr));
 	return r;
 	}
 void Mmu::FreeContiguousRam(TPhysAddr aPhysAddr, TUint aCount)
 	TInt r = AllocRam(aPages, aCount, aFlags, EPageFixed);
 	if (r!=KErrNone)
 		return r;
 	// update page infos...
-	TPhysAddr* pages = aPages;
+	SetAllocPhysRam(aPages, aCount);
-	TPhysAddr* pagesEnd = pages+aCount;
-	MmuLock::Lock();
-	TUint flash = 0;
-	while(pages<pagesEnd)
-		{
-		MmuLock::Flash(flash,KMaxPageInfoUpdatesInOneGo/2);
-		TPhysAddr pagePhys = *pages++;
-		__NK_ASSERT_DEBUG(pagePhys!=KPhysAddrInvalid);
-		SPageInfo* pi = SPageInfo::FromPhysAddr(pagePhys);
-		pi->SetPhysAlloc();
-		}
-	MmuLock::Unlock();
 	return KErrNone;
 	}
 		pi->SetUnused();
 		}
 	MmuLock::Unlock();
 	iRamPageAllocator->FreeRamPages(aPages,aCount, EPageFixed);
+#ifdef BTRACE_KERNEL_MEMORY
+	if (BTrace::CheckFilter(BTrace::EKernelMemory))
+		{// Only loop round each page if EKernelMemory tracing is enabled
+		pages = aPages;
+		pagesEnd = aPages + aCount;
+		while (pages < pagesEnd)
+			{
+			BTrace8(BTrace::EKernelMemory, BTrace::EKernelMemoryDrvPhysFree, KPageSize, *pages++);
+			Epoc::DriverAllocdPhysRam -= KPageSize;
+			}
+		}
+#endif
 	}
 TInt Mmu::AllocPhysicalRam(TPhysAddr& aPhysAddr, TUint aCount, TUint aAlign, TRamAllocFlags aFlags)
 	{
 	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::AllocPhysicalRam(?,0x%x,d,%x)",aCount,aAlign,aFlags));
 	TInt r = AllocContiguousRam(aPhysAddr,aCount,aAlign,aFlags);
 	if (r!=KErrNone)
 		return r;
+	// update page infos...
+	SetAllocPhysRam(aPhysAddr, aCount);
+	return KErrNone;
+	}
+void Mmu::FreePhysicalRam(TPhysAddr aPhysAddr, TUint aCount)
+	{
+	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::FreePhysicalRam(0x%08x,0x%x)",aPhysAddr,aCount));
 	// update page infos...
 	SPageInfo* pi = SPageInfo::FromPhysAddr(aPhysAddr);
 	SPageInfo* piEnd = pi+aCount;
 	TUint flash = 0;
 	MmuLock::Lock();
 	while(pi<piEnd)
 		{
 		MmuLock::Flash(flash,KMaxPageInfoUpdatesInOneGo);
-		pi->SetPhysAlloc();
+		__ASSERT_ALWAYS(pi->Type()==SPageInfo::EPhysAlloc, Panic(EBadFreePhysicalRam));
+		__ASSERT_ALWAYS(!pi->UseCount(), Panic(EBadFreePhysicalRam));
+		pi->SetUnused();
 		++pi;
 		}
 	MmuLock::Unlock();
+	TUint bytes = aCount << KPageShift;
+	iRamPageAllocator->FreePhysicalRam(aPhysAddr, bytes);
+#ifdef BTRACE_KERNEL_MEMORY
+	BTrace8(BTrace::EKernelMemory, BTrace::EKernelMemoryDrvPhysFree, bytes, aPhysAddr);
+	Epoc::DriverAllocdPhysRam -= bytes;
+#endif
+	}
+TInt Mmu::FreeRamZone(TUint aZoneId)
+	{
+	TPhysAddr zoneBase;
+	TUint zonePages;
+	TInt r = iRamPageAllocator->GetZoneAddress(aZoneId, zoneBase, zonePages);
+	if (r != KErrNone)
+		return r;
+	FreePhysicalRam(zoneBase, zonePages);
 	return KErrNone;
 	}
-void Mmu::FreePhysicalRam(TPhysAddr aPhysAddr, TUint aCount)
+TInt Mmu::ClaimPhysicalRam(TPhysAddr aPhysAddr, TUint aCount, TRamAllocFlags aFlags)
 	{
-	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::FreePhysicalRam(0x%08x,0x%x)",aPhysAddr,aCount));
+	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::ClaimPhysicalRam(0x%08x,0x%x,0x%08x)",aPhysAddr,aCount,aFlags));
+	aPhysAddr &= ~KPageMask;
+	TInt r = iRamPageAllocator->ClaimPhysicalRam(aPhysAddr, aCount << KPageShift);
+	if(r != KErrNone)
+		return r;
+	AllocatedPhysicalRam(aPhysAddr, aCount, aFlags);
+	return KErrNone;
+	}
+void Mmu::AllocatedPhysicalRam(TPhysAddr aPhysAddr, TUint aCount, TRamAllocFlags aFlags)
+	{
+	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::AllocatedPhysicalRam(0x%08x,0x%x,d,%x)",aPhysAddr,aCount,aFlags));
+	PagesAllocated((TPhysAddr*)(aPhysAddr|1), aCount, aFlags);
 	// update page infos...
+	SetAllocPhysRam(aPhysAddr, aCount);
+	}
+void Mmu::SetAllocPhysRam(TPhysAddr aPhysAddr, TUint aCount)
+	{
 	SPageInfo* pi = SPageInfo::FromPhysAddr(aPhysAddr);
 	SPageInfo* piEnd = pi+aCount;
 	TUint flash = 0;
 	MmuLock::Lock();
 	while(pi<piEnd)
 		{
-		MmuLock::Flash(flash,KMaxPageInfoUpdatesInOneGo);
+		MmuLock::Flash(flash, KMaxPageInfoUpdatesInOneGo);
-		__ASSERT_ALWAYS(pi->Type()==SPageInfo::EPhysAlloc, Panic(EBadFreePhysicalRam));
+		pi->SetPhysAlloc();
-		__ASSERT_ALWAYS(!pi->UseCount(), Panic(EBadFreePhysicalRam));
-		pi->SetUnused();
 		++pi;
 		}
 	MmuLock::Unlock();
-	iRamPageAllocator->FreePhysicalRam(aPhysAddr, aCount << KPageShift);
+#ifdef BTRACE_KERNEL_MEMORY
-	}
+	TUint bytes = aCount << KPageShift;
+	BTrace8(BTrace::EKernelMemory, BTrace::EKernelMemoryDrvPhysAlloc, bytes, aPhysAddr);
+	Epoc::DriverAllocdPhysRam += bytes;
-TInt Mmu::ClaimPhysicalRam(TPhysAddr aPhysAddr, TUint aCount, TRamAllocFlags aFlags)
+#endif
-	{
+	}
-	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::ClaimPhysicalRam(0x%08x,0x%x,0x%08x)",aPhysAddr,aCount,aFlags));
-	aPhysAddr &= ~KPageMask;
-	TInt r = iRamPageAllocator->ClaimPhysicalRam(aPhysAddr,(aCount << KPageShift));
+void Mmu::SetAllocPhysRam(TPhysAddr* aPageList, TUint aNumPages)
-	if(r!=KErrNone)
+	{
-		return r;
+	TPhysAddr* page = aPageList;
+	TPhysAddr* pageEnd = aPageList + aNumPages;
-	PagesAllocated((TPhysAddr*)(aPhysAddr|1), aCount, aFlags);
-	// update page infos...
-	SPageInfo* pi = SPageInfo::FromPhysAddr(aPhysAddr);
-	SPageInfo* piEnd = pi+aCount;
 	TUint flash = 0;
 	MmuLock::Lock();
-	while(pi<piEnd)
+	while (page < pageEnd)
 		{
-		MmuLock::Flash(flash,KMaxPageInfoUpdatesInOneGo);
+		MmuLock::Flash(flash, KMaxPageInfoUpdatesInOneGo / 2);
-		pi->SetPhysAlloc();
+		TPhysAddr pagePhys = *page++;
-		++pi;
+		__NK_ASSERT_DEBUG(pagePhys != KPhysAddrInvalid);
+		SPageInfo::FromPhysAddr(pagePhys)->SetPhysAlloc();
 		}
 	MmuLock::Unlock();
-	return KErrNone;
+#ifdef BTRACE_KERNEL_MEMORY
-	}
+	if (BTrace::CheckFilter(BTrace::EKernelMemory))
+		{// Only loop round each page if EKernelMemory tracing is enabled
+		TPhysAddr* pAddr = aPageList;
-void Mmu::AllocatedPhysicalRam(TPhysAddr aPhysAddr, TUint aCount, TRamAllocFlags aFlags)
+		TPhysAddr* pAddrEnd = aPageList + aNumPages;
-	{
+		while (pAddr < pAddrEnd)
-	__KTRACE_OPT(KMMU,Kern::Printf("Mmu::AllocatedPhysicalRam(0x%08x,0x%x,d,%x)",aPhysAddr,aCount,aFlags));
+			{
+			BTrace8(BTrace::EKernelMemory, BTrace::EKernelMemoryDrvPhysAlloc, KPageSize, *pAddr++);
-	PagesAllocated((TPhysAddr*)(aPhysAddr|1), aCount, aFlags);
+			Epoc::DriverAllocdPhysRam += KPageSize;
+			}
-	// update page infos...
+		}
-	SPageInfo* pi = SPageInfo::FromPhysAddr(aPhysAddr);
+#endif
-	SPageInfo* piEnd = pi+aCount;
-	TUint flash = 0;
-	MmuLock::Lock();
-	while(pi<piEnd)
-		{
-		MmuLock::Flash(flash,KMaxPageInfoUpdatesInOneGo);
-		pi->SetPhysAlloc();
-		++pi;
-		}
-	MmuLock::Unlock();
 	}
 //
 // Misc
 TLinAddr Mmu::TTempMapping::Map(TPhysAddr aPage, TUint aColour)
 	{
 	__NK_ASSERT_DEBUG(iSize>=1);
 	__NK_ASSERT_DEBUG(iCount==0);
+	return Map(aPage, aColour, iBlankPte);
+	}
+/**
+Map a single physical page into this temporary mapping using the given page table entry (PTE) value.
+@param aPage		The physical page to map.
+@param aColour 		The required colour for the mapping.
+@param aBlankPte	The PTE value to use for mapping the page,
+					with the physical address component equal to zero.
+@return 			The linear address at which the page is mapped.
+*/
+TLinAddr Mmu::TTempMapping::Map(TPhysAddr aPage, TUint aColour, TPte aBlankPte)
+	{
+	__NK_ASSERT_DEBUG(iSize>=1);
+	__NK_ASSERT_DEBUG(iCount==0);
+	__NK_ASSERT_DEBUG(!(aBlankPte & ~KPageMask));
+	TUint colour = aColour & KPageColourMask;
+	TLinAddr addr = iLinAddr + (colour << KPageShift);
+	TPte* pPte = iPtePtr + colour;
+	iColour = colour;
+	__ASSERT_DEBUG(*pPte == KPteUnallocatedEntry, MM::Panic(MM::ETempMappingAlreadyInUse));
+	*pPte = (aPage & ~KPageMask) | aBlankPte;
+	CacheMaintenance::SinglePteUpdated((TLinAddr)pPte);
+	InvalidateTLBForPage(addr | KKernelOsAsid);
+	iCount = 1;
+	return addr;
+	}
+/**
+Map a number of physical pages into this temporary mapping.
+Supervisor read/write access and EMemoryAttributeStandard memory attributes apply.
+@param aPages		The array of physical pages to map.
+@param aCount		The number of pages to map.
+@param aColour 		The required colour for the first page.
+					Consecutive pages will be coloured accordingly.
+@return 			The linear address at which the first page is mapped.
+*/
+TLinAddr Mmu::TTempMapping::Map(TPhysAddr* aPages, TUint aCount, TUint aColour)
+	{
+	__NK_ASSERT_DEBUG(iSize>=aCount);
+	__NK_ASSERT_DEBUG(iCount==0);
 	TUint colour = aColour&KPageColourMask;
 	TLinAddr addr = iLinAddr+(colour<<KPageShift);
 	TPte* pPte = iPtePtr+colour;
 	iColour = colour;
-	__ASSERT_DEBUG(*pPte==KPteUnallocatedEntry,MM::Panic(MM::ETempMappingAlreadyInUse));
-	*pPte = (aPage&~KPageMask) | iBlankPte;
-	CacheMaintenance::SinglePteUpdated((TLinAddr)pPte);
-	InvalidateTLBForPage(addr|KKernelOsAsid);
-	iCount = 1;
-	return addr;
-	}
-/**
-Map a single physical page into this temporary mapping using the given page table entry (PTE) value.
-@param aPage		The physical page to map.
-@param aColour 		The required colour for the mapping.
-@param aBlankPte	The PTE value to use for mapping the page,
-					with the physical address component equal to zero.
-@return 			The linear address at which the page is mapped.
-*/
-TLinAddr Mmu::TTempMapping::Map(TPhysAddr aPage, TUint aColour, TPte aBlankPte)
-	{
-	__NK_ASSERT_DEBUG(iSize>=1);
-	__NK_ASSERT_DEBUG(iCount==0);
-	TUint colour = aColour&KPageColourMask;
-	TLinAddr addr = iLinAddr+(colour<<KPageShift);
-	TPte* pPte = iPtePtr+colour;
-	iColour = colour;
-	__ASSERT_DEBUG(*pPte==KPteUnallocatedEntry,MM::Panic(MM::ETempMappingAlreadyInUse));
-	*pPte = (aPage&~KPageMask) | aBlankPte;
-	CacheMaintenance::SinglePteUpdated((TLinAddr)pPte);
-	InvalidateTLBForPage(addr|KKernelOsAsid);
-	iCount = 1;
-	return addr;
-	}
-/**
-Map a number of physical pages into this temporary mapping.
-Supervisor read/write access and EMemoryAttributeStandard memory attributes apply.
-@param aPages		The array of physical pages to map.
-@param aCount		The number of pages to map.
-@param aColour 		The required colour for the first page.
-					Consecutive pages will be coloured accordingly.
-@return 			The linear address at which the first page is mapped.
-*/
-TLinAddr Mmu::TTempMapping::Map(TPhysAddr* aPages, TUint aCount, TUint aColour)
-	{
-	__NK_ASSERT_DEBUG(iSize>=aCount);
-	__NK_ASSERT_DEBUG(iCount==0);
-	TUint colour = aColour&KPageColourMask;
-	TLinAddr addr = iLinAddr+(colour<<KPageShift);
-	TPte* pPte = iPtePtr+colour;
-	iColour = colour;
 	for(TUint i=0; i<aCount; ++i)
 		{
 		__ASSERT_DEBUG(pPte[i]==KPteUnallocatedEntry,MM::Panic(MM::ETempMappingAlreadyInUse));
 		pPte[i] = (aPages[i]&~KPageMask) | iBlankPte;
 		CacheMaintenance::SinglePteUpdated((TLinAddr)&pPte[i]);
 	__NK_ASSERT_DEBUG(iSize>=1);
 	TUint colour = iColour;
 	TLinAddr addr = iLinAddr+(colour<<KPageShift);
 	TPte* pPte = iPtePtr+colour;
-	TUint count = iCount;
+	while(iCount)
-	while(count)
 		{
 		*pPte = KPteUnallocatedEntry;
 		CacheMaintenance::SinglePteUpdated((TLinAddr)pPte);
 		InvalidateTLBForPage(addr|KKernelOsAsid);
 		addr += KPageSize;
 		++pPte;
-		--count;
+		--iCount;
 		}
-	iCount = 0;
 	}
 #ifdef __SMP__
 /**
 Dummy IPI to be invoked when a thread's alias pde members are updated remotely

changeset 132	e4a7b1cbe40c
parent 90	947f0dc9f7a8
child 176	af6ec97d9189