// 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/flexible/memmodel.h

 // Flexible Memory Model header file

 /**

  @file

  @internalComponent

 */

 #ifndef __MEMMODEL_H__

 #define __MEMMODEL_H__

 #include <plat_priv.h>

 #include <memmodel/epoc/mmubase/kblockmap.h>

 #include <mmtypes.h>

 #include <mmboot.h>

 #ifdef __SMP__

 // SubScheduler fields for each processor

 #define	i_AliasLinAddr			iExtras[0]

 #define	i_AliasPdePtr			iExtras[1]

 #endif

 /********************************************

  * Deterministic Scheduler Implementation

  ********************************************/

 /**

 @internalComponent

 */

 #define TheCurrentAddressSpace			((DMemModelProcess*&)TheScheduler.iAddressSpace)

 class DMemoryObject;

 class DMemoryMapping;

 /********************************************

  * Thread Control Block

  ********************************************/

 class DMemModelProcess;

 /**

 @internalComponent

 */

 class DMemModelThread : public DThread

 	{

 public:

 	TInt Alias(TLinAddr aAddr, DMemModelProcess* aProcess, TInt aSize, TLinAddr& aAliasAddr, TUint& aAliasSize);

 	void RemoveAlias();

 	void RefreshAlias();

 	virtual void DoExit1();

 	static void RestoreAddressSpace();

  	virtual void BTracePrime(TInt aCategory);

 protected:

 	virtual void SetPaging(TUint& aCreateFlags);

 private:

 	void DoRemoveAlias(TLinAddr aAddr);

 public:

 	TLinAddr iAliasLinAddr;	// linear address to access aliased memory (0 means no alias is present).

 	TPde* iAliasPdePtr;		// Address of PDE which has been modified to make aliased memory accessible.

 	TPde iAliasPde;			// PDE to store at iAliasPdePtr.

 	DMemModelProcess* iAliasProcess;		// The process whose memory is aliased.

 	SDblQueLink iAliasLink;	// link to make TheMmu.iAliasList.

 	TLinAddr iAliasTarget;	// linear address of the memory which has been aliased

 	DMemoryMapping* iKernelStackMapping;

 	DMemoryMapping* iUserStackMapping;

 #ifdef __SMP__

 	TInt iCpuRestoreCookie;

 #endif

 	};

 /********************************************

  * Process Control Block

  ********************************************/

 class DMemModelChunk;

 class DMemModelCodeSegMemory;

 class RAddressedContainer;

 #ifdef INCLUDED_FROM_ASM

 #define PRIVATE_EXCEPT_ASM public

 #else

 #define PRIVATE_EXCEPT_ASM private

 #endif

 /**

 @internalComponent

 */

 class DMemModelProcess : public DEpocProcess

 	{

 public:

 	~DMemModelProcess();

 private:

 	void Destruct();

 protected:

 	virtual TInt AttachExistingCodeSeg(TProcessCreateInfo& aInfo);

 	virtual TInt SetPaging(const TProcessCreateInfo& aInfo);

 public:

 	virtual TInt DoCreate(TBool aKernelProcess, TProcessCreateInfo& aInfo);

 	virtual TInt NewChunk(DChunk*& aChunk, SChunkCreateInfo& aInfo, TLinAddr& aRunAddr);

 	virtual TInt AddChunk(DChunk* aChunk,TBool aIsReadOnly);

 	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();

 	virtual void BTracePrime(TInt aCategory);

 public:

 	TInt DoAddChunk(DMemModelChunk* aChunk, TBool aIsReadOnly);

 	TInt AllocateDataSectionBase(DMemModelChunk& aChunk, TUint& aBase);

 	TUint8* DataSectionBase(DMemModelChunk* aChunk);

 	void RemoveChunk(DMemModelChunk *aChunk);

 	void DoRemoveChunk(TInt aIndex);

 	TInt ChunkIndex(DMemModelChunk* aChunk);

 	TUint ChunkInsertIndex(DMemModelChunk* aChunk);

 	TInt CommitDllData(TLinAddr aBase, TInt aSize, DCodeSeg* aCodeSeg);

 	void DecommitDllData(TLinAddr aBase, TInt aSize);

 	TInt MapUserRamCode(DMemModelCodeSegMemory* aMemory);

 	void UnmapUserRamCode(DMemModelCodeSegMemory* aMemory);

 	inline TInt OsAsid()

 		{__NK_ASSERT_DEBUG(	TheCurrentThread->iOwningProcess == this || // current thread's process so asid can't be freed.

 							iOsAsid == (TInt)KKernelOsAsid ||	// kernel process so asid can't be freed.

 							iContainerID != EProcess ||	// process not fully created yet so asid can't be freed.

 							iOsAsidRefCount > 1);		// if none of the others are true then should have a reference 

 														// to prevent asid being freed (this check isn't very 

 														// robust but best we can do).

 		return iOsAsid;

 		};

 	TInt TryOpenOsAsid();

 	void CloseOsAsid();

 	void AsyncCloseOsAsid();

 public:

 	struct SChunkInfo

 		{

 		DMemModelChunk* iChunk;

 		DMemoryMapping* iMapping;

 		TInt16 iAccessCount;

 		TInt16 iIsReadOnly;

 		};

 	TInt iChunkCount;

 	TInt iChunkAlloc;

 	SChunkInfo* iChunks;

 	RAddressedContainer* iSharedChunks;

 	TPhysAddr iPageDir;

 	DMemoryMapping* iDataBssMapping;

 	/**

 	Size of virtual memory allocated in process for EXE code, but which hasn't yet been been

 	adopted by the codeseg memory mapping.

 	*/

 	TUint iCodeVirtualAllocSize;

 	/**

 	Address of virtual memory allocated in process for EXE code.

 	*/

 	TLinAddr iCodeVirtualAllocAddress;

 PRIVATE_EXCEPT_ASM:

 	TInt iOsAsid;		// This should only be accessed directly by the scheduler, 

 						// in all other cases use either OsAsid() or TryOpenOsAsid().

 private:

 	TUint iOsAsidRefCount;

 public:

 	friend class Monitor;

 	};

 /********************************************

  * Chunk Control Block

  ********************************************/

 /**

 @internalComponent

 */

 class DMemModelChunk : public DChunk

 	{

 public:

 	/**

 	@see DChunk::TChunkAttributes for generic attribute flags

 	*/

 	enum TMemModelChunkAttributes

 		{

 		EPrivate			=0x00000000, // need to be iOwningProcess in order to map or change chunk

 		EPublic				=0x80000000, // not EPrivate

 		ECode				=0x40000000, // contents are executable

 		EMMChunkAttributesMask = EPrivate | EPublic | ECode,

 		};

 public:

 	DMemModelChunk();

 	~DMemModelChunk();

 public:

 	virtual TInt Close(TAny* aPtr);

 	virtual TInt DoCreate(SChunkCreateInfo& aInfo);

 	virtual TInt Adjust(TInt aNewSize);

 	virtual TInt AdjustDoubleEnded(TInt aBottom, TInt aTop);

 	virtual TInt CheckAccess();

 	virtual TInt Commit(TInt aOffset, TInt aSize, TCommitType aCommitType=DChunk::ECommitDiscontiguous, TUint32* aExtraArg=0);

 	virtual TInt Allocate(TInt aSize, TInt aGuard=0, TInt aAlign=0);

 	virtual TInt Decommit(TInt aOffset, TInt aSize);

 	virtual TInt Lock(TInt aOffset, TInt aSize);

 	virtual TInt Unlock(TInt aOffset, 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);

 protected:

 	virtual void SetPaging(TUint aCreateAtt);

 public:

 	void SetFixedAddress(TLinAddr aAddr, TInt aInitialSize);

 	TInt SetAttributes(SChunkCreateInfo& aInfo);

 	TInt DoCommit(TInt aOffset, TInt aSize, TCommitType aCommitType=DChunk::ECommitDiscontiguous, TUint32* aExtraArg=0);

 	void DoDecommit(TInt aOffset, TInt aSize);

 	TInt CheckRegion(TInt& aOffset, TInt& aSize);

 public:

 	TBitMapAllocator* iPageBitMap;		// NULL if not disconnected chunk

 	TBitMapAllocator* iPermanentPageBitMap;

 	/**

 	The memory object containing this chunk's memory.

 	*/

 	DMemoryObject* iMemoryObject;

 	/**

 	For shared chunks and shared i/o buffers this is the mapping

 	which maps #iMemoryObject into the kernel's address space.

 	*/

 	DMemoryMapping* iKernelMapping;

 public:

 	friend class Monitor;

 	};

 /**

 @internalComponent

 */

 class DMemModelChunkHw : public DPlatChunkHw

 	{

 public:

 	virtual TInt Close(TAny* aPtr);

 public:

 	DMemoryObject* iMemoryObject;

 	DMemoryMapping* iKernelMapping;

 	};

 /********************************************

  * Code segment

  ********************************************/

 class TPagedCodeInfo;

 /**

 @internalComponent

 */

 class DMemModelCodeSegMemory : public DEpocCodeSegMemory

 	{

 public:

 	DMemModelCodeSegMemory(DEpocCodeSeg* aCodeSeg);

 	~DMemModelCodeSegMemory();

 	TInt Create(TCodeSegCreateInfo& aInfo, DMemModelProcess* aProcess);

 	TInt Loaded(TCodeSegCreateInfo& aInfo);

 	void Destroy();

 public:

 	/**

 	The process loading this code segment.

 	*/

 	DMemModelProcess* iCreator;

 	/**

 	Kernel side copy of the codeseg's export directory or NULL.

 	*/

 	TLinAddr* iCopyOfExportDir;

 	/**

 	For demand paged codeseg's, pointer to saved copy of the data section.

 	*/

 	TAny* iDataSectionMemory;

 	/**

 	The memory object containing the memory for the codeseg.

 	*/

 	DMemoryObject* iCodeMemoryObject;

 	/**

 	A writable mapping which maps #iCodeMemoryObject into the loader

 	process's memory so it can be accessed by the loader.

 	This mapping is destroyed once #Loaded is called.

 	*/

 	DMemoryMapping* iCodeLoadMapping;

 	/**

 	For demand paged codeseg's, this is a writable mapping added to the

 	loader process's address space which maps a memory object used to

 	hold the initial contents of the codeseg's data section.

 	This mapping, and it's memory object, is destroyed once #Loaded is called.

 	*/

 	DMemoryMapping* iDataLoadMapping;

 	/**

 	Size of any shared virtual memory allocated for the code.

 	*/

 	TUint iVirtualAllocCommonSize;

 	/**

 	For demand paged codeseg's, a pointer to the #TPagedCodeInfo

 	used with #iCodeMemoryObject.

 	*/

 	TPagedCodeInfo* iPagedCodeInfo;

 	};

 /**

 @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; }

 	virtual void BTracePrime(TInt aCategory);

 public:

 	/**

 	For kernel codesegs, the address of the memory allocated for its static data.

 	*/

 	TAny* iKernelData;

 	/**

 	The memory object containing the memory for this codeseg.

 	*/

 	DMemoryObject* iCodeMemoryObject;

 	/**

 	A writable mapping which maps #iCodeMemoryObject into the loader

 	process's memory so it can be accessed by the loader.

 	This mapping is destroyed once #Loaded is called.

 	*/

 	DMemoryMapping* iCodeLoadMapping;

 	/**

 	The read=only mapping used for kernel and global codesegs to map

 	#iCodeMemoryObject into the global address region.

 	*/

 	DMemoryMapping* iCodeGlobalMapping;

 	/**

 	Base address of virtual memory allocated for the codeseg's static data.

 	*/

 	TLinAddr iDataAllocBase;	

 	/**

 	Size of virtual memory allocated for the codeseg's static data.

 	*/

 	TUint iDataAllocSize;

 	};

 /********************************************

  * Shared buffers and pools

  ********************************************/

 #include <kernel/sshbuf.h>

 class DShBufMapping;

 class DMemModelNonAlignedShBuf : public DShBuf

 	{

 public:

 	DMemModelNonAlignedShBuf(DShPool* aPool, TLinAddr aRelAddr);

 	~DMemModelNonAlignedShBuf();

 	TInt Close(TAny*);

 	TInt AddToProcess(DProcess* aProcess, TUint aAttr);

 protected:

 	virtual TInt Pin(TPhysicalPinObject* aPinObject, TBool aReadOnly, TPhysAddr& aAddress, TPhysAddr* aPages, TUint32& aMapAttr, TUint& aColour);

 	virtual TInt Map(TUint, DProcess*, TLinAddr&);

 	virtual TInt UnMap(DProcess*);

 	virtual TUint8* Base(DProcess* aProcess);

 	virtual TUint8* Base();

 	};

 class DMemModelAlignedShBuf : public DShBuf

 	{

 public:

 	DMemModelAlignedShBuf(DShPool* aPool);

 	virtual ~DMemModelAlignedShBuf();

 	TInt Create();

 	virtual TInt Construct();

 	TInt Close(TAny*);

 	TInt AddToProcess(DProcess* aProcess, TUint aAttr);

 protected:

 	TUint8* Base(DProcess* aProcess);

 	TUint8* Base();

 	TInt Map(TUint, DProcess*, TLinAddr&);

 	TInt UnMap(DProcess*);

 	TInt Pin(TPhysicalPinObject* aPinObject, TBool aReadOnly, TPhysAddr& Address, TPhysAddr* aPages, TUint32& aMapAttr, TUint& aColour);

 private:

 	TInt FindMapping(DShBufMapping*&, DMemModelProcess*);

 	DMemoryObject* iMemoryObject;

 	DMemoryMapping* iKernelMapping;

 	SDblQue iMappings;

 	friend class DMemModelAlignedShPool;

 	};

 class DMemModelShPool : public DShPool

 	{

 public:

 	DMemModelShPool();

 	virtual ~DMemModelShPool();

 protected:

 	void DestroyClientResources(DProcess* aProcess);

 	virtual TInt DestroyAllMappingsAndReservedHandles(DProcess* aProcess) = 0;

 	};

 class DMemModelAlignedShPoolClient : public DShPoolClient

 	{

 public:

 	SDblQue iMappingFreeList;

 	TInt iWindowSize;

 	};

 class DMemModelNonAlignedShPoolClient : public DShPoolClient

 	{

 public:

 	DMemoryMapping* iMapping;

 	};

 class DShBufMapping;

 class DMemModelAlignedShPool : public DMemModelShPool

 	{

 public:

 	DMemModelAlignedShPool();

 	virtual ~DMemModelAlignedShPool();

 	TInt Close(TAny* aPtr);

 	TInt CreateInitialBuffers();

 	TInt SetBufferWindow(DProcess* aProcess, TInt aWindowSize);

 	TInt AddToProcess(DProcess* aProcess, TUint aAttr);

 	TInt Alloc(DShBuf*&);

 private:

 	TInt DoCreate(TShPoolCreateInfo& aInfo);

 	TInt GrowPool();

 	TInt ShrinkPool();

 	TInt MappingNew(DShBufMapping*& aMapping, DMemModelProcess* aProcess);

 	TInt GetFreeMapping(DShBufMapping*& aMapping, DMemModelAlignedShPoolClient* aClient);

 	TInt ReleaseMapping(DShBufMapping*& aMapping, DMemModelAlignedShPoolClient* aClient);

 	TInt UpdateMappingsAndReservedHandles(TInt aNoOfBuffers);

 	TInt UpdateFreeList();

 	void Free(DShBuf* aBuf);

 	TInt CreateMappings(DMemModelAlignedShPoolClient* aClient, TInt aNoOfMappings, DMemModelProcess* aProcess);

 	TInt DestroyAllMappingsAndReservedHandles(DProcess* aProcess);

 	TInt DestroyMappings(DMemModelAlignedShPoolClient* aClient, TInt aNoOfMappings);

 	TInt DeleteInitialBuffers();

 	SDblQue iPendingList;

 	DMemModelAlignedShBuf* iInitialBuffersArray;

 	friend class DMemModelAlignedShBuf;

 	};

 class DMemModelNonAlignedShPool : public DMemModelShPool

 	{

 public:

 	DMemModelNonAlignedShPool();

 	virtual ~DMemModelNonAlignedShPool();

 	TInt Close(TAny* aPtr);

 	TInt DoInitFreeList();

 	TUint8* Base(DProcess* aProcess);

 	inline TUint8* Base()

 		{

 		return reinterpret_cast<TUint8*>(iBaseAddress);

 		};

 	TInt AddToProcess(DProcess* aProcess, TUint aAttr);

 	TInt CreateInitialBuffers();

 	TInt Alloc(DShBuf*&);

 private:

 	void Free(DShBuf* aBuf);

 	TInt UpdateFreeList();

 	TInt DoCreate(TShPoolCreateInfo& aInfo);

 	void FreeBufferPages(TUint aOffset);

 	TInt GrowPool();

 	TInt ShrinkPool();

 	TInt DeleteInitialBuffers();

 	TInt DestroyAllMappingsAndReservedHandles(DProcess* aProcess);

 private:

 	TLinAddr iBaseAddress;

 	DMemoryObject* iMemoryObject;		// the 'real' memory pool (in the kernel)

 	DMemModelNonAlignedShBuf* iInitialBuffersArray;

 	TBitMapAllocator* iBufMap;

 	TBitMapAllocator* iPagesMap;

 	friend class DMemModelNonAlignedShBuf;

 	};

 #endif