--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kernel/eka/include/memmodel/emul/win32/memmodel.h	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,313 @@
+// 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\emul\win32\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.
+//
+
+/**
+ @file
+ @internalComponent
+*/
+
+#ifndef __WIN32_MEM_H__
+#define __WIN32_MEM_H__
+#include <win32.h>
+#include <plat_priv.h>
+#include <kernel/sshbuf.h>
+
+const TInt KRamChunkSize=0x10000;
+const TInt KRamChunkShift=16;
+const TInt KRamPageSize=0x1000;
+const TInt KRamPageShift=12;
+
+/********************************************
+ * Thread Control Block
+ ********************************************/
+
+class DWin32Thread : public DThread
+	{
+public:
+	~DWin32Thread();
+	virtual TInt Context(TDes8& aDes);
+	virtual TInt SetupContext(SThreadCreateInfo& anInfo);
+	virtual void DoExit2();
+	};
+
+/********************************************
+ * Process Control Block
+ ********************************************/
+class DWin32CodeSeg;
+class DWin32Chunk;
+struct SProcessDllDataBlock;
+class DWin32Process : public DProcess
+	{
+public:
+	DWin32Process();
+	~DWin32Process();
+public:
+	virtual TInt DoCreate(TBool aKernelProcess, TProcessCreateInfo& aInfo);
+	virtual TInt NewChunk(DChunk*& aChunk, SChunkCreateInfo& aInfo, TLinAddr& aRunAddr);
+	virtual TInt AddChunk(DChunk* aChunk,TBool isReadOnly);
+	virtual TInt NewShPool(DShPool*& aPool, TShPoolCreateInfo& aInfo);
+	virtual TInt CreateDataBssStackArea(TProcessCreateInfo& aInfo);
+	virtual TInt GetNewThread(DThread*& aThread, SThreadCreateInfo& anInfo);
+	virtual TInt AttachExistingCodeSeg(TProcessCreateInfo& aInfo);
+	virtual TInt MapCodeSeg(DCodeSeg* aCodeSeg);
+	virtual void UnmapCodeSeg(DCodeSeg* aCodeSeg);
+	virtual void RemoveDllData();
+	virtual void FinalRelease();
+	virtual void Release();
+	void CallRuntimeHook(TWin32RuntimeReason aReason);
+public:
+	TWin32RuntimeHook iWin32RuntimeHook;
+	RArray<SProcessDllDataBlock> iDllData;
+	};
+
+/******************************************************************
+ * structure to keep static data in code segments within a process
+ ******************************************************************/
+struct SProcessDllDataBlock
+	{
+	DWin32CodeSeg* iCodeSeg;
+	TAny* iDataCopy;			// copy of .data
+	TAny* iBssCopy;				// copy of .bss
+	};
+
+/********************************************
+ * Chunk Control Block
+ ********************************************/
+class DWin32Chunk : public DChunk
+	{
+public:
+	enum TMemModelChunkAttributes
+		{
+		EPrivate=0x10000000,
+
+		EMMChunkAttributesMask = EPrivate,
+		};
+
+public:
+	~DWin32Chunk();
+public:
+	virtual TInt DoCreate(SChunkCreateInfo& aInfo);
+	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);
+	virtual 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(); }
+private:
+	TInt DoCommit(TInt aOffset, TInt aSize);
+	void DoDecommit(TInt aOffset, TInt aSize);
+public:
+	TBitMapAllocator* iPageBitMap;
+	TBitMapAllocator* iUnlockedPageBitMap;
+	TBitMapAllocator* iPermanentPageBitMap;
+	};
+
+/********************************************
+ * Code segment
+ ********************************************/
+class DModuleList;
+class DWin32CodeSeg: public DCodeSeg
+	{
+public:
+	DWin32CodeSeg();
+	virtual ~DWin32CodeSeg();
+	TInt ProcessImports(DProcess* aProcess);
+	TInt CreateAlreadyLoaded(HMODULE aModule, TInt aDepCount);
+	TInt RegisterCodeSeg(HMODULE aModule);
+	TInt CopyDataBss();
+public:
+	virtual TLibraryFunction Lookup(TInt aOrdinal);
+	virtual TInt GetMemoryInfo(TModuleMemoryInfo& aInfo, DProcess* aProcess);
+	virtual TInt DoCreate(TCodeSegCreateInfo& aInfo, DProcess* aProcess);
+	virtual TInt Loaded(TCodeSegCreateInfo& aInfo);
+	virtual void InitData();
+	virtual void ReadExportDir(TUint32* aDest);
+	virtual TBool FindCheck(DProcess* aProcess);
+	virtual TBool OpenCheck(DProcess* aProcess);
+	virtual void Info(TCodeSegCreateInfo& aInfo);
+public:
+	HINSTANCE iWinInstance;
+	HMODULE iModuleHandle;
+	wchar_t* iModuleFile;
+	TBool iAlwaysLoaded;		// TRUE for variant or extension
+	DModuleList* iModuleList;
+	TAny* iDataCopy;			// copy of .data
+	TInt iRealDataSize;
+	TInt iRealBssSize;
+	TLinAddr iDataDest;			// load address of .data
+	TLinAddr iBssDest;			// load address of .bss
+	TInt iCodeSegId;			// unique ID, incremented each time a code segment is loaded
+	DWin32Process* iLiveProcess;// process who's static data is currently loaded in the codeseg
+	};
+
+struct SWin32Module
+	{
+	TLinAddr iWin32ModuleHandle;
+	DWin32CodeSeg* iCodeSeg;
+	};
+
+	
+/********************************************
+ * Functions/Data defined in memory model
+ ********************************************/
+
+class MM
+	{
+public:
+	enum TMemModelPanic
+		{
+		EKernelHeapReserveFailed = 0,
+		EKernelHeapCommitFailed = 1,
+		ERamAllocMutexCreateFailed = 2,
+		EInvalidChunkCreate = 3,
+		EInvalidSharedModule = 4,
+		ECompileDepLists=5,
+		EWin32RuntimeError=6,
+		ENotSupportedOnEmulator=7,
+		EWsdBadReserve=8,
+		EWsdDllNotInProcess=9,
+    	};
+
+	static void Panic(TMemModelPanic aPanic);
+public:
+	static void Init1();
+	static void Wait();
+	static void Signal();
+	static TUint32 RoundToPageSize(TUint32 aSize);
+	static TUint32 RoundToChunkSize(TUint32 aSize);
+	static TInt RegisterModule(HMODULE aModule);
+	static TInt Commit(TLinAddr aBase, TInt aSize, TInt aClearByte, TBool aExecute);
+	static TInt Decommit(TLinAddr aBase, TInt aSize);
+	static void CheckMemoryCounters();
+	static void DoProcessSwitch(TAny* aAddressSpace);
+	static TAny* CurrentAddress(DThread* aThread, const TAny* aPtr, TInt aSize, TBool aWrite, TBool& aLocked);
+public:
+	static TAny* KernelHeapAddress;
+	static DMutex* RamAllocatorMutex;
+	static TInt RamChunkSize;
+	static TInt RamChunkShift;
+	static TInt RamPageSize;
+	static TInt RamPageShift;
+	static TInt FreeMemory;	// number of bytes in the system free memory 
+	static TInt CacheMemory; // number of bytes of memory being used for cache chunks (RChunk::Unlock)
+	static TInt ReclaimedCacheMemory; // number of bytes of memory removed from CacheMemory in order to satisfy memory allocation
+	static TInt InitialFreeMemory;
+	static TBool AllocFailed;
+	static RArray<SWin32Module> Win32Modules;
+	static TInt NextCodeSegId;
+	};
+
+
+/********************************************
+ * Shared buffers and pools
+ ********************************************/
+
+class DWin32ShBuf : public DShBuf
+	{
+public:
+	DWin32ShBuf(DShPool* aPool, TLinAddr aRelAddr);
+	~DWin32ShBuf();
+
+	TInt AddToProcess(DProcess* aProcess, TUint aAttr);
+
+	TInt Close(TAny* aPtr);
+
+protected:
+	virtual TInt Map(TUint, DProcess*, TLinAddr&);
+	virtual TInt UnMap(DProcess*);
+	virtual TUint8* Base(DProcess* aProcess);
+	virtual TUint8* Base();
+
+private:
+	TBool iMapped;
+	};
+
+
+class DWin32ShPool : public DShPool
+	{
+public:
+	DWin32ShPool();
+	virtual ~DWin32ShPool();
+
+	TInt Close(TAny* aPtr);
+	TInt AddToProcess(DProcess* aProcess, TUint aAttr);
+	TInt Alloc(DShBuf*&);
+
+protected:
+	TInt DoCreate(TShPoolCreateInfo& aInfo);
+	TInt AddToFreeList(TInt aOffset);
+	TInt CreateInitialBuffers();
+	TInt DeleteInitialBuffers();
+	TInt DestroyHandles(DProcess* aProcess);
+	void DestroyClientResources(DProcess* aProcess);
+
+	void Free(DShBuf* aBuf);
+	TInt UpdateFreeList();
+
+	TUint8* Base();
+	TUint8* Base(DProcess* aProcess);
+	TBool IsOpen(DProcess* aProcess);
+
+	TBitMapAllocator* iBufMap;
+	DWin32ShBuf* iInitialBuffersArray;
+	TUint8* iWin32MemoryBase;
+	TInt iWin32MemorySize;
+	friend class DWin32ShBuf;
+	};
+
+
+class DWin32AlignedShPool : public DWin32ShPool
+	{
+public:
+	DWin32AlignedShPool();
+	virtual ~DWin32AlignedShPool();
+	TInt SetBufferWindow(DProcess* aProcess, TInt aWindowSize);
+
+private:
+	TInt DoCreate(TShPoolCreateInfo& aInfo);
+	TInt GrowPool();
+	TInt ShrinkPool();
+	};
+
+
+class DWin32NonAlignedShPool : public DWin32ShPool
+	{
+public:
+	DWin32NonAlignedShPool();
+	virtual ~DWin32NonAlignedShPool();
+
+private:
+	TInt DoCreate(TShPoolCreateInfo& aInfo);
+	void FreeBufferPages(TUint aOffset);
+	TInt GrowPool();
+	TInt ShrinkPool();
+
+	TBitMapAllocator* iPagesMap;
+	};
+
+#endif	// __WIN32_MEM_H__