sl@0: // Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of the License "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: /**
sl@0:  @file
sl@0:  @internalComponent
sl@0: */
sl@0: 
sl@0: #ifndef __MMU_H__
sl@0: #define __MMU_H__
sl@0: 
sl@0: #define _USE_OLDEST_LISTS
sl@0: 
sl@0: #include "mm.h"
sl@0: #include "mmboot.h"
sl@0: #include <mmtypes.h>
sl@0: #include <kern_priv.h>
sl@0: 
sl@0: 
sl@0: class DCoarseMemory;
sl@0: class DMemoryObject;
sl@0: class DMemoryMapping;
sl@0: 
sl@0: /**
sl@0: A page information structure giving the current use and state for a
sl@0: RAM page being managed by the kernel.
sl@0: 
sl@0: Any modification to the contents of any SPageInfo structure requires the
sl@0: #MmuLock to be held. The exceptions to this is when a page is unused (#Type()==#EUnused),
sl@0: in this case only the #RamAllocLock is required to use #SetAllocated(), #SetUncached(),
sl@0: and #CacheInvalidateCounter().
sl@0: 
sl@0: These structures are stored in an array at the virtual address #KPageInfoLinearBase
sl@0: which is indexed by the physical address of the page they are associated with, divided
sl@0: by #KPageSize. The memory for this array is allocated by the bootstrap and it has
sl@0: unallocated regions where no memory is required to store SPageInfo structures.
sl@0: These unallocated memory regions are indicated by zeros in the bitmap stored at
sl@0: #KPageInfoMap.
sl@0: */
sl@0: struct SPageInfo
sl@0: 	{
sl@0: 	/**
sl@0: 	Enumeration for the usage of a RAM page. This is stored in #iType.
sl@0: 	*/
sl@0: 	enum TType
sl@0: 		{
sl@0: 		/**
sl@0: 		No physical RAM exists for this page.
sl@0: 
sl@0: 		This represents memory which doesn't exist or is not part of the physical
sl@0: 		address range being managed by the kernel.
sl@0: 		*/
sl@0: 		EInvalid,
sl@0: 
sl@0: 		/**
sl@0: 		RAM fixed at boot time.
sl@0: 
sl@0: 		This is for memory which was allocated by the bootstrap and which
sl@0: 		the kernel does not actively manage.
sl@0: 		*/
sl@0: 		EFixed,
sl@0: 
sl@0: 		/**
sl@0: 		Page is unused.
sl@0: 
sl@0: 		The page is either free memory in Mmu::iRamPageAllocator or the demand
sl@0: 		paging 'live' list.
sl@0: 
sl@0: 		To change from or to this type the #RamAllocLock must be held.
sl@0: 		*/
sl@0: 		EUnused,
sl@0: 
sl@0: 		/**
sl@0: 		Page is in an indeterminate state.
sl@0: 
sl@0: 		A page is placed into this state by Mmu::PagesAllocated when it is
sl@0: 		allocated (ceases to be #EUnused). Once the page
sl@0: 		*/
sl@0: 		EUnknown,
sl@0: 
sl@0: 		/**
sl@0: 		Page was allocated with Mmu::AllocPhysicalRam, Mmu::ClaimPhysicalRam
sl@0: 		or is part of a reserved RAM bank set at system boot.
sl@0: 		*/
sl@0: 		EPhysAlloc,
sl@0: 
sl@0: 		/**
sl@0: 		Page is owned by a memory object.
sl@0: 
sl@0: 		#iOwner will point to the owning memory object and #iIndex will
sl@0: 		be the page index into its memory for this page.
sl@0: 		*/
sl@0: 		EManaged,
sl@0: 
sl@0: 		/**
sl@0: 		Page is being used as a shadow page.
sl@0: 
sl@0: 		@see DShadowPage.
sl@0: 		*/
sl@0: 		EShadow
sl@0: 		};
sl@0: 
sl@0: 
sl@0: 	/**
sl@0: 	Flags stored in #iFlags.
sl@0: 
sl@0: 	The least significant bits of these flags are used for the #TMemoryAttributes
sl@0: 	value for the page.
sl@0: 	*/
sl@0: 	enum TFlags
sl@0: 		{
sl@0: 		// lower bits hold TMemoryAttribute value for this page
sl@0: 
sl@0: 		/**
sl@0: 		Flag set to indicate that the page has writable mappings.
sl@0: 		(This is to facilitate demand paged memory.)
sl@0: 		*/
sl@0: 		EWritable			= 1<<(EMemoryAttributeShift),
sl@0: 
sl@0: 		/**
sl@0: 		Flag set to indicate that the memory page contents may be different
sl@0: 		to those previously saved to backing store (contents are 'dirty').
sl@0: 		This is set whenever a page gains a writeable mapping and only every
sl@0: 		cleared once a demand paging memory manager 'cleans' the page.
sl@0: 		*/
sl@0: 		EDirty				= 1<<(EMemoryAttributeShift+1)
sl@0: 		};
sl@0: 
sl@0: 
sl@0: 	/**
sl@0: 	State for the page when being used to contain demand paged content.
sl@0: 	*/
sl@0: 	enum TPagedState
sl@0: 		{
sl@0: 		/**
sl@0: 		Page is not being managed for demand paging purposes, is has been transiently
sl@0: 		removed from the demand paging live list.
sl@0: 		*/
sl@0: 		EUnpaged 			= 0x0,
sl@0: 
sl@0: 		/**
sl@0: 		Page is in the live list as a young page.
sl@0: 		*/
sl@0: 		EPagedYoung 		= 0x1,
sl@0: 
sl@0: 		/**
sl@0: 		Page is in the live list as an old page.
sl@0: 		*/
sl@0: 		EPagedOld 			= 0x2,
sl@0: 
sl@0: 		/**
sl@0: 		Page was pinned but it has been moved but not yet freed.
sl@0: 		*/
sl@0: 		EPagedPinnedMoved	= 0x3,
sl@0: 
sl@0: 		/**
sl@0: 		Page has been removed from live list to prevent contents being paged-out.
sl@0: 		*/
sl@0: 		// NOTE - This must be the same value as EStatePagedLocked as defined in mmubase.h
sl@0: 		EPagedPinned 		= 0x4,
sl@0: 
sl@0: #ifdef _USE_OLDEST_LISTS
sl@0: 		/**
sl@0: 		Page is in the live list as one of oldest pages that is clean.
sl@0: 		*/
sl@0: 		EPagedOldestClean	= 0x5,
sl@0: 
sl@0: 		/**
sl@0: 		Page is in the live list as one of oldest pages that is dirty.
sl@0: 		*/
sl@0: 		EPagedOldestDirty 	= 0x6
sl@0: #endif
sl@0: 		};
sl@0: 
sl@0: 
sl@0: 	/**
sl@0: 	Additional flags, stored in #iFlags2.
sl@0: 	*/
sl@0: 	enum TFlags2
sl@0: 		{
sl@0: 		/**
sl@0: 		When #iPagedState==#EPagedPinned this indicates the page is a 'reserved' page
sl@0: 		and is does not increase free page count when returned to the live list.
sl@0: 		*/
sl@0: 		EPinnedReserve	= 1<<0,
sl@0: 		};
sl@0: 
sl@0: private:
sl@0: 	/**
sl@0: 	Value from enum #TType, returned by #Type().
sl@0: 	*/
sl@0: 	TUint8 iType;
sl@0: 
sl@0: 	/**
sl@0: 	Bitmask of values from #TFlags, returned by #Flags().
sl@0: 	*/
sl@0: 	TUint8 iFlags;
sl@0: 
sl@0: 	/**
sl@0: 	Value from enum #TPagedState, returned by #PagedState().
sl@0: 	*/
sl@0: 	TUint8 iPagedState;
sl@0: 
sl@0: 	/**
sl@0: 	Bitmask of values from #TFlags2.
sl@0: 	*/
sl@0: 	TUint8 iFlags2;
sl@0: 
sl@0: 	union
sl@0: 		{
sl@0: 		/**
sl@0: 		The memory object which owns this page.
sl@0: 		Used for always set for #EManaged pages and can be set for #PhysAlloc pages.
sl@0: 		*/
sl@0: 		DMemoryObject* iOwner;
sl@0: 
sl@0: 		/**
sl@0: 		A pointer to the SPageInfo of the page that is being shadowed.
sl@0: 		For use with #EShadow pages only.
sl@0: 		*/
sl@0: 		SPageInfo* iOriginalPageInfo;
sl@0: 		};
sl@0: 
sl@0: 	/**
sl@0: 	The index for this page within within the owning object's (#iOwner) memory.
sl@0: 	*/
sl@0: 	TUint32 iIndex;
sl@0: 
sl@0: 	/**
sl@0: 	Pointer identifying the current modifier of the page. See #SetModifier.
sl@0: 	*/
sl@0: 	TAny* iModifier;
sl@0: 
sl@0: 	/**
sl@0: 	Storage location for data specific to the memory manager object handling this page.
sl@0: 	See #SetPagingManagerData.
sl@0: 	*/
sl@0: 	TUint32 iPagingManagerData;
sl@0: 
sl@0: 	/**
sl@0: 	Union of values which vary depending of the current value of #iType.
sl@0: 	*/
sl@0: 	union
sl@0: 		{
sl@0: 		/**
sl@0: 		When #iType==#EPhysAlloc, this stores a count of the number of memory objects
sl@0: 		this page has been added to.
sl@0: 		*/
sl@0: 		TUint32 iUseCount;
sl@0: 
sl@0: 		/**
sl@0: 		When #iType==#EUnused, this stores the value of Mmu::iCacheInvalidateCounter
sl@0: 		at the time the page was freed. This is used for some cache maintenance optimisations.
sl@0: 		*/
sl@0: 		TUint32 iCacheInvalidateCounter;
sl@0: 
sl@0: 		/**
sl@0: 		When #iType==#EManaged, this holds the count of the number of times the page was pinned.
sl@0: 		This will only be non-zero for demand paged memory.
sl@0: 		*/
sl@0: 		TUint32 iPinCount;
sl@0: 		};
sl@0: 
sl@0: public:
sl@0: 	/**
sl@0: 	Used for placing page into linked lists. E.g. the various demand paging live lists.
sl@0: 	*/
sl@0: 	SDblQueLink iLink;
sl@0: 
sl@0: public:
sl@0: 	/**
sl@0: 	Return the SPageInfo for a given page of physical RAM.
sl@0: 	*/
sl@0: 	static SPageInfo* FromPhysAddr(TPhysAddr aAddress);
sl@0: 
sl@0: 	/**
sl@0: 	Return physical address of the RAM page which this SPageInfo object is associated.
sl@0: 	If the address has no SPageInfo, then a null pointer is returned.
sl@0: 	*/
sl@0: 	static SPageInfo* SafeFromPhysAddr(TPhysAddr aAddress);
sl@0: 
sl@0: 	/**
sl@0: 	Return physical address of the RAM page which this SPageInfo object is associated.
sl@0: 	*/
sl@0: 	FORCE_INLINE TPhysAddr PhysAddr();
sl@0: 
sl@0: 	/**
sl@0: 	Return a SPageInfo by conversion from the address of its embedded link member #iLink.
sl@0: 	*/
sl@0: 	FORCE_INLINE static SPageInfo* FromLink(SDblQueLink* aLink)
sl@0: 		{
sl@0: 		return (SPageInfo*)((TInt)aLink-_FOFF(SPageInfo,iLink));
sl@0: 		}
sl@0: 
sl@0: 	//
sl@0: 	// Getters...
sl@0: 	//
sl@0: 
sl@0: 	/**
sl@0: 	Return the current #TType value stored in #iType.
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	FORCE_INLINE TType Type()
sl@0: 		{
sl@0: 		CheckAccess("Type");
sl@0: 		return (TType)iType;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return the current value of #iFlags.
sl@0: 	@pre #MmuLock held (if \a aNoCheck false).
sl@0: 	*/
sl@0: 	FORCE_INLINE TUint Flags(TBool aNoCheck=false)
sl@0: 		{
sl@0: 		if(!aNoCheck)
sl@0: 			CheckAccess("Flags");
sl@0: 		return iFlags;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return the current value of #iPagedState.
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	FORCE_INLINE TPagedState PagedState()
sl@0: 		{
sl@0: 		CheckAccess("PagedState");
sl@0: 		return (TPagedState)iPagedState;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return the current value of #iOwner.
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	FORCE_INLINE DMemoryObject* Owner()
sl@0: 		{
sl@0: 		CheckAccess("Owner");
sl@0: 		return iOwner;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return the current value of #iIndex.
sl@0: 	@pre #MmuLock held (if \a aNoCheck false).
sl@0: 	*/
sl@0: 	FORCE_INLINE TUint32 Index(TBool aNoCheck=false)
sl@0: 		{
sl@0: 		if(!aNoCheck)
sl@0: 			CheckAccess("Index");
sl@0: 		return iIndex;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return the current value of #iModifier.
sl@0: 	@pre #MmuLock held (if \a aNoCheck false).
sl@0: 	*/
sl@0: 	FORCE_INLINE TAny* Modifier()
sl@0: 		{
sl@0: 		CheckAccess("Modifier");
sl@0: 		return iModifier;
sl@0: 		}
sl@0: 
sl@0: 
sl@0: 	//
sl@0: 	// Setters..
sl@0: 	//
sl@0: 
sl@0: 	/**
sl@0: 	Set this page as type #EFixed.
sl@0: 	This is only used during boot by Mmu::Init2Common.
sl@0: 	*/
sl@0: 	inline void SetFixed(TUint32 aIndex=0)
sl@0: 		{
sl@0: 		CheckAccess("SetFixed");
sl@0: 		Set(EFixed,0,aIndex);
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Set this page as type #EUnused.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	@pre #RamAllocLock held if previous page type != #EUnknown.
sl@0: 
sl@0: 	@post #iModifier==0 to indicate that page usage has changed.
sl@0: 	*/
sl@0: 	inline void SetUnused()
sl@0: 		{
sl@0: 		CheckAccess("SetUnused",ECheckNotUnused|((iType!=EUnknown)?(TInt)ECheckRamAllocLock:0));
sl@0: 		iType = EUnused;
sl@0: 		iModifier = 0;
sl@0: 		// do not modify iFlags or iIndex in this function because page allocating cache cleaning operations rely on using this value
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Set this page as type #EUnknown.
sl@0: 	This is only used by Mmu::PagesAllocated.
sl@0: 
sl@0: 	@pre #RamAllocLock held.
sl@0: 
sl@0: 	@post #iModifier==0 to indicate that page usage has changed.
sl@0: 	*/
sl@0: 	inline void SetAllocated()
sl@0: 		{
sl@0: 		CheckAccess("SetAllocated",ECheckUnused|ECheckRamAllocLock|ENoCheckMmuLock);
sl@0: 		iType = EUnknown;
sl@0: 		iModifier = 0;
sl@0: 		// do not modify iFlags or iIndex in this function because cache cleaning operations rely on using this value
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Set this page as type #EPhysAlloc.
sl@0: 	@param aOwner	 Optional value for #iOwner.
sl@0: 	@param aIndex	 Optional value for #iIndex.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 
sl@0: 	@post #iModifier==0 to indicate that page usage has changed.
sl@0: 	*/
sl@0: 	inline void SetPhysAlloc(DMemoryObject* aOwner=0, TUint32 aIndex=0)
sl@0: 		{
sl@0: 		CheckAccess("SetPhysAlloc");
sl@0: 		Set(EPhysAlloc,aOwner,aIndex);
sl@0: 		iUseCount = 0;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Set this page as type #EManaged.
sl@0: 
sl@0: 	@param aOwner	Value for #iOwner.
sl@0: 	@param aIndex 	Value for #iIndex.
sl@0: 	@param aFlags 	Value for #iFlags (aOwner->PageInfoFlags()).
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 
sl@0: 	@post #iModifier==0 to indicate that page usage has changed.
sl@0: 	*/
sl@0: 	inline void SetManaged(DMemoryObject* aOwner, TUint32 aIndex, TUint8 aFlags)
sl@0: 		{
sl@0: 		CheckAccess("SetManaged");
sl@0: 		Set(EManaged,aOwner,aIndex);
sl@0: 		iFlags = aFlags;
sl@0: 		iPinCount = 0;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Set this page as type #EShadow.
sl@0: 
sl@0: 	This is for use by #DShadowPage.
sl@0: 
sl@0: 	@param aIndex 	Value for #iIndex.
sl@0: 	@param aFlags 	Value for #iFlags.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 
sl@0: 	@post #iModifier==0 to indicate that page usage has changed.
sl@0: 	*/
sl@0: 	inline void SetShadow(TUint32 aIndex, TUint8 aFlags)
sl@0: 		{
sl@0: 		CheckAccess("SetShadow");
sl@0: 		Set(EShadow,0,aIndex);
sl@0: 		iFlags = aFlags;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Store a pointer to the SPageInfo of the page that this page is shadowing.
sl@0: 
sl@0: 	@param aOrigPageInfo	Pointer to the SPageInfo that this page is shadowing
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	inline void SetOriginalPage(SPageInfo* aOrigPageInfo)
sl@0: 		{
sl@0: 		CheckAccess("SetOriginalPage");
sl@0: 		__NK_ASSERT_DEBUG(iType == EShadow);
sl@0: 		__NK_ASSERT_DEBUG(!iOriginalPageInfo);
sl@0: 		iOriginalPageInfo = aOrigPageInfo;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Reutrns a pointer to the SPageInfo of the page that this page is shadowing.
sl@0: 
sl@0: 	@return	A pointer to the SPageInfo that this page is shadowing
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	inline SPageInfo* GetOriginalPage()
sl@0: 		{
sl@0: 		CheckAccess("GetOriginalPage");
sl@0: 		__NK_ASSERT_DEBUG(iType == EShadow);
sl@0: 		__NK_ASSERT_DEBUG(iOriginalPageInfo);
sl@0: 		return iOriginalPageInfo;
sl@0: 		}
sl@0: 
sl@0: 
sl@0: private:
sl@0: 	/** Internal implementation factor for methods which set page type. */
sl@0: 	FORCE_INLINE void Set(TType aType, DMemoryObject* aOwner, TUint32 aIndex)
sl@0: 		{
sl@0: 		CheckAccess("Set",ECheckNotAllocated|ECheckNotPaged);
sl@0: 		(TUint32&)iType = aType; // also clears iFlags, iFlags2 and iPagedState
sl@0: 		iOwner = aOwner;
sl@0: 		iIndex = aIndex;
sl@0: 		iModifier = 0;
sl@0: 		}
sl@0: 
sl@0: public:
sl@0: 
sl@0: 
sl@0: 	//
sl@0: 	//
sl@0: 	//
sl@0: 
sl@0: 	/**
sl@0: 	Set #iFlags to indicate that the contents of this page have been removed from
sl@0: 	any caches.
sl@0: 
sl@0: 	@pre #MmuLock held if #iType!=#EUnused, #RamAllocLock held if #iType==#EUnused.
sl@0: 	*/
sl@0: 	FORCE_INLINE void SetUncached()
sl@0: 		{
sl@0: 		CheckAccess("SetUncached",iType==EUnused ? ECheckRamAllocLock|ENoCheckMmuLock : 0);
sl@0: 		__NK_ASSERT_DEBUG(iType==EUnused || (iType==EPhysAlloc && iUseCount==0));
sl@0: 		iFlags = EMemAttNormalUncached;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Set memory attributes and colour for a page of type #EPhysAlloc.
sl@0: 	
sl@0: 	This is set the first time a page of type #EPhysAlloc is added to a memory
sl@0: 	object with DMemoryManager::AddPages or DMemoryManager::AddContiguous.
sl@0: 	The set values are used to check constraints are met if the page is
sl@0: 	also added to other memory objects.
sl@0: 
sl@0: 	@param aIndex	The page index within a memory object at which this page
sl@0: 					has been added. This is stored in #iIndex and used to determine
sl@0: 					the page's 'colour'.
sl@0: 	@param aFlags 	Value for #iFlags. This sets the memory attributes for the page.
sl@0: 
sl@0: 	@post #iModifier==0 to indicate that page usage has changed.
sl@0: 	*/
sl@0: 	inline void SetMapped(TUint32 aIndex, TUint aFlags)
sl@0: 		{
sl@0: 		CheckAccess("SetMapped");
sl@0: 		__NK_ASSERT_DEBUG(iType==EPhysAlloc);
sl@0: 		__NK_ASSERT_DEBUG(iUseCount==0); // check page not already added to an object
sl@0: 		iIndex = aIndex;
sl@0: 		iFlags = aFlags;
sl@0: 		iModifier = 0;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Set #iPagedState
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 
sl@0: 	@post #iModifier==0 to indicate that page state has changed.
sl@0: 	*/
sl@0: 	FORCE_INLINE void SetPagedState(TPagedState aPagedState)
sl@0: 		{
sl@0: 		CheckAccess("SetPagedState");
sl@0: 		__NK_ASSERT_DEBUG(aPagedState==iPagedState || iPagedState!=EPagedPinned || iPinCount==0); // make sure don't set an unpinned state if iPinCount!=0
sl@0: 		iPagedState = aPagedState;
sl@0: 		iModifier = 0;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	The the pages #iModifier value.
sl@0: 
sl@0: 	#iModifier is cleared to zero whenever the usage or paging state of the page
sl@0: 	changes. So if a thread sets this to a suitable unique value (e.g. the address
sl@0: 	of a local variable) then it may perform a long running operation on the page
sl@0: 	and later check with #CheckModified that no other thread has changed the page
sl@0: 	state or used SetModifier in the intervening time.
sl@0: 	Example.
sl@0: 
sl@0: 	@code
sl@0: 	TInt anyLocalVariable; // arbitrary local variable
sl@0: 
sl@0: 	MmuLock::Lock();
sl@0: 	SPageInfo* thePageInfo = GetAPage();
sl@0: 	thePageInfo->SetModifier(&anyLocalVariable); // use &anyLocalVariable as value unique to this thread 
sl@0: 	MmuLock::Unlock();
sl@0: 
sl@0: 	DoOperation(thePageInfo);
sl@0: 
sl@0: 	MmuLock::Lock();
sl@0: 	TInt r;
sl@0: 	if(!thePageInfo->CheckModified(&anyLocalVariable));
sl@0: 		{
sl@0: 		// nobody else touched the page...
sl@0: 		OperationSucceeded(thePageInfo);
sl@0: 		r = KErrNone;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		// somebody else changed our page...
sl@0: 		OperationInterrupted(thePageInfo);
sl@0: 		r = KErrAbort;
sl@0: 		}
sl@0: 	MmuLock::Unlock();
sl@0: 
sl@0: 	return r;
sl@0: 	@endcode
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	FORCE_INLINE void SetModifier(TAny* aModifier)
sl@0: 		{
sl@0: 		CheckAccess("SetModifier");
sl@0: 		iModifier = aModifier;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return true if the #iModifier value does not match a specified value.
sl@0: 
sl@0: 	@param aModifier	A 'modifier' value previously set with #SetModifier.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 
sl@0: 	@see SetModifier.
sl@0: 	*/
sl@0: 	FORCE_INLINE TBool CheckModified(TAny* aModifier)
sl@0: 		{
sl@0: 		CheckAccess("CheckModified");
sl@0: 		return iModifier!=aModifier;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Flag this page as having Page Table Entries which give writeable access permissions.
sl@0: 	This sets flags #EWritable and #EDirty.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	FORCE_INLINE void SetWritable()
sl@0: 		{
sl@0: 		CheckAccess("SetWritable");
sl@0: 		// This should only be invoked on paged pages.
sl@0: 		__NK_ASSERT_DEBUG(PagedState() != EUnpaged);
sl@0: 		iFlags |= EWritable;
sl@0: 		SetDirty();
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Flag this page as having no longer having any Page Table Entries which give writeable
sl@0: 	access permissions.
sl@0: 	This clears the flag #EWritable.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	FORCE_INLINE void SetReadOnly()
sl@0: 		{
sl@0: 		CheckAccess("SetReadOnly");
sl@0: 		iFlags &= ~EWritable;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Returns true if #SetWritable has been called without a subsequent #SetReadOnly.
sl@0: 	This returns the flag #EWritable.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	FORCE_INLINE TBool IsWritable()
sl@0: 		{
sl@0: 		CheckAccess("IsWritable");
sl@0: 		return iFlags&EWritable;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Flag this page as 'dirty', indicating that its contents may no longer match those saved
sl@0: 	to a backing store. This sets the flag #EWritable.
sl@0: 
sl@0: 	This is used in the management of demand paged memory.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	FORCE_INLINE void SetDirty()
sl@0: 		{
sl@0: 		CheckAccess("SetDirty");
sl@0: 		iFlags |= EDirty;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Flag this page as 'clean', indicating that its contents now match those saved
sl@0: 	to a backing store. This clears the flag #EWritable.
sl@0: 
sl@0: 	This is used in the management of demand paged memory.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	FORCE_INLINE void SetClean()
sl@0: 		{
sl@0: 		CheckAccess("SetClean");
sl@0: 		iFlags &= ~EDirty;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return the  #EDirty flag. See #SetDirty and #SetClean.
sl@0: 
sl@0: 	This is used in the management of demand paged memory.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	FORCE_INLINE TBool IsDirty()
sl@0: 		{
sl@0: 		CheckAccess("IsDirty");
sl@0: 		return iFlags&EDirty;
sl@0: 		}
sl@0: 
sl@0: 
sl@0: 	//
sl@0: 	// Type specific...
sl@0: 	//
sl@0: 
sl@0: 	/**
sl@0: 	Set #iCacheInvalidateCounter to the specified value.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	@pre #iType==#EUnused.
sl@0: 	*/
sl@0: 	void SetCacheInvalidateCounter(TUint32 aCacheInvalidateCounter)
sl@0: 		{
sl@0: 		CheckAccess("SetCacheInvalidateCounter");
sl@0: 		__NK_ASSERT_DEBUG(iType==EUnused);
sl@0: 		iCacheInvalidateCounter = aCacheInvalidateCounter;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return #iCacheInvalidateCounter.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	@pre #iType==#EUnused.
sl@0: 	*/
sl@0: 	TUint32 CacheInvalidateCounter()
sl@0: 		{
sl@0: 		CheckAccess("CacheInvalidateCounter",ECheckRamAllocLock|ENoCheckMmuLock);
sl@0: 		__NK_ASSERT_DEBUG(iType==EUnused);
sl@0: 		return iCacheInvalidateCounter;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Increment #iUseCount to indicate that the page has been added to a memory object.
sl@0: 
sl@0: 	@return New value of #iUseCount.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	@pre #iType==#EPhysAlloc.
sl@0: 	*/
sl@0: 	TUint32 IncUseCount()
sl@0: 		{
sl@0: 		CheckAccess("IncUseCount");
sl@0: 		__NK_ASSERT_DEBUG(iType==EPhysAlloc);
sl@0: 		return ++iUseCount;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Decrement #iUseCount to indicate that the page has been removed from a memory object.
sl@0: 
sl@0: 	@return New value of #iUseCount.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	@pre #iType==#EPhysAlloc.
sl@0: 	*/
sl@0: 	TUint32 DecUseCount()
sl@0: 		{
sl@0: 		CheckAccess("DecUseCount");
sl@0: 		__NK_ASSERT_DEBUG(iType==EPhysAlloc);
sl@0: 		__NK_ASSERT_DEBUG(iUseCount);
sl@0: 		return --iUseCount;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return #iUseCount, this indicates the number of times the page has been added to memory object(s).
sl@0: 
sl@0: 	@return #iUseCount.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	@pre #iType==#EPhysAlloc.
sl@0: 	*/
sl@0: 	TUint32 UseCount()
sl@0: 		{
sl@0: 		CheckAccess("UseCount");
sl@0: 		__NK_ASSERT_DEBUG(iType==EPhysAlloc);
sl@0: 		return iUseCount;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Increment #iPinCount to indicate that a mapping has pinned this page.
sl@0: 	This is only done for demand paged memory; unpaged memory does not have
sl@0: 	#iPinCount updated when it is pinned.
sl@0: 
sl@0: 	@return New value of #iPinCount.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	@pre #iType==#EManaged.
sl@0: 	*/
sl@0: 	TUint32 IncPinCount()
sl@0: 		{
sl@0: 		CheckAccess("IncPinCount");
sl@0: 		__NK_ASSERT_DEBUG(iType==EManaged);
sl@0: 		return ++iPinCount;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Decrement #iPinCount to indicate that a mapping which was pinning this page has been removed.
sl@0: 	This is only done for demand paged memory; unpaged memory does not have
sl@0: 	#iPinCount updated when it is unpinned.
sl@0: 
sl@0: 	@return New value of #iPinCount.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	@pre #iType==#EManaged.
sl@0: 	*/
sl@0: 	TUint32 DecPinCount()
sl@0: 		{
sl@0: 		CheckAccess("DecPinCount");
sl@0: 		__NK_ASSERT_DEBUG(iType==EManaged);
sl@0: 		__NK_ASSERT_DEBUG(iPinCount);
sl@0: 		return --iPinCount;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Clear #iPinCount to zero as this page is no longer being used for the 
sl@0: 	pinned page.
sl@0: 	This is only done for demand paged memory; unpaged memory does not have
sl@0: 	#iPinCount set.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	@pre #iType==#EManaged.
sl@0: 	*/
sl@0: 	void ClearPinCount()
sl@0: 		{
sl@0: 		CheckAccess("ClearPinCount");
sl@0: 		__NK_ASSERT_DEBUG(iType==EManaged);
sl@0: 		__NK_ASSERT_DEBUG(iPinCount);
sl@0: 		iPinCount = 0;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return #iPinCount which indicates the number of mappings that have pinned this page.
sl@0: 	This is only valid for demand paged memory; unpaged memory does not have
sl@0: 	#iPinCount updated when it is pinned.
sl@0: 
sl@0: 	@return #iPinCount.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	@pre #iType==#EManaged.
sl@0: 	*/
sl@0: 	TUint32 PinCount()
sl@0: 		{
sl@0: 		CheckAccess("PinCount");
sl@0: 		__NK_ASSERT_DEBUG(iType==EManaged);
sl@0: 		return iPinCount;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Set the #EPinnedReserve flag.
sl@0: 	@pre #MmuLock held.
sl@0: 	@see EPinnedReserve.
sl@0: 	*/
sl@0: 	void SetPinnedReserve()
sl@0: 		{
sl@0: 		CheckAccess("SetPinnedReserve");
sl@0: 		iFlags2 |= EPinnedReserve;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Clear the #EPinnedReserve flag.
sl@0: 	@pre #MmuLock held.
sl@0: 	@see EPinnedReserve.
sl@0: 	*/
sl@0: 	TBool ClearPinnedReserve()
sl@0: 		{
sl@0: 		CheckAccess("ClearPinnedReserve");
sl@0: 		TUint oldFlags2 = iFlags2;
sl@0: 		iFlags2 = oldFlags2&~EPinnedReserve;
sl@0: 		return oldFlags2&EPinnedReserve;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Set #iPagingManagerData to the specified value.
sl@0: 	@pre #MmuLock held.
sl@0: 	@pre #iType==#EManaged.
sl@0: 	*/
sl@0: 	void SetPagingManagerData(TUint32 aPagingManagerData)
sl@0: 		{
sl@0: 		CheckAccess("SetPagingManagerData");
sl@0: 		__NK_ASSERT_DEBUG(iType==EManaged);
sl@0: 		iPagingManagerData = aPagingManagerData;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return #iPagingManagerData.
sl@0: 	@pre #MmuLock held.
sl@0: 	@pre #iType==#EManaged.
sl@0: 	*/
sl@0: 	TUint32 PagingManagerData()
sl@0: 		{
sl@0: 		CheckAccess("PagingManagerData");
sl@0: 		__NK_ASSERT_DEBUG(iType==EManaged);
sl@0: 		return iPagingManagerData;
sl@0: 		}
sl@0: 
sl@0: 	//
sl@0: 	// Debug...
sl@0: 	//
sl@0: 
sl@0: private:
sl@0: 	enum TChecks
sl@0: 		{
sl@0: 		ECheckNotAllocated	= 1<<0,
sl@0: 		ECheckNotUnused		= 1<<1,
sl@0: 		ECheckUnused		= 1<<2,
sl@0: 		ECheckNotPaged		= 1<<3,
sl@0: 		ECheckRamAllocLock	= 1<<4,
sl@0: 		ENoCheckMmuLock		= 1<<5
sl@0: 		};
sl@0: #ifdef _DEBUG
sl@0: 	void CheckAccess(const char* aMessage, TUint aFlags=0);
sl@0: #else
sl@0: 	FORCE_INLINE void CheckAccess(const char* /*aMessage*/, TUint /*aFlags*/=0)
sl@0: 		{}
sl@0: #endif
sl@0: 
sl@0: public:
sl@0: #ifdef _DEBUG
sl@0: 	/**
sl@0: 	Debug function which outputs the contents of this object to the kernel debug port.
sl@0: 	*/
sl@0: 	void Dump();
sl@0: #else
sl@0: 	FORCE_INLINE void Dump()
sl@0: 		{}
sl@0: #endif
sl@0: 	};
sl@0: 
sl@0: 
sl@0: const TInt KPageInfosPerPageShift = KPageShift-KPageInfoShift;
sl@0: const TInt KPageInfosPerPage = 1<<KPageInfosPerPageShift;
sl@0: const TInt KNumPageInfoPagesShift = 32-KPageShift-KPageInfosPerPageShift;
sl@0: const TInt KNumPageInfoPages = 1<<KNumPageInfoPagesShift;
sl@0: 
sl@0: FORCE_INLINE SPageInfo* SPageInfo::FromPhysAddr(TPhysAddr aAddress)
sl@0: 	{
sl@0: 	return ((SPageInfo*)KPageInfoLinearBase)+(aAddress>>KPageShift);
sl@0: 	}
sl@0: 
sl@0: FORCE_INLINE TPhysAddr SPageInfo::PhysAddr()
sl@0: 	{
sl@0: 	return ((TPhysAddr)this)<<KPageInfosPerPageShift;
sl@0: 	}
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: A page table information structure giving the current use and state for a
sl@0: page table.
sl@0: */
sl@0: struct SPageTableInfo
sl@0: 	{
sl@0: public:
sl@0: 
sl@0: 	/**
sl@0: 	Enumeration for the usage of a page table. This is stored in #iType.
sl@0: 	*/
sl@0: 	enum TType
sl@0: 		{
sl@0: 		/**
sl@0: 		Page table is unused (implementation assumes this enumeration == 0).
sl@0: 		@see #iUnused and #SPageTableInfo::TUnused.
sl@0: 		*/
sl@0: 		EUnused=0,
sl@0: 
sl@0: 		/**
sl@0: 		Page table has undetermined use.
sl@0: 		(Either created by the bootstrap or is newly allocated but not yet assigned.)
sl@0: 		*/
sl@0: 		EUnknown=1,
sl@0: 
sl@0: 		/**
sl@0: 		Page table is being used by a coarse memory object.
sl@0: 		@see #iCoarse and #SPageTableInfo::TCoarse.
sl@0: 		*/
sl@0: 		ECoarseMapping=2,
sl@0: 
sl@0: 		/**
sl@0: 		Page table is being used for fine mappings.
sl@0: 		@see #iFine and #SPageTableInfo::TFine.
sl@0: 		*/
sl@0: 		EFineMapping=3
sl@0: 		};
sl@0: 
sl@0: private:
sl@0: 
sl@0: 	/**
sl@0: 	Flags stored in #iFlags.
sl@0: 	*/
sl@0: 	enum TFlags
sl@0: 		{
sl@0: 		/**
sl@0: 		Page table if for mapping demand paged content.
sl@0: 		*/
sl@0: 		EDemandPaged		= 	1<<0,
sl@0: 		/**
sl@0: 		Page table is in Page Table Allocator's cleanup list
sl@0: 		(only set for first page table in a RAM page)
sl@0: 		*/
sl@0: 		EOnCleanupList		= 	1<<1,
sl@0: 		/**
sl@0: 		The page table cluster that this page table info refers to is currently allocated.
sl@0: 		*/
sl@0: 		EPtClusterAllocated 	=	1<<2
sl@0: 		};
sl@0: 
sl@0: 	/**
sl@0: 	Value from enum #TType.
sl@0: 	*/
sl@0: 	TUint8 iType;				
sl@0: 
sl@0: 	/**
sl@0: 	Bitmask of values from #TFlags.
sl@0: 	*/
sl@0: 	TUint8 iFlags;
sl@0: 
sl@0: 	/**
sl@0: 	Spare member used for padding.
sl@0: 	*/
sl@0: 	TUint16 iSpare2;
sl@0: 
sl@0: 	/**
sl@0: 	Number of pages currently mapped by this page table.
sl@0: 	Normally, when #iPageCount==0 and #iPermanenceCount==0, the page table is freed.
sl@0: 	*/
sl@0: 	TUint16 iPageCount;
sl@0: 
sl@0: 	/**
sl@0: 	Count for the number of uses of this page table which require it to be permanently allocated;
sl@0: 	even when it maps no pages (#iPageCount==0).
sl@0: 	*/
sl@0: 	TUint16 iPermanenceCount;
sl@0: 
sl@0: 	/**
sl@0: 	Information about a page table when #iType==#EUnused.
sl@0: 	*/
sl@0: 	struct TUnused
sl@0: 		{
sl@0: 		/**
sl@0: 		Cast this object to a SDblQueLink reference.
sl@0: 		This is used for placing unused SPageTableInfo objects into free lists.
sl@0: 		*/
sl@0: 		FORCE_INLINE SDblQueLink& Link()
sl@0: 			{ return *(SDblQueLink*)this; }
sl@0: 	private:
sl@0: 		SDblQueLink* iNext;	///< Next free page table
sl@0: 		SDblQueLink* iPrev;	///< Previous free page table
sl@0: 		};
sl@0: 
sl@0: 	/**
sl@0: 	Information about a page table when #iType==#ECoarseMapping.
sl@0: 	*/
sl@0: 	struct TCoarse
sl@0: 		{
sl@0: 		/**
sl@0: 		Memory object which owns this page table.
sl@0: 		*/
sl@0: 		DCoarseMemory*	iMemoryObject;
sl@0: 
sl@0: 		/**
sl@0: 		The index of the page table, i.e. the offset, in 'chunks',
sl@0: 		into the object's memory that the page table is being used to map.
sl@0: 		*/
sl@0: 		TUint16			iChunkIndex;
sl@0: 
sl@0: 		/**
sl@0: 		The #TPteType the page table is being used for.
sl@0: 		*/
sl@0: 		TUint8			iPteType;
sl@0: 		};
sl@0: 
sl@0: 	/**
sl@0: 	Information about a page table when #iType==#EFineMapping.
sl@0: 	*/
sl@0: 	struct TFine
sl@0: 		{
sl@0: 		/**
sl@0: 		Start of the virtual address region that this page table is currently
sl@0: 		mapping memory at, ORed with the OS ASID of the address space this lies in.
sl@0: 		*/
sl@0: 		TLinAddr		iLinAddrAndOsAsid;
sl@0: 		};
sl@0: 
sl@0: 	/**
sl@0: 	Union of type specific info.
sl@0: 	*/
sl@0: 	union
sl@0: 		{
sl@0: 		TUnused	iUnused; ///< Information about a page table when #iType==#EUnused.
sl@0: 		TCoarse	iCoarse; ///< Information about a page table when #iType==#ECoarseMapping.
sl@0: 		TFine	iFine;   ///< Information about a page table when #iType==#EFineMapping.
sl@0: 		};
sl@0: 
sl@0: public:
sl@0: 	/**
sl@0: 	Return the SPageTableInfo for the page table in which a given PTE lies.
sl@0: 	*/
sl@0: 	static SPageTableInfo* FromPtPtr(TPte* aPtPte);
sl@0: 
sl@0: 	/**
sl@0: 	Return the page table with which this SPageTableInfo is associated.
sl@0: 	*/
sl@0: 	TPte* PageTable();
sl@0: 
sl@0: 	/**
sl@0: 	Used at boot time to initialise page tables which were allocated by the bootstrap. 
sl@0: 
sl@0: 	@param aCount	The number of pages being mapped by this page table.
sl@0: 	*/
sl@0: 	FORCE_INLINE void Boot(TUint aCount)
sl@0: 		{
sl@0: 		CheckInit("Boot");
sl@0: 		iPageCount = aCount;
sl@0: 		iPermanenceCount = 1; // assume page table shouldn't be freed
sl@0: 		iType = EUnknown;
sl@0: 		iFlags = EPtClusterAllocated;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Initialise a page table after it has had memory allocated for it.
sl@0: 
sl@0: 	@param aDemandPaged	True if this page table has been allocated for use with
sl@0: 						demand paged memory.
sl@0: 	*/
sl@0: 	FORCE_INLINE void New(TBool aDemandPaged)
sl@0: 		{
sl@0: 		iType = EUnused;
sl@0: 		iFlags = EPtClusterAllocated | (aDemandPaged ? EDemandPaged : 0);
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return true if the page table cluster that this page table info refers to has
sl@0: 	been previously allocated.
sl@0: 	*/
sl@0: 	FORCE_INLINE TBool IsPtClusterAllocated()
sl@0: 		{
sl@0: 		return iFlags & EPtClusterAllocated;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	The page table cluster that this page table info refers to has been freed.
sl@0: 	*/
sl@0: 	FORCE_INLINE void PtClusterFreed()
sl@0: 		{
sl@0: 		__NK_ASSERT_DEBUG(IsPtClusterAllocated());
sl@0: 		iFlags &= ~EPtClusterAllocated;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	The page table cluster that this page table info refers to has been allocated.
sl@0: 	*/
sl@0: 	FORCE_INLINE void PtClusterAlloc()
sl@0: 		{
sl@0: 		__NK_ASSERT_DEBUG(!IsPtClusterAllocated());
sl@0: 		iFlags |= EPtClusterAllocated;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Initialilse a page table to type #EUnknown after it has been newly allocated.
sl@0: 
sl@0: 	@pre #PageTablesLockIsHeld.
sl@0: 	*/
sl@0: 	FORCE_INLINE void Init()
sl@0: 		{
sl@0: 		__NK_ASSERT_DEBUG(IsPtClusterAllocated());
sl@0: 		CheckInit("Init");
sl@0: 		iPageCount = 0;
sl@0: 		iPermanenceCount = 0;
sl@0: 		iType = EUnknown;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Increment #iPageCount to account for newly mapped pages.
sl@0: 
sl@0: 	@param aStep	Amount to add to #iPageCount. Default is one.
sl@0: 
sl@0: 	@return New value of #iPageCount.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	FORCE_INLINE TUint IncPageCount(TUint aStep=1)
sl@0: 		{
sl@0: 		CheckAccess("IncPageCount");
sl@0: 		TUint count = iPageCount; // compiler handles half-word values stupidly, so give it a hand
sl@0: 		count += aStep;
sl@0: 		iPageCount = count;
sl@0: 		return count;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Decrement #iPageCount to account for removed pages.
sl@0: 
sl@0: 	@param aStep	Amount to subtract from #iPageCount. Default is one.
sl@0: 
sl@0: 	@return New value of #iPageCount.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	FORCE_INLINE TUint DecPageCount(TUint aStep=1)
sl@0: 		{
sl@0: 		CheckAccess("DecPageCount");
sl@0: 		TUint count = iPageCount; // compiler handles half-word values stupidly, so give it a hand
sl@0: 		count -= aStep;
sl@0: 		iPageCount = count;
sl@0: 		return count;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return #iPageCount.
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	FORCE_INLINE TUint PageCount()
sl@0: 		{
sl@0: 		CheckAccess("PageCount");
sl@0: 		return iPageCount;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Increment #iPermanenceCount to indicate a new use of this page table which
sl@0: 	requires it to be permanently allocated.
sl@0: 
sl@0: 	@return New value of #iPermanenceCount.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	FORCE_INLINE TUint IncPermanenceCount()
sl@0: 		{
sl@0: 		CheckAccess("IncPermanenceCount");
sl@0: 		TUint count = iPermanenceCount; // compiler handles half-word values stupidly, so give it a hand
sl@0: 		++count;
sl@0: 		iPermanenceCount = count;
sl@0: 		return count;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Decrement #iPermanenceCount to indicate the removal of a use added by #IncPermanenceCount.
sl@0: 
sl@0: 	@return New value of #iPermanenceCount.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	FORCE_INLINE TUint DecPermanenceCount()
sl@0: 		{
sl@0: 		CheckAccess("DecPermanenceCount");
sl@0: 		TUint count = iPermanenceCount; // compiler handles half-word values stupidly, so give it a hand
sl@0: 		__NK_ASSERT_DEBUG(count);
sl@0: 		--count;
sl@0: 		iPermanenceCount = count;
sl@0: 		return count;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return #iPermanenceCount.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	FORCE_INLINE TUint PermanenceCount()
sl@0: 		{
sl@0: 		CheckAccess("PermanenceCount");
sl@0: 		return iPermanenceCount;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Set page table to the #EUnused state.
sl@0: 	This is only intended for use by #PageTableAllocator.
sl@0: 
sl@0: 	@pre #MmuLock held and #PageTablesLockIsHeld.
sl@0: 	*/
sl@0: 	FORCE_INLINE void SetUnused()
sl@0: 		{
sl@0: 		CheckChangeUse("SetUnused");
sl@0: 		iType = EUnused;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return true if the page table is in the #EUnused state.
sl@0: 	This is only intended for use by #PageTableAllocator.
sl@0: 
sl@0: 	@pre #MmuLock held or #PageTablesLockIsHeld.
sl@0: 	*/
sl@0: 	FORCE_INLINE TBool IsUnused()
sl@0: 		{
sl@0: 		CheckCheckUse("IsUnused");
sl@0: 		return iType==EUnused;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Set page table as being used by a coarse memory object.
sl@0: 
sl@0: 	@param aMemory		Memory object which owns this page table.
sl@0: 	@param aChunkIndex	The index of the page table, i.e. the offset, in 'chunks',
sl@0: 						into the object's memory that the page table is being used to map.
sl@0: 	@param aPteType		The #TPteType the page table is being used for.
sl@0: 
sl@0: 	@pre #MmuLock held and #PageTablesLockIsHeld.
sl@0: 
sl@0: 	@see TCoarse.
sl@0: 	*/
sl@0: 	inline void SetCoarse(DCoarseMemory* aMemory, TUint aChunkIndex, TUint aPteType)
sl@0: 		{
sl@0: 		CheckChangeUse("SetCoarse");
sl@0: 		iPageCount = 0;
sl@0: 		iPermanenceCount = 0;
sl@0: 		iType = ECoarseMapping;
sl@0: 		iCoarse.iMemoryObject = aMemory;
sl@0: 		iCoarse.iChunkIndex = aChunkIndex;
sl@0: 		iCoarse.iPteType = aPteType;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return true if this page table is currently being used by a coarse memory object
sl@0: 	matching the specified arguments.
sl@0: 	For arguments, see #SetCoarse.
sl@0: 
sl@0: 	@pre #MmuLock held or #PageTablesLockIsHeld.
sl@0: 	*/
sl@0: 	inline TBool CheckCoarse(DCoarseMemory* aMemory, TUint aChunkIndex, TUint aPteType)
sl@0: 		{
sl@0: 		CheckCheckUse("CheckCoarse");
sl@0: 		return iType==ECoarseMapping
sl@0: 			&& iCoarse.iMemoryObject==aMemory
sl@0: 			&& iCoarse.iChunkIndex==aChunkIndex
sl@0: 			&& iCoarse.iPteType==aPteType;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Set page table as being used for fine mappings.
sl@0: 
sl@0: 	@param aLinAddr	Start of the virtual address region that the page table is
sl@0: 					mapping memory at.
sl@0: 	@param aOsAsid	The OS ASID of the address space which \a aLinAddr lies in.
sl@0: 
sl@0: 	@pre #MmuLock held and #PageTablesLockIsHeld.
sl@0: 	*/
sl@0: 	inline void SetFine(TLinAddr aLinAddr, TUint aOsAsid)
sl@0: 		{
sl@0: 		CheckChangeUse("SetFine");
sl@0: 		__NK_ASSERT_DEBUG((aLinAddr&KPageMask)==0);
sl@0: 		iPageCount = 0;
sl@0: 		iPermanenceCount = 0;
sl@0: 		iType = EFineMapping;
sl@0: 		iFine.iLinAddrAndOsAsid = aLinAddr|aOsAsid;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return true if this page table is currently being used for fine mappings
sl@0: 	matching the specified arguments.
sl@0: 	For arguments, see #SetFine.
sl@0: 
sl@0: 	@pre #MmuLock held or #PageTablesLockIsHeld.
sl@0: 	*/
sl@0: 	inline TBool CheckFine(TLinAddr aLinAddr, TUint aOsAsid)
sl@0: 		{
sl@0: 		CheckCheckUse("CheckFine");
sl@0: 		__NK_ASSERT_DEBUG((aLinAddr&KPageMask)==0);
sl@0: 		return iType==EFineMapping
sl@0: 			&& iFine.iLinAddrAndOsAsid==(aLinAddr|aOsAsid);
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Set a previously unknown page table as now being used for fine mappings.
sl@0: 	This is used during the boot process by DFineMemory::ClaimInitialPages
sl@0: 	to initialise the state of a page table allocated by the bootstrap.
sl@0: 
sl@0: 	@param aLinAddr	Start of the virtual address region that the page table is
sl@0: 					mapping memory at.
sl@0: 	@param aOsAsid	The OS ASID of the address space which \a aLinAddr lies in.
sl@0: 					(This should be KKernelOsAsid.)
sl@0: 
sl@0: 	@pre #MmuLock held and #PageTablesLockIsHeld.
sl@0: 	*/
sl@0: 	inline TBool ClaimFine(TLinAddr aLinAddr, TUint aOsAsid)
sl@0: 		{
sl@0: 		CheckChangeUse("ClaimFine");
sl@0: 		__NK_ASSERT_DEBUG((aLinAddr&KPageMask)==0);
sl@0: 		if(iType==EFineMapping)
sl@0: 			return CheckFine(aLinAddr,aOsAsid);
sl@0: 		if(iType!=EUnknown)
sl@0: 			return false;
sl@0: 		iType = EFineMapping;
sl@0: 		iFine.iLinAddrAndOsAsid = aLinAddr|aOsAsid;
sl@0: 		return true;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return true if page table was allocated for use with demand paged memory.
sl@0: 	*/
sl@0: 	FORCE_INLINE TBool IsDemandPaged()
sl@0: 		{
sl@0: 		return iFlags&EDemandPaged;
sl@0: 		}
sl@0: 
sl@0: #ifdef _DEBUG
sl@0: 	/**
sl@0: 	Debug check returning true if the value of #iPageCount is consistent with
sl@0: 	the PTEs in this page table.
sl@0: 
sl@0: 	@pre #MmuLock held.
sl@0: 	*/
sl@0: 	TBool CheckPageCount();
sl@0: #endif
sl@0: 
sl@0: 	/**
sl@0: 	Return a reference to an embedded SDblQueLink which is used for placing this
sl@0: 	SPageTableInfo objects into free lists.
sl@0: 	@pre #PageTablesLockIsHeld.
sl@0: 	@pre #iType==#EUnused.
sl@0: 	*/
sl@0: 	inline SDblQueLink& FreeLink()
sl@0: 		{
sl@0: 		__NK_ASSERT_DEBUG(IsUnused());
sl@0: 		return iUnused.Link();
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return a pointer to a SPageTableInfo by conversion from the address
sl@0: 	of its embedded link as returned by #FreeLink.
sl@0: 	*/
sl@0: 	FORCE_INLINE static SPageTableInfo* FromFreeLink(SDblQueLink* aLink)
sl@0: 		{
sl@0: 		return (SPageTableInfo*)((TInt)aLink-_FOFF(SPageTableInfo,iUnused));
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return the SPageTableInfo for the first page table in the same
sl@0: 	physical ram page as the page table for this SPageTableInfo.
sl@0: 	*/
sl@0: 	FORCE_INLINE SPageTableInfo* FirstInPage()
sl@0: 		{
sl@0: 		return (SPageTableInfo*)(TLinAddr(this)&~(KPtClusterMask*sizeof(SPageTableInfo)));
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return the SPageTableInfo for the last page table in the same
sl@0: 	physical ram page as the page table for this SPageTableInfo.
sl@0: 	*/
sl@0: 	FORCE_INLINE SPageTableInfo* LastInPage()
sl@0: 		{
sl@0: 		return (SPageTableInfo*)(TLinAddr(this)|(KPtClusterMask*sizeof(SPageTableInfo)));
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return true if the page table for this SPageTableInfo is
sl@0: 	the first page table in the physical page it occupies.
sl@0: 	*/
sl@0: 	FORCE_INLINE TBool IsFirstInPage()
sl@0: 		{
sl@0: 		return (TLinAddr(this)&(KPtClusterMask*sizeof(SPageTableInfo)))==0;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return true if this page table has been added to the cleanup list with
sl@0: 	#AddToCleanupList.
sl@0: 	Must only be used for page tables which return true for #IsFirstInPage.
sl@0: 
sl@0: 	@pre #PageTablesLockIsHeld.
sl@0: 	*/
sl@0: 	FORCE_INLINE TBool IsOnCleanupList()
sl@0: 		{
sl@0: 		__NK_ASSERT_DEBUG(IsFirstInPage());
sl@0: 		return iFlags&EOnCleanupList;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Add the RAM page containing this page table to the specified cleanup list.
sl@0: 	Must only be used for page tables which return true for #IsFirstInPage.
sl@0: 
sl@0: 	@pre #PageTablesLockIsHeld.
sl@0: 	*/
sl@0: 	FORCE_INLINE void AddToCleanupList(SDblQue& aCleanupList)
sl@0: 		{
sl@0: 		__NK_ASSERT_DEBUG(IsUnused());
sl@0: 		__NK_ASSERT_DEBUG(IsFirstInPage());
sl@0: 		__NK_ASSERT_DEBUG(!IsOnCleanupList());
sl@0: 		aCleanupList.Add(&FreeLink());
sl@0: 		iFlags |= EOnCleanupList;
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Remove the RAM page containing this page table from a cleanup list it
sl@0: 	was added to with aCleanupList.
sl@0: 	Must only be used for page tables which return true for #IsFirstInPage.
sl@0: 
sl@0: 	@pre #PageTablesLockIsHeld.
sl@0: 	*/
sl@0: 	FORCE_INLINE void RemoveFromCleanupList()
sl@0: 		{
sl@0: 		__NK_ASSERT_DEBUG(IsUnused());
sl@0: 		__NK_ASSERT_DEBUG(IsFirstInPage());
sl@0: 		__NK_ASSERT_DEBUG(IsOnCleanupList());
sl@0: 		iFlags &= ~EOnCleanupList;
sl@0: 		FreeLink().Deque();
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Remove this page table from its owner and free it.
sl@0: 	This is only used with page tables which map demand paged memory
sl@0: 	and is intended for use in implementing #DPageTableMemoryManager.
sl@0: 
sl@0: 	@return KErrNone if successful,
sl@0: 			otherwise one of the system wide error codes.
sl@0: 
sl@0: 	@pre #MmuLock held and #PageTablesLockIsHeld.
sl@0: 	*/
sl@0: 	TInt ForcedFree();
sl@0: 
sl@0: private:
sl@0: 
sl@0: #ifdef _DEBUG
sl@0: 	void CheckChangeUse(const char* aName);
sl@0: 	void CheckCheckUse(const char* aName);
sl@0: 	void CheckAccess(const char* aName);
sl@0: 	void CheckInit(const char* aName);
sl@0: #else
sl@0: 	FORCE_INLINE void CheckChangeUse(const char* /*aName*/)
sl@0: 		{}
sl@0: 	FORCE_INLINE void CheckCheckUse(const char* /*aName*/)
sl@0: 		{}
sl@0: 	FORCE_INLINE void CheckAccess(const char* /*aName*/)
sl@0: 		{}
sl@0: 	FORCE_INLINE void CheckInit(const char* /*aName*/)
sl@0: 		{}
sl@0: #endif
sl@0: 	};
sl@0: 
sl@0: 
sl@0: const TInt KPageTableInfoShift = 4;
sl@0: __ASSERT_COMPILE(sizeof(SPageTableInfo)==(1<<KPageTableInfoShift));
sl@0: 
sl@0: FORCE_INLINE SPageTableInfo* SPageTableInfo::FromPtPtr(TPte* aPtPte)
sl@0: 	{
sl@0: 	TUint id = ((TLinAddr)aPtPte-KPageTableBase)>>KPageTableShift;
sl@0: 	return (SPageTableInfo*)KPageTableInfoBase+id;
sl@0: 	}
sl@0: 
sl@0: FORCE_INLINE TPte* SPageTableInfo::PageTable()
sl@0: 	{
sl@0: 	return (TPte*)
sl@0: 		(KPageTableBase+
sl@0: 			(
sl@0: 			((TLinAddr)this-(TLinAddr)KPageTableInfoBase)
sl@0: 			<<(KPageTableShift-KPageTableInfoShift)
sl@0: 			)
sl@0: 		);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Class providing access to the mutex used to protect memory allocation operations;
sl@0: this is the mutex Mmu::iRamAllocatorMutex.
sl@0: In addition to providing locking, these functions monitor the system's free RAM
sl@0: levels and call K::CheckFreeMemoryLevel to notify the system of changes.
sl@0: */
sl@0: class RamAllocLock
sl@0: 	{
sl@0: public:
sl@0: 	/**
sl@0: 	Acquire the lock.
sl@0: 	The lock may be acquired multiple times by a thread, and will remain locked
sl@0: 	until #Unlock has been used enough times to balance this.
sl@0: 	*/
sl@0: 	static void Lock();
sl@0: 
sl@0: 	/**
sl@0: 	Release the lock.
sl@0: 
sl@0: 	@pre The current thread has previously acquired the lock.
sl@0: 	*/
sl@0: 	static void Unlock();
sl@0: 
sl@0: 	/**
sl@0: 	Allow another thread to acquire the lock.
sl@0: 	This is equivalent to #Unlock followed by #Lock, but optimised
sl@0: 	to only do this if there is another thread waiting on the lock.
sl@0: 
sl@0: 	@return True if the lock was released by this function.
sl@0: 
sl@0: 	@pre The current thread has previously acquired the lock.
sl@0: 	*/
sl@0: 	static TBool Flash();
sl@0: 
sl@0: 	/**
sl@0: 	Return true if the current thread holds the lock.
sl@0: 	This is used for debug checks.
sl@0: 	*/
sl@0: 	static TBool IsHeld();
sl@0: 	};
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Return true if the PageTableLock is held by the current thread.
sl@0: This lock is the mutex used to protect page table allocation; it is acquired
sl@0: with
sl@0: @code
sl@0: 	::PageTables.Lock();
sl@0: @endcode
sl@0: and released with
sl@0: @code
sl@0: 	::PageTables.Unlock();
sl@0: @endcode
sl@0: */
sl@0: TBool PageTablesLockIsHeld();
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Class providing access to the fast mutex used to protect various
sl@0: low level memory operations.
sl@0: 
sl@0: This lock must only be held for a very short and bounded time.
sl@0: */
sl@0: class MmuLock
sl@0: 	{
sl@0: public:
sl@0: 	/**
sl@0: 	Acquire the lock.
sl@0: 	*/
sl@0: 	static void Lock();
sl@0: 
sl@0: 	/**
sl@0: 	Release the lock.
sl@0: 
sl@0: 	@pre The current thread has previously acquired the lock.
sl@0: 	*/
sl@0: 	static void Unlock();
sl@0: 
sl@0: 	/**
sl@0: 	Allow another thread to acquire the lock.
sl@0: 	This is equivalent to #Unlock followed by #Lock, but optimised
sl@0: 	to only do this if there is another thread waiting on the lock.
sl@0: 
sl@0: 	@return True if the lock was released by this function.
sl@0: 
sl@0: 	@pre The current thread has previously acquired the lock.
sl@0: 	*/
sl@0: 	static TBool Flash();
sl@0: 
sl@0: 	/**
sl@0: 	Return true if the current thread holds the lock.
sl@0: 	This is used for debug checks.
sl@0: 	*/
sl@0: 	static TBool IsHeld();
sl@0: 
sl@0: 	/**
sl@0: 	Increment a counter and perform the action of #Flash() once a given threshold
sl@0: 	value is reached. After flashing the counter is reset.
sl@0: 
sl@0: 	This is typically used in long running loops to periodically flash the lock
sl@0: 	and so avoid holding it for too long, e.g.
sl@0: 
sl@0: 	@code
sl@0: 	MmuLock::Lock();
sl@0: 	TUint flash = 0;
sl@0: 	const TUint KMaxInterationsWithLock = 10;
sl@0: 	while(WorkToDo)
sl@0: 		{
sl@0: 		DoSomeWork();
sl@0: 		MmuLock::Flash(flash,KMaxInterationsWithLock); // flash every N loops
sl@0: 		}
sl@0: 	MmuLock::Unlock();
sl@0: 	@endcode
sl@0: 
sl@0: 	@param aCounter			Reference to the counter.
sl@0: 	@param aFlashThreshold	Value \a aCounter must reach before flashing the lock.
sl@0: 	@param aStep			Value to add to \a aCounter.
sl@0: 
sl@0: 	@return True if the lock was released by this function.
sl@0: 
sl@0: 	@pre The current thread has previously acquired the lock.
sl@0: 	*/
sl@0: 	static FORCE_INLINE TBool Flash(TUint& aCounter, TUint aFlashThreshold, TUint aStep=1)
sl@0: 		{
sl@0: 		UnlockGuardCheck();
sl@0: 		if((aCounter+=aStep)<aFlashThreshold)
sl@0: 			return EFalse;
sl@0: 		aCounter -= aFlashThreshold;
sl@0: 		return MmuLock::Flash();
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Begin a debug check to test that the MmuLock is not unlocked unexpectedly.
sl@0: 
sl@0: 	This is used in situations where a series of operation must be performed
sl@0: 	atomically with the MmuLock held. It is usually used via the
sl@0: 	#__UNLOCK_GUARD_START macro, e.g.
sl@0: 
sl@0: 	@code
sl@0: 	__UNLOCK_GUARD_START(MmuLock);
sl@0: 	SomeCode();
sl@0: 	SomeMoreCode();
sl@0: 	__UNLOCK_GUARD_END(MmuLock); // fault if MmuLock released by SomeCode or SomeMoreCode
sl@0: 	@endcode
sl@0: 	*/
sl@0: 	static FORCE_INLINE void UnlockGuardStart()
sl@0: 		{
sl@0: 		#ifdef _DEBUG
sl@0: 			++UnlockGuardNest;
sl@0: 		#endif
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	End a debug check testing that the MmuLock is not unlocked unexpectedly.
sl@0: 	This is usually used via the #__UNLOCK_GUARD_END which faults if true is returned.
sl@0: 
sl@0: 	@see UnlockGuardStart
sl@0: 
sl@0: 	@return True if the MmuLock was released between a previous #UnlockGuardStart
sl@0: 			and the call this function.
sl@0: 	*/
sl@0: 	static FORCE_INLINE TBool UnlockGuardEnd()
sl@0: 		{
sl@0: 		#ifdef _DEBUG
sl@0: 			__NK_ASSERT_DEBUG(UnlockGuardNest);
sl@0: 			--UnlockGuardNest;
sl@0: 			return UnlockGuardFail==0;
sl@0: 		#else
sl@0: 			return true;
sl@0: 		#endif
sl@0: 		}
sl@0: 
sl@0: private:
sl@0: 	/**
sl@0: 	Exectued whenever the lock is released to check that
sl@0: 	#UnlockGuardStart and #UnlockGuardEnd are balanced.
sl@0: 	*/
sl@0: 	static FORCE_INLINE void UnlockGuardCheck()
sl@0: 		{
sl@0: 		#ifdef _DEBUG
sl@0: 			if(UnlockGuardNest)
sl@0: 				UnlockGuardFail = true;
sl@0: 		#endif
sl@0: 		}
sl@0: 
sl@0: private:
sl@0: 	/** The lock */
sl@0: 	static NFastMutex iLock;
sl@0: 
sl@0: #ifdef _DEBUG
sl@0: 	static TUint UnlockGuardNest;
sl@0: 	static TUint UnlockGuardFail;
sl@0: #endif
sl@0: 	};
sl@0: 
sl@0: 
sl@0: 
sl@0: /**
sl@0: Interface for accessing the lock mutex being used to serialise
sl@0: explicit modifications to a specified memory object.
sl@0: 
sl@0: The lock mutex is either the one which was previously assigned with
sl@0: DMemoryObject::SetLock. Or, if none was set, a dynamically assigned
sl@0: mutex from #MemoryObjectMutexPool will be of 'order' #KMutexOrdMemoryObject.
sl@0: */
sl@0: class MemoryObjectLock
sl@0: 	{
sl@0: public:
sl@0: 	/**
sl@0: 	Acquire the lock for the specified memory object.
sl@0: 	If the object has no lock, one is assigned from #MemoryObjectMutexPool.
sl@0: 	*/
sl@0: 	static void Lock(DMemoryObject* aMemory);
sl@0: 
sl@0: 	/**
sl@0: 	Release the lock for the specified memory object, which was acquired
sl@0: 	with #Lock. If the lock was one which was dynamically assigned, and there
sl@0: 	are no threads waiting for it, the the lock is unassigned from the memory
sl@0: 	object.
sl@0: 	*/
sl@0: 	static void Unlock(DMemoryObject* aMemory);
sl@0: 
sl@0: 	/**
sl@0: 	Return true if the current thread holds lock for the specified memory object.
sl@0: 	This is used for debug checks.
sl@0: 	*/
sl@0: 	static TBool IsHeld(DMemoryObject* aMemory);
sl@0: 	};
sl@0: 
sl@0: 
sl@0: #define __UNLOCK_GUARD_START(_l) __DEBUG_ONLY(_l::UnlockGuardStart())
sl@0: #define __UNLOCK_GUARD_END(_l) __NK_ASSERT_DEBUG(_l::UnlockGuardEnd())
sl@0: 
sl@0: 
sl@0: const TUint KMutexOrdAddresSpace = KMutexOrdKernelHeap + 2;
sl@0: const TUint KMutexOrdMemoryObject = KMutexOrdKernelHeap + 1;
sl@0: const TUint KMutexOrdMmuAlloc = KMutexOrdRamAlloc + 1;
sl@0: 
sl@0: 
sl@0: #ifdef _DEBUG
sl@0: //#define FORCE_TRACE
sl@0: //#define FORCE_TRACE2
sl@0: //#define FORCE_TRACEB
sl@0: //#define FORCE_TRACEP
sl@0: #endif
sl@0: 
sl@0: 
sl@0: 
sl@0: #define TRACE_printf Kern::Printf
sl@0: 
sl@0: #define TRACE_ALWAYS(t) TRACE_printf t
sl@0: 
sl@0: #ifdef FORCE_TRACE
sl@0: #define TRACE(t) TRACE_printf t
sl@0: #else
sl@0: #define TRACE(t) __KTRACE_OPT(KMMU2,TRACE_printf t)
sl@0: #endif
sl@0: 
sl@0: #ifdef FORCE_TRACE2
sl@0: #define TRACE2(t) TRACE_printf t
sl@0: #else
sl@0: #define TRACE2(t) __KTRACE_OPT(KMMU2,TRACE_printf t)
sl@0: #endif
sl@0: 
sl@0: #ifdef FORCE_TRACEB
sl@0: #define TRACEB(t) TRACE_printf t
sl@0: #else
sl@0: #define TRACEB(t) __KTRACE_OPT2(KMMU,KBOOT,TRACE_printf t)
sl@0: #endif
sl@0: 
sl@0: #ifdef FORCE_TRACEP
sl@0: #define TRACEP(t) TRACE_printf t
sl@0: #else
sl@0: #define TRACEP(t) __KTRACE_OPT(KPAGING,TRACE_printf t)
sl@0: #endif
sl@0: 
sl@0: 
sl@0: /**
sl@0: The maximum number of consecutive updates to #SPageInfo structures which
sl@0: should be executed without releasing the #MmuLock.
sl@0: 
sl@0: This value must be an integer power of two.
sl@0: */
sl@0: const TUint KMaxPageInfoUpdatesInOneGo = 64;
sl@0: 
sl@0: /**
sl@0: The maximum number of simple operations on memory page state which should
sl@0: occur without releasing the #MmuLock. Examples of the operations are
sl@0: read-modify-write of a Page Table Entry (PTE) or entries in a memory objects
sl@0: RPageArray.
sl@0: 
sl@0: This value must be an integer power of two.
sl@0: */
sl@0: const TUint KMaxPagesInOneGo = KMaxPageInfoUpdatesInOneGo/2;
sl@0: 
sl@0: /**
sl@0: The maximum number of Page Directory Entries which should be updated
sl@0: without releasing the #MmuLock.
sl@0: 
sl@0: This value must be an integer power of two.
sl@0: */
sl@0: const TUint KMaxPdesInOneGo = KMaxPageInfoUpdatesInOneGo;
sl@0: 
sl@0: 
sl@0: /********************************************
sl@0:  * MMU stuff
sl@0:  ********************************************/
sl@0: 
sl@0: class DRamAllocator;
sl@0: class TPinArgs;
sl@0: class Defrag;
sl@0: 
sl@0: /**
sl@0: Interface to RAM allocation and MMU data structure manipulation.
sl@0: */
sl@0: class Mmu
sl@0: 	{
sl@0: public:
sl@0: 	enum TPanic
sl@0: 		{
sl@0: 		EInvalidRamBankAtBoot,
sl@0: 		EInvalidReservedBankAtBoot,
sl@0: 		EInvalidPageTableAtBoot,
sl@0: 		EInvalidPdeAtBoot,
sl@0: 		EBadMappedPageAfterBoot,
sl@0: 		ERamAllocMutexCreateFailed,
sl@0: 		EBadFreePhysicalRam,
sl@0: 		EUnsafePageInfoAccess,
sl@0: 		EUnsafePageTableInfoAccess,
sl@0: 		EPhysMemSyncMutexCreateFailed,
sl@0: 		EDefragAllocFailed
sl@0: 		};
sl@0: 
sl@0: 	/**
sl@0: 	Attribute flags used when allocating RAM pages.
sl@0: 	See #AllocRam etc.
sl@0: 
sl@0: 	The least significant bits of these flags are used for the #TMemoryType
sl@0: 	value for the memory.
sl@0: 	*/
sl@0: 	enum TRamAllocFlags
sl@0: 		{
sl@0: 		// lower bits hold TMemoryType
sl@0: 
sl@0: 		/**
sl@0: 		If this flag is set, don't wipe the contents of the memory when allocated.
sl@0: 		By default, for security and confidentiality reasons, the memory is filled
sl@0: 		with a 'wipe' value to erase the previous contents.
sl@0: 		*/
sl@0: 		EAllocNoWipe			= 1<<(KMemoryTypeShift),
sl@0: 
sl@0: 		/**
sl@0: 		If this flag is set, any memory wiping will fill memory with the byte
sl@0: 		value starting at bit position #EAllocWipeByteShift in these flags.
sl@0: 		*/
sl@0: 		EAllocUseCustomWipeByte	= 1<<(KMemoryTypeShift+1),
sl@0: 
sl@0: 		/**
sl@0: 		If this flag is set, memory allocation won't attempt to reclaim pages
sl@0: 		from the demand paging system.
sl@0: 		This is used to prevent deadlock when the paging system itself attempts
sl@0: 		to allocate memory for itself.
sl@0: 		*/
sl@0: 		EAllocNoPagerReclaim	= 1<<(KMemoryTypeShift+2),
sl@0: 
sl@0: 		/**
sl@0: 		@internal
sl@0: 		*/
sl@0: 		EAllocFlagLast,
sl@0: 
sl@0: 		/*
sl@0: 		Bit position within these flags, for the least significant bit of the
sl@0: 		byte value used when #EAllocUseCustomWipeByte is set.
sl@0: 		*/
sl@0: 		EAllocWipeByteShift		= 8
sl@0: 		};
sl@0: 
sl@0: public:
sl@0: 	void Init1();
sl@0: 	void Init1Common();
sl@0: 	void Init2();
sl@0: 	void Init2Common();
sl@0: 	void Init2Final();
sl@0: 	void Init2FinalCommon();
sl@0: 	void Init3();
sl@0: 
sl@0: 	static void Panic(TPanic aPanic);
sl@0: 
sl@0: 	static TInt HandlePageFault(TLinAddr aPc, TLinAddr aFaultAddress, TUint aAccessPermissions, TAny* aExceptionInfo);
sl@0: 
sl@0: 	TUint FreeRamInPages();
sl@0: 	TUint TotalPhysicalRamPages();
sl@0: 
sl@0: 	TInt AllocRam(	TPhysAddr* aPages, TUint aCount, TRamAllocFlags aFlags, TZonePageType aZonePageType, 
sl@0: 					TUint aBlockZoneId=KRamZoneInvalidId, TBool aBlockRest=EFalse);
sl@0: 	void FreeRam(TPhysAddr* aPages, TUint aCount, TZonePageType aZonePageType);
sl@0: 	TInt AllocContiguousRam(TPhysAddr& aPhysAddr, TUint aCount, TUint aAlign, TRamAllocFlags aFlags);
sl@0: 	void FreeContiguousRam(TPhysAddr aPhysAddr, TUint aCount);
sl@0: 
sl@0: 	const SRamZone* RamZoneConfig(TRamZoneCallback& aCallback) const;
sl@0: 	void SetRamZoneConfig(const SRamZone* aZones, TRamZoneCallback aCallback);
sl@0: 	TInt ModifyRamZoneFlags(TUint aId, TUint aClearMask, TUint aSetMask);
sl@0: 	TInt GetRamZonePageCount(TUint aId, SRamZonePageCount& aPageData);
sl@0: 	TInt ZoneAllocPhysicalRam(TUint* aZoneIdList, TUint aZoneIdCount, TInt aBytes, TPhysAddr& aPhysAddr, TInt aAlign);
sl@0: 	TInt ZoneAllocPhysicalRam(TUint* aZoneIdList, TUint aZoneIdCount, TInt aNumPages, TPhysAddr* aPageList);
sl@0: 	TInt RamHalFunction(TInt aFunction, TAny* a1, TAny* a2);	
sl@0: 	void ChangePageType(SPageInfo* aPageInfo, TZonePageType aOldPageType, TZonePageType aNewPageType);
sl@0: 
sl@0: 	TInt AllocPhysicalRam(TPhysAddr* aPages, TUint aCount, TRamAllocFlags aFlags);
sl@0: 	void FreePhysicalRam(TPhysAddr* aPages, TUint aCount);
sl@0: 	TInt AllocPhysicalRam(TPhysAddr& aPhysAddr, TUint aCount, TUint aAlign, TRamAllocFlags aFlags);
sl@0: 	void FreePhysicalRam(TPhysAddr aPhysAddr, TUint aCount);
sl@0: 	TInt ClaimPhysicalRam(TPhysAddr aPhysAddr, TUint aCount, TRamAllocFlags aFlags);
sl@0: 	void AllocatedPhysicalRam(TPhysAddr aPhysAddr, TUint aCount, TRamAllocFlags aFlags);
sl@0: 
sl@0: 	TLinAddr MapTemp(TPhysAddr aPage, TUint aColour, TUint aSlot=0);
sl@0: 	void UnmapTemp(TUint aSlot=0);
sl@0: 	void RemoveAliasesForPageTable(TPhysAddr aPageTable);
sl@0: 
sl@0: 	static TBool MapPages(TPte* const aPtePtr, const TUint aCount, TPhysAddr* aPages, TPte aBlankPte);
sl@0: 	static TBool UnmapPages(TPte* const aPtePtr, TUint aCount);
sl@0: 	static TBool UnmapPages(TPte* const aPtePtr, TUint aCount, TPhysAddr* aPages);
sl@0: 	static void RemapPage(TPte* const aPtePtr, TPhysAddr& aPage, TPte aBlankPte);
sl@0: 	static void RestrictPagesNA(TPte* const aPtePtr, TUint aCount, TPhysAddr* aPages);
sl@0: 	static TBool PageInPages(TPte* const aPtePtr, const TUint aCount, TPhysAddr* aPages, TPte aBlankPte);
sl@0: 
sl@0: 	// implemented in CPU-specific code...
sl@0: 	static TUint PteType(TMappingPermissions aPermissions, TBool aGlobal);
sl@0: 	static TUint PdeType(TMemoryAttributes aAttributes);
sl@0: 	static TPte BlankPte(TMemoryAttributes aAttributes, TUint aPteType);
sl@0: 	static TPde BlankPde(TMemoryAttributes aAttributes);
sl@0: 	static TPde BlankSectionPde(TMemoryAttributes aAttributes, TUint aPteType);
sl@0: 	static TBool CheckPteTypePermissions(TUint aPteType, TUint aAccessPermissions);
sl@0: 	static TMappingPermissions PermissionsFromPteType(TUint aPteType);
sl@0: 	void PagesAllocated(TPhysAddr* aPageList, TUint aCount, TRamAllocFlags aFlags, TBool aReallocate=false);
sl@0: 	void PageFreed(SPageInfo* aPageInfo);
sl@0: 	void CleanAndInvalidatePages(TPhysAddr* aPages, TUint aCount, TMemoryAttributes aAttributes, TUint aColour);
sl@0: public:
sl@0: 	// utils, implemented in CPU-specific code...
sl@0: 	static TPde* PageDirectory(TInt aOsAsid);
sl@0: 	static TPde* PageDirectoryEntry(TInt aOsAsid, TLinAddr aAddress);
sl@0: 	static TPhysAddr PdePhysAddr(TPde aPde);
sl@0: 	static TPhysAddr PtePhysAddr(TPte aPte, TUint aPteIndex);
sl@0: 	static TPte* PageTableFromPde(TPde aPde);
sl@0: 	static TPte* SafePageTableFromPde(TPde aPde);
sl@0: 	static TPhysAddr SectionBaseFromPde(TPde aPde);
sl@0: 	static TPte* PtePtrFromLinAddr(TLinAddr aAddress, TInt aOsAsid);
sl@0: 	static TPte* SafePtePtrFromLinAddr(TLinAddr aAddress, TInt aOsAsid);
sl@0: 	static TPhysAddr PageTablePhysAddr(TPte* aPt);
sl@0: 	static TPhysAddr LinearToPhysical(TLinAddr aAddr, TInt aOsAsid=KKernelOsAsid);
sl@0: 	static TPhysAddr UncheckedLinearToPhysical(TLinAddr aAddr, TInt aOsAsid);
sl@0: 	static TPte MakePteInaccessible(TPte aPte, TBool aReadOnly);
sl@0: 	static TPte MakePteAccessible(TPte aPte, TBool aWrite);
sl@0: 	static TBool IsPteReadOnly(TPte aPte);
sl@0: 	static TBool IsPteMoreAccessible(TPte aNewPte, TPte aOldPte);
sl@0: 	static TBool IsPteInaccessible(TPte aPte);
sl@0: 	static TBool PdeMapsPageTable(TPde aPde);
sl@0: 	static TBool PdeMapsSection(TPde aPde);
sl@0: 
sl@0: 	void SyncPhysicalMemoryBeforeDmaWrite(TPhysAddr* aPages, TUint aColour, TUint aOffset, TUint aSize, TUint32 aMapAttr);
sl@0: 	void SyncPhysicalMemoryBeforeDmaRead (TPhysAddr* aPages, TUint aColour, TUint aOffset, TUint aSize, TUint32 aMapAttr);
sl@0: 	void SyncPhysicalMemoryAfterDmaRead  (TPhysAddr* aPages, TUint aColour, TUint aOffset, TUint aSize, TUint32 aMapAttr);
sl@0: 
sl@0: 	static TPte SectionToPageEntry(TPde& aPde);
sl@0: 	static TPde PageToSectionEntry(TPte aPte, TPde aPde);
sl@0: 	static TMemoryAttributes CanonicalMemoryAttributes(TMemoryAttributes aAttr);
sl@0: 
sl@0: public:
sl@0: 	/**
sl@0: 	Class representing the resources and methods required to create temporary
sl@0: 	mappings of physical memory pages in order to make them accessible to
sl@0: 	software.
sl@0: 	These mare required by various memory model functions and are created only
sl@0: 	during system boot.
sl@0: 	*/
sl@0: 	class TTempMapping
sl@0: 		{
sl@0: 	public:
sl@0: 		void Alloc(TUint aNumPages);
sl@0: 		TLinAddr Map(TPhysAddr aPage, TUint aColour);
sl@0: 		TLinAddr Map(TPhysAddr aPage, TUint aColour, TPte aBlankPte);
sl@0: 		TLinAddr Map(TPhysAddr* aPages, TUint aCount, TUint aColour);
sl@0: 		void Unmap();
sl@0: 		void Unmap(TBool aIMBRequired);
sl@0: 		FORCE_INLINE TTempMapping()
sl@0: 			: iSize(0)
sl@0: 			{}
sl@0: 	public:
sl@0: 		TLinAddr iLinAddr;		///< Virtual address of the memory page mapped by #iPtePtr.
sl@0: 		TPte* iPtePtr;			///< Pointer to first PTE allocated to this object.
sl@0: 	private:
sl@0: 		TPte iBlankPte;			///< PTE value to use for mapping pages, with the physical address component equal to zero.
sl@0: 		TUint8 iSize;			///< Maximum number of pages which can be mapped in one go.
sl@0: 		TUint8 iCount;			///< Number of pages currently mapped.
sl@0: 		TUint8 iColour;			///< Colour of any pages mapped (acts as index from #iLinAddr and #iPtePtr).
sl@0: 		TUint8 iSpare1;
sl@0: 	private:
sl@0: 		static TLinAddr iNextLinAddr;
sl@0: 		};
sl@0: private:
sl@0: 	enum { KNumTempMappingSlots=2 };
sl@0: 	/**
sl@0: 	Temporary mappings used by various functions.
sl@0: 	Use of these is serialised by the #RamAllocLock.
sl@0: 	*/
sl@0: 	TTempMapping iTempMap[KNumTempMappingSlots];
sl@0: 
sl@0: 	TTempMapping iPhysMemSyncTemp;	///< Temporary mapping used for physical memory sync.
sl@0: 	DMutex* 	 iPhysMemSyncMutex;	///< Mutex used to serialise use of #iPhysMemSyncTemp.
sl@0: 
sl@0: public:
sl@0: 	TPte iTempPteCached;			///< PTE value for cached temporary mappings
sl@0: 	TPte iTempPteUncached;			///< PTE value for uncached temporary mappings
sl@0: 	TPte iTempPteCacheMaintenance;	///< PTE value for temporary mapping of cache maintenance
sl@0: private:
sl@0: 	DRamAllocator* iRamPageAllocator;			///< The RAM allocator used for managing free RAM pages.
sl@0: 	const SRamZone* iRamZones;					///< A pointer to the RAM zone configuration from the variant.
sl@0: 	TRamZoneCallback iRamZoneCallback;			///< Pointer to the RAM zone callback function.
sl@0: 	Defrag* iDefrag;							///< The RAM defrag class implementation.
sl@0: 
sl@0: 	/**
sl@0: 	A counter incremented every time Mmu::PagesAllocated invalidates the L1 cache.
sl@0: 	This is used as part of a cache maintenance optimisation.
sl@0: 	*/
sl@0: 	TInt iCacheInvalidateCounter;
sl@0: 
sl@0: 	/**
sl@0: 	Number of free RAM pages which are cached at L1 and have
sl@0: 	SPageInfo::CacheInvalidateCounter()==#iCacheInvalidateCounter.
sl@0: 	This is used as part of a cache maintenance optimisation.
sl@0: 	*/
sl@0: 	TInt iCacheInvalidatePageCount;
sl@0: 
sl@0: public:
sl@0: 	/**
sl@0: 	Linked list of threads which have an active IPC alias. I.e. have called
sl@0: 	DMemModelThread::Alias. Threads are linked by their DMemModelThread::iAliasLink member.
sl@0: 	Updates to this list are protected by the #MmuLock.
sl@0: 	*/
sl@0: 	SDblQue iAliasList;
sl@0: 
sl@0: 	/**
sl@0: 	The mutex used to protect RAM allocation.
sl@0: 	This is the mutex #RamAllocLock operates on.
sl@0: 	*/
sl@0: 	DMutex* iRamAllocatorMutex;
sl@0: 
sl@0: private:
sl@0: 	/**
sl@0: 	Number of nested calls to RamAllocLock::Lock.
sl@0: 	*/
sl@0: 	TUint iRamAllocLockCount;
sl@0: 
sl@0: 	/**
sl@0: 	Set by various memory allocation routines to indicate that a memory allocation
sl@0: 	has failed. This is used by #RamAllocLock in its management of out-of-memory
sl@0: 	notifications.
sl@0: 	*/
sl@0: 	TBool iRamAllocFailed;
sl@0: 
sl@0: 	/**
sl@0: 	Saved value for #FreeRamInPages which is used by #RamAllocLock in its management
sl@0: 	of memory level change notifications.
sl@0: 	*/
sl@0: 	TUint iRamAllocInitialFreePages;
sl@0: 
sl@0: 	friend class RamAllocLock;
sl@0: private:
sl@0: 	void VerifyRam();
sl@0: 	};
sl@0: 
sl@0: /**
sl@0: The single instance of class #Mmu.
sl@0: */
sl@0: extern Mmu TheMmu;
sl@0: 
sl@0: 
sl@0: #ifndef _DEBUG
sl@0: /**
sl@0: Perform a page table walk to return the physical address of
sl@0: the memory mapped at virtual address \a aLinAddr in the
sl@0: address space \a aOsAsid.
sl@0: 
sl@0: If the page table used was not one allocated by the kernel
sl@0: then the results are unpredictable and may cause a system fault.
sl@0: 
sl@0: @pre #MmuLock held.
sl@0: */
sl@0: FORCE_INLINE TPhysAddr Mmu::LinearToPhysical(TLinAddr aAddr, TInt aOsAsid)
sl@0: 	{
sl@0: 	return Mmu::UncheckedLinearToPhysical(aAddr,aOsAsid);
sl@0: 	}
sl@0: #endif
sl@0: 
sl@0: 
sl@0: __ASSERT_COMPILE((Mmu::EAllocFlagLast>>Mmu::EAllocWipeByteShift)==0); // make sure flags don't run into wipe byte value
sl@0: 
sl@0: 
sl@0: /**
sl@0: Create a temporary mapping of a physical page.
sl@0: The RamAllocatorMutex must be held before this function is called and not released
sl@0: until after UnmapTemp has been called.
sl@0: 
sl@0: @param aPage	The physical address of the page to be mapped.
sl@0: @param aColour	The 'colour' of the page if relevant.
sl@0: @param aSlot	Slot number to use, must be less than Mmu::KNumTempMappingSlots.
sl@0: 
sl@0: @return The linear address of where the page has been mapped.
sl@0: */
sl@0: FORCE_INLINE TLinAddr Mmu::MapTemp(TPhysAddr aPage, TUint aColour, TUint aSlot)
sl@0: 	{
sl@0: //	Kern::Printf("Mmu::MapTemp(0x%08x,%d,%d)",aPage,aColour,aSlot);
sl@0: 	__NK_ASSERT_DEBUG(RamAllocLock::IsHeld());
sl@0: 	__NK_ASSERT_DEBUG(aSlot<KNumTempMappingSlots);
sl@0: 	return iTempMap[aSlot].Map(aPage,aColour);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Remove the temporary mapping created with MapTemp.
sl@0: 
sl@0: @param aSlot	Slot number which was used when temp mapping was made.
sl@0: */
sl@0: FORCE_INLINE void Mmu::UnmapTemp(TUint aSlot)
sl@0: 	{
sl@0: //	Kern::Printf("Mmu::UnmapTemp(%d)",aSlot);
sl@0: 	__NK_ASSERT_DEBUG(RamAllocLock::IsHeld());
sl@0: 	__NK_ASSERT_DEBUG(aSlot<KNumTempMappingSlots);
sl@0: 	iTempMap[aSlot].Unmap();
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: Class representing the resources and arguments needed for various
sl@0: memory pinning operations.
sl@0: 
sl@0: The term 'replacement pages' in this documentation means excess
sl@0: RAM pages which have been allocated to the demand paging pool so
sl@0: that when a demand paged memory is pinned and removed the pool
sl@0: does not become too small.
sl@0: 
sl@0: Relacement pages are allocated with #AllocReplacementPages and their
sl@0: number remembered in #iReplacementPages. When a memory pinning operation
sl@0: removes pages from the paging pool it will reduce #iReplacementPages
sl@0: accordingly. At the end of the pinning operation, #FreeReplacementPages
sl@0: is used to free any unused replacement pages.
sl@0: */
sl@0: class TPinArgs
sl@0: 	{
sl@0: public:
sl@0: 	/**
sl@0: 	Boolean value set to true if the requester of the pinning operation
sl@0: 	will only read from the pinned memory, not write to it.
sl@0: 	This is used as an optimisation to avoid unnecessarily marking
sl@0: 	demand paged memory as dirty.
sl@0: 	*/
sl@0: 	TBool iReadOnly;
sl@0: 
sl@0: 	/**
sl@0: 	Boolean value set to true if sufficient replacement pages already exists
sl@0: 	in the demand paging pool and that #AllocReplacementPages does not need
sl@0: 	to actually allocated any.
sl@0: 	*/
sl@0: 	TBool iUseReserve;
sl@0: 
sl@0: 	/**
sl@0: 	The number of replacement pages allocated to this object by #AllocReplacementPages.
sl@0: 	A value of #EUseReserveForPinReplacementPages indicates that #iUseReserve
sl@0: 	was true, and there is sufficient RAM already reserved for the operation
sl@0: 	being attempted.
sl@0: 	*/
sl@0: 	TUint iReplacementPages;
sl@0: 
sl@0: 	/**
sl@0: 	The number of page tables which have been pinned during the course
sl@0: 	of an operation. This is the number of valid entries written to
sl@0: 	#iPinnedPageTables.
sl@0: 	*/
sl@0: 	TUint iNumPinnedPageTables;
sl@0: 
sl@0: 	/**
sl@0: 	Pointer to the location to store the addresses of any page tables
sl@0: 	which have been pinned during the course of an operation. This is
sl@0: 	incremented as entries are added.
sl@0: 
sl@0: 	The null-pointer indicates that page tables do not require pinning.
sl@0: 	*/
sl@0: 	TPte** iPinnedPageTables;
sl@0: 
sl@0: public:
sl@0: 	/**
sl@0: 	Construct an empty TPinArgs, one which owns no resources.
sl@0: 	*/
sl@0: 	inline TPinArgs()
sl@0: 		: iReadOnly(0), iUseReserve(0), iReplacementPages(0), iNumPinnedPageTables(0), iPinnedPageTables(0)
sl@0: 		{
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Return true if this TPinArgs has at least \a aRequired number of
sl@0: 	replacement pages allocated.
sl@0: 	*/
sl@0: 	FORCE_INLINE TBool HaveSufficientPages(TUint aRequired)
sl@0: 		{
sl@0: 		return iReplacementPages>=aRequired; // Note, EUseReserveForPinReplacementPages will always return true.
sl@0: 		}
sl@0: 
sl@0: 	/**
sl@0: 	Allocate replacement pages for this TPinArgs so that it has at least
sl@0: 	\a aNumPages.
sl@0: 	*/
sl@0: 	TInt AllocReplacementPages(TUint aNumPages);
sl@0: 
sl@0: 	/**
sl@0: 	Free all replacement pages which this TPinArgs still owns.
sl@0: 	*/
sl@0: 	void FreeReplacementPages();
sl@0: 
sl@0: #ifdef _DEBUG
sl@0: 	~TPinArgs();
sl@0: #endif
sl@0: 
sl@0: 	/**
sl@0: 	Value used to indicate that replacement pages are to come
sl@0: 	from an already allocated reserve and don't need specially
sl@0: 	allocating.
sl@0: 	*/
sl@0: 	enum { EUseReserveForPinReplacementPages = 0xffffffffu };
sl@0: 	};
sl@0: 
sl@0: 
sl@0: #ifdef _DEBUG
sl@0: inline TPinArgs::~TPinArgs()
sl@0: 	{
sl@0: 	__NK_ASSERT_DEBUG(!iReplacementPages);
sl@0: 	}
sl@0: #endif
sl@0: 
sl@0: 
sl@0: /**
sl@0: Enumeration used in various RestrictPages APIs to specify the type of restrictions to apply.
sl@0: */
sl@0: enum TRestrictPagesType
sl@0: 	{
sl@0: 	/**
sl@0: 	Make all mappings of page not accessible.
sl@0: 	Pinned mappings will veto this operation.
sl@0: 	*/
sl@0: 	ERestrictPagesNoAccess			 = 1,
sl@0: 
sl@0: 	/**
sl@0: 	Demand paged memory being made 'old'.
sl@0: 	Specific case of ERestrictPagesNoAccess.
sl@0: 	*/
sl@0: 	ERestrictPagesNoAccessForOldPage = ERestrictPagesNoAccess|0x80000000,
sl@0: 
sl@0: 	/**
sl@0: 	For page moving pinned mappings always veto the moving operation.
sl@0: 	*/
sl@0: 	ERestrictPagesForMovingFlag  = 0x40000000,
sl@0: 
sl@0: 	/**
sl@0: 	Movable memory being made no access whilst its being copied.
sl@0: 	Special case of ERestrictPagesNoAccess where pinned mappings always veto 
sl@0: 	this operation even if they are read-only mappings.
sl@0: 	*/
sl@0: 	ERestrictPagesNoAccessForMoving  = ERestrictPagesNoAccess|ERestrictPagesForMovingFlag,
sl@0: 	};
sl@0: 
sl@0: #include "xmmu.h"
sl@0: 
sl@0: #endif