// 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

		{

		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;

    }