// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// 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:

// Purpose: Kernel-side tracking of debug agent information associated

// with each process being debugged.

// 

//

#include <e32def.h>

#include <e32def_private.h>

#include <e32cmn.h>

#include <e32cmn_private.h>

#include <kernel/kernel.h> 

#include <kernel/kern_priv.h>

#include <nk_trace.h>

#include <arm.h>

#include "d_process_tracker.h"

#include "debug_logging.h"

#include "d_debug_agent.h"

#include "debug_utils.h"

#include "d_debug_agent.inl"

using namespace Debug;

// ctor

DDebugAgent::DDebugAgent(TUint64 aId) :

	iId(aId),

	iRequestGetEventStatus(NULL),

	iClientThread(0),

	iEventQueue(KNumberOfEventsToQueue, 0),

	iHead(0),

	iTail(0),

	iEventQueueLock(NULL),

	iFreeSlots(KNumberOfEventsToQueue),

	iIgnoringTrace(EFalse),

	iEventBalance(0)

	{

	LOG_MSG2("DDebugAgent::DDebugAgent(), this=0x%x ", this);

	// Initialize all the Event Actions to Ignore

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

		{

		iEventActions[i] = EActionIgnore;

		}

	}

DDebugAgent* DDebugAgent::New(TUint64 aId)

	{

	LOG_MSG2("DDebugAgent::New(id=0x%lx)", aId);

	DDebugAgent* agent = new DDebugAgent(aId);

	if(agent == NULL)

		{

		return (NULL);

		}

	if(KErrNone != agent->Construct())

		{

		delete agent;

		return (NULL);

		}

	// Use a semaphore to serialise access

	TInt err = Kern::SemaphoreCreate(agent->iEventQueueLock, _L("RM_DebugAgentQueueLock"), 1 /* Initial count */);

	if (err != KErrNone)

		return NULL;

	return agent;

	}

/** Standard contructor.

 * Fills event queue with empty events

 * @return : standard system error code

 */

TInt DDebugAgent::Construct()

	{

	// Empty the event queue

	TDriverEventInfo emptyEvent;

	TInt err = KErrNone;

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

		{

		err = iEventQueue.Append(emptyEvent);

		if (err != KErrNone)

			{

			LOG_MSG("Error appending blank event entry");

			return err;

			}

		}

	err = Kern::CreateClientDataRequest(iRequestGetEventStatus);

	if(err != KErrNone)

		{

		LOG_MSG("Error creating TClientDataRequest");

		return err;

		}

	LOG_MSG2("DDebugAgent::Construct() iRequestGetEventStatus=0x%08x", iRequestGetEventStatus);

	return err;

	}

// dtor

DDebugAgent::~DDebugAgent()

	{

	iEventQueue.Reset();

	if (iEventQueueLock)

		iEventQueueLock->Close(NULL);

	if(iRequestGetEventStatus)

		Kern::DestroyClientRequest(iRequestGetEventStatus);

	}

// Associate an action with a particular kernel event

TInt DDebugAgent::SetEventAction(TEventType aEvent, TKernelEventAction aEventAction)

	{

	// Valid Event?

	if (aEvent >= EEventsLast)

		{

		LOG_MSG2("DDebugAgent::EventAction: Bad Event number %d",aEvent);

		return KErrArgument;

		}

	iEventActions[aEvent] = aEventAction;

	return KErrNone;

	}

/** Get the aEventAction associated with aEvent

 *

 * @return : aEventAction (always +ve), or KErrArgument.

 */

TInt DDebugAgent::EventAction(TEventType aEvent)

	{

	// Validate the Event id

	if (aEvent >= EEventsLast)

		{

		LOG_MSG2("DDebugAgent::EventAction: Bad Event number %d",aEvent);

		return KErrArgument;

		}

	// Return the action associated with this event

	return iEventActions[aEvent];

	}

/** Obtain the details of the latest kernel event (if it exists) and place the details in aEventInfo

 * If there is no event in the queue for this process+agent combination, store the details

 * so that it can be notified later when an event actually occurs.

 * 

 * @param aAsyncGetValueRequest - TClientDataRequest object used for pinning user memory

 * @param aClientThread - The ThreadId of the requesting user-side process. In this case the DSS.

 */

