// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// e32\include\memmodel\epoc\moving\memmodel.h
// 
// WARNING: This file contains some APIs which are internal and are subject
//          to change without notice. Such APIs should therefore not be used
//          outside the Kernel and Hardware Services package.
//

#ifndef __MEMMODEL_H__
#define __MEMMODEL_H__
#include <memmodel/epoc/mmubase/mmubase.h>

/********************************************
 * Deterministic Scheduler Implementation
 ********************************************/

/**
@internalComponent
*/
#define TheCurrentAddressSpace			((DMemModelProcess*&)TheScheduler.iAddressSpace)

/**
@internalComponent
*/
#define TheCurrentVMProcess				((DMemModelProcess*&)TheScheduler.iExtras[0])

/**
@internalComponent
*/
#define TheCurrentDataSectionProcess	((DMemModelProcess*&)TheScheduler.iExtras[1])

/**
@internalComponent
*/
#define TheCompleteDataSectionProcess	((DMemModelProcess*&)TheScheduler.iExtras[2])

/**
@internalComponent
*/
#define FlushProgress					((TInt&)TheScheduler.iExtras[3])


/********************************************
 * Process Control Block
 ********************************************/
/**
@internalComponent
*/
const TInt KMaxChunksInProcess=16;

class DMemModelChunk;
/**
@internalComponent
*/
class DMemModelProcess : public DEpocProcess
	{
public:
	void Destruct();
public:
	virtual TInt DoCreate(TBool aKernelProcess, TProcessCreateInfo& aInfo);
	virtual TInt NewChunk(DChunk*& aChunk, SChunkCreateInfo& anInfo, TLinAddr& aRunAddr);
	virtual TInt AddChunk(DChunk* aChunk,TBool isReadOnly);
	virtual TInt NewShPool(DShPool*& aPool, TShPoolCreateInfo& aInfo);
	virtual TInt CreateDataBssStackArea(TProcessCreateInfo& aInfo);
	virtual TInt MapCodeSeg(DCodeSeg* aCodeSeg);
	virtual void UnmapCodeSeg(DCodeSeg* aCodeSeg);
	virtual void RemoveDllData();
	virtual void FinalRelease();
public:
	virtual TInt GetNewChunk(DMemModelChunk*& aChunk, SChunkCreateInfo& anInfo)=0;
	virtual TInt AddFixedAccessChunk(DMemModelChunk *aChunk)=0;
	virtual TInt RemoveFixedAccessChunk(DMemModelChunk *aChunk)=0;
	virtual void CheckForFixedAccess()=0;
	virtual void DoAttributeChange()=0;
public:
	TInt AddChunk(DMemModelChunk* aChunk, TLinAddr& aDataSectionBase, TBool isReadOnly);
	TInt AllocateDataSectionBase(DMemModelChunk& aChunk, TUint& aBase);
	TUint8* DataSectionBase(DMemModelChunk* aChunk);
	void RemoveChunk(DMemModelChunk *aChunk);
	void DoRemoveChunk(TInt aIndex);
	TInt ChunkIndex(DMemModelChunk* aChunk,TInt& aPos);
	TInt CreateDllDataChunk();
	void FreeDllDataChunk();
	TInt CommitDllData(TLinAddr aBase, TInt aSize);
	void DecommitDllData(TLinAddr aBase, TInt aSize);
public:
	enum TMemModelProcessAttributes
		{
		EFixedAddress=1,
		EMoving=0x40000000,
		EVariableAccess=0x20000000,
//		EMovingCode=0x10000000,		NEVER USED
		EVariableCode=0x04000000,
		EMMProcessAttributesMask = EFixedAddress|EMoving|EVariableAccess|EVariableCode,
		};

	struct SChunkInfo
		{
		TLinAddr iDataSectionBase;
		DMemModelChunk *iChunk;
		TInt16 iAccessCount;
		TInt16 isReadOnly;
		};

	TInt iNumChunks;
	SChunkInfo iChunks[KMaxChunksInProcess];
	TInt iNumMovingChunks;
	TInt iNumNonFixedAccessChunks;
	TInt iNumNonFixedAccessCodeChunks;
	DMemModelChunk* iDllDataChunk;
public:
	friend class Monitor;
	};


/********************************************
 * Chunk Control Block
 ********************************************/
