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

// LDD-based debug agent used to track kernel events.  See

// t_eventtracker.cpp

// 

//

#include <kernel/kern_priv.h>

#include "reventtracker.h"

#include "d_eventtracker.h"

#include "nk_trace.h"

#ifdef __MARM__

#include <kernel/kdebug.h>

#endif //__MARM__

#ifdef _DEBUG

static const char KPanicCat[] = "D_EVENTTRACKER";

#endif // _DEBUG

_LIT(KClientPanicCat, "D_EVENTTRACKER");

DEventTracker* TheEventTracker;

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

/** Data about objects being tracked.

	All tracked objects are kept in a tracking list.  The object address 

	is a key and so must be unique.

 */

TTrackedItem::TTrackedItem(const DBase* aObject)

	: iObject(aObject), iAccountedFor(EFalse)

	{

	}

/** Subclass for DObjects being tracked */

TTrackedObject::TTrackedObject(DObject* aObject, TObjectType aType)

	:	TTrackedItem(aObject),

		iType(aType)

	{

	aObject->FullName(iFullName);

	}

TBool TTrackedObject::CheckIntegrity(const TDesC& aName, TObjectType aType) const

	{

	TBool ok = EFalse;

	if (aType == iType)

		{

		if (aType == EThread || aType == EProcess)

			{

			ok = (iFullName == aName);

			}

		else

			{

			ok = ETrue;

			}

		}

	if (!ok)

		{

		Kern::Printf("EVENTTRACKER: container / tracking list mismatch (0x%08x)", iObject);

		Kern::Printf("EVENTTRACKER: \tcontainer: %S (type %d)", &aName, aType);

		Kern::Printf("EVENTTRACKER: \ttracking list: %S (type %d)", &iFullName, iType);

		}

	return ok;

	}

/** Subclass for DCodeSegs being tracked */

TTrackedCodeSeg::TTrackedCodeSeg(const DCodeSeg* aCodeSeg)

	:	TTrackedItem(aCodeSeg),

		iAccessCount(aCodeSeg ? aCodeSeg->iAccessCount : 0)

	{

	}

TBool TTrackedCodeSeg::CheckIntegrity(TInt aAccessCount) const

	{

	const TBool ok = (aAccessCount == iAccessCount);

	if (!ok)

		{

		Kern::Printf("EVENTTRACKER: code seg list / tracking list mismatch (0x%08x)", iObject);

		Kern::Printf("EVENTTRACKER: \tcode seg list: %d", aAccessCount);

		Kern::Printf("EVENTTRACKER: \ttracking list: %d", iAccessCount);

		}

	return ok;

	}

/** Event handler and container for all objects being tracked.  */

DEventTracker::DEventTracker()

	:	DKernelEventHandler(EventHandler, this)

	{

	__ASSERT_DEBUG(!TheEventTracker, Kern::Fault(KPanicCat, __LINE__));

	TheEventTracker = this;

	}

//

// If aUseHook is true, the event tracker hooks the stop-mode debugger 

// breakpoint in preference to adding itself to the kernel event handler

// queue.  In order to clean up on its destruction, it has to

// reset the breakpoint by installing a dummy nop breakpoint

// handler, which is cut-and-pasted from kdebug.dll in order to

// avoid a dependency on kdebug.dll.  In order to use the event

// tracker using the stop-mode debugger breakpoint rather than

// the kernel event handler queue, kdebug.dll must be present in

// the ROM

//

TInt DEventTracker::Create(DLogicalDevice* aDevice, TBool aUseHook)

	{

	TInt err = aDevice->Open();

	if (err)

		{

		return err;

		}

	iDevice = aDevice;

	err = Kern::MutexCreate(iLock, _L("EventHandlerLock"), KMutexOrdNone);

	if (!err)

		{

		if (aUseHook)

			{

			// Find debugger info, if any

			DDebuggerInfo* const debugInfo = Kern::SuperPage().iDebuggerInfo;

			// Test stop-mode breakpoint if available

			if (debugInfo)

				{

#ifdef __MARM__

				// Receive all events

				for (TInt i = 0; i < ((EEventLimit + 31) >> 5); ++i)

					{

					debugInfo->iEventMask[i] = 0xffffffffu;

					}

				__KTRACE_OPT(KDEBUGGER, Kern::Printf("EVENTTRACKER: Copying breakpoint (0x%x) into handler (0x%x), size %d", &BranchToEventHandler, debugInfo->iEventHandlerBreakpoint, BreakPointSize()));

				// Set up breakpoint to call handler

				memcpy((TAny*)debugInfo->iEventHandlerBreakpoint, (TAny*) &BranchToEventHandler, BreakPointSize());

#else // !__MARM__

				err = KErrNotFound;

#endif // __MARM__

				}

			else

				{

				err = KErrNotFound;

				}

			}

		else

			{

			err = Add();

			}

		}

	return err;

	}

