// Copyright (c) 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_shbuf.cpp

//

#include "d_shbuf.h"

#include <kernel/kernel.h>

#include <kernel/cache.h>

#include "plat_priv.h"

#include <kernel/sshbuf.h>

#define TEST_EXP(a)					CheckPoint(a, __LINE__)

#define TEST_KERRNONE(a)			CheckPointError(a, __LINE__)

#ifdef TEST_CLIENT_THREAD

#define TEST_ENTERCS()	NKern::ThreadEnterCS()

#define TEST_LEAVECS()	NKern::ThreadLeaveCS()

#else

#define TEST_ENTERCS()

#define TEST_LEAVECS()

#endif // TEST_CLIENT_THREAD

const TInt KMaxPhysicalMemoryBlockSize = 512 << 10; // 512KB;

// ----------------------------------------------------------------------------

class DShBufTestDrvFactory : public DLogicalDevice

	{

public:

	DShBufTestDrvFactory();

	~DShBufTestDrvFactory();

	virtual TInt Install();

	virtual void GetCaps(TDes8& aDes) const;

	virtual TInt Create(DLogicalChannelBase*& aChannel);

public:

#ifndef TEST_CLIENT_THREAD

	TDynamicDfcQue* iDfcQ;

#endif

	};

// ----------------------------------------------------------------------------

#ifdef TEST_CLIENT_THREAD

class DShBufTestDrvChannel : public DLogicalChannelBase

#else

class DShBufTestDrvChannel : public DLogicalChannel

#endif

	{

public:

	DShBufTestDrvChannel();

	~DShBufTestDrvChannel();

	// Inherited from DLogicalChannel

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

#ifdef TEST_CLIENT_THREAD

	// Inherited from DLogicalChannelBase: process all DoControl in the user's context

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

#else

	TInt DoControl(TInt aReqNo, TAny* a1, TAny* a2);

	virtual void HandleMsg(TMessageBase* aMsg);

    virtual TInt SendMsg(TMessageBase* aMsg);

#endif

public:

	TShPoolCreateInfo* iCreateinfo;

	TShPoolInfo iUserpoolinfo;

	TShPool* iPools[2];

	TShBuf* iAdopted;

	TUint8  iDriverTxBuffer[8192];

	TUint8  iDriverRxBuffer[8192];

#ifndef TEST_CLIENT_THREAD

	DThread* iClient;

	TVirtualPinObject* iPin;

#endif

	};

// ----------------------------------------------------------------------------

void CheckPoint(TInt aCondition, TInt aLine)

	{

	if (!aCondition)

		{

		Kern::Printf("Device driver test failed (line %d)", aLine);

		}

	}

void CheckPointError(TInt aErrorCode, TInt aLine)

	{

	if (aErrorCode != KErrNone)

		{

		Kern::Printf("Device driver error %d (line %d)", aErrorCode, aLine);

		}

	}

TInt Log2(TInt aNum)

	{

	TInt res = -1;

	while(aNum)

		{

		res++;

		aNum >>= 1;

		}

	return res;

	}

TInt RoundUp(TInt aNum, TInt aAlignmentLog2)

	{

	if (aNum % (1 << aAlignmentLog2) == 0)

		{

		return aNum;

		}

	return (aNum & ~((1 << aAlignmentLog2) - 1)) + (1 << aAlignmentLog2);

	}

#ifdef __WINS__

#define SHBUF_NOT_WINS(x)

#else

#define SHBUF_NOT_WINS(x)	x

#endif

TBool IsBufferContiguous(TShBuf* SHBUF_NOT_WINS(aBuf))

	{

	TInt pagesize;

	TInt r = Kern::HalFunction(EHalGroupKernel, EKernelHalPageSizeInBytes, &pagesize, 0);

	TEST_KERRNONE(r);

#ifdef __WINS__

	return ETrue;

#else

	TUint8* ptr = Kern::ShBufPtr(aBuf);

	TUint size = Kern::ShBufSize(aBuf);

	TBool iscontiguous = ETrue;

	TPhysAddr startphys = Epoc::LinearToPhysical((TLinAddr) ptr);

	TUint i;

	for (i = 0; i < size; i += pagesize)

		{

		TPhysAddr current = Epoc::LinearToPhysical((TLinAddr) ptr + i);

		if (current != startphys + i)

			{

			Kern::Printf("Page %d: 0x%08x (started@0x%08x expected 0x%08x)", i, current, startphys, startphys + i);

			iscontiguous = EFalse;

			break;

			}

		}

	return iscontiguous;

#endif // __WINS__

	}

