// Copyright (c) 2002-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\debug\d_traceredirect.cpp
// Trace redirection LDD
// This device driver captures RDebug::Prints from user side code using the
// debug event handler.
// The text can be retrieved with the RTraceRedirect::NextTrace() function 
// TODO: Modify this LDD to use asynchronous retrieval.
// 
//

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

_LIT(KLddName,"D_TRACEREDIRECT");

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

const TInt KMaxTraceEventLength=100;
const TInt KTraceBufferSize=256;
const TInt KTraceBufferSizeMask=0xff;


class TTraceEvent
	{
public:
	TInt iLength;
	TUint16 iText[KMaxTraceEventLength];
	};

class DTraceRedirect;

class DTraceEventHandler : public DKernelEventHandler
	{
public:
	DTraceEventHandler()
		: DKernelEventHandler(HandleEvent, this) {}
	TInt Create(DLogicalDevice* aDevice);
	~DTraceEventHandler();
	TInt GetNextEvent(TAny *outdes);
private:
	static TUint HandleEvent(TKernelEvent aEvent, TAny* a1, TAny* a2, TAny* aThis);
	void HandleUserTrace(TText* aStr, TInt aLen);
public:
	DTraceRedirect *iChannel;
	TTraceEvent *iTraceBuffer;
	TInt iFront;
	TInt iBack;
	DMutex* iLock; // serialise calls to handler
	DLogicalDevice* iDevice;	// open reference to LDD for avoiding lifetime issues
	};

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

class DTraceRedirect : public DLogicalChannelBase
	{
public:
	virtual ~DTraceRedirect();
protected:
	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);
	virtual TInt Request(TInt aFunction, TAny* a1, TAny* a2);
	TInt NextTrace(TAny *outdes);
public:
	DTraceEventHandler *iEventHandler;
	};



DECLARE_STANDARD_LDD()
	{
	return new DTraceRedirectFactory;
	}

//
// DTraceRedirectFactory
//

DTraceRedirectFactory::DTraceRedirectFactory()
	{
	iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);
	}

TInt DTraceRedirectFactory::Create(DLogicalChannelBase*& aChannel)
/**
 Create a new DSchedhookTest on this logical device
*/
	{
	aChannel=new DTraceRedirect;
	return aChannel ? KErrNone : KErrNoMemory;
	}

TInt DTraceRedirectFactory::Install()
/**
 Install the LDD - overriding pure virtual
*/
	{
	return SetName(&KLddName);
	}

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


//
// DSchedhookTest
//

TInt DTraceRedirect::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& aVer)
/**
 Create channel
*/
	{
	if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber),aVer))
		return KErrNotSupported;

	iEventHandler=new DTraceEventHandler;
	if (iEventHandler == NULL)
		return KErrNoMemory;
	return iEventHandler->Create(iDevice);
	}

DTraceRedirect::~DTraceRedirect()
	{
	iEventHandler->Close();
	}

TInt DTraceEventHandler::Create(DLogicalDevice* aDevice)
	{
	TInt r;
	r = aDevice->Open();
	if (r != KErrNone)
		return r;
	iDevice = aDevice;
	iFront=0;
	iBack=0;
	iTraceBuffer=new TTraceEvent[KTraceBufferSize];
	if (iTraceBuffer == NULL)
		return KErrNoMemory;
	_LIT(KDataMutexName, "EventHandlerMutex");
	r = Kern::MutexCreate(iLock, KDataMutexName, KMutexOrdDebug);
	if (r != KErrNone)
		return r;
	return Add();
	}

DTraceEventHandler::~DTraceEventHandler()
	{
	if (iLock)
		iLock->Close(NULL);
	delete [] iTraceBuffer;
	if (iDevice)
		iDevice->Close(NULL);
	}

TUint DTraceEventHandler::HandleEvent(TKernelEvent aEvent, TAny* a1, TAny* a2, TAny* aThis)
	{
	if (aEvent==EEventUserTrace)
		{
		((DTraceEventHandler*)aThis)->HandleUserTrace((TText*)a1, (TInt)a2);
		return ETraceHandled;
		}
	return ERunNext;
	}

// called in CS
void DTraceEventHandler::HandleUserTrace(TText* aStr, TInt aLen)
	{
	Kern::MutexWait(*iLock);
	TInt frontplus1=(iFront+1)&KTraceBufferSizeMask;
	if (frontplus1!=iBack)  // check overflow
		{
		TTraceEvent *e=&iTraceBuffer[iFront];
		XTRAPD(r, XT_DEFAULT, kumemget(e->iText, aStr, aLen*2));
		if (r == KErrNone)
			e->iLength=aLen;
		else
			e->iLength = -1; // an error will be reported in GetNextEvent()
		iFront=frontplus1;
		}
	Kern::MutexSignal(*iLock);
	}

TInt DTraceEventHandler::GetNextEvent(TAny *outdes)
	{

	if (iBack==iFront)
		{ // buffer empty
		return KErrNone;
		}
	TTraceEvent *e=&iTraceBuffer[iBack];
	if (e->iLength == -1)
		return KErrCorrupt; // earlier error when copying trace data from userland
	TPtr ptr((TUint8*)e->iText, e->iLength, e->iLength);
	TInt r=KErrNone;
	Kern::KUDesPut(*(TDes *)outdes, ptr);
	iBack=(iBack+1)&KTraceBufferSizeMask;
	return r;
	}

TInt DTraceRedirect::NextTrace(TAny *outdes)
	{

	TInt r=iEventHandler->GetNextEvent(outdes);
	return r;
	}

TInt DTraceRedirect::Request(TInt aFunction, TAny* a1, TAny* /*a2*/)
/**
 Handle requests from the test program
*/
	{
	TInt r=KErrNone;
	switch (aFunction)
		{
		case RTraceRedirect::ENextTrace:
			r=NextTrace(a1);
			break;
		default:
			r=KErrNotSupported;
			break;
		}
	return r;
	}