// 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__));

 	TInt err = KErrNone;

 	Kern::Printf("Adding processes");

 	err = AddObjectsFromContainer(EProcess);

 	if (err)

 		{

 		return err;

 		}

 	Kern::Printf("Adding threads");

 	err = AddObjectsFromContainer(EThread);

 	if (err)

 		{

 		return err;

 		}

 	Kern::Printf("Adding libraries");

 	err = AddObjectsFromContainer(ELibrary);

 	if (err)

 		{

 		return err;

 		}

 	Kern::Printf("Adding chunks");

 	err = AddObjectsFromContainer(EChunk);

 	if (err)

 		{

 		return err;

 		}

 	Kern::Printf("Adding LDDs");

 	err = AddObjectsFromContainer(ELogicalDevice);

 	if (err)

 		{

 		return err;

 		}

 	Kern::Printf("Adding PDDs");

 	err = AddObjectsFromContainer(EPhysicalDevice);

 	if (err)

 		{

 		return err;

 		}

 	Kern::Printf("Adding code segs");

 	return AddCodeSegsFromList();

 	}

 /** Add all objects from specified container into tracking list.  */

 TInt DEventTracker::AddObjectsFromContainer(TObjectType aType)

 	{

 	DObjectCon* const container = Kern::Containers()[aType];

 	NKern::ThreadEnterCS();

 	container->Wait();

 	const TInt count = container->Count();

 	TInt err = KErrNone;

 	for (TInt i = 0; (i < count && err == KErrNone); ++i)

 		{

 		DObject* const object = (*container)[i];

 		if (object->Open() == KErrNone)

 			{

 			AddObject(aType, object);

 			if (iOOM)

 				{

 				err = KErrNoMemory;

 				}

 			object->Close(NULL);

 			}

 		}

 	container->Signal();

 	NKern::ThreadLeaveCS();

 	return err;

 	}

 TInt DEventTracker::AddCodeSegsFromList()

 	{

 	Kern::AccessCode();

 	const SDblQueLink* const anchor = &Kern::CodeSegList()->iA;

 	for (SDblQueLink* link = Kern::CodeSegList()->First(); link != anchor; link = link->iNext)

 		{

 		DCodeSeg* const codeSeg = _LOFF(link, DCodeSeg, iLink);

 		AddCodeSeg(codeSeg, NULL);

 		}

 	Kern::EndAccessCode();

 	return KErrNone;

 	}

 /** Check that tracking list matches existing objects. 

 	@return number of discrepancies found

  */

 TInt DEventTracker::CheckIntegrity()

 	{

 	// Tracking must be stopped to avoid race conditions.

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

 	if (iOOM)

 		{

 		Kern::Printf("EVENTTRACKER: OOM during tracking");

 		}

 	CheckContainerIntegrity(EProcess);

 	CheckContainerIntegrity(EThread);

 	CheckContainerIntegrity(ELibrary);

 	CheckContainerIntegrity(EChunk);

 	CheckContainerIntegrity(ELogicalDevice);

 	CheckContainerIntegrity(EPhysicalDevice);

 	CheckCodeSegListIntegrity();

 	CheckAllAccountedFor();

 	if (iErrorCount)

 		{

 		Kern::Printf("EVENTTRACKER: %d error(s) found", iErrorCount);

 		return KErrGeneral;

 		}

 	return KErrNone;

 	}

 /** Check all objects in specified container are in tracking list.  */

 void DEventTracker::CheckContainerIntegrity(TObjectType aType)

 	{

 	DObjectCon* const container = Kern::Containers()[aType];

 	NKern::ThreadEnterCS();

 	container->Wait();

 	const TInt count = container->Count();

 	for (TInt i = 0; i < count; ++i)

 		{

 		DObject* const object = (*container)[i];

 		if (object->Open() == KErrNone)

 			{

 			TFullName name;

 			object->FullName(name);

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

 			if (trackedObject)

 				{

 				trackedObject->iAccountedFor = ETrue;

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

 					{

 					++iErrorCount;

 					}

 				}

 			else

 				{

 				Kern::Printf("EVENTTRACKER: %S (type %d) is in container but not in tracking list", &name, aType);

 				++iErrorCount;

 				}

 			object->Close(NULL);

 			}

 		}

 	container->Signal();

 	NKern::ThreadLeaveCS();

 	}

 void DEventTracker::CheckCodeSegListIntegrity()

 	{

 	Kern::AccessCode();

 	const SDblQueLink* const anchor = &Kern::CodeSegList()->iA;

 	for (SDblQueLink* link = Kern::CodeSegList()->First(); link != anchor; link = link->iNext)

 		{

 		DCodeSeg* const codeSeg = _LOFF(link, DCodeSeg, iLink);

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

 		if (trackedCodeSeg)

 			{

 			trackedCodeSeg->iAccountedFor = ETrue;

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

 				{

 				++iErrorCount;

 				}

 			}

 		else

 			{

 			Kern::Printf("EVENTTRACKER: %C is in global list but not in tracking list", codeSeg);

 			++iErrorCount;

 			}

 		}

 	Kern::EndAccessCode();

 	}

 /** Check that all objects in tracking list have been accounted for. */

 void DEventTracker::CheckAllAccountedFor()

 	{

 	const SDblQueLink* link = iItems.GetFirst();

 	while (link)

 		{

 		TTrackedItem* const item = _LOFF(link, TTrackedItem, iLink);

 		if (!item->iAccountedFor)

 			{

 			Kern::Printf(

 				"EVENTTRACKER: 0x%x is in tracking list but not in container / list", 

 				&item->iObject

 				);

 			++iErrorCount;

 			}

 		link = iItems.GetFirst();

 		}

 	}

 /** Look for specified object in the tracking list. 

 	@pre iLock held

 	@post iLock held

  */

 TTrackedItem* DEventTracker::LookupItem(DBase* aItem) const

 	{

 	const SDblQueLink* const anchor = &iItems.iA;

 	for (SDblQueLink* link = iItems.First(); link != anchor; link = link->iNext)

 		{

 		TTrackedItem* const item = _LOFF(link, TTrackedItem, iLink);

 		if (item->iObject == aItem)

 			{

 			return item;

 			}

 		}

 	return NULL;

 	}

 void DEventTracker::DumpCounters() const

 	{

 	static const char* const KEventName[] = 

 		{

 		"SwExc           ",

 		"HwExc           ",

 		"AddProcess      ",

 		"UpdateProcess   ",

 		"RemoveProcess   ",

 		"AddThread       ",

 		"StartThread     ",

 		"UpdateThread    ",

 		"KillThread      ",

 		"RemoveThread    ",

 		"NewChunk        ",

 		"UpdateChunk     ",

 		"DeleteChunk     ",

 		"AddLibrary      ",

 		"RemoveLibrary   ",

 		"LoadLdd         ",

 		"UnloadLdd       ",

 		"LoadPdd         ",

 		"UnloadPdd       ",

 		"UserTrace       ",

 		"AddCodeSeg      ",

 		"RemoveCodeSeg   ",

 		"LoadedProcess   ",

 		"UnloadingProcess"

 		};

 	Kern::Printf("EVENT USAGE STATISTICS:");

 	for (TInt i = 0; i < EEventLimit; ++i)

 		{

 		Kern::Printf("\t%s\t\t %d times", KEventName[i], iCounters[i]);

 		}

 	}

 #ifdef __MARM__

 void DEventTracker::CopyDummyHandler(TLinAddr aLinAddr)

 	{

 	const TUint handlerSize = DummyHandlerSize();

 	// Copy the breakpoint-able handler into RAM by copying from the one (possibly) in ROM

 	memcpy((TAny*)aLinAddr, (TAny*) &DummyHandler, handlerSize);

 	__KTRACE_OPT(KBOOT, Kern::Printf("Breakpoint-able handler copied from 0x%x to (va) 0x%x, size %d", &DummyHandler, aLinAddr, handlerSize));

 	}

 #endif

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

 class DTestChannel : public DLogicalChannelBase

 	{

 public:

 	virtual ~DTestChannel();

 protected:

 	// from DLogicalChannelBase

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

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

 private:

 	DEventTracker* iHandler;

 	};

 // called in thread critical section

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

 	{

 	if((TUint)aUnit>=2)

 		return KErrNotSupported;

 	TBool useHook = aUnit;

 	iHandler = new DEventTracker;

 	if (!iHandler)

 		{

 		return KErrNoMemory;

 		}

 	return iHandler->Create(iDevice, useHook);

 	}

 // called in thread critical section

 DTestChannel::~DTestChannel()

 	{

 	if (iHandler)

 		{

 		iHandler->Close();

 		}

 	}

 TInt DTestChannel::Request(TInt aFunction, TAny* /*a1*/, TAny* /*a2*/)

 	{

 	TInt r = KErrNone;

 	switch (aFunction)

 		{

 	case REventTracker::EStart:

 		iHandler->Start();

 		break;

 	case REventTracker::EStop:

 		iHandler->Stop();

 		break;

 	default:

 		Kern::PanicCurrentThread(KClientPanicCat, __LINE__);

 		break;

 		}

 	return r;

 	}

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

 class DTestFactory : public DLogicalDevice

 	{

 public:

 	DTestFactory();

 	// from DLogicalDevice

 	virtual TInt Install();

 	virtual void GetCaps(TDes8& aDes) const;

 	virtual TInt Create(DLogicalChannelBase*& aChannel);

 	};

 DTestFactory::DTestFactory()

     {

     iVersion = REventTracker::Version();

     iParseMask = KDeviceAllowUnit;

     iUnitsMask = 0x3;

     }

 TInt DTestFactory::Create(DLogicalChannelBase*& aChannel)

     {

 	aChannel = new DTestChannel;

 	return (aChannel ? KErrNone : KErrNoMemory);

     }

 TInt DTestFactory::Install()

     {

     return SetName(&KTestLddName);

     }

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

     {

     }

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

 DECLARE_STANDARD_LDD()

 	{

     return new DTestFactory;

 	}