/**
@internalComponent
*/
class DMemModelChunk : public DChunk
	{
public:
	/**
	@see DChunk::TChunkAttributes for generic attribute flags
	*/
	enum TMemModelChunkAttributes
		{
		EFixedAccess	=0x80000000,
		EFixedAddress	=0x40000000,
		EPrivate		=0x10000000,
		ECode			=0x08000000,

		EMMChunkAttributesMask = EFixedAccess | EFixedAddress | EPrivate | ECode,
		};

	enum TChunkState {ENotRunning=0, ERunningRO=1, ERunningRW=2};
public:
	DMemModelChunk();
	void Destruct();
public:
	virtual TInt Close(TAny* aPtr);
	virtual TInt DoCreate(SChunkCreateInfo& anInfo);
	virtual TInt Adjust(TInt aNewSize);
	virtual TInt AdjustDoubleEnded(TInt aBottom, TInt aTop);
	virtual TInt CheckAccess();
	virtual TInt Commit(TInt anOffset, TInt aSize, TCommitType aCommitType=DChunk::ECommitDiscontiguous, TUint32* aExtraArg=0);
	virtual TInt Allocate(TInt aSize, TInt aGuard=0, TInt aAlign=0);
	TInt Decommit(TInt anOffset, TInt aSize);
	virtual TInt Lock(TInt anOffset, TInt aSize);
	virtual TInt Unlock(TInt anOffset, TInt aSize);
	virtual TInt Address(TInt aOffset, TInt aSize, TLinAddr& aKernelAddress);
	virtual TInt PhysicalAddress(TInt aOffset, TInt aSize, TLinAddr& aKernelAddress, TUint32& aPhysicalAddress, TUint32* aPhysicalPageList=NULL);
	virtual void BTracePrime(TInt aCategory);
	virtual void Substitute(TInt aOffset, TPhysAddr aOldAddr, TPhysAddr aNewAddr);
	virtual TUint8* Base(DProcess* aProcess);
	inline TUint8* Base() const { return DChunk::Base(); }
public:
	TInt Decommit(TInt aOffset, TInt aSize, TDecommitType aDecommitType);
	TInt FindFree(TInt aSize, TInt aGuard, TInt aAlign);
	void SetFixedAddress(TLinAddr anAddr, TInt anInitialSize);
	TInt Reserve(TInt anInitialSize);
	TUint32 ApplyTopLevelPermissions(TChunkState aChunkState);
	TUint32 MoveToRunAddress(TLinAddr aLinearAddr,TChunkState aChunkState);
	TUint32 MoveToHomeSection();
	TZonePageType GetPageType();
protected:
	TInt DoCommit(TInt aOffset, TInt aSize, TCommitType aCommitType=DChunk::ECommitDiscontiguous, TUint32* aExtraArg=0);
	void DoDecommit(TInt aOffset, TInt aSize, TDecommitType aDecommitType=EDecommitNormal);
private:
	void ClaimInitialPages();
	TInt ExpandHomeRegion(TInt anOffset, TInt aSize);
	TLinAddr AllocateHomeAddress(TInt aSize);
	void DeallocateHomeAddress();
	TLinAddr ReallocateHomeAddress(TInt aNewSize);
	TInt DoAllocate(TInt aSize, TInt aGuard, TInt aAlign, TBool aCommit);
private:
	virtual TInt SetupPermissions()=0;
	virtual void AddPde(TInt anOffset)=0;
	virtual void RemovePde(TInt anOffset)=0;
	virtual void MoveHomePdes(TLinAddr anOldAddr, TLinAddr aNewAddr)=0;
	virtual void MoveCurrentPdes(TLinAddr anOldAddr, TLinAddr aNewAddr)=0;
public:
	TChunkState iChunkState;
	TPte iPtePermissions;
	TPde iPdePermissions[3];	// indexed by iChunkState
	TInt iHomeRegionOffset;
	TInt iHomeRegionSize;
	TLinAddr iHomeRegionBase;
	TLinAddr iHomeBase;
	TInt iNumPdes;
	TPde* iPdes;
	TPde* iHomePdes;
	TUint32* iPdeBitMap;
	TBitMapAllocator* iPageBitMap;
	TBitMapAllocator* iPermanentPageBitMap;
public:
	friend class Monitor;
	};


/********************************************
 * Code segment
 ********************************************/

