// 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:
		{
		TInt isThreadLocal = (TInt)a1;
		TOwnerType ownertype;
		if (isThreadLocal)
			ownertype = EOwnerThread;
		else
			ownertype = EOwnerProcess;

		NKern::ThreadEnterCS();
		DChunk* chunk=OpenChunk();
		if(chunk)
			{
			r = Kern::MakeHandleAndOpen(0,chunk,ownertype);
			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;
		}
	}