// debugRouter.cpp

// 

// Copyright (c) 2007 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include <nkern.h>

#include <kernel.h>

#include <kern_priv.h>

#include <fshell/common.mmh>

#include <e32cmn.h>

#include "debugRouter.h"

#include <platform.h>

#include "dobject_compat.h"

#include "debugRouter-kext.h"

using namespace CloggerDebugRouter;

//define this to get log output

//#define DO_LOGGING

#ifdef DO_LOGGING

#	define LOG Kern::Printf

#else

#	ifdef __WINS__

		inline void LOG(...) {}

#	else

#		define LOG(args...)

#	endif

#endif

#undef ASSERT

#define ASSERT __NK_ASSERT_DEBUG

EXPORT_C extern const TInt KChunkSize; // See patchables.cpp

EXPORT_C extern const TInt KIsrBufSize; // Likewise

EXPORT_C extern const TBool KEnableEarlyRdebug; // Likewise

////////////////////////////////////////////////

const TInt KMajorVersionNumber=1;

const TInt KMinorVersionNumber=0;

const TInt KBuildVersionNumber=0;

_LIT(KPanicCategory,"CloggerRouter");

const TUid KCloggerUid = { FSHELL_UID_CLOGGERSERVER };

class DCloggerDebugRouter;

class DCloggerDebugRouterLDD;

DCloggerDebugRouter* gRouter = NULL;

// DCloggerDebugRouterFactory

//

NONSHARABLE_CLASS(DCloggerDebugRouterFactory) : public DLogicalDevice

    {

public:

    DCloggerDebugRouterFactory();

private:

    TInt Install();                     //overriding pure virtual

    void GetCaps(TDes8& aDes) const;    //overriding pure virtual

    TInt Create(DLogicalChannelBase*& aChannel);         //overriding pure virtual

private:

	DOBJECT_PADDING;

    };

const TInt KMaxCrashDumpAreas = 8;

NONSHARABLE_CLASS(DCloggerDebugRouter) : public DBase

	{

public:

	DCloggerDebugRouter();

	~DCloggerDebugRouter();

	static TInt Init();

	static TBool TraceHook(const TDesC8& aText, TTraceSource aTraceSource);

	void SetCrashDumpFunctions(TRegisterFn aRegisterFn, TUnregisterFn aUnregisterFn);

	// Functions for the LDD

	TInt OpenChunk();

	void CloseChunk();

	TInt RegisterCrashDumpAreas(const TDesC8& aAreas); // Kernel must be unlocked & system lock not held

	TDfcQue& PrivateDfcQ();

	void SetConsumeLogs(TBool aConsume);

	void SetEnabled(TBool aEnabled);

	void ClientRequestData(TRequestStatus* aStatus);

	// DFC callback functions

	static void HandleInterrupt(TAny* aSelf);

	static void KillThreadDFC(TAny* aSelf);

	static void CompleteClient(TAny* aSelf);

	static TBool StayEnabled();

private:

	TBool DoTraceHook(const TDesC8& aText, TTraceSource aTraceSource);

	TBool WriteOut(const TDesC8& aBuf, TInt aLengthToConsider = 0);

	void DoTrace(const TDesC8& aText, TTraceSource aTraceSource, TUint aTraceThread);

	void DoCompleteClient();

	void NotifyClient();

	TInt Construct();

	void CheckInterruptBuffer();

private:

	DChunk* iChunk;

	TLinAddr iStartAddr;

	TLinAddr iEndAddr;

	TLinAddr iCurrent;

	TLinAddr iFirstFrame; // This isn't necessarily the same as iStartAddr, because if we wrap the first thing in the buffer will be continuation and not a header

	TTraceSource iTempBufTraceSource;

	TDfcQue iPrivateDfcQ;

	TDfc iHandleInterruptDfc;

	TDfc iCompleteClientDfc;

	HBuf8* iInterruptBuf;

	//TBuf8<2048> iTempBuf; // This is used to get the data from the unknown context of the trace handler to the DFC

	// Using iTempBuf means we can minimise the amount of time we have to run with interrupts off, while at the same

	// time allowing logging from ISRs and suchlike.

#ifdef __SMP__

	TSpinLock iInterruptBufLock;

	TSpinLock iBufferLock;

#endif

	TBool iConsumeLogs;

	TUint iOverflows;

	TBool iInTheMiddleOfTracing;

	TBool iClientIsBeingNotified;

	TInt iNumCrashDumpAreas;

	SCrashDumpArea iCrashDumpAreas[KMaxCrashDumpAreas];

	TRegisterFn iRegisterCrashDumpFn;

	TUnregisterFn iUnregisterCrashDumpFn;

public: // Accessible by LDD class

	DThread* iClient;

	TLinAddr iClientStart;

	TLinAddr iClientEnd;

	TRequestStatus* iClientStatus;

	TBuf8<sizeof(SCloggerCrashDumpArea) * 8> iClientCrashDumpBuf; // For temporary use

	};

