/*

* Copyright (c) 2004 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

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

*

*/

#include <e32def.h>

#include <e32cmn.h>

#include <arm.h>

#include <kernel.h>

#include <kern_priv.h>

#include <nk_trace.h>

#include "TrkKernelDriver.h"

#include "TrkDriver.h"

#include "TrkEventHandler.h"

DMetroTrkEventHandler::DMetroTrkEventHandler()

	:	DKernelEventHandler(EventHandler, this)

{

	LOG_MSG("DMetroTrkEventHandler::DMetroTrkEventHandler()");

}

TInt DMetroTrkEventHandler::Create(DLogicalDevice* aDevice, DLogicalChannel* aChannel, DThread* aClient)

{

	LOG_MSG("DMetroTrkEventHandler::Create()");

	TInt err;

	err = aDevice->Open();

	if (err != KErrNone)

		return err;

	iDevice = aDevice;

	iChannel = aChannel; //Don't add ref the channel, since channel closes the event handler before it ever gets destroyed.

	err = aClient->Open();

	if (err != KErrNone)

		return err;

	iClientThread = aClient;

	// Use a semaphore to protect our data structures from concurrent access.

	err = Kern::SemaphoreCreate(iLock, _L("TrkEventHandlerLock"), 1 /* Initial count */);

	if (err != KErrNone)

		return err;

	return Add();

}

DMetroTrkEventHandler::~DMetroTrkEventHandler()

{

	LOG_MSG("DMetroTrkEventHandler::~DMetroTrkEventHandler()");

	if (iLock)

		iLock->Close(NULL);

	if (iDevice)

		iDevice->Close(NULL);	

	if (iClientThread)

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

}

TInt DMetroTrkEventHandler::Start()

{

	LOG_MSG("DMetroTrkEventHandler::Start()");

	TInt r = KErrNone;

	iTracking = ETrue;

	return r;

}

TInt DMetroTrkEventHandler::Stop()

{

	LOG_MSG("DMetroTrkEventHandler::Stop()");

	//NKern::ThreadEnterCS();

	//Kern::SemaphoreWait(*iLock);

	iTracking = EFalse;

	//Kern::SemaphoreSignal(*iLock);

	//NKern::ThreadLeaveCS();

	return KErrNone;

}

TUint DMetroTrkEventHandler::EventHandler(TKernelEvent aType, TAny* a1, TAny* a2, TAny* aThis)

{

	return ((DMetroTrkEventHandler*)aThis)->HandleEvent(aType, a1, a2);

}

TUint DMetroTrkEventHandler::HandleEvent(TKernelEvent aType, TAny* a1, TAny* a2)

{

	if (iTracking)

	{

		iCounters[aType]++;

		switch (aType)

		{

			case EEventSwExc:

			{

				if (HandleSwException((TExcType)(TInt)a1))

					return (TUint)DKernelEventHandler::EExcHandled;

			}

			case EEventHwExc:

			{

				if (HandleHwException((TArmExcInfo*)a1))

					return (TUint)DKernelEventHandler::EExcHandled; 

			}

			case EEventUpdateProcess:

			case EEventAddThread:

			case EEventUpdateThread:

			case EEventRemoveThread:

			case EEventNewChunk:

			case EEventDeleteChunk:				

			//currently we don't handle any of these events;

				break;				

			case EEventAddProcess:

			{			

				AddProcess((DProcess*)a1, (DThread*)a2);

				break;

			}		

			case EEventRemoveProcess:

			{

				RemoveProcess((DProcess*)a1);

				break;

			}

			case EEventStartThread:

			{

				StartThread((DThread*)a1);

				break;

			}

			// According to Symbian, the only way to catch panics in EKA2 is through this event.

			case EEventKillThread:

			{

				if (HandleEventKillThread((DThread*)a1))

					return (TUint)DKernelEventHandler::EExcHandled; 

				break;

			}

			case EEventAddLibrary:

			{

				AddLibrary((DLibrary*)a1, (DThread*)a2);

				break;

			}

			case EEventRemoveLibrary:

			{

				RemoveLibrary((DLibrary*)a1);

				break;

			}

			case EEventUserTrace:

			{

				HandleUserTrace((TText*)a1, (TInt)a2);

				break;

			}

			case EEventAddCodeSeg:

			{

				//

				// EventAddCodeSeg is not fired for all libs, for example, if a static lib is in ROM,

				// then you don't need get AddCodeSeg event for that lib.

				// 

				//AddCodeSegment((DCodeSeg*)a1, (DProcess*)a2);

				break;

			}			

			case EEventRemoveCodeSeg:

			{

				// RemoveCodeSegment((DCodeSeg*)a1, (DProcess*)a2);

				break;

			}

			default:

				break;

		}

	}

	return DKernelEventHandler::ERunNext;

}

//

// DMetroTrkEventHandler::HandleEventKillThread

//

TBool DMetroTrkEventHandler::HandleEventKillThread(DThread* aThread)

{

	LOG_MSG("DMetroTrkEventHandler::HandleEventKillThread()");

	//NKern::ThreadEnterCS();

	//Kern::SemaphoreWait(*iLock);

	TBool ret = ((DMetroTrkChannel*)iChannel)->HandleEventKillThread(aThread);

	//Kern::SemaphoreSignal(*iLock);

	//NKern::ThreadLeaveCS();

	return ret;

}

//

// DMetroTrkEventHandler::HandleSwException

//

TBool DMetroTrkEventHandler::HandleSwException(TExcType aExcType)