void DDebugAgent::GetEvent(TClientDataRequest<TEventInfo>* aAsyncGetValueRequest, DThread* aClientThread)

	{

	LockEventQueue();

	iRequestGetEventStatus->Reset();

	TInt err = iRequestGetEventStatus->SetStatus( aAsyncGetValueRequest->StatusPtr() );

	if (err != KErrNone)

		{

		LOG_MSG2("Error :iRequestGetEventStatus->SetStatus ret %d", err);

		UnlockEventQueue();

		return;

		}

	iRequestGetEventStatus->SetDestPtr( aAsyncGetValueRequest->DestPtr() );

	iEventBalance++;

	LOG_MSG5("DDebugAgent::GetEvent: this=0x%08x, iRequestGetEventStatus=0x%08x, iEventBalance=%d, destPrt=0x%08x", 

		this, iRequestGetEventStatus, iEventBalance, aAsyncGetValueRequest->DestPtr() );

	iClientThread = aClientThread;

	if (BufferEmpty())

		{

		LOG_MSG2("Event buffer empty, iEventBalance=%d", iEventBalance);		

		UnlockEventQueue();

		return;

		}

	LOG_MSG5("Event already available at queue pos (tail)=%d, evType=%d, threadId=0x%x, actionTaken=%d", 

	        iTail,	iEventQueue[iTail].iEventType,	

	        iEventQueue[iTail].iThreadId, iEventQueue[iTail].iActionTaken );

	// returning the event to the client

	err = iEventQueue[iTail].WriteEventToClientThread(iRequestGetEventStatus,iClientThread);

	if (err != KErrNone)

		{

		LOG_MSG2("Error writing event info: %d", err);

		UnlockEventQueue();

		return;

		}

	// signal the DSS thread

	Kern::QueueRequestComplete(iClientThread, iRequestGetEventStatus, KErrNone);

	iEventBalance--;

	iEventQueue[iTail].Reset();

	// move to the next slot

	IncrementTailPosition();

	UnlockEventQueue();

	}

/**

 * Stop waiting for an event to occur. This means events will be placed 

 * in the iEventQueue (by setting iEventBalance to 0) until GetEvent is called. 

 */ 

TInt DDebugAgent::CancelGetEvent(void)

	{

	LOG_MSG2("DDebugAgent::CancelGetEvent. iEventBalance=%d. > QueueRequestComplete", iEventBalance);

	Kern::QueueRequestComplete(iClientThread, iRequestGetEventStatus, KErrCancel);

	iEventBalance=0;

	iClientThread = 0;

	return KErrNone;

	}

/** Signal a kernel event to the user-side DSS when it occurs, or queue it for later

 * if the user-side has not called GetEvent (see above).

 * 

 * @param aEventInfo - the details of the event to queue.

 */

void DDebugAgent::NotifyEvent(const TDriverEventInfo& aEventInfo)

	{

	if(aEventInfo.iEventType >= EEventsLast)

		{

		LOG_MSG3("DDebugAgent::NotifyEvent(),iEventType %d, this=0x%x. Ignoring since > EEventsLast", aEventInfo.iEventType, this);

		return;

		}

	LockEventQueue();

	DThread* currentThread = &Kern::CurrentThread();

	TKernelEventAction action = iEventActions[aEventInfo.iEventType];

	if (aEventInfo.iProcessId == Id() &&

		(aEventInfo.iEventType == EEventsSwExc || aEventInfo.iEventType == EEventsHwExc ||	aEventInfo.iEventType == EEventsKillThread))

		{

		// It might be nice not to deliver *any* events about the debug agent to the agent itself, but this is a bit too drastic a change to make.

		// There's a risk it might completely break TRK or similar, and at a more practical level it would require major rewriting of the t_rmdebug2

		// tests.

		//

		// So instead, we only don't suspend&deliver events about the debug agent IF it's a thread crash event AND the thread is process

		// critical/permanent AND (in the case of a critical thread) it's an abnormal exit. We're not worrying (yet) about the case where the entire

		// process is set as system critical

		// This fixes the original problem with CDS's worker thread crashing, and doesn't wreck the t_rmdebug2 tests.

		TBool problematic = (

			(aEventInfo.iThreadFlags & (KThreadFlagProcessCritical|KThreadFlagSystemCritical) && (aEventInfo.iEventType != EEventsKillThread || aEventInfo.iExitType != EExitKill)) // process or system critical, and either an exception (not a EEventsKillThread) or a non EExitKill exit

			|| (aEventInfo.iThreadFlags & (KThreadFlagProcessPermanent|KThreadFlagSystemPermanent))

			);

		if (problematic)

			{

			LOG_MSG("Agent is dying - no further events will be delivered to it");

			iAgentDying = ETrue;

			}

		}

	if (iAgentDying && action == EActionSuspend)

		{

		LOG_MSG("Not delivering this event or suspending the thread because agent is dying");

		action = EActionIgnore;

		}

	switch (action)

		{

		case EActionSuspend:

			{

			LOG_MSG5("DDebugAgent::NotifyEvent(), Suspend thread, iEventType %d, this=0x%x currThrd=0x%08x, iEventBalance=%d",

				aEventInfo.iEventType, this, currentThread, iEventBalance );

			switch(aEventInfo.iEventType)

				{

				case EEventsAddLibrary:

				case EEventsRemoveLibrary:

					// TomS: Anybody want to explain what is going on here??

					currentThread = DebugUtils::OpenThreadHandle(aEventInfo.iThreadId);

					if(currentThread)

						{

						currentThread->Close(NULL);

						}

					break;

				default:

					break;

				}

			// Do not call suspend for breakpoints, since the breakpoint code that runs when deciding if an exception

			// is a breakpoint will itself suspend the thread 

			if( (aEventInfo.iEventType != EEventsBreakPoint) && (aEventInfo.iEventType != EEventsProcessBreakPoint) )

			    {

                TInt err = TheDProcessTracker.SuspendThread(currentThread, aEventInfo.FreezeOnSuspend());

                if((err != KErrNone) && (err != KErrAlreadyExists))

                    {

                    // Is there anything we can do in the future to deal with this error having happened?

                    LOG_MSG2("DDebugAgent::NotifyEvent() Problem while suspending thread: %d", err);

                    }

			    }

			// now drop through to the continue case, which typically notifies

			// the debug agent of the event

			}

		case EActionContinue:

			{

			if( action == EActionContinue )

				{

				LOG_MSG5("DDebugAgent::NotifyEvent(), Action continue, iEventType %d, this=0x%x currThrd=0x%08x, iEventBalance=%d",

					aEventInfo.iEventType, this, currentThread, iEventBalance );

				}

			// Queue this event

			TDriverEventInfo eventInfo = aEventInfo;

			eventInfo.iActionTaken = action;

			QueueEvent(eventInfo);

			// Tell the user about the oldest event in the queue

			if ( iClientThread )

				{

				if( iRequestGetEventStatus && (iEventBalance > 0) )

					{

					// Fill the event data

					TInt err = iEventQueue[iTail].WriteEventToClientThread(iRequestGetEventStatus,iClientThread);

					if (err != KErrNone)

						{

						LOG_MSG2("Error writing event info: %d", err);

						}

					// signal the debugger thread 

					LOG_MSG4("> QueueRequestComplete iRequestGetEventStatus=0x%08x, iEventBalance=%d, iTail=%d",

						iRequestGetEventStatus->iStatus, iEventBalance, iTail );

					Kern::QueueRequestComplete(iClientThread, iRequestGetEventStatus, KErrNone);

					iEventBalance--;

					iEventQueue[iTail].Reset();

					// move to the next slot

					IncrementTailPosition();

					}

				else

					{

					if( !iRequestGetEventStatus )

						{

						LOG_MSG("iRequestGetEventStatus is NULL so not signalling client" );

						}

					else

						{

						LOG_MSG2("Queued event. iEventBalance=%d (unbalanced event requests vs notifications)", 

							iEventBalance );

						}

					}

				}

			else

				{

				 LOG_MSG("DDebugAgent::NotifyEvent() : Not informing client since its thread is NULL");

				}

			break;

			}

		case EActionIgnore:

		default:

			// Ignore everything we don't understand.

			break;

		}

	UnlockEventQueue();

	}

