// Copyright (c) 2006-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\heap\d_kheap.cpp
// 
//

#include "d_kheap.h"
#include <kernel/kern_priv.h>

class  DKHeap : public DLogicalChannelBase
	{
public:
	DKHeap();
	~DKHeap();
	static TBool Handler (const TDesC8& aText, TTraceSource aTraceSource);
protected:
	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);
	virtual TInt Request(TInt aFunction, TAny* a1, TAny* a2);

	TInt TestBurstFailNext(TUint aCount, TUint aBurst);
	TInt TestBurstDeterministic(TUint aRate, TUint aBurst);
	};

DKHeap* KHeapDriver;

DKHeap::DKHeap() 
	{}

DKHeap::~DKHeap() 
	{KHeapDriver = NULL;}

TInt DKHeap::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& /*aVer*/)
	{return KErrNone;}

/**User side request entry point.*/
TInt DKHeap::Request(TInt aFunction, TAny* a1, TAny* a2)
	{
	TInt r = KErrNone;
	switch (aFunction)
	{
		case RKHeapDevice::ESetThreadPriorityHigh:
			{
			NKern::ThreadEnterCS();
			Kern::SetThreadPriority(47);
			NKern::ThreadLeaveCS();
			}
			break;

		case RKHeapDevice::ECreateSharedChunk:
			{
			TChunkCreateInfo info;
		    info.iType         = TChunkCreateInfo::ESharedKernelSingle;
			info.iMaxSize      = 0x40000;
		#ifdef __EPOC32__
			info.iMapAttr      = EMapAttrSupRw | EMapAttrCachedWBWA | EMapAttrL2CachedWBWA;
		#endif
			info.iOwnsMemory   = ETrue; // Use memory from system's free pool
			info.iDestroyedDfc = NULL;

		    TLinAddr chunkAddr;
		    TUint32 mapAttr;
		    DChunk* chunk;

			NKern::ThreadEnterCS();
		    if (KErrNone != (r = Kern::ChunkCreate(info, chunk, chunkAddr, mapAttr)))
				{
				NKern::ThreadLeaveCS();
				break;
				}
			Kern::ChunkClose(chunk);
			NKern::ThreadLeaveCS();
			}
			break;

		#ifdef __EPOC32__
		case RKHeapDevice::ECreatHwChunk:
			{
			const TInt KSize = 4*1024;
			TPhysAddr physbase;

			NKern::ThreadEnterCS();
			r = Epoc::AllocPhysicalRam(KSize, physbase);
			if (r)	{NKern::ThreadLeaveCS();break;}
			
			DPlatChunkHw* hwchunk;
			r = DPlatChunkHw::New(hwchunk, physbase, KSize, EMapAttrSupRw);
			if (r==KErrNone)	hwchunk->Close(NULL);
			
			Epoc::FreePhysicalRam(physbase, KSize);
			NKern::ThreadLeaveCS();
			}
			break;
		#endif//__EPOC32__

		case RKHeapDevice::ETestBurstFailNext:
			r = TestBurstFailNext((TUint)a1, (TUint)a2);
			break;

		case RKHeapDevice::ETestBurstDeterministic:
			r = TestBurstDeterministic((TUint)a1, (TUint)a2);
			break;

		default:
			r=KErrNotSupported;
		}
	return r;
	}



TInt DKHeap::TestBurstFailNext(TUint aCount, TUint aBurst)
	{
	NKern::ThreadEnterCS();

	TInt r = KErrNone;
	TUint i = 0;
	TInt* p = NULL;
	for (; i < aCount; i++)
		{
		if (i < aCount - 1)
			{
			p = new TInt;
			if (p == NULL)
				{// Shouldn't have failed
				r = KErrNoMemory;
				goto exit;
				}
			delete p;
			}
		else 
			{
			for (TUint j = 0; j < aBurst; j++)
				{
				p = new TInt;
				if (p != NULL)
					{// Should be failing
					delete p;
					r = KErrGeneral;
					goto exit;
					}
				}
			} 
		}
exit:
	NKern::ThreadLeaveCS();
	return r;
	}

TInt DKHeap::TestBurstDeterministic(TUint aRate, TUint aBurst)
	{
	NKern::ThreadEnterCS();

	TInt r = KErrNone;
	TInt* p = NULL;
	for (TUint i = 1; i <= aRate * KHeapFailCycles; i++)
		{
		if (i % aRate == 0)
			{
			for (TUint j = 0; j < aBurst; j++)
				{
				p = new TInt;
				if (p != NULL)
					{// Should have failed but didn't
					delete p;
					r = KErrGeneral;
					goto exit;
					}
				}
			}
		else
			{
			p = new TInt;
			if (p == NULL)
				{// Shouldn't have failed but did
				r = KErrNoMemory;
				goto exit;
				}
			delete p;
			}
		}
exit:
	NKern::ThreadLeaveCS();
	return r;
	}

//////////////////////////////////////////
class DTestFactory : public DLogicalDevice
	{
public:
	DTestFactory();
	// from DLogicalDevice
	virtual TInt Install();
	virtual void GetCaps(TDes8& aDes) const;
	virtual TInt Create(DLogicalChannelBase*& aChannel);
	};

DTestFactory::DTestFactory()
    {
    iParseMask = KDeviceAllowUnit;
    iUnitsMask = 0x3;
    }

TInt DTestFactory::Create(DLogicalChannelBase*& aChannel)
    {
	KHeapDriver = new DKHeap;
	aChannel = KHeapDriver;
	return (aChannel ? KErrNone : KErrNoMemory);
    }

TInt DTestFactory::Install()
    {return SetName(&KHeapTestDriverName);}

void DTestFactory::GetCaps(TDes8& /*aDes*/) const	
	{}

DECLARE_STANDARD_LDD()
	{return new DTestFactory;}