class DMemModelCodeSegMemory : public DMmuCodeSegMemory
	{
public:
	DMemModelCodeSegMemory(DEpocCodeSeg* aCodeSeg);
	~DMemModelCodeSegMemory();
	TInt Create(TCodeSegCreateInfo& aInfo);
	TInt Loaded(TCodeSegCreateInfo& aInfo);
	void Destroy();
	};

/**
@internalComponent
*/
class DMemModelCodeSeg: public DEpocCodeSeg
	{
public:
	DMemModelCodeSeg();
	virtual ~DMemModelCodeSeg();
	virtual TInt DoCreateRam(TCodeSegCreateInfo& aInfo, DProcess* aProcess);
	virtual TInt DoCreateXIP(DProcess* aProcess);
	virtual TInt Loaded(TCodeSegCreateInfo& aInfo);
	virtual void ReadExportDir(TUint32* aDest);
	virtual TBool FindCheck(DProcess* aProcess);
	virtual TBool OpenCheck(DProcess* aProcess);
	inline DMemModelCodeSegMemory* Memory()
		{ return (DMemModelCodeSegMemory*)iMemory; }
public:
	TInt iCodeAllocBase;
	TInt iDataAllocBase;
	TAny* iKernelData;			// only for kernel modules
	};


/********************************************
 * MMU stuff
 ********************************************/

typedef void (*TCopyPageFn)(TLinAddr aDest, TLinAddr aSrc);

