// Copyright (c) 2007-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\misc\d_gobble.cpp
// LDD for gobbling RAM
// 
//

#include "platform.h"
#include <kernel/kern_priv.h>
#include "d_gobble.h"

const TInt KMajorVersionNumber=0;
const TInt KMinorVersionNumber=1;
const TInt KBuildVersionNumber=1;

class DGobblerFactory : public DLogicalDevice
//
// Gobbler LDD factory
//
	{
public:
	DGobblerFactory();
	~DGobblerFactory();
	virtual TInt Install();
	virtual void GetCaps(TDes8& aDes) const;
	virtual TInt Create(DLogicalChannelBase*& aChannel);
	};

class DGobbler : public DLogicalChannelBase
//
// RAM Gobbler LDD channel
//
	{
public:
	DGobbler();
	virtual ~DGobbler();
private:
	virtual TInt Request(TInt aFunc, TAny* a1, TAny* a2);
	virtual TInt DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer);
private:
	enum {ESmallBufferSize = 64};

	TUint32 Gobble(TUint32 aLeave);
#ifdef __EPOC32__
	TInt GobbleMultiPages(TUint32& aTake, TUint32* aMultiPageBuf, TInt aMaxMultiPages);
	void FreeMultiPage(TPhysAddr aMultiPage);
	TUint32 AllocMultiPage(TUint32 aSize);
	TUint32 Size(TUint32 aMultiPage);
#endif
private:
#ifdef __EPOC32__
	TPhysAddr iPhys[ESmallBufferSize];
#endif
	DChunk* iSharedChunk;
	TUint32 iPageShift;
	TUint32 iPageSize;
	};

DGobblerFactory::DGobblerFactory()
    {
    iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);
    //iParseMask=0;//No units, no info, no PDD
    //iUnitsMask=0;//Only one thing
    }

DGobblerFactory::~DGobblerFactory()
	{
	}

TInt DGobblerFactory::Create(DLogicalChannelBase*& aChannel)
    {
	aChannel = new DGobbler;
    return aChannel ? KErrNone : KErrNoMemory;
    }

TInt DGobblerFactory::Install()
//
// Install the LDD - overriding pure virtual
//
    {
    return SetName(&KGobblerLddName);
    }

void DGobblerFactory::GetCaps(TDes8& aDes) const
//
// Get capabilities - overriding pure virtual
//
    {
    TCapsGobblerV01 b;
    b.iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);
    Kern::InfoCopy(aDes,(TUint8*)&b,sizeof(b));
    }

DGobbler::DGobbler()
    {
	iPageSize = Kern::RoundToPageSize(1);
	iPageShift = __e32_find_ms1_32(iPageSize);
    }

DGobbler::~DGobbler()
	{
	// Free all the RAM we've gobbled

#ifdef __EPOC32__
	// Free the addresses held in the shared chunk
	if (iSharedChunk)
		{
		TLinAddr ka;
		TInt r = Kern::ChunkAddress(iSharedChunk, 0, 1, ka);
		if (r==KErrNone)
			{
			const TUint32* p = (const TUint32*)ka;
			const TUint32* pE = p + (iSharedChunk->Size() / sizeof(TUint32));
			while (p<pE)
				{
				TUint32 mp = *p++;
				if (mp)
					FreeMultiPage(mp);
				}
			}
		}
#endif
	if (iSharedChunk)
		Kern::ChunkClose(iSharedChunk);
#ifdef __EPOC32__
	TInt i;
	for (i=0; i<ESmallBufferSize; ++i)
		{
		TUint32 mp = iPhys[i];
		if (mp)
			FreeMultiPage(mp);
		}
#endif
	}

TInt DGobbler::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)
//
// Create channel
//
    {

    if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber),aVer))
    	return KErrNotSupported;
	return KErrNone;
	}