// Functions for testing purposes

void DummyRegisterCrashDump(TAny* aAddr, TUint aSize, SCrashDumpArea& aCrashDumpArea)

	{

	LOG("Registering crashdump 0x%x %d %S", aAddr, aSize, &aCrashDumpArea.iName);

	LOG("First and last words are %x %x", ((TUint*)aAddr)[0], ((TUint*)aAddr)[(aSize/4)-1]);

	}

void DummyUnregisterCrashDump(SCrashDumpArea& aCrashDumpArea)

	{

	LOG("Unregistering crashdump %S", &aCrashDumpArea.iName);

	}

// DECLARE_STANDARD_LDD

//  Standard Extension Framework export

DECLARE_STANDARD_EXTENSION()

	{

	//__BREAKPOINT();

	TInt err = DCloggerDebugRouter::Init();

#ifdef __WINS__

	// On WINS there's no way of setting the debug port to indicate we should enable ourselves.

	// Therefore we assume that if someone's gone to the trouble of adding "extension += clogger-debugrouter.ldd" to

	// their epoc.ini, then they want us to be enabled.

	if (!err)

		{

		err = gRouter->OpenChunk();

		}

	if (!err)

		{

		gRouter->SetConsumeLogs(ETrue);

		gRouter->SetEnabled(ETrue);

		}

#endif

	return err;

	}

DECLARE_EXTENSION_LDD()

	{

	//__BREAKPOINT();

	TBool ok = CalculateDObjectSize();

	if (!ok) return NULL;

	return new DCloggerDebugRouterFactory();

	}

// DCloggerDebugRouter

//

NONSHARABLE_CLASS(DCloggerDebugRouterLDD) : public DLogicalChannel

    {

public:

	DCloggerDebugRouterLDD(DCloggerDebugRouter* aRouter);

	~DCloggerDebugRouterLDD();

private:

//Framework

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

	void HandleMsg(TMessageBase* aMsg);

    void DoCancel(TInt aReqNo);

    TInt DoRequest(TInt aReqNo,TRequestStatus* aStatus,TAny* a1,TAny* a2);

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

	DCloggerDebugRouter* _iRouter;

	DOBJECT_PADDING;

	};

#define iRouter SAFE_MEMBER(_iRouter)

DCloggerDebugRouterFactory::DCloggerDebugRouterFactory()

	{

	SAFE_MEMBER(iVersion)=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

	}

TInt DCloggerDebugRouterFactory::Create(DLogicalChannelBase*& aChannel)

    {

	TInt err = DCloggerDebugRouter::Init();

	if (err) return err;

    aChannel = new DCloggerDebugRouterLDD(gRouter);

	if (aChannel==NULL)

		return KErrNoMemory;

	else

		return KErrNone;

    }

TInt DCloggerDebugRouterFactory::Install()

    {

    return(SetName(&KDebugRouterName));

    }

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

    {

/*    TCapsMemoryAccessV01 b;

    b.iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

    aDes.FillZ(aDes.MaxLength());

    aDes.Copy((TUint8*)&b,Min(aDes.MaxLength(),sizeof(b)));

*/    } 

// class DCloggerDebugRouter Implementation

DCloggerDebugRouterLDD::DCloggerDebugRouterLDD(DCloggerDebugRouter* aRouter)

    : DLogicalChannel()

    {

    //SetBehaviour(-1); //JR

	iRouter = aRouter;

    }

DCloggerDebugRouter::DCloggerDebugRouter()

	: iHandleInterruptDfc(NULL, NULL), iCompleteClientDfc(NULL, NULL)

#ifdef __SMP__

	, iInterruptBufLock(TSpinLock::EOrderGenericIrqLow0), iBufferLock(TSpinLock::EOrderGenericPreLow0)

#endif

	{

	}

const TInt KMemAccessDfcThreadPriority = 27;

// DCloggerDebugRouter::DoCreate

//  Check capabilities & version & start listening for events