// Used to identify which Debug Agent this DDebugAgent is associated with.

TUint64 DDebugAgent::Id(void)

	{

	return iId;

	}

/**

 * Used to add an event to the event queue for this debug agent if event 

 * queue is not at critical level. If it is at critical and it is trace event, 

 * we start ignoring trace events and insert a lost trace event.

 * If the buffer cannot store an event, only insert a buffer full event.

 * @see EEventsBufferFull

 * @see EEventsUserTracesLost

 * @see TDriverEventInfo

 * @see iEventQueue

 */

void DDebugAgent::QueueEvent(const TDriverEventInfo& aEventInfo)

	{

	// Have we caught the tail?

	if(BufferFull())

		{

		LOG_MSG("DDebugAgent::QueueEvent : BufferFull. Not queueing");

		return;

		}

	// Assert if we think there is space but the slot is not marked empty

	__NK_ASSERT_DEBUG(iEventQueue[iHead].iEventType == EEventsUnknown);

	const TBool bufferAtCritical = BufferAtCriticalLevel();

	if(!bufferAtCritical)

		{

		//reset the iIgnoringTrace flag as we are not at 

		//critical level and can store event

		iIgnoringTrace = EFalse; 

		// Insert the event into the ring buffer at iHead

		iEventQueue[iHead] = aEventInfo;

		IncrementHeadPosition();

		}

	else if(bufferAtCritical && BufferCanStoreEvent())

		{

		LOG_MSG("DDebugAgent::QueueEvent : BufferCritical");

		if(aEventInfo.iEventType == EEventsUserTrace)

			{

			if(!iIgnoringTrace)

				{

				//if this is the first time we are ignoring trace events, 

				//we need to issue a EEventsUserTracesLost event

				iEventQueue[iHead].Reset();

				iEventQueue[iHead].iEventType = EEventsUserTracesLost;

				IncrementHeadPosition();

				iIgnoringTrace = ETrue;

				}

			else

				{

				//otherwise, ignore this event

				LOG_MSG("DDebugAgent::QueueEvent : Ignore EEventsUserTrace event");

				}

			}

		else

			{

			// Store the event since its not a trace event

			iEventQueue[iHead] = aEventInfo;

			IncrementHeadPosition();

			}

		}

	else

		{

		//At critical level and cannot store new events, so 

		//only one space left. Store a EEventsBufferFull event

		LOG_MSG("DDebugAgent::QueueEvent : Event Buffer Full, ignoring event");

		iEventQueue[iHead].Reset();

		iEventQueue[iHead].iEventType = EEventsBufferFull;

		IncrementHeadPosition();

		}

	}

// End of file - d_debug_agent.cpp