/**
@internalComponent
*/
class Mmu : public MmuBase
	{
public:
	enum TFlushFlags	{
						EFlushDTLB=0x01,
						EFlushDCache=0x02,
						EFlushITLB=0x04,
						EFlushICache=0x08,
						EFlushDDecommit=0x80000000,
						EFlushDPermChg=0x20000000,		// =DProcess::EVariableAccess
						EFlushDMove=0x40000000,			// =DProcess::EMoving
						EFlushIPermChg=0x04000000,		// =DProcess::EVariableCode
						EFlushIMove=0x10000000,			// =DProcess::EMovingCode
						EFlushInheritMask=EFlushDPermChg|EFlushDMove|EFlushIPermChg|EFlushIMove,
						};

	enum TPanic
		{
		EBadInitialPageAddr,
		EAssignPageTableInvalidUsage,
		EUserCodeAllocatorCreateFailed,
		EDllDataAllocatorCreateFailed,
		ERomUserDataAddressInvalid,
		ERomUserDataSizeInvalid,
		ERomLinearAddressInvalid,
		ERemapPageFailed,
		ERemapPageTableFailed,
		ENoCopyPageFunction,
		EFixupXPTFailed,
		ECacheMaintenance,
		EDefragDisablePageFailed,
		EDefragFaultWhilstFMHeld,
		EDefragKernelChunkNoPageTable,
		};

public:
	inline TPde& PDE(TLinAddr aAddr)
		{return *(((TPde*)iPdeBase)+(aAddr>>iChunkShift));}

	// virtual - inherited/overridden from MmuBase
	virtual void Init1();
//	virtual void Init2();
	virtual void DoInit2();
//	virtual TBool PteIsPresent(TPte aPte)=0;
//	virtual TPhysAddr PtePhysAddr(TPte aPte, TInt aPteIndex)=0;
//	virtual TPhysAddr PdePhysAddr(TLinAddr aAddr)=0;
	virtual void SetupInitialPageInfo(SPageInfo* aPageInfo, TLinAddr aChunkAddr, TInt aPdeIndex);
	virtual void SetupInitialPageTableInfo(TInt aId, TLinAddr aChunkAddr, TInt aNumPtes);
	virtual void AssignPageTable(TInt aId, TInt aUsage, TAny* aObject, TLinAddr aAddr, TPde aPdePerm);
	virtual TInt UnassignPageTable(TLinAddr aAddr);
//	virtual void BootstrapPageTable(TInt aXptId, TPhysAddr aXptPhys, TInt aId, TPhysAddr aPhysAddr)=0;
	virtual TInt PageTableId(TLinAddr aAddr);
//	virtual TInt BootPageTableId(TLinAddr aAddr, TPhysAddr& aPtPhys)=0;
//	virtual void ClearPageTable(TInt aId, TInt aFirstIndex=0)=0;
//	virtual TPhysAddr LinearToPhysical(TLinAddr aAddr)=0;
//	virtual TInt LinearToPhysical(TLinAddr aAddr, TInt aSize, TPhysAddr& aPhysicalAddress, TPhysAddr* aPhysicalPageList=NULL)=0;
//	virtual void MapRamPages(TInt aId, SPageInfo::TType aType, TAny* aPtr, TUint32 aOffset, const TPhysAddr* aPageList, TInt aNumPages, TPte aPtePerm)=0;
//	virtual void MapPhysicalPages(TInt aId, SPageInfo::TType aType, TAny* aPtr, TUint32 aOffset, TPhysAddr aPhysAddr, TInt aNumPages, TPte aPtePerm)=0;
//	virtual TInt UnmapPages(TInt aId, TUint32 aAddr, TInt aNumPages, TPhysAddr* aPageList, TBool aSetPagesFree, TInt& aNumPtes, TInt& aNumFree, DProcess* aProcess)=0;
//	virtual void ClearRamDrive(TLinAddr aStart)=0;
//	virtual TInt PdePtePermissions(TUint& aMapAttr, TPde& aPde, TPte& aPte, TBool aGlobal)=0;
//	virtual void Map(TLinAddr aLinAddr, TPhysAddr aPhysAddr, TInt aSize, TPde aPdePerm, TPte aPtePerm, TInt aMapShift)=0;
//	virtual void Unmap(TLinAddr aLinAddr, TInt aSize)=0;
//	virtual void InitShadowPageTable(TInt aId, TLinAddr aRomAddr, TPhysAddr aOrigPhys)=0;
//	virtual void InitShadowPage(TPhysAddr aShadowPhys, TLinAddr aRomAddr)=0;
//	virtual void DoUnmapShadowPage(TInt aId, TLinAddr aRomAddr, TPhysAddr aOrigPhys)=0;
//	virtual TInt UnassignShadowPageTable(TLinAddr aRomAddr, TPhysAddr aOrigPhys)=0;
//	virtual void DoFreezeShadowPage(TInt aId, TLinAddr aRomAddr)=0;
//	virtual void FlushShadow(TLinAddr aRomAddr)=0;
//	virtual void AssignShadowPageTable(TInt aId, TLinAddr aRomAddr)=0;
//	virtual void ClearPages(TInt aNumPages, TPhysAddr* aPageList)=0;
	virtual TPte PtePermissions(TChunkType aChunkType)=0;
	virtual TInt MoveKernelPage(DChunk* aChunk, TUint32 aOffset, TPhysAddr aOld, TPhysAddr& aNew, TUint aBlockZoneId, TBool aBlockRest);
	virtual TInt MoveCodeSegMemoryPage(DMemModelCodeSegMemory* aCodeSegMemory, TUint32 aOffset, TPhysAddr aOld, TPhysAddr& aNew, TUint aBlockZoneId, TBool aBlockRest);
	virtual TInt MoveCodeChunkPage(DChunk* aChunk, TUint32 aOffset, TPhysAddr aOld, TPhysAddr& aNew, TUint aBlockZoneId, TBool aBlockRest);
	virtual TInt MoveDataChunkPage(DChunk* aChunk, TUint32 aOffset, TPhysAddr aOld, TPhysAddr& aNew, TUint aBlockZoneId, TBool aBlockRest);

	// pure virtual - new in Mmu
	virtual void DoAssignPageTable(TInt aId, TLinAddr aAddr, TPde aPdePerm)=0;
	virtual void RemapPageTable(TPhysAddr aOld, TPhysAddr aNewId, TLinAddr aAddr)=0;
	virtual void DoUnassignPageTable(TLinAddr aAddr)=0;
	virtual void MoveChunk(TLinAddr anInitAddr, TUint aSize, TLinAddr aFinalAddr, TPde aPermissions)=0;
	virtual void MoveChunk(TLinAddr anInitAddr, TLinAddr aFinalAddr, TInt aNumPdes)=0;
	virtual void ApplyTopLevelPermissions(TLinAddr anAddr, TUint aChunkSize, TPde aPermissions)=0;
	virtual void ApplyPagePermissions(TInt aId, TInt aPageOffset, TInt aNumPages, TPte aPtePerm)=0;
	virtual void SyncCodeMappings()=0;
	virtual void GenericFlush(TUint32 aMask)=0;
	virtual TPde PdePermissions(TChunkType aChunkType, TInt aChunkState)=0;
	virtual TInt UnlockRamCachePages(TUint8* volatile & aBase, TInt aFirstPage, TInt aNumPages)=0;
	virtual TInt LockRamCachePages(TUint8* volatile & aBase, TInt aFirstPage, TInt aNumPages)=0;
	virtual void MapVirtual(TInt aId, TInt aNumPages)=0;
	virtual TInt UnmapVirtual(TInt aId, TUint32 aAddr, TInt aNumPages, TPhysAddr* aPageList, TBool aSetPagesFree, TInt& aNumPtes, TInt& aNumFree, DProcess* aProcess)=0;
	virtual TLinAddr MapTemp(TPhysAddr aPage, TBool aCached)=0;
	virtual TLinAddr MapSecondTemp(TPhysAddr aPage, TBool aCached)=0;
	virtual void UnmapTemp()=0;
	virtual void UnmapSecondTemp()=0;
	virtual void RemapKernelPage(TInt aId, TLinAddr aSrc, TLinAddr aDest, TPhysAddr aNewPhys, TPte aPtePerm)=0;
	virtual TInt PreparePagesForDMA(TLinAddr aAddr, TInt aSize, TPhysAddr* aPhysicalPageList)=0;
	virtual TInt ReleasePagesFromDMA(TPhysAddr* aPhysicalPageList, TInt aPageCount)=0;
	
public:
	TInt GetPageTableId(TLinAddr aAddr);
public:
	inline static Mmu& Get()
		{return *(Mmu*)TheMmu;}
	inline void CopyPageForRemap(TLinAddr aDest, TLinAddr aSrc)
		{iCopyPageFn(aDest, aSrc);}
	static void Panic(TPanic aPanic);
public:
	TLinAddr iDataSectionBase;		// lowest data section address
	TLinAddr iDllDataBase;			// start of DLL static data area
	TLinAddr iDataSectionEnd;		// highest data section address + 1
	TInt iMaxDllDataSize;
	TLinAddr iUserCodeBase;
	TInt iMaxUserCodeSize;
	TLinAddr iKernelCodeBase;
	TInt iMaxKernelCodeSize;
	TLinAddr iPdeBase;
	TPte iUserCodeLoadPtePerm;
	TPte iKernelCodePtePerm;
	TUint32* iHomePdeMap;
	TCopyPageFn iCopyPageFn;
	TPte* iSecondTempPte;		// second PTE used for temporary mappings
	TLinAddr iSecondTempAddr;	// address corresponding to iSecondTempPte
	};