TInt DCloggerDebugRouterLDD::DoCreate(TInt /*aUnit*/,const TDesC* /*anInfo*/,const TVersion& aVer)

    {

	TInt ret=KErrNone;

	/*

	//Require Power Management and All Files to use this driver

	//Not ideal, but better than nothing

	if(!Kern::CurrentThreadHasCapability(ECapabilityPowerMgmt,__PLATSEC_DIAGNOSTIC_STRING("Checked by MEMORYACCESS.LDD (Memory Access for Task Managers)")))

	    ret= KErrPermissionDenied;

	if(!Kern::CurrentThreadHasCapability(ECapabilityAllFiles,__PLATSEC_DIAGNOSTIC_STRING("Checked by MEMORYACCESS.LDD (Memory Access for Task Managers)")))

	    ret= KErrPermissionDenied;

    */

    if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber),aVer))

    	{

    	return KErrNotSupported;

    	}

	if (iRouter->iClient)

		{

		return KErrAlreadyExists;

		}

    iRouter->iClient=&Kern::CurrentThread();

   	SetDfcQ(&iRouter->PrivateDfcQ());

   	SAFE_MEMBER(iMsgQ).Receive();		

	//Kern::Printf("DCloggerDebugRouter::DoCreate %d",ret);

    return ret;

    }

TDfcQue& DCloggerDebugRouter::PrivateDfcQ()

	{

	return iPrivateDfcQ;

	}

TInt DCloggerDebugRouter::Init()

	{

	//__BREAKPOINT();

	if (gRouter) return KErrNone;

	TInt err;

#ifdef __WINS__

	// WINSCW can't handle DLLs with WSD very well, particularly dynamically loaded ones like LDDs

	RPropertyRef property; // use this to stash the pointer that DLL loading keeps stomping over

	NKern::ThreadEnterCS();

	const TInt EDebugRouterPtr = 1000; // from cliserv.h

	err = property.Open(KCloggerUid, EDebugRouterPtr);

	if (!err)

		{

		TInt& ptr = *reinterpret_cast<TInt*>(&gRouter);

		property.Get(ptr);

		}

	property.Close();

	NKern::ThreadLeaveCS();

	if (gRouter) return KErrNone;

#endif

	DCloggerDebugRouter* self = new DCloggerDebugRouter;

	if (!self) return KErrNoMemory;

	err = self->Construct();

	if (err == KErrNone && StayEnabled())

		{

		// Then enable ourselves

		err = self->OpenChunk();

		if (!err)

			{

			self->SetConsumeLogs(ETrue);

			self->SetEnabled(ETrue);

			}

		}

	if (err)

		{

		delete self;

		return err;

		}

	gRouter = self;

#ifdef __WINS__

	// See comment at top of function

	NKern::ThreadEnterCS();

	err = property.Attach(KCloggerUid, EDebugRouterPtr);

	if (!err)

		{

		_LIT_SECURITY_POLICY_FAIL(KKernOnlyPolicy);

		err = property.Define(RProperty::EInt, KKernOnlyPolicy, KKernOnlyPolicy);

		}

	if (err == KErrNone || err == KErrAlreadyExists)

		{

		TInt& ptr = *reinterpret_cast<TInt*>(&gRouter);

		property.Set(ptr);

		}

	property.Close();

	NKern::ThreadLeaveCS();

#endif

	// And finally, set up some dummy functions for debugging

#ifdef __WINS__

	CloggerDebugRouter::SetCrashDumpFunctions(&DummyRegisterCrashDump, &DummyUnregisterCrashDump);

#endif

	return KErrNone;

	}

TInt DCloggerDebugRouter::Construct()

	{

	iInterruptBuf = HBuf8::New(KIsrBufSize);

	if (!iInterruptBuf) return KErrNoMemory;

	_LIT(KDfcThreadName, "CloggerDebugRouter");

	TInt err = Kern::DfcQInit(&iPrivateDfcQ, KMemAccessDfcThreadPriority, &KDfcThreadName);

	if (err) 

		{

		return err;

		}

	iHandleInterruptDfc = TDfc(&HandleInterrupt, this, &iPrivateDfcQ, 1); // Interrupt handler DFC higher priority than completing client

	iCompleteClientDfc = TDfc(&CompleteClient, this, &iPrivateDfcQ, 0);

	return err;

	}

// dtor

//

DCloggerDebugRouter::~DCloggerDebugRouter()

    {

	//__BREAKPOINT();

	TTraceHandler old = Kern::SetTraceHandler(NULL);

	if (old != &TraceHook)

		{

		// Then set it back. What we wanted to do is if (TraceHandler == &TraceHook) { SetTraceHandler(NULL) }

		// But there is no API to get the hook without also setting it.

		Kern::SetTraceHandler(old);

		}

	CloseChunk();

	// Finally queue a DFC to kill our DFC thread

	if (iPrivateDfcQ.iThread)

		{

		TDfc killDfcThread(KillThreadDFC, this, &iPrivateDfcQ, 0); 

		killDfcThread.Enque();

		}

	}