DEventTracker::~DEventTracker()

	{

#ifdef __MARM__

	// Remove breakpoint, if any

	DDebuggerInfo* const debugInfo = Kern::SuperPage().iDebuggerInfo;

	if (debugInfo)

		{

		CopyDummyHandler(debugInfo->iEventHandlerBreakpoint);

		}

#endif //__MARM__

	// clean-up tracking list

	SDblQueLink* link = iItems.GetFirst();

	while (link)

		{

		delete _LOFF(link, TTrackedItem, iLink);

		link = iItems.GetFirst();

		}

	if (iLock)

		{

		iLock->Close(NULL);

		}

	if (iDevice)

		{

		iDevice->Close(NULL);

		}

	TheEventTracker = NULL;

	}

TInt DEventTracker::Start()

	{

	TInt err = AddExistingObjects();

	if (!err)

		{

		iTracking = ETrue;

		}

	return err;

	}

TInt DEventTracker::Stop()

	{

	NKern::ThreadEnterCS();

	Kern::MutexWait(*iLock);

	iTracking = EFalse;

	Kern::MutexSignal(*iLock);

	NKern::ThreadLeaveCS();

	DumpCounters();

	return CheckIntegrity();

	}

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

	{

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

	}

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

	{ 

	__KTRACE_OPT(KDEBUGGER, Kern::Printf("EVENTTRACKER: Handling event type 0x%x", aType));

	Kern::MutexWait(*iLock);

	if (iTracking)

		{

		++iCounters[aType];

		switch (aType)

			{

		case EEventAddProcess:

			AddObject(EProcess, (DObject*)a1);

			break;

		case EEventUpdateProcess:

			// could be renaming or chunk addition/deletion

			UpdateObject(EProcess, (DObject*)a1, EFalse);

			break;

		case EEventRemoveProcess:

			RemoveObject(EProcess, (DObject*)a1);

			break;

		case EEventAddThread:

			AddObject(EThread, (DObject*)a1);

			break;

		case EEventUpdateThread:

			UpdateObject(EThread, (DObject*)a1, ETrue);

			break;

		case EEventRemoveThread:

			RemoveObject(EThread, (DObject*)a1);

			break;

		case EEventAddLibrary:

			{

			DLibrary* pL = (DLibrary*)a1;

			if (pL->iMapCount == 1)

				AddObject(ELibrary, pL);

			}

			break;

		case EEventRemoveLibrary:

			{

			DLibrary* pL = (DLibrary*)a1;

			if (pL->iMapCount == 0)

				RemoveObject(ELibrary, pL);

			}

			break;

		case EEventNewChunk:

			AddObject(EChunk, (DObject*)a1);

			break;

		case EEventDeleteChunk:

			RemoveObject(EChunk, (DObject*)a1);

			break;

		case EEventAddCodeSeg:

			{

			AddCodeSeg((DCodeSeg*)a1, (DProcess*)a2);

			}

			break;

		case EEventRemoveCodeSeg:

			{

			RemoveCodeSeg((DCodeSeg*)a1, (DProcess*)a2);

			}

			break;

		case EEventLoadedProcess:

			{

			__KTRACE_OPT(KDEBUGGER, Kern::Printf("EVENTTRACKER: Process %O loaded", a1));

			ProcessLoaded((DProcess*)a1);

			}

			break;

		case EEventUnloadingProcess:

			__KTRACE_OPT(KDEBUGGER, Kern::Printf("EVENTTRACKER: Process %O unloaded", a1));

			break;

		default:

			// no-op

			__KTRACE_OPT(KDEBUGGER, Kern::Printf("EVENTTRACKER: Handling default case"));

			break;

			}

		}

	Kern::MutexSignal(*iLock);

	// Allow other handlers to see this event

	return DKernelEventHandler::ERunNext;

	}

void DEventTracker::AddObject(TObjectType aType, DObject* aObject)

	{

	TTrackedObject* trackedObject = (TTrackedObject*)LookupItem(aObject);

	if (trackedObject)

		{

		Kern::Printf("EVENTTRACKER: Found orphaned object %O in tracking list while adding new object", aObject);

		++iErrorCount;

		return;

		}

	NKern::ThreadEnterCS();

	trackedObject = new TTrackedObject(aObject, aType);

	NKern::ThreadLeaveCS();

	if (trackedObject)

		{

		__KTRACE_OPT(KDEBUGGER, Kern::Printf("EVENTTRACKER: Adding %O (type %d) to tracking list", aObject, aType));

		__KTRACE_OPT(KDEBUGGER, Kern::Printf("EVENTTRACKER: DBase ptr == 0x%x", trackedObject->iObject));

		iItems.Add(&trackedObject->iLink);

		}

	else

		{

		iOOM = ETrue;

		++iErrorCount;

		}

	}

void DEventTracker::RemoveObject(TObjectType aType, DObject* aObject)

	{

	TTrackedObject* const trackedObject = (TTrackedObject*)LookupItem(aObject);

	if (trackedObject)

		{

 		TFullName name;

		aObject->FullName(name);

		if (!trackedObject->CheckIntegrity(name, aType))

			{

			++iErrorCount;

			}

		__KTRACE_OPT(KDEBUGGER, Kern::Printf("EVENTTRACKER: Removing %S (type %d) from tracking list", &name, aType));

		trackedObject->iLink.Deque();

		NKern::ThreadEnterCS();

		delete trackedObject;

		NKern::ThreadLeaveCS();

		}

	else

		{

		Kern::Printf("EVENTTRACKER: %O (type %d) removed but not in tracking list", aObject, aType);

		++iErrorCount;

		}

	}