/********************************************
 * Functions/Data defined in memory model
 ********************************************/

/**
@internalComponent
*/
class MM
	{
public:
	enum TMemModelPanic
		{
		EUserCodeNotFixed=0,
		EClaimInitialPagesBadPageTable=1,
		EFreeInvalidDomain=2,
		EFreeDomainNotAllocated=3,
		EFixedChunkMoving=4,
		EChunkDecommitNoPageTable=5,
		ECommitInvalidDllDataAddress=6,
		EDecommitInvalidDllDataAddress=7,
		EPdeAlreadyInUse=8,
		EPteAlreadyInUse=9,
		EMmuMapNoPageTable=10,
		EUnmapBadAlignment=11,
		EBootstrapPageTableBadAddr=12,
		EAddFixedBadPerm=13,
		ERemoveFixedBadPerm=14,
		EUnexpectedPageType=15,
		EOperationNotImplemented=16,
		ECodeAddressOutOfRange=17,
		ETempMappingAlreadyInUse=18,
		EChunkRemapNoPageTable=19,
		EChunkRemapWrongPageTable=20,
		};

	static void Panic(TMemModelPanic aPanic);
public:
	static void Init1();
	static TAny* CurrentAddress(DThread* aThread, const TAny* aAddress, TInt aSize, TBool aWrite);
	static void StartCrashDebugger();
	static TInt CreateCodeChunk(TBool aKernel);
public:
	static TInt MaxPagesInOneGo;
	static DMemModelChunk* SvStackChunk;
	static DMemModelChunk* TheRamDriveChunk;
	static DMemModelChunk* UserCodeChunk;
	static DMemModelChunk* KernelCodeChunk;
	static TBitMapAllocator* DllDataAllocator;
	};

#endif