DECLARE_STANDARD_LDD()

	{

	return new DShBufTestDrvFactory;

	}

DShBufTestDrvFactory::DShBufTestDrvFactory()

	{

	iParseMask=0; //no units, no info, no pdd

	iUnitsMask=0;

	iVersion=TVersion(1,0,KE32BuildVersionNumber);

	}

DShBufTestDrvFactory::~DShBufTestDrvFactory()

	{

#ifndef TEST_CLIENT_THREAD

	if (iDfcQ)

		iDfcQ->Destroy();

#endif

	}

#ifndef TEST_CLIENT_THREAD

const TInt KShBufTestThreadPriority = 1;

_LIT(KShBufTestThread,"ShBufTestThread");

#endif

TInt DShBufTestDrvFactory::Install()

	{

#ifndef TEST_CLIENT_THREAD

	TInt r = Kern::DynamicDfcQCreate(iDfcQ, KShBufTestThreadPriority, KShBufTestThread);

	if (r != KErrNone)

		return r;

	return(SetName(&KTestShBufOwn));

#else

	return(SetName(&KTestShBufClient));

#endif

	}

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

	{

	// Get capabilities - overriding pure virtual

	}

TInt DShBufTestDrvFactory::Create(DLogicalChannelBase*& aChannel)

	{

	aChannel=new DShBufTestDrvChannel;

	return aChannel?KErrNone:KErrNoMemory;

	}

// ----------------------------------------------------------------------------

DShBufTestDrvChannel::DShBufTestDrvChannel()

	{

#ifndef TEST_CLIENT_THREAD

	iClient=&Kern::CurrentThread();

	iClient->Open();

#endif

	TPtr8 bufp(iDriverRxBuffer,0,sizeof(iDriverRxBuffer));

	for(TInt pos = 0;  pos < bufp.Length();  pos++)

		{

		bufp[pos] = (TUint8)(pos & 31);

		}

	}

DShBufTestDrvChannel::~DShBufTestDrvChannel()

	{

	NKern::ThreadEnterCS();

#ifndef TEST_CLIENT_THREAD

	Kern::SafeClose((DObject*&)iClient, NULL);

	if(iPin)

		{

		Kern::DestroyVirtualPinObject(iPin);

		}

#endif

	delete iCreateinfo;

	NKern::ThreadLeaveCS();

	}

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

	{

#ifndef TEST_CLIENT_THREAD

	SetDfcQ(((DShBufTestDrvFactory*)iDevice)->iDfcQ);

	iMsgQ.Receive();

#endif

	return KErrNone;

	}

#ifndef TEST_CLIENT_THREAD

void DShBufTestDrvChannel::HandleMsg(TMessageBase* aMsg)

	{

    TInt r=KErrNone;

	TThreadMessage& m=*(TThreadMessage*)aMsg;

	TInt id=m.iValue;

	if (id==(TInt)ECloseMsg)

		{

		m.Complete(KErrNone,EFalse);

		return;

		}

	else

		{

		r=DoControl(id,m.Ptr0(),m.Ptr1());

		}

	m.Complete(r,ETrue);

	}