#ifdef __EPOC32__
void DGobbler::FreeMultiPage(TPhysAddr aMultiPage)
	{
	TPhysAddr base = (aMultiPage>>iPageShift) << iPageShift;
	TUint32 size = Size(aMultiPage);
	Epoc::FreePhysicalRam(base, size);
	}

TUint32 DGobbler::AllocMultiPage(TUint32 aSize)
	{
	TUint32 sz = 1u << __e32_find_ms1_32(aSize);	// round size down to power of 2
	while (sz >= iPageSize)
		{
		TPhysAddr pa;
		TInt r = Epoc::AllocPhysicalRam(sz, pa);
		if (r == KErrNone)
			return pa | __e32_find_ms1_32(sz);
		sz >>= 1;
		}
	return 0;
	}

TUint32 DGobbler::Size(TUint32 aMultiPage)
	{
	return 1u << (aMultiPage & 0x1f);
	}
#endif

#ifdef __EPOC32__
TInt DGobbler::GobbleMultiPages(TUint32& aTake, TUint32* aMultiPageBuf, TInt aMaxMultiPages)
	{
	TInt i = 0;
	TUint32 mp = 0;
	while (i<aMaxMultiPages && aTake)
		{
		mp = AllocMultiPage(aTake);
		if (mp==0)
			break;	// someone else gobbled all the RAM
		aTake -= Size(mp);
		aMultiPageBuf[i] = mp;
		++i;
		}
	if (mp == 0)
		return KErrNoMemory;	// someone else gobbled all the RAM
	if (aTake==0)
		return KErrNone;
	return KErrOverflow;		// buffer filled up
	}
#endif

TUint32 DGobbler::Gobble(TUint32 aLeave)
	{
	TUint32 free = Kern::FreeRamInBytes();
	if (free < aLeave)
		return 0;	// no need to gobble anything
	TUint32 take = free - aLeave;
	TUint32 take2 = take;
	TInt r = KErrNone;
#ifdef __EPOC32__
	r = GobbleMultiPages(take2, iPhys, ESmallBufferSize);
	if (r==KErrNoMemory)
		return take - take2;	// someone else gobbled all the RAM
	if (r==KErrNone)
		return take;			// small buffer did the job

	TUint32 chunkMax = (take >> iPageShift) * sizeof(TPhysAddr);
#else
	TUint32 chunkMax = take;
#endif
	TChunkCreateInfo info;
	info.iType = TChunkCreateInfo::ESharedKernelSingle;
	info.iMaxSize = chunkMax;
#ifdef __EPOC32__
	info.iMapAttr = EMapAttrCachedMax;
#else
	info.iMapAttr = 0;
#endif
	info.iOwnsMemory = 1;
	info.iDestroyedDfc = 0;
	TLinAddr ka = 0;
	TUint32 ma = 0;
	r = Kern::ChunkCreate(info, iSharedChunk, ka, ma);
	if (r!=KErrNone)
		return take - take2;	// someone else gobbled all the RAM
	TUint32 chunkSz = (chunkMax + iPageSize - 1) &~ (iPageSize - 1);
	r = Kern::ChunkCommit(iSharedChunk, 0, chunkSz);
	if (r!=KErrNone)
		return take - take2;	// someone else gobbled all the RAM
#ifndef __EPOC32__
	return take;				// on emulator we are finished here
#else
	TUint32* p = (TUint32*)ka;
	memclr(p, chunkSz);
	r = GobbleMultiPages(take2, p, chunkSz/sizeof(TUint32));
	if (r==KErrNoMemory)
		return take - take2;	// someone else gobbled all the RAM
	return take; // done
#endif
	}

TInt DGobbler::Request(TInt aFunc, TAny* a1, TAny*)
	{
	if (aFunc == RGobbler::EControlGobbleRAM)
		{
		NKern::ThreadEnterCS();
		TUint32 ret = Gobble(TUint32(a1));
		NKern::ThreadLeaveCS();
		return ret;
		}
	else
		return KErrNotSupported;
	}

DECLARE_STANDARD_LDD()
	{
    return new DGobblerFactory;
    }