{

	LOG_MSG("DMetroTrkEventHandler::HandleSwException()");

	NKern::ThreadEnterCS();

	Kern::SemaphoreWait(*iLock);

	TBool ret = ((DMetroTrkChannel*)iChannel)->HandleSwException(aExcType);

	Kern::SemaphoreSignal(*iLock);

	NKern::ThreadLeaveCS();

	return ret;

}

//

// DMetroTrkEventHandler::HandleHwException

//

TBool DMetroTrkEventHandler::HandleHwException(TArmExcInfo* aExcInfo)

{

	LOG_MSG("DMetroTrkEventHandler::HandleHwException()");

	TBool ret = EFalse;

	NKern::ThreadEnterCS();

	Kern::SemaphoreWait(*iLock);

	if (aExcInfo)

	{

		ret = ((DMetroTrkChannel*)iChannel)->HandleHwException(aExcInfo);

	}

	Kern::SemaphoreSignal(*iLock);

	NKern::ThreadLeaveCS();

	return ret;

}

//

// DMetroTrkEventHandler::HandleUserTrace

//

TBool DMetroTrkEventHandler::HandleUserTrace(TText* aStr, TInt aLen)

{

	LOG_MSG("DMetroTrkEventHandler::HandleUserTrace()");

	TBool ret = EFalse;

	NKern::ThreadEnterCS();

	Kern::SemaphoreWait(*iLock);

	if (aStr && aLen > 0)

	{

		ret = ((DMetroTrkChannel*)iChannel)->HandleUserTrace(aStr, aLen);

	}

	Kern::SemaphoreSignal(*iLock);

	NKern::ThreadLeaveCS();

	return ret;

}

//

// DMetroTrkEventHandler::AddProcess

//

void DMetroTrkEventHandler::AddProcess(DProcess* aProcess, DThread *aThread)

{

	LOG_MSG("DMetroTrkEventHandler::AddProcess()");

	NKern::ThreadEnterCS();

	Kern::SemaphoreWait(*iLock);

	if (iChannel && aProcess && aThread)

		((DMetroTrkChannel*)iChannel)->AddProcess(aProcess, aThread);

	Kern::SemaphoreSignal(*iLock);

	NKern::ThreadLeaveCS();

}

//

// DMetroTrkEventHandler::StartThread

//

void DMetroTrkEventHandler::StartThread(DThread *aThread)

{

	LOG_MSG("DMetroTrkEventHandler::StartThread()");

	NKern::ThreadEnterCS();

	Kern::SemaphoreWait(*iLock);

	if (iChannel && aThread)

		((DMetroTrkChannel*)iChannel)->StartThread(aThread);

	Kern::SemaphoreSignal(*iLock);

	NKern::ThreadLeaveCS();

}

//

// DMetroTrkEventHandler::RemoveProcess

//

void DMetroTrkEventHandler::RemoveProcess(DProcess *aProcess)

{

	LOG_MSG("DMetroTrkEventHandler::RemoveProcess()");

	NKern::ThreadEnterCS();

	Kern::SemaphoreWait(*iLock);

	if (iChannel && aProcess)

		((DMetroTrkChannel*)iChannel)->RemoveProcess(aProcess);

	Kern::SemaphoreSignal(*iLock);

	NKern::ThreadLeaveCS();

}

//

// DMetroTrkEventHandler::AddLibrary

//

void DMetroTrkEventHandler::AddLibrary(DLibrary *aLibrary, DThread *aThread)

{

	LOG_MSG("DMetroTrkEventHandler::AddLibrary()");

	NKern::ThreadEnterCS();

	Kern::SemaphoreWait(*iLock);

	if (iChannel && aLibrary)

		((DMetroTrkChannel*)iChannel)->AddLibrary(aLibrary, aThread);

	Kern::SemaphoreSignal(*iLock);

	NKern::ThreadLeaveCS();

}

//

// DMetroTrkEventHandler::RemoveLibrary

//

void DMetroTrkEventHandler::RemoveLibrary(DLibrary *aLibrary)

{

	LOG_MSG("DMetroTrkEventHandler::RemoveLibrary()");

	NKern::ThreadEnterCS();

	Kern::SemaphoreWait(*iLock);

	if (iChannel && aLibrary)

		((DMetroTrkChannel*)iChannel)->RemoveLibrary(aLibrary);

	Kern::SemaphoreSignal(*iLock);

	NKern::ThreadLeaveCS();

}

//

// DMetroTrkEventHandler::AddCodeSegment

//

void DMetroTrkEventHandler::AddCodeSegment(DCodeSeg *aCodeSeg, DProcess *aProcess)

{

	LOG_MSG("DMetroTrkEventHandler::AddCodeSegment()");

	NKern::ThreadEnterCS();

	Kern::SemaphoreWait(*iLock);

	if (iChannel && aCodeSeg && aProcess)

		((DMetroTrkChannel*)iChannel)->AddCodeSegment(aCodeSeg, aProcess);

	Kern::SemaphoreSignal(*iLock);

	NKern::ThreadLeaveCS();

}

//

// DMetroTrkEventHandler::RemoveCodeSegment

//

void DMetroTrkEventHandler::RemoveCodeSegment(DCodeSeg *aCodeSeg, DProcess *aProcess)

{

	LOG_MSG("DMetroTrkEventHandler::RemoveCodeSegment()");

	NKern::ThreadEnterCS();

	Kern::SemaphoreWait(*iLock);

	if (iChannel && aCodeSeg && aProcess)

		((DMetroTrkChannel*)iChannel)->RemoveCodeSegment(aCodeSeg, aProcess);

	Kern::SemaphoreSignal(*iLock);

	NKern::ThreadLeaveCS();

}