// Copyright (c) 2005-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\demandpaging\d_ramsterss.cpp

 // 

 //

 #include <kernel/kern_priv.h>

 #include <kernel/cache.h>

 #include "t_ramstress.h"

 //

 // Class definitions

 //

 class DRamStressTestFactory : public DLogicalDevice

 	{

 public:

 	~DRamStressTestFactory();

 	virtual TInt Install();

 	virtual void GetCaps(TDes8& aDes) const;

 	virtual TInt Create(DLogicalChannelBase*& aChannel);

 	};

 class DRamStressTestChannel : public DLogicalChannelBase

 	{

 public:

 	DRamStressTestChannel();

 	~DRamStressTestChannel();

 	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

 	virtual TInt Request(TInt aFunction, TAny* a1, TAny* a2);

 	TInt FreeRam();

 	TInt DoSetDebugFlag(TInt aState);

 	TInt DoSetEndFlag(TInt aState);

 public:

 	DRamStressTestFactory*	iFactory;

 private:

 	TInt DoMovePagesInZone(TUint aZoneIndex);

 	TInt DoPageMove(TLinAddr aAddr);

 	TInt DoAllocPagesInZone(TUint aZoneIndex);

 private:

 	TInt		 iDebug;

 	TInt		 iFinish;

 	TInt		 iThreadCounter;

 	TInt		 iPageSize;

 	};

 //

 // DRamStressTestFactory

 //

 TInt DRamStressTestFactory::Install()

 	{

 	return SetName(&KRamStressTestLddName);

 	}

 DRamStressTestFactory::~DRamStressTestFactory()

 	{

 	}

 void DRamStressTestFactory::GetCaps(TDes8& /*aDes*/) const

 	{

 	// Not used but required as DLogicalDevice::GetCaps is pure virtual

 	}

 TInt DRamStressTestFactory::Create(DLogicalChannelBase*& aChannel)

 	{

 	aChannel = NULL;

 	DRamStressTestChannel* channel=new DRamStressTestChannel;

 	if(!channel)

 		return KErrNoMemory;

 	channel->iFactory = this;

 	aChannel = channel;

 	return KErrNone;

 	}

 DECLARE_STANDARD_LDD()

 	{

 	return new DRamStressTestFactory;

 	}

 //

 // DRamStressTestChannel

 //

 TInt DRamStressTestChannel::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)

 	{

 	return KErrNone;

 	}

 //

 // DRamStressTestChannel::DRamStressTestChannel()

 //

 DRamStressTestChannel::DRamStressTestChannel()

 	: iDebug(0), iFinish(0), iThreadCounter(1), iPageSize(0)

 	{

 	TInt pageSize = 0;

 	if (Kern::HalFunction(EHalGroupKernel,EKernelHalPageSizeInBytes,&pageSize,0) == KErrNone)

 		{

 		iPageSize = pageSize;

 		}

 	}

 //

 // DRamStressTestChannel::~DRamStressTestChannel()

 //

 DRamStressTestChannel::~DRamStressTestChannel()

 	{

 	}

 //

 // DRamStressTestChannel::Request

 //

 TInt DRamStressTestChannel::Request(TInt aFunction, TAny* a1, TAny* a2)

 	{

 	TInt threadCount = __e32_atomic_tas_ord32(&iThreadCounter, 1, 1, 0);

 	if (threadCount >= 2)

 		if (iDebug)

 			Kern::Printf("DRamStressTestChannel::Request threadCount = %d\n", threadCount);

 	NKern::ThreadEnterCS();

 	TInt retVal = KErrNotSupported;

 	switch(aFunction)

 		{

 		case RRamStressTestLdd::EDoMovePagesInZone:

 			{

 			retVal = DoMovePagesInZone((TUint)a1);

 			}

 		break;

 		case RRamStressTestLdd::EDoSetDebugFlag:

 			{

 			retVal = DoSetDebugFlag((TInt) a1);

 			}

 		break;

 		case RRamStressTestLdd::EDoSetEndFlag:

 			{

 			retVal = DoSetEndFlag((TInt) a1);

 			}

 		break;

 		default: break;

 		}

 	NKern::ThreadLeaveCS();

 	__e32_atomic_tas_ord32(&iThreadCounter, 1, -1, 0);

 	return retVal;

 	}

 TInt DRamStressTestChannel::DoAllocPagesInZone(TUint aZoneIndex)

 	{

 	TInt retVal = KErrNone;

 	return retVal;

 	}

 //

 // DRamStressTestChannel::DoMovePagesInZone

 //

 TInt DRamStressTestChannel::DoMovePagesInZone(TUint aZoneIndex)

 	{

 	if (iDebug)

 		{

 		Kern::Printf("DRamStressTestChannel::DoMovePagesInZone(%d)", aZoneIndex);

 		}

 	// first get info on the 2 zones....

 	struct SRamZoneConfig	zoneConfig;

 	TInt retVal;

 	if (KErrNone != Kern::HalFunction(EHalGroupRam,ERamHalGetZoneConfig,(TAny*)aZoneIndex, (TAny*)&zoneConfig))

 		{

 		Kern::Printf("Error ::: DoMovePagesInZone : bad zone %d", aZoneIndex); 

 		retVal = KErrArgument;

 		}

 	else

 		{

 		//Kern::Printf("DoMovePagesInZone : zone %d", aZoneIndex); 

 		TPhysAddr addr = zoneConfig.iPhysBase;

 		TUint moved = 0;

 		TUint failed = 0;

 		TUint unused = 0;

 		TUint bad = 0;

 		TUint nosupport = 0;

 		retVal = KErrNone;

 		while (addr < zoneConfig.iPhysEnd)

 			{

 			//Kern::Printf("DoMovePagesInZone(%d) moving 0x%08x", aZoneIndex, addr);

 			retVal = DoPageMove(addr);

 			if (retVal == KErrNone)

 				{

 				moved ++;

 				}

 			else

 				{

 				switch (retVal)

 					{

 					case KErrArgument:

 						bad ++;		

 					break;

 					case KErrNotFound:

 						unused ++;	

 					break;

 					case KErrNotSupported:

 						nosupport ++;

 					break;

 					case KErrGeneral:

 					default:

 						failed ++;

 						if (iDebug)

 							{

 							Kern::Printf("DRamStressTestChannel::DoMovePagesInZone(%d) failed 0x%08x err=%d", aZoneIndex, addr, retVal);

 							}

 					break;

 					}

 				}

 			addr += iPageSize;

 			NKern::Sleep(1);

 			if (iFinish)

 				{

 				Kern::Printf("DRamStressTestChannel::DoMovePagesInZone(%d) Finishing", aZoneIndex);

 				break;

 				}

 			}

 		if (iDebug)

 			{

 			Kern::Printf("DRamStressTestChannel::DoMovePagesInZone(%d) moved %u failed %u bad %u unused %u nosupport %u", aZoneIndex, moved, failed, bad, unused, nosupport);

 			}

 		retVal = (failed==0) ? KErrNone : KErrGeneral;

 		}

 	return retVal;

 	}

 //

 // DRamStressTestChannel::DoPageMove

 //

 TInt DRamStressTestChannel::DoPageMove(TPhysAddr aAddr)

 	{

 	aAddr = _ALIGN_DOWN(aAddr, iPageSize);

 	TInt r;

 	TPhysAddr aNew;

 	r=Epoc::MovePhysicalPage(aAddr, aNew);

 	if ((r==KErrNone) && (aNew == aAddr))

 		{

 		Kern::Printf("DRamStressTestChannel::DoPageMove moved bad 0x%08x now 0x%08x ", aAddr, aNew);

 		r=KErrGeneral;

 		}

 	return r;

 	}

 TInt DRamStressTestChannel::FreeRam()

 	{

 	return Kern::FreeRamInBytes();

 	}

 TInt DRamStressTestChannel::DoSetDebugFlag(TInt aState)

 	{

 	iDebug = aState;

 	return KErrNone;

 	}

 TInt DRamStressTestChannel::DoSetEndFlag(TInt aState)

 	{

 	iFinish = aState;

 	return KErrNone;

 	}