DCloggerDebugRouterLDD::~DCloggerDebugRouterLDD()

    {

	//__BREAKPOINT();

	ASSERT(!iRouter->iClientStatus); // Should have received a close message first

	iRouter->iClient = NULL;

	}

void DCloggerDebugRouter::KillThreadDFC(TAny* /*aSelfP*/)

	{

	Kern::Exit(KErrNone);

	} 

void DCloggerDebugRouter::HandleInterrupt(TAny* aSelf)

	{

	static_cast<DCloggerDebugRouter*>(aSelf)->CheckInterruptBuffer();

	}

void DCloggerDebugRouter::CheckInterruptBuffer()

	{

	TBuf8<256> interruptBufCopy; // Using a stack buffer here means we don't have to lock the kernel just yet

#ifdef __SMP__

	TInt irq = __SPIN_LOCK_IRQSAVE(iInterruptBufLock);

#else

	TInt irq = NKern::DisableAllInterrupts(); // Prevent an interrupt changing it while we're copying it

#endif

	if (iInterruptBuf->Length() > 256)

		{

		// Need to rethink the stack buffer!

		__BREAKPOINT();

		}

	interruptBufCopy.Copy(*iInterruptBuf);

	iInterruptBuf->Zero();

	memclr((TAny*)iInterruptBuf->Ptr(), iInterruptBuf->Length()); // So that you don't see old data in the crashlog

#ifdef __SMP__

	__SPIN_UNLOCK_IRQRESTORE(iInterruptBufLock, irq);

#else

	NKern::RestoreInterrupts(irq);

#endif

	if (interruptBufCopy.Length())

		{

		//__BREAKPOINT();

		DoTrace(interruptBufCopy, EKernelTrace, 0);

		}

	}

// DCloggerDebugRouter::HandleMsg

//  Called when user side sends us something

void DCloggerDebugRouterLDD::HandleMsg(TMessageBase* aMsg)

	{

	//Kern::Printf("DCloggerDebugRouter::HandleMsg");

    TThreadMessage& m=*(TThreadMessage*)aMsg;

    // Get message type

    TInt id=m.iValue;

    // Decode the message type and dispatch it to the relevent handler function...

    // A logical channel can be closed either explicitly by its user-side client,

    // or implicitly if the client thread dies. In the latter case, the channel

    // is closed in the context of the kernel supervisor thread. 

    if (id==(TInt)ECloseMsg)

        {

        //Kern::Printf("DCloggerDebugRouter::HandleMsg Close");

        // Channel Close

        DoCancel(RCloggerDebugRouter::EAllRequests); //JR

        m.Complete(KErrNone, EFalse);

        return;

        }

    // For all other message types, we check that the message is from the thread

    // that created us.

    if(m.Client()!=iRouter->iClient)

        {

      	//Kern::Printf("DCloggerDebugRouter::HandleMsg About");

        Kern::ThreadKill(m.Client(),EExitPanic,ERequestFromWrongThread,KPanicCategory);

        m.Complete(KErrNone,ETrue);

        return;

        }

    if (id==KMaxTInt)

        {

        //Kern::Printf("DCloggerDebugRouter::HandleMsg Cancel");

        // DoCancel

        DoCancel(m.Int0());

        m.Complete(KErrNone,ETrue);

        return;

        }

    if (id<0)

        {

        // DoRequest

        //Kern::Printf("DCloggerDebugRouter::HandleMsg Do Request");

        TRequestStatus* pS=(TRequestStatus*)m.Ptr0();

        TInt r=DoRequest(~id, pS, m.Ptr1(), m.Ptr2());

        if (r!=KErrNone)

            Kern::RequestComplete(iRouter->iClient,pS,r);

        m.Complete(KErrNone,ETrue);

        }

    else

        {

        // DoControl

        //Kern::Printf("DCloggerDebugRouter::HandleMsg Do Control");

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

        m.Complete(r,ETrue);

        }	

	}

// DCloggerDebugRouter::DoRequest

//  Handles async messages, called from HandleMsg

TInt DCloggerDebugRouterLDD::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* /*a1*/, TAny* /*a2*/)

    {

	if (aReqNo == RCloggerDebugRouter::ERequestGetData)

		{

		iRouter->ClientRequestData(aStatus);

		}

    return KErrNone;

    }

void DCloggerDebugRouter::ClientRequestData(TRequestStatus* aStatus)

	{

	iClientStatus = aStatus;

	NKern::Lock();

#ifdef __SMP__

	__SPIN_LOCK(iBufferLock);

	NotifyClient();

	__SPIN_UNLOCK(iBufferLock);

#else