void DEventTracker::UpdateObject(TObjectType aType, DObject* aObject, TBool aMustBeRenamed)

	{

	TTrackedObject* const trackedObject = (TTrackedObject*)LookupItem(aObject);

	if (trackedObject)

		{

		TFullName newName;

		aObject->FullName(newName);

		if (newName != trackedObject->iFullName)

			{

			__KTRACE_OPT(KDEBUGGER, Kern::Printf("EVENTTRACKER: Renaming %S --> %S (type %d)", 

						&trackedObject->iFullName, &newName));

			trackedObject->iFullName = newName;

			}

		else if (aMustBeRenamed)

			{

			Kern::Printf("EVENTTRACKER: %O (type %d) renamed with same name", aObject, aType);

			++iErrorCount;

			}

		}

	else

		{

		Kern::Printf("EVENTTRACKER: %O (type %d) updated but not in tracking list", aObject, aType);

		Kern::Printf("EVENTTRACKER: DBase ptr == 0x%x", (DBase*)aObject);

		++iErrorCount;

		}

	}

void DEventTracker::AddCodeSeg(DCodeSeg* aCodeSeg, DProcess* aProcess)

	{

	TTrackedCodeSeg* trackedCodeSeg = (TTrackedCodeSeg*)LookupItem(aCodeSeg);

	if (trackedCodeSeg)

		{

		if (aProcess && (aProcess->iTempCodeSeg == aCodeSeg))

			{

			// This is the exe code seg for a loading process

			// and hence the access count is currently

			// incremented by one

			++trackedCodeSeg->iAccessCount;

			}

		if (trackedCodeSeg->iAccessCount != aCodeSeg->iAccessCount)

			{

			Kern::Printf(

				"EVENTTRACKER: Access count for %C (%d) does not match the tracking list (%d)",

				aCodeSeg,

				aCodeSeg->iAccessCount,

				trackedCodeSeg->iAccessCount

				);

			++iErrorCount;

			return;

			}

		}

	if (!trackedCodeSeg)

		{

		NKern::ThreadEnterCS();

		trackedCodeSeg = new TTrackedCodeSeg(aCodeSeg);

		NKern::ThreadLeaveCS();

		if (trackedCodeSeg)

			{

			__KTRACE_OPT(KDEBUGGER, Kern::Printf("EVENTTRACKER: Adding %C to tracking list", aCodeSeg));

			iItems.Add(&trackedCodeSeg->iLink);

			}

		}

	else // trackedCodeSeg

		{

		if (aProcess)

			{

			__KTRACE_OPT(KDEBUGGER, Kern::Printf("EVENTTRACKER: Updating access count for %C (%d), attaching to process %O", aCodeSeg, aCodeSeg->iAccessCount, aProcess));

			}

		else // !aProcess

			{

			Kern::Printf("EVENTTRACKER: Found orphaned code seg %C in tracking list while adding new code seg", aCodeSeg);

			++iErrorCount;

			}

		}

	if (!trackedCodeSeg)

		{

		iOOM = ETrue;

		++iErrorCount;

		}

	}

void DEventTracker::ProcessLoaded(DProcess* aProcess)

	{

	if (aProcess->iCodeSeg)

		{

		TTrackedCodeSeg* trackedCodeSeg = (TTrackedCodeSeg*)LookupItem(aProcess->iCodeSeg);

		if (trackedCodeSeg)

			{

			// This is the exe code seg for a process that

			// has completed loading and hence the access

			// count has just been decremented by one

			--trackedCodeSeg->iAccessCount;

			}

		}

	}

void DEventTracker::RemoveCodeSeg(DCodeSeg* aCodeSeg, DProcess* aProcess)

	{

	TTrackedCodeSeg* const trackedCodeSeg = (TTrackedCodeSeg*)LookupItem(aCodeSeg);

	if (trackedCodeSeg)

		{

		if (!trackedCodeSeg->CheckIntegrity(aCodeSeg->iAccessCount))

			{

			++iErrorCount;

			}

		if (aCodeSeg->iAccessCount == 1)

			{

			__KTRACE_OPT(KDEBUGGER, Kern::Printf("EVENTTRACKER: Removing %C from tracking list, process %O", aCodeSeg, aProcess));

			trackedCodeSeg->iLink.Deque();

			NKern::ThreadEnterCS();

			delete trackedCodeSeg;

			NKern::ThreadLeaveCS();

			}

		}

	else

		{

		Kern::Printf("EVENTTRACKER: %C removed but not in tracking list.  Removing from process %O", aCodeSeg, aProcess);

		++iErrorCount;

		}

	}

/** Add all objects from relevant containers into the tracking list.  */

TInt DEventTracker::AddExistingObjects()

	{

	// Tracking can be started only after all containers read to avoid 

	// race conditions.

	__ASSERT_DEBUG(!iTracking, Kern::Fault(KPanicCat, __LINE__));