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

equal deleted inserted replaced

-:947f0dc9f7a8
+:ef2a444a7410
 		/**
 		Page is in an indeterminate state.
 		A page is placed into this state by Mmu::PagesAllocated when it is
-		allocated (ceases to be #EUnused). Once the page
+		allocated (ceases to be #EUnused). Once the page has been assigned to
+		its new use its type will be updated.
 		*/
 		EUnknown,
 		/**
 		Page was allocated with Mmu::AllocPhysicalRam, Mmu::ClaimPhysicalRam
 	union
 		{
 		/**
 		The memory object which owns this page.
-		Used for always set for #EManaged pages and can be set for #PhysAlloc pages.
+		Always set for #EManaged pages and can be set for #PhysAlloc pages.
 		*/
 		DMemoryObject* iOwner;
 		/**
 		A pointer to the SPageInfo of the page that is being shadowed.
 	/**
 	Return a SPageInfo by conversion from the address of its embedded link member #iLink.
 	*/
 	FORCE_INLINE static SPageInfo* FromLink(SDblQueLink* aLink)
 		{
-		return (SPageInfo*)((TInt)aLink-_FOFF(SPageInfo,iLink));
+		return _LOFF(aLink, SPageInfo, iLink);
 		}
 	//
 	// Getters...
 	//
 		__NK_ASSERT_DEBUG(!iOriginalPageInfo);
 		iOriginalPageInfo = aOrigPageInfo;
 		}
 	/**
-	Reutrns a pointer to the SPageInfo of the page that this page is shadowing.
+	Returns a pointer to the SPageInfo of the page that this page is shadowing.
 	@return	A pointer to the SPageInfo that this page is shadowing
 	@pre #MmuLock held.
 	*/
 		iPagedState = aPagedState;
 		iModifier = 0;
 		}
 	/**
-	The the pages #iModifier value.
+	Set the page's #iModifier value.
 	#iModifier is cleared to zero whenever the usage or paging state of the page
 	changes. So if a thread sets this to a suitable unique value (e.g. the address
 	of a local variable) then it may perform a long running operation on the page
 	and later check with #CheckModified that no other thread has changed the page
 	Return a pointer to a SPageTableInfo by conversion from the address
 	of its embedded link as returned by #FreeLink.
 	*/
 	FORCE_INLINE static SPageTableInfo* FromFreeLink(SDblQueLink* aLink)
 		{
-		return (SPageTableInfo*)((TInt)aLink-_FOFF(SPageTableInfo,iUnused));
+		return _LOFF(aLink, SPageTableInfo, iUnused);
 		}
 	/**
 	Return the SPageTableInfo for the first page table in the same
 	physical ram page as the page table for this SPageTableInfo.
 	__UNLOCK_GUARD_END(MmuLock); // fault if MmuLock released by SomeCode or SomeMoreCode
 	@endcode
 	*/
 	static FORCE_INLINE void UnlockGuardStart()
 		{
-		#ifdef _DEBUG
+#ifdef _DEBUG
-			++UnlockGuardNest;
+		++UnlockGuardNest;
-		#endif
+#endif
 		}
 	/**
 	End a debug check testing that the MmuLock is not unlocked unexpectedly.
 	This is usually used via the #__UNLOCK_GUARD_END which faults if true is returned.
 	@see UnlockGuardStart
-	@return True if the MmuLock was released between a previous #UnlockGuardStart
+	@return EFalse if the MmuLock was released between a previous #UnlockGuardStart
 			and the call this function.
 	*/
 	static FORCE_INLINE TBool UnlockGuardEnd()
 		{
-		#ifdef _DEBUG
+#ifdef _DEBUG
-			__NK_ASSERT_DEBUG(UnlockGuardNest);
+		__NK_ASSERT_DEBUG(UnlockGuardNest);
-			--UnlockGuardNest;
+		--UnlockGuardNest;
-			return UnlockGuardFail==0;
+		return UnlockGuardFail==0;
-		#else
+#else
-			return true;
+		return ETrue;
-		#endif
+#endif
 		}
 private:
 	/**
 	Exectued whenever the lock is released to check that
 	#UnlockGuardStart and #UnlockGuardEnd are balanced.
 	*/
 	static FORCE_INLINE void UnlockGuardCheck()
 		{
-		#ifdef _DEBUG
+#ifdef _DEBUG
-			if(UnlockGuardNest)
+		if(UnlockGuardNest)
-				UnlockGuardFail = true;
+			UnlockGuardFail = ETrue;
-		#endif
+#endif
 		}
 public:
 	/** The lock */
 	static NFastMutex iLock;
 	void Init2Common();
 	void Init2Final();
 	void Init2FinalCommon();
 	void Init3();
+	void BTracePrime(TUint aCategory);
 	static void Panic(TPanic aPanic);
 	static TInt HandlePageFault(TLinAddr aPc, TLinAddr aFaultAddress, TUint aAccessPermissions, TAny* aExceptionInfo);
 	TUint FreeRamInPages();
 	TInt GetRamZonePageCount(TUint aId, SRamZonePageCount& aPageData);
 	TInt ZoneAllocPhysicalRam(TUint* aZoneIdList, TUint aZoneIdCount, TInt aBytes, TPhysAddr& aPhysAddr, TInt aAlign);
 	TInt ZoneAllocPhysicalRam(TUint* aZoneIdList, TUint aZoneIdCount, TInt aNumPages, TPhysAddr* aPageList);
 	TInt RamHalFunction(TInt aFunction, TAny* a1, TAny* a2);
 	void ChangePageType(SPageInfo* aPageInfo, TZonePageType aOldPageType, TZonePageType aNewPageType);
+	TInt FreeRamZone(TUint aZoneId);
 	TInt AllocPhysicalRam(TPhysAddr* aPages, TUint aCount, TRamAllocFlags aFlags);
 	void FreePhysicalRam(TPhysAddr* aPages, TUint aCount);
 	TInt AllocPhysicalRam(TPhysAddr& aPhysAddr, TUint aCount, TUint aAlign, TRamAllocFlags aFlags);
 	void FreePhysicalRam(TPhysAddr aPhysAddr, TUint aCount);
 	TInt ClaimPhysicalRam(TPhysAddr aPhysAddr, TUint aCount, TRamAllocFlags aFlags);
 	void AllocatedPhysicalRam(TPhysAddr aPhysAddr, TUint aCount, TRamAllocFlags aFlags);
+private:
+	void SetAllocPhysRam(TPhysAddr aPhysAddr, TUint aCount);
+	void SetAllocPhysRam(TPhysAddr* aPageList, TUint aNumPages);
+public:
 	TLinAddr MapTemp(TPhysAddr aPage, TUint aColour, TUint aSlot=0);
 	void UnmapTemp(TUint aSlot=0);
 	void RemoveAliasesForPageTable(TPhysAddr aPageTable);
 	static TBool MapPages(TPte* const aPtePtr, const TUint aCount, TPhysAddr* aPages, TPte aBlankPte);
 	of memory level change notifications.
 	*/
 	TUint iRamAllocInitialFreePages;
 	friend class RamAllocLock;
+#ifdef FMM_VERIFY_RAM
 private:
 	void VerifyRam();
+#endif
 	};
 /**
 The single instance of class #Mmu.
 */

changeset 102	ef2a444a7410
parent 90	947f0dc9f7a8
child 152	657f875b013e