TInt DShBufTestDrvChannel::SendMsg(TMessageBase* aMsg)

	{

	// We can only handle one request at a time.

	TEST_EXP(!iCreateinfo && !iPin);

	if(iCreateinfo || iPin)

		{

		return KErrInUse;

		}

	TThreadMessage& m = *(TThreadMessage*)aMsg;

	TAny* a1 = m.Ptr0();

	TAny* a2 = m.Ptr1();

	TInt r = KErrNone;

	// Make a copy of the parameters in the asynchronous read case so that we don't

	// risk a page fault by reading user-mode memory from the msg DFC.

	//

	// Manage writes using a TClientBufferRequest.

	switch(aMsg->iValue)

		{

		// Reads

		case RShBufTestChannel::ETestOpenUserPool:

			kumemget(&iUserpoolinfo, a2, sizeof(iUserpoolinfo));

		break;

		case RShBufTestChannel::ETestCreatePoolContiguousPool:

			NKern::ThreadEnterCS();

			iCreateinfo = new TShPoolCreateInfo;

			NKern::ThreadLeaveCS();

			TEST_EXP(iCreateinfo != NULL);

			if(!iCreateinfo)

				{

				r = KErrNoMemory;

				break;

				}

			kumemget(iCreateinfo, a1, sizeof(TShPoolInfo));

		break;

		case RShBufTestChannel::EFromTPtr8ProcessAndRelease:

			{

			TPtr8 dest(iDriverTxBuffer, sizeof(iDriverTxBuffer));

			Kern::ThreadDesRead(iClient, a1, dest, 0, KChunkShiftBy0);

			}

		break;

		// Writes

		case RShBufTestChannel::ETestOpenKernelPool:

			NKern::ThreadEnterCS();

			iCreateinfo = new TShPoolCreateInfo;

			NKern::ThreadLeaveCS();

			TEST_EXP(iCreateinfo != NULL);

			if(!iCreateinfo)

				{

				r = KErrNoMemory;

				break;

				}

			kumemget(iCreateinfo, a1, sizeof(TShPoolInfo));

			// Fallthrough...

		case RShBufTestChannel::ETestAllocateMax:

		case RShBufTestChannel::ETestAllocateKernelBuffer:

			{

			NKern::ThreadEnterCS();

			r = Kern::CreateAndPinVirtualMemory(iPin, (TLinAddr)a2, sizeof(TInt));

			NKern::ThreadLeaveCS();

			}

		break;

		// Descriptor writes

		case RShBufTestChannel::EFromTPtr8ProcessAndReturn:

			{

			if(size <= sizeof(iDriverRxBuffer))

				{

				NKern::ThreadEnterCS();

				NKern::ThreadLeaveCS();

				}

			else

				{

				r = KErrNoMemory;

				}

			}

		break;

		}

	if(r == KErrNone)

		{

		r = DLogicalChannel::SendMsg(aMsg);

		}

	return r;

	}

#endif

#ifdef TEST_CLIENT_THREAD

TInt DShBufTestDrvChannel::Request(TInt aReqNo, TAny* a1, TAny* a2)

#else

TInt DShBufTestDrvChannel::DoControl(TInt aReqNo, TAny* a1, TAny* a2)

#endif

	{

	TInt r=KErrNotSupported;

	switch (aReqNo)

		{

// ----------------------------------------------------------------------------

// TInt RShBufTestChannel::OpenUserPool(TInt aHandle, TShPoolInfo& aPoolInfo)

		case RShBufTestChannel::ETestOpenUserPool:

			{

			DThread* tP=NULL;

#ifdef TEST_CLIENT_THREAD

			kumemget(&iUserpoolinfo, a2, sizeof(iUserpoolinfo));

			tP=&Kern::CurrentThread();

#else

			tP=iClient;

#endif

			TEST_EXP(!iPools[0]);

			if(iPools[0])

				{

				r = KErrAlreadyExists;

				break;

				}

			NKern::ThreadEnterCS();

			r = Kern::ShPoolOpen(iPools[0], tP, (TInt) a1, ETrue, KDefaultPoolHandleFlags);

			NKern::ThreadLeaveCS();

			TEST_KERRNONE(r);

			if (r)

				{

				break;

				}

			TInt n;

			n = reinterpret_cast<DShPool*>(iPools[0])->AccessCount();

			TEST_EXP(n == 2);

			if (n != 2)

				{

				r = KErrUnknown;

				break;

				}

			TShPoolInfo poolinfo;

			Kern::ShPoolGetInfo(iPools[0], poolinfo);

			if (!((poolinfo.iBufSize == iUserpoolinfo.iBufSize) &&

				((TUint)Kern::ShPoolBufSize(iPools[0]) == iUserpoolinfo.iBufSize) &&

				(poolinfo.iInitialBufs == iUserpoolinfo.iInitialBufs) &&

				(poolinfo.iMaxBufs == iUserpoolinfo.iMaxBufs) &&

				(poolinfo.iGrowTriggerRatio == iUserpoolinfo.iGrowTriggerRatio) &&

				(poolinfo.iGrowByRatio == iUserpoolinfo.iGrowByRatio) &&

				(poolinfo.iShrinkHysteresisRatio == iUserpoolinfo.iShrinkHysteresisRatio) &&

				(poolinfo.iAlignment == iUserpoolinfo.iAlignment) &&

				((poolinfo.iFlags & EShPoolNonPageAlignedBuffer) == (iUserpoolinfo.iFlags & EShPoolNonPageAlignedBuffer)) &&

				((poolinfo.iFlags & EShPoolPageAlignedBuffer) == (iUserpoolinfo.iFlags & EShPoolPageAlignedBuffer))))

				{

				TEST_EXP(EFalse);

				Kern::Printf("poolinfo.iBufSize == %d (expected %d)", poolinfo.iBufSize, iUserpoolinfo.iBufSize);

				Kern::Printf("BufSize() == %d", Kern::ShPoolBufSize(iPools[0]));

				Kern::Printf("poolinfo.iInitialBufs == %d (expected %d)", poolinfo.iInitialBufs, iUserpoolinfo.iInitialBufs);

				Kern::Printf("poolinfo.iMaxBufs == %d (expected %d)", poolinfo.iMaxBufs, iUserpoolinfo.iMaxBufs);

				Kern::Printf("poolinfo.iGrowTriggerRatio == %d (expected %d)", poolinfo.iGrowTriggerRatio, iUserpoolinfo.iGrowTriggerRatio);

				Kern::Printf("poolinfo.iGrowByRatio == %d (expected %d)", poolinfo.iGrowByRatio, iUserpoolinfo.iGrowByRatio);

				Kern::Printf("poolinfo.iShrinkHysteresisRatio == %d (expected %d)", poolinfo.iShrinkHysteresisRatio, iUserpoolinfo.iShrinkHysteresisRatio);

				Kern::Printf("poolinfo.iAlignment == %d (expected %d)", poolinfo.iAlignment, iUserpoolinfo.iAlignment);

				Kern::Printf("poolinfo.iFlags == 0x%08x (user=0x%08x)", poolinfo.iFlags, iUserpoolinfo.iFlags);

				r = KErrUnknown;

				break;

				}

			if(poolinfo.iFlags & EShPoolPageAlignedBuffer)

				{

				NKern::ThreadEnterCS();

				r = Kern::ShPoolSetBufferWindow(iPools[0],-1);

				NKern::ThreadLeaveCS();

				TEST_KERRNONE(r);

				if(r!=KErrNone)

					break;

				}

			r = KErrNone;

			}

		break;

// ----------------------------------------------------------------------------

// TInt RShBufTestChannel::OpenKernelPool(TShPoolCreateInfo& aInfo, TInt& aHandle)

		case RShBufTestChannel::ETestOpenKernelPool:

			{

			TInt handle;

#ifdef TEST_CLIENT_THREAD

			// We can only handle one request at a time.

			TEST_EXP(!iCreateinfo);

			if(iCreateinfo)

				{

				r = KErrInUse;

				break;

				}

			NKern::ThreadEnterCS();

			iCreateinfo = new TShPoolCreateInfo;

			NKern::ThreadLeaveCS();

			TEST_EXP(iCreateinfo != NULL);

			if(!iCreateinfo)

				{

				r = KErrNoMemory;

				break;

				}

			kumemget(iCreateinfo, a1, sizeof(TShPoolInfo));

#endif

			TEST_EXP(!iPools[1]);

			if(iPools[1])

				{

				r = KErrAlreadyExists;

				break;

				}

			NKern::ThreadEnterCS();

			r = Kern::ShPoolCreate(iPools[1], *iCreateinfo, ETrue, KDefaultPoolHandleFlags);

			delete iCreateinfo;

			iCreateinfo = NULL;

			NKern::ThreadLeaveCS();

			TEST_KERRNONE(r);

			if (r)

				{

#ifndef TEST_CLIENT_THREAD

					NKern::ThreadEnterCS();

					Kern::DestroyVirtualPinObject(iPin);

					NKern::ThreadLeaveCS();

#endif

				break;

				}

			TInt n;

			n = reinterpret_cast<DShPool*>(iPools[1])->AccessCount();

			TEST_EXP(n == 1);

			if (n != 1)

				{

#ifndef TEST_CLIENT_THREAD

					NKern::ThreadEnterCS();

					Kern::DestroyVirtualPinObject(iPin);

					NKern::ThreadLeaveCS();

#endif

				r = KErrUnknown;

				break;

				}

			TShPoolInfo poolinfo;

			Kern::ShPoolGetInfo(iPools[1], poolinfo);

			if(poolinfo.iFlags & EShPoolPageAlignedBuffer)