diff -r 000000000000 -r a41df078684a kerneltest/e32test/mmu/d_sharedchunk.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/mmu/d_sharedchunk.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,916 @@
+// Copyright (c) 2004-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:
+// e32test\mmu\d_sharedchunk.cpp
+// 
+//
+
+#include <kernel/kern_priv.h>
+#include <kernel/cache.h>
+#include "d_sharedchunk.h"
+
+TBool PhysicalCommitSupported = ETrue;
+
+#ifdef __EPOC32__
+#define TEST_PHYSICAL_COMMIT
+#endif
+
+static volatile TInt ChunkDestroyedCount=1;	// Test counter
+
+//
+// Class definitions
+//
+
+class DSharedChunkFactory : public DLogicalDevice
+	{
+public:
+	~DSharedChunkFactory();
+	virtual TInt Install();
+	virtual void GetCaps(TDes8& aDes) const;
+	virtual TInt Create(DLogicalChannelBase*& aChannel);
+	TInt ClaimMemory();
+	void ReleaseMemory();
+	TInt AllocMemory(TInt aSize, TUint32& aPhysAddr);
+	void FreeMemory(TInt aSize,TUint32 aPhysAddr);
+	void LockWait();
+	void LockSignal();
+private:
+	NFastMutex iLock;
+public:
+	TBool iMemoryInUse;
+	TUint32 iPhysBase;
+	TUint32 iPhysEnd;
+	TUint32 iPhysNext;
+	TInt* iDummyCell;
+	};
+
+class DSharedChunkChannel : public DLogicalChannelBase
+	{
+public:
+	DSharedChunkChannel();
+	~DSharedChunkChannel();
+	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);
+	virtual TInt Request(TInt aFunction, TAny* a1, TAny* a2);
+	DChunk* OpenChunk(TLinAddr* aKernelAddr=0, TInt* aMaxSize=0);
+	inline void LockWait()
+		{ iFactory->LockWait(); }
+	inline void LockSignal()
+		{ iFactory->LockSignal(); }
+	TUint32 DfcReadWrite(TUint32* aPtr, TUint32 aValue);
+	TUint32 IsrReadWrite(TUint32* aPtr, TUint32 aValue);
+public:
+	DSharedChunkFactory*	iFactory;
+	DChunk*					iChunk;
+	TLinAddr				iKernelAddress;
+	TInt					iMaxSize;
+	};
+
+class TChunkCleanup : public TDfc
+	{
+public:
+	TChunkCleanup(DSharedChunkFactory* aFactory,TBool aReleasePhysicalMemory);
+	~TChunkCleanup();
+	static void ChunkDestroyed(TChunkCleanup* aSelf);
+	void Cancel();
+public:
+	DSharedChunkFactory* iFactory;
+	TBool iReleasePhysicalMemory;
+	};
+
+//
+// TChunkCleanup
+//
+
+TChunkCleanup::TChunkCleanup(DSharedChunkFactory* aFactory,TBool aReleasePhysicalMemory)
+	: TDfc((TDfcFn)TChunkCleanup::ChunkDestroyed,this,Kern::SvMsgQue(),0)
+	, iFactory(0), iReleasePhysicalMemory(aReleasePhysicalMemory)
+	{
+	aFactory->Open();
+	iFactory = aFactory;
+	}
+
+TChunkCleanup::~TChunkCleanup()
+	{
+	if(iFactory)
+		iFactory->Close(0);
+	}
+
+void TChunkCleanup::ChunkDestroyed(TChunkCleanup* aSelf)
+	{
+	__KTRACE_OPT(KMMU,Kern::Printf("D_SHAREDCHUNK ChunkDestroyed DFC\n"));
+	DSharedChunkFactory* factory = aSelf->iFactory;
+	if(factory)
+		{
+		factory->LockWait();
+		if(aSelf->iReleasePhysicalMemory)
+			factory->ReleaseMemory();
+		factory->LockSignal();
+		__e32_atomic_add_ord32(&ChunkDestroyedCount, 1);
+		__KTRACE_OPT(KMMU,Kern::Printf("D_SHAREDCHUNK ChunkDestroyedCount=%d\n",ChunkDestroyedCount));
+		}
+	delete aSelf;
+	}
+
+void TChunkCleanup::Cancel()
+	{
+	if(iFactory)
+		{
+		iFactory->Close(0);
+		iFactory = 0;
+		}
+	};
+
+//
+// DSharedChunkFactory
+//
+
+TInt DSharedChunkFactory::Install()
+	{
+	TUint mm=Kern::HalFunction(EHalGroupKernel,EKernelHalMemModelInfo,0,0)&EMemModelTypeMask;
+	PhysicalCommitSupported = mm!=EMemModelTypeDirect && mm!=EMemModelTypeEmul;
+#ifdef __EPOC32__
+	if(PhysicalCommitSupported)
+		{
+		TInt physSize = 4096*1024;
+		TInt r=Epoc::AllocPhysicalRam(physSize, iPhysBase);
+		if(r!=KErrNone)
+			return r;
+		iPhysNext = iPhysBase;
+		iPhysEnd = iPhysBase+physSize;
+		iMemoryInUse = EFalse;
+		}
+#endif
+	// Make sure there is enough space on kernel heap to that heap doesn't need
+	// to expand when allocating objects. (Required for OOM and memory leak testing.)
+	TAny* expandHeap = Kern::Alloc(16*1024);
+	iDummyCell = new TInt;
+	Kern::Free(expandHeap);
+
+	return SetName(&KSharedChunkLddName);
+	}
+
+DSharedChunkFactory::~DSharedChunkFactory()
+	{
+#ifdef __EPOC32__
+	if(PhysicalCommitSupported)
+		Epoc::FreePhysicalRam(iPhysBase, iPhysEnd-iPhysBase);
+#endif
+	delete iDummyCell;
+	}
+
+void DSharedChunkFactory::GetCaps(TDes8& /*aDes*/) const
+	{
+	// Not used but required as DLogicalDevice::GetCaps is pure virtual
+	}
+
+TInt DSharedChunkFactory::Create(DLogicalChannelBase*& aChannel)
+	{
+	aChannel = NULL;
+	DSharedChunkChannel* channel=new DSharedChunkChannel;
+	if(!channel)
+		return KErrNoMemory;
+	channel->iFactory = this;
+	aChannel = channel;
+	return KErrNone;
+	}
+
+void DSharedChunkFactory::LockWait()
+	{
+	NKern::FMWait(&iLock);
+	}
+
+void DSharedChunkFactory::LockSignal()
+	{
+	NKern::FMSignal(&iLock);
+	}
+
+TInt DSharedChunkFactory::AllocMemory(TInt aSize, TUint32& aPhysAddr)
+	{
+	if(!PhysicalCommitSupported)
+		aSize = 0;
+	TInt r=KErrNone;
+	Kern::RoundToPageSize(aSize);
+	LockWait();
+	if(iPhysNext+aSize>iPhysEnd)
+		r = KErrNoMemory;
+	else
+		{
+		aPhysAddr = iPhysNext;
+		iPhysNext += aSize;
+		}
+	LockSignal();
+	return r;
+	}
+
+TInt DSharedChunkFactory::ClaimMemory()
+	{
+	if (__e32_atomic_swp_ord32(&iMemoryInUse, 1))
+		return KErrInUse;
+	iPhysNext = iPhysBase;	// reset allocation pointer
+	return KErrNone;
+	}
+
+void DSharedChunkFactory::ReleaseMemory()
+	{
+	iMemoryInUse=EFalse;
+	}
+
+void DSharedChunkFactory::FreeMemory(TInt aSize,TUint32 aPhysAddr)
+	{
+	if(!PhysicalCommitSupported)
+		aSize = 0;
+	if(iPhysNext!=aPhysAddr+aSize)
+		{ FAULT(); }	// Only support freeing from the end
+	Kern::RoundToPageSize(aSize);
+	LockWait();
+	iPhysNext -= aSize;
+	LockSignal();
+	}
+
+DECLARE_STANDARD_LDD()
+	{
+	return new DSharedChunkFactory;
+	}
+
+//
+// DSharedChunkChannel
+//
+
+TInt DSharedChunkChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)
+	{
+	return KErrNone;
+	}
+
+DSharedChunkChannel::DSharedChunkChannel()
+	{
+	}
+
+DSharedChunkChannel::~DSharedChunkChannel()
+	{
+	if(iChunk)
+		iChunk->Close(0);
+	}
+
+
+void DoDfcReadWrite(TUint32* aArgs)
+	{
+	TUint32* ptr = (TUint32*)aArgs[0];
+	TUint32 value = aArgs[1];
+	aArgs[1] = *ptr;
+	*ptr = value;
+	NKern::FSSignal((NFastSemaphore*)aArgs[2]);
+	}
+
+TUint32 DSharedChunkChannel::DfcReadWrite(TUint32* aPtr, TUint32 aValue)
+	{
+	NFastSemaphore sem;
+	NKern::FSSetOwner(&sem,0);
+
+	TUint32 args[3];
+	args[0] = (TUint32)aPtr;
+	args[1] = aValue;
+	args[2] = (TUint32)&sem;
+
+	TDfc dfc((TDfcFn)DoDfcReadWrite,&args,Kern::SvMsgQue(),0);
+	dfc.Enque();
+	NKern::FSWait(&sem);
+
+	return args[1];
+	}
+
+
+void DoIsrReadWrite(TUint32* aArgs)
+	{
+	TUint32* ptr = (TUint32*)aArgs[0];
+	TUint32 value = aArgs[1];
+	aArgs[1] = *ptr;
+	*ptr = value;
+	((TDfc*)aArgs[2])->Add();
+	}
+
+void DoIsrReadWriteDfcCallback(TUint32* aArgs)
+	{
+	NKern::FSSignal((NFastSemaphore*)aArgs);
+	}
+
+TUint32 DSharedChunkChannel::IsrReadWrite(TUint32* aPtr, TUint32 aValue)
+	{
+	NFastSemaphore sem;
+	NKern::FSSetOwner(&sem,0);
+
+	TDfc dfc((TDfcFn)DoIsrReadWriteDfcCallback,&sem,Kern::SvMsgQue(),0);
+
+	TUint32 args[3];
+	args[0] = (TUint32)aPtr;
+	args[1] = aValue;
+	args[2] = (TUint32)&dfc;
+
+	NTimer timer((NTimerFn)DoIsrReadWrite,&args);
+	timer.OneShot(1);
+
+	NKern::FSWait(&sem);
+	return args[1];
+	}
+
+
+DChunk* DSharedChunkChannel::OpenChunk(TLinAddr* aKernelAddr,TInt* aMaxSize)
+	{
+	__ASSERT_CRITICAL	// Thread must be in critical section (to avoid leaking access count on chunk)
+	LockWait();
+	DChunk* chunk=iChunk;
+	if(chunk)
+		if(chunk->Open()!=KErrNone)
+			chunk = NULL;
+	if(aKernelAddr)
+		*aKernelAddr = chunk ? iKernelAddress : NULL;
+	if(aMaxSize)
+		*aMaxSize = chunk ? iMaxSize : 0;
+	LockSignal();
+	return chunk;
+	}
+
+
+TUint8 ReadByte(volatile TUint8* aPtr)
+	{
+	return *aPtr;
+	}
+
+void signal_sem(TAny* aPtr)
+	{
+	NKern::FSSignal((NFastSemaphore*)aPtr);
+	}
+
+TInt WaitForIdle()
+	{
+	NFastSemaphore s(0);
+	TDfc idler(&signal_sem, &s, Kern::SvMsgQue(), 0);	// supervisor thread, priority 0, so will run after destroyed DFC
+	NTimer timer(&signal_sem, &s);
+	idler.QueueOnIdle();
+	timer.OneShot(NKern::TimerTicks(5000), ETrue);	// runs in DFCThread1
+	NKern::FSWait(&s);	// wait for either idle DFC or timer
+	TBool timeout = idler.Cancel();	// cancel idler, return TRUE if it hadn't run
+	TBool tmc = timer.Cancel();	// cancel timer, return TRUE if it hadn't expired
+	if (!timeout && !tmc)
+		NKern::FSWait(&s);	// both the DFC and the timer went off - wait for the second one
+	if (timeout)
+		return KErrTimedOut;
+	return KErrNone;
+	}
+
+
+TInt WaitForIdle2()
+	{
+	TInt r = WaitForIdle(); // wait for chunk async delete
+	if(r==KErrNone)
+		r = WaitForIdle();	// wait for chunk destroyed notification DFC
+	return r;
+	}
+
+
+TInt DSharedChunkChannel::Request(TInt aFunction, TAny* a1, TAny* a2)
+	{
+	TInt i1 = (TInt)a1;
+	TInt i2 = (TInt)a2;
+
+	TInt r=KErrNotSupported;
+
+	switch(aFunction)
+		{
+
+	case RSharedChunkLdd::ECreateChunk:
+		{
+		NKern::ThreadEnterCS();
+		if (__e32_atomic_load_acq32(&ChunkDestroyedCount)==0)
+			{
+			WaitForIdle2(); // Go idle for a while to let chunk cleanup DFCs to be called
+			}
+
+		// Create cleanup item
+		TBool chunkUsesPhysicalMemory = (i1&EOwnsMemory)==0;
+
+		TChunkCleanup* cleanup = new TChunkCleanup(this->iFactory,chunkUsesPhysicalMemory);
+		if(!cleanup)
+			{
+			NKern::ThreadLeaveCS();
+			return KErrNoMemory;
+			}
+
+		// Try and create chunk...
+		DChunk* chunk;
+		TChunkCreateInfo info;
+
+		info.iType		 = (i1&EMultiple)
+							? TChunkCreateInfo::ESharedKernelMultiple
+							: TChunkCreateInfo::ESharedKernelSingle;
+
+		info.iMaxSize	 = i1&~ECreateFlagsMask;
+#ifdef __EPOC32__
+		info.iMapAttr	 = (i1&ECached) ? EMapAttrCachedMax
+						 : (i1&EBuffered) ? EMapAttrBufferedC
+						 : EMapAttrFullyBlocking;
+#endif
+		info.iOwnsMemory = (i1&EOwnsMemory)!=0;
+
+		info.iDestroyedDfc = cleanup;
+
+		if(i1&EBadType) *(TUint8*)&info.iType = 0xff;
+
+		TUint32 mapAttr;
+		TUint32 kernAddr;
+		r = Kern::ChunkCreate(info, chunk, kernAddr, mapAttr);
+		if(r!=KErrNone)
+			{
+			delete cleanup;
+			NKern::ThreadLeaveCS();
+			return r;
+			}
+
+		// Setup data members
+		LockWait();
+		if(iChunk)
+			r = KErrAlreadyExists;
+		else
+			{
+			if(chunkUsesPhysicalMemory)
+				r = iFactory->ClaimMemory();
+			if(r==KErrNone)
+				{
+				iChunk = chunk;
+				iKernelAddress = kernAddr;
+				iMaxSize = info.iMaxSize;
+				__e32_atomic_store_ord32(&ChunkDestroyedCount,0);
+				}
+			}
+		LockSignal();
+
+		if(r!=KErrNone)
+			{
+			// There was an error, so discard created chunk
+			cleanup->Cancel();
+			Kern::ChunkClose(chunk);
+			NKern::ThreadLeaveCS();
+			return r;
+			}
+
+		NKern::ThreadLeaveCS();
+
+		// Write back kernel address of chunk
+		if(a2)
+			kumemput32(a2,(TAny*)&kernAddr,4);
+
+		return KErrNone;
+		}
+
+
+	case RSharedChunkLdd::EGetChunkHandle:
+		{
+		NKern::ThreadEnterCS();
+		DChunk* chunk=OpenChunk();
+		if(chunk)
+			{
+			r = Kern::MakeHandleAndOpen(0,chunk);
+			chunk->Close(0);
+			}
+		else
+			r = KErrNotFound;
+		NKern::ThreadLeaveCS();
+		return r;
+		}
+
+
+	case RSharedChunkLdd::ECloseChunkHandle:
+		{
+		NKern::ThreadEnterCS();
+		r = Kern::CloseHandle(0,i1);
+		NKern::ThreadLeaveCS();
+		return r;
+		}
+
+
+	case RSharedChunkLdd::ECommitMemory:
+		{
+		NKern::ThreadEnterCS();
+		TUint32 chunkKernelAddress;
+		DChunk* chunk=OpenChunk(&chunkKernelAddress);
+		if(chunk)
+			{
+			TInt type = i1&ECommitTypeMask;
+			i1 &= ~ECommitTypeMask;
+			switch(type)
+				{
+			case EDiscontiguous:
+				r = Kern::ChunkCommit(chunk,i1,i2);
+				break;
+
+			case EContiguous:
+				{
+				TUint32 physAddr=~0u;
+				r = Kern::ChunkCommitContiguous(chunk,i1,i2,physAddr);
+				if(r!=KErrNone || i2==0)
+					break;
+				if(physAddr==~0u)
+					{ r=KErrGeneral; break; }
+
+				// Check that ChunkPhysicalAddress returns addresses consistant with the commit
+				TUint32 kernAddr;
+				TUint32 mapAttr;
+				TUint32 physAddr2;
+				r = Kern::ChunkPhysicalAddress(chunk, i1, i2, kernAddr, mapAttr, physAddr2);
+				if(r==KErrNone)
+					if(kernAddr!=chunkKernelAddress+i1 || physAddr2!=physAddr)
+						r=KErrGeneral;
+
+				if(r==KErrNone)
+					{
+					// Exercise memory sync functions
+					Cache::SyncMemoryBeforeDmaRead(kernAddr, i2, mapAttr);
+					Cache::SyncMemoryBeforeDmaWrite(kernAddr, i2, mapAttr);
+					}
+				}
+				break;
+
+			case EDiscontiguousPhysical|EBadPhysicalAddress:
+			case EDiscontiguousPhysical:
+				{
+				TUint32 physAddr;
+				r = iFactory->AllocMemory(i2,physAddr);
+				if(r!=KErrNone)
+					break;
+
+				TInt pageSize =	Kern::RoundToPageSize(1);
+				TInt numPages = Kern::RoundToPageSize(i2)/pageSize;
+				TUint32* physAddrList = new TUint32[numPages];
+				TInt i;
+				for(i=0; i<numPages; i++)
+					physAddrList[i] = physAddr+i*pageSize;
+				if(type&EBadPhysicalAddress)
+					physAddrList[i-1] |= 1;
+				r = Kern::ChunkCommitPhysical(chunk,i1,i2,physAddrList);
+				delete[] physAddrList;
+				if(r!=KErrNone || i2==0)
+					{
+					iFactory->FreeMemory(i2,physAddr);
+					break;
+					}
+
+				// Check that ChunkPhysicalAddress returns the same addresses we used in the commit
+				TUint32 kernAddr;
+				TUint32 mapAttr;
+				TUint32 physAddr2;
+				TUint32* physAddrList2 = new TUint32[numPages];
+				r = Kern::ChunkPhysicalAddress(chunk, i1, i2, kernAddr, mapAttr, physAddr2, physAddrList2);
+				if(r==KErrNone)
+					{
+					if(kernAddr!=chunkKernelAddress+i1 || physAddr2!=physAddr)
+						r=KErrGeneral;
+					else
+						for(i=0; i<numPages; i++)
+							if(physAddrList2[i] != physAddr+i*pageSize)
+								r = KErrGeneral;
+					}
+				delete[] physAddrList2;
+
+				if(r==KErrNone)
+					{
+					// Exercise memory sync functions
+					Cache::SyncMemoryBeforeDmaRead(kernAddr, i2, mapAttr);
+					Cache::SyncMemoryBeforeDmaWrite(kernAddr, i2, mapAttr);
+					}
+				}
+				break;
+
+			case EContiguousPhysical|EBadPhysicalAddress:
+			case EContiguousPhysical:
+				{
+				TUint32 physAddr;
+				r = iFactory->AllocMemory(i2,physAddr);
+				if(r==KErrNone)
+					{
+					if(type&EBadPhysicalAddress)
+						r = Kern::ChunkCommitPhysical(chunk,i1,i2,physAddr|1);
+					else
+						r = Kern::ChunkCommitPhysical(chunk,i1,i2,physAddr);
+					}
+				if(r!=KErrNone || i2==0)
+					{
+					iFactory->FreeMemory(i2,physAddr);
+					break;
+					}
+
+				// Check that ChunkPhysicalAddress returns the same addresses we used in the commit
+				TUint32 kernAddr;
+				TUint32 mapAttr;
+				TUint32 physAddr2;
+				r = Kern::ChunkPhysicalAddress(chunk, i1, i2, kernAddr, mapAttr, physAddr2);
+				if(r==KErrNone)
+					if(kernAddr!=chunkKernelAddress+i1 || physAddr2!=physAddr)
+						r=KErrGeneral;
+
+				if(r==KErrNone)
+					{
+					// Exercise memory sync functions
+					Cache::SyncMemoryBeforeDmaRead(kernAddr, i2, mapAttr);
+					Cache::SyncMemoryBeforeDmaWrite(kernAddr, i2, mapAttr);
+					}
+				}
+				break;
+
+			default:
+				r = KErrNotSupported;
+				break;
+
+				}
+			chunk->Close(0);
+			}
+		else
+			r = KErrNotFound;
+		NKern::ThreadLeaveCS();
+		return r;
+		}
+
+
+	case RSharedChunkLdd::EIsDestroyed:
+		{
+		NKern::ThreadEnterCS();
+		TInt r = WaitForIdle2();
+		NKern::ThreadLeaveCS();
+		if (r==KErrNone)
+			return __e32_atomic_load_acq32(&ChunkDestroyedCount);
+		return 0;		// never went idle so can't have been destroyed
+		}
+
+
+	case RSharedChunkLdd::ECloseChunk:
+		{
+		NKern::ThreadEnterCS();
+
+		// Claim ownership of the chunk
+		LockWait();
+		DChunk* chunk=iChunk;
+		iChunk = 0;
+		LockSignal();
+
+		// Close the chunk
+		if(chunk)
+			r = Kern::ChunkClose(chunk);
+		else
+			r = KErrNotFound;
+
+		NKern::ThreadLeaveCS();
+		return r;
+		}
+
+
+	case RSharedChunkLdd::ECheckMemory:
+	case RSharedChunkLdd::EReadMemory:
+	case RSharedChunkLdd::EWriteMemory:
+		{
+		TUint32 value=0;
+
+		NKern::ThreadEnterCS();
+		TLinAddr kernAddr;
+		TInt maxSize;
+		DChunk* chunk=OpenChunk(&kernAddr,&maxSize);
+		if(chunk)
+			{
+			if((TUint)i1>=(TUint)maxSize)
+				r = KErrArgument;
+			else
+				{
+				TInt addr = kernAddr+i1;
+#ifdef _DEBUG
+				TInt debugMask = Kern::CurrentThread().iDebugMask;
+				Kern::CurrentThread().iDebugMask = debugMask&~(1<<KPANIC);
+#endif
+				XTRAP(r, XT_DEFAULT, 
+					if(aFunction==RSharedChunkLdd::ECheckMemory)
+						ReadByte((volatile TUint8*)addr);
+					else if(aFunction==RSharedChunkLdd::EReadMemory)
+						value = *(volatile TUint32*)addr;
+					else if(aFunction==RSharedChunkLdd::EWriteMemory)
+						*(volatile TUint32*)addr = i2;
+					);
+#ifdef _DEBUG
+				Kern::CurrentThread().iDebugMask = debugMask;
+#endif
+				if(aFunction==RSharedChunkLdd::ECheckMemory)
+					r = r==KErrNone;
+				}
+			chunk->Close(0);
+			}
+		else
+			r = KErrNotFound;
+
+		NKern::ThreadLeaveCS();
+
+		if(aFunction==RSharedChunkLdd::EReadMemory)
+			kumemput32(a2,&value,sizeof(value));
+
+		return r;
+		}
+
+
+	case RSharedChunkLdd::EDfcReadWrite:
+	case RSharedChunkLdd::EIsrReadWrite:
+		{
+		TUint32 value=0;
+		kumemget32(&value,a2,sizeof(value));
+
+		NKern::ThreadEnterCS();
+		TLinAddr kernAddr;
+		TInt maxSize;
+		DChunk* chunk=OpenChunk(&kernAddr,&maxSize);
+		if(chunk)
+			{
+			if((TUint)i1>=(TUint)maxSize)
+				r = KErrArgument;
+			else
+				{
+				TInt addr = kernAddr+i1;
+				if(aFunction==RSharedChunkLdd::EDfcReadWrite)
+					value = DfcReadWrite((TUint32*)addr,value);
+				else if(aFunction==RSharedChunkLdd::EIsrReadWrite)
+					value = IsrReadWrite((TUint32*)addr,value);
+				r = KErrNone;
+				}
+			chunk->Close(0);
+			}
+		else
+			r = KErrNotFound;
+		NKern::ThreadLeaveCS();
+
+		kumemput32(a2,&value,sizeof(value));
+		return r;
+		}
+
+
+	case RSharedChunkLdd::ETestOpenAddress:
+		{
+		NKern::ThreadEnterCS();
+
+		TLinAddr kernAddr;
+		DChunk* chunk=OpenChunk(&kernAddr);
+		if(!chunk)
+			{
+			NKern::ThreadLeaveCS();
+			return KErrNotReady;
+			}
+
+		TInt offset;
+		DChunk* chunk2 = Kern::OpenSharedChunk(0,a1,EFalse,offset);
+		if(chunk2)
+			{
+			if(chunk2!=chunk)
+				r = KErrGeneral;
+			else
+				r = KErrNone;
+			chunk2->Close(0);
+			}
+		else
+			r = KErrNotFound;
+
+		chunk->Close(0);
+
+		NKern::ThreadLeaveCS();
+		return r;
+		}
+
+	case RSharedChunkLdd::ETestOpenHandle:
+		{
+		NKern::ThreadEnterCS();
+
+		TLinAddr kernAddr;
+		DChunk* chunk=OpenChunk(&kernAddr);
+		if(!chunk)
+			{
+			NKern::ThreadLeaveCS();
+			return KErrNotReady;
+			}
+
+		DChunk* chunk2 = Kern::OpenSharedChunk(0,i1,EFalse);
+		if(chunk2)
+			{
+			if(chunk2==chunk)
+				r = KErrNone;
+			else
+				r = KErrGeneral;
+			chunk2->Close(0);
+			}
+		else
+			r = KErrNotFound;
+
+		chunk->Close(0);
+
+		NKern::ThreadLeaveCS();
+		return r;
+		}
+
+	case RSharedChunkLdd::ETestAddress:
+		{
+		NKern::ThreadEnterCS();
+
+		TLinAddr kernAddr;
+		DChunk* chunk=OpenChunk(&kernAddr);
+		if(!chunk)
+			{
+			NKern::ThreadLeaveCS();
+			return KErrNotReady;
+			}
+
+		TLinAddr kernAddr2;
+		r = Kern::ChunkAddress(chunk,i1,i2,kernAddr2);
+		if(r==KErrNone)
+			if(kernAddr2!=kernAddr+i1)
+				r = KErrGeneral;
+
+		chunk->Close(0);
+
+		NKern::ThreadLeaveCS();
+		return r;
+		}
+		
+	case RSharedChunkLdd::EChunkUserBase:
+		{
+		NKern::ThreadEnterCS();
+
+		DChunk* chunk=OpenChunk();
+		if(!chunk)
+			{
+			NKern::ThreadLeaveCS();
+			return KErrNotReady;
+			}
+
+		TUint8* baseAddress = Kern::ChunkUserBase(chunk, &Kern::CurrentThread());
+
+		chunk->Close(0);
+		if(a1)
+			kumemput32(a1,(TAny*)&baseAddress,4);
+
+		NKern::ThreadLeaveCS();
+		return KErrNone;
+		}		
+
+	case RSharedChunkLdd::EChunkCloseAndFree:
+		{
+#ifdef __EPOC32__
+		// Allocate and then commit some physical ram to a chunk
+		NKern::ThreadEnterCS();
+		const TUint KPhysPages = 5;
+		TUint pageSize =	Kern::RoundToPageSize(1);
+		TUint physBytes = KPhysPages * pageSize;
+		TPhysAddr addrArray[KPhysPages];
+		TLinAddr linAddr;
+		TUint32 mapAttr;
+		DChunk* chunk;
+
+		TChunkCreateInfo chunkInfo;
+		chunkInfo.iType			= TChunkCreateInfo::ESharedKernelSingle;
+		chunkInfo.iMaxSize		= physBytes;
+		chunkInfo.iMapAttr		= EMapAttrFullyBlocking;
+		chunkInfo.iOwnsMemory	= EFalse;
+
+		r = Kern::ChunkCreate(chunkInfo, chunk, linAddr, mapAttr);
+		if (r != KErrNone)
+			{
+			NKern::ThreadLeaveCS();
+			return r;
+			}
+		r = Epoc::AllocPhysicalRam(KPhysPages, addrArray);
+		if (r != KErrNone)
+			{
+			Kern::ChunkClose(chunk);
+			NKern::ThreadLeaveCS();
+			return r;
+			}
+		r = Kern::ChunkCommitPhysical(chunk, 0, physBytes, addrArray);
+		if (r != KErrNone)
+			{
+			Kern::ChunkClose(chunk);
+			r = Epoc::FreePhysicalRam(KPhysPages, addrArray);
+			NKern::ThreadLeaveCS();
+			return r;
+			}
+		// Now attempt to free the physical ram immediately after the chunk 
+		// has been closed.
+		Kern::ChunkClose(chunk);
+		r = Epoc::FreePhysicalRam(KPhysPages, addrArray);
+		NKern::ThreadLeaveCS();
+		return r;
+#endif
+		}
+
+	default:
+		return KErrNotSupported;
+		}
+	}
+