// Copyright (c) 2004-2010 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:

// Device driver for kernel side debug assist

//

#ifdef __WINS__

#error - this driver cannot be built for emulation

#endif

#include <e32def.h>

#include <e32def_private.h>

#include <e32cmn.h>

#include <e32cmn_private.h>

#include <e32ldr.h>

#include <u32std.h>

#include <kernel/kernel.h>

#include <kernel/kern_priv.h>

#include <nk_trace.h>

#include <arm.h>

#include <kernel/cache.h>

#include <platform.h>

#include <nkern.h>

#include <u32hal.h>

#include <rm_debug_api.h>

#include "debug_logging.h"

#include "d_rmd_breakpoints.h"	// moved breakpoints code lives here

#include "d_rmd_stepping.h"		// moved stepping code lives here

#include "rm_debug_kerneldriver.h"

#include "d_list_manager.h"

#include "rm_debug_driver.h"

#include "rm_debug_eventhandler.h"

#include "d_debug_functionality.h"

#include "d_process_tracker.h"

#include "debug_utils.h"

using namespace Debug;

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

//

// DRM_DebugDriverFactory implementation

//

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

//

// DRM_DebugDriverFactory constructor

//

DRM_DebugDriverFactory::DRM_DebugDriverFactory()

	{

	iVersion = TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

	}

//

// DRM_DebugDriverFactory::Create

//

TInt DRM_DebugDriverFactory::Create(DLogicalChannelBase*& aChannel)

	{

	if (iOpenChannels != 0)

		return KErrInUse; // a channel is already open

	aChannel = new DRM_DebugChannel(this);

	return aChannel ? KErrNone : KErrNoMemory;

	}

//

// DRM_DebugDriverFactory::Install

//

TInt DRM_DebugDriverFactory::Install()

	{

	return(SetName(&KRM_DebugDriverName));

	}

//

// DRM_DebugDriverFactory::Install

//

void DRM_DebugDriverFactory::GetCaps(TDes8& aDes) const

	{

	TCapsRM_DebugDriver b;

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

	Kern::InfoCopy(aDes,(TUint8*)&b,sizeof(b));

	}

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

//

// DRM_DebugChannel implementation

//

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

//

// DRM_DebugChannel constructor

//

DRM_DebugChannel::DRM_DebugChannel(DLogicalDevice* aLogicalDevice)

	: iExcludedROMAddressStart(ROM_LINEAR_BASE),

	iExcludedROMAddressEnd(0),

	iPageSize(0x1000),

	iBreakManager(0),

	iStepper(0),

	iStepLock(0),

	iDfcQ(NULL),

	iInitialisedCodeModifier(0),

	iAsyncGetValueRequest(NULL)

	{

	LOG_MSG("DRM_DebugChannel::DRM_DebugChannel()");

	iDevice = aLogicalDevice;

	iClientThread = &Kern::CurrentThread();	

	// Opening handle to current thread, so no need to check for return-value

	(void)iClientThread->Open();

	LOG_MSG3("DRM_DebugChannel::DRM_DebugChannel() clientThread = 0x%08x, id=%d", 

	            iClientThread, iClientThread->iId );

	iPageSize = Kern::RoundToPageSize(1);

	}

//

// DRM_DebugChannel destructor

//

DRM_DebugChannel::~DRM_DebugChannel()

	{

	LOG_MSG("DRM_DebugChannel::~DRM_DebugChannel()");

	if (iAsyncGetValueRequest)

		{

		Kern::QueueRequestComplete(iClientThread, iAsyncGetValueRequest, KErrCancel); // does nothing if request not pending

		Kern::DestroyClientRequest(iAsyncGetValueRequest);

		}

	NKern::ThreadEnterCS();

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

	NKern::ThreadLeaveCS();

	// Close breakpoint manager

	if (iBreakManager)

		{

		NKern::ThreadEnterCS();

		delete iBreakManager;

		NKern::ThreadLeaveCS();

		}

	// Close stepping manager

	if (iStepper)

		{

		NKern::ThreadEnterCS();

		delete iStepper;

		NKern::ThreadLeaveCS();

		}

	//close the debug process list

	iDebugProcessList.Close();

	DestroyDfcQ();

	//close the code modifier

	if (iInitialisedCodeModifier)

		{

		DebugSupport::CloseCodeModifier();

		}

	}

void DRM_DebugChannel::DestroyDfcQ()

	{

	LOG_MSG("DRM_DebugChannel::DestroyDfcQ()");

	if (iDfcQ)

		{

		NKern::ThreadEnterCS();

		iDfcQ->Destroy();

		NKern::ThreadLeaveCS();

		}

	}

//

// DRM_DebugChannel::DoCreate

//

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

	{

	LOG_MSG("DRM_DebugChannel::DoCreate()");

	TInt err = Kern::CreateClientDataRequest(iAsyncGetValueRequest);

	if(err != KErrNone)

		return err;

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

		return KErrNotSupported;

	// Do the security check here so that any arbitrary application doesn't make

	// use of Trk kernel driver.

	if (!DoSecurityCheck())

		{

		LOG_MSG("DRM_DebugChannel::DoCreate() - permission denied!");

			return KErrPermissionDenied;

		}

	if (anInfo)

		{

		// this is the end address of the user library.

		// this doesn't seem to be valid for EKA2.

		// right now we dont need this for EKA2 since we are not worried

		// about kernel being stopped as kernel is multithreaded.

		// just retaining this for future use.

		TBuf8<32> buf;

		TInt err = Kern::ThreadRawRead(iClientThread, anInfo, &buf, 32);

		if(err != KErrNone)

			return err;

		}

	// Allocate a D_RMD_Breakpoints class as a breakpoint manager

	NKern::ThreadEnterCS();

	iBreakManager = new D_RMD_Breakpoints(this);

	NKern::ThreadLeaveCS();

	if (iBreakManager == NULL)

		{

		LOG_MSG("DRM_DebugChannel::DRM_DebugChannel - could not construct breakpoint manager");

		return KErrNoMemory;

		}

	// Initialise the new breakpoint manager object

	iBreakManager->Init();

	// Allocate a DRMDStepping class as the stepping manager

	NKern::ThreadEnterCS();

	iStepper = new DRMDStepping(this);

	NKern::ThreadLeaveCS();

	if (iStepper == NULL)

		{

		LOG_MSG("DRM_DebugChannel::DRM_DebugChannel - could not construct stepper manager");

		return KErrNoMemory;

		}

	// Initialize the code modifier for managing breakpoints.

	TUint caps; //ignored for now

	err = DebugSupport::InitialiseCodeModifier(caps, NUMBER_OF_MAX_BREAKPOINTS);

	//if code modifier initializer failed,

	//return here, since we can't set an breakpoints

	if(err != KErrNone)

		{

		return err;

		}

	else

		{

		iInitialisedCodeModifier = ETrue;

		}

	//create and set the driver's Dfc queue

	err = CreateDfcQ();

	if(err != KErrNone)

		{

		LOG_MSG("DRM_DebugChannel::DoCreate() Creating Dfc queue failed.");

		}

	SetDfcQ(iDfcQ);

	iMsgQ.Receive();

	iEventHandler = new DRM_DebugEventHandler;

	if (!iEventHandler)

		return KErrNoMemory;

	err = iEventHandler->Create(iDevice, this, iClientThread);

	if (err != KErrNone)

		return err;

	//return KErrNone;

	return iEventHandler->Start();

	}

/**

Forward call to either synch or asynch methods while serialising all calls via lock.

Protect access via a the event handler lock to 

serialise all calls and protect concurrent access to data structures

@param aMsg pointer to a TMessageBase object 

@return error returned by called methods

@see DRM_DebugEventHandler::HandleSpecificEvent where lock is also used

@see DRM_DebugEventHandler::iProtectionLock

*/

TInt DRM_DebugChannel::SendMsg(TMessageBase* aMsg)

	{

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

	iEventHandler->LockDataAccess();

	LOG_MSG3("DRM_DebugChannel::SendMsg() currThread = 0x%08x, iClientThread=0x%08x", currThread, iClientThread );

	TThreadMessage& m = *(TThreadMessage*)aMsg;

	TInt id = m.iValue;

	TInt err = KErrNone;

	if (id != (TInt)ECloseMsg && id != KMaxTInt && id < 0)

		{

		// DoRequest

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

		err = SendRequest(aMsg);

		if (err != KErrNone)

			Kern::RequestComplete(pStatus,err);

		}

	else

		{

		err = DLogicalChannel::SendMsg(aMsg);

		}

	iEventHandler->ReleaseDataAccess();

	return err;

	}

//

// DRM_DebugChannel::SendRequest

//

TInt DRM_DebugChannel::SendRequest(TMessageBase* aMsg)

	{

	LOG_MSG("DRM_DebugChannel::SendRequest()");

	TThreadMessage& m = *(TThreadMessage*)aMsg;

	TInt function = ~m.iValue;

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

	TAny* a1 = m.Ptr1();

	TInt err = KErrNotSupported;

	switch(function)

		{

		case RRM_DebugDriver::ERequestGetEvent:

			err = PreAsyncGetValue((TEventInfo*)a1,pStatus);

			break;

		}

	if (err == KErrNone)

		err = DLogicalChannel::SendMsg(aMsg);

	return err;

	}

//

// DRM_DebugChannel::PreAsyncGetValue

//

TInt DRM_DebugChannel::PreAsyncGetValue(TEventInfo* aValue, TRequestStatus* aStatus)

	{

	LOG_MSG3("DRM_DebugChannel::PreAsyncGetValue() TEventInfo=0x%08x, TRequestStatus=0x%08x",

		aValue, aStatus );

	iAsyncGetValueRequest->Reset();

	TInt err = iAsyncGetValueRequest->SetStatus(aStatus);

	if (err != KErrNone)

		return err;

	iAsyncGetValueRequest->SetDestPtr(aValue);

	return KErrNone;

	}

/**

  Create the Dfc queue for receiving messages

  */

TInt DRM_DebugChannel::CreateDfcQ()

	{

	LOG_MSG("DRM_DebugChannel::CreateDfcQ()");

	TInt r = Kern::DynamicDfcQCreate(iDfcQ, KRmDebugDriverThreadPriority, KRM_DebugDriverName);

	if (r == KErrNone)

		iDfcQ->SetRealtimeState(ERealtimeStateOff);

	return r;

	}

//

// DRM_DebugChannel::DoCancel

//

// New: The cancel call does not take an enum parameter describing

// the request to be cancelled. Rather it supplies a pointer

// to a user-side struct defining the cancellation

//

void DRM_DebugChannel::DoCancel(TInt aReqNo)

	{

	LOG_MSG("DRM_DebugChannel::DoCancel()");

	TRMD_DebugCancelInfo info;

	TInt err = Kern::ThreadRawRead(iClientThread,(TAny*)aReqNo,(TAny*)&info,sizeof(info));

	if (err != KErrNone)

		{

		// How do we cancel something we know nothing about???

		LOG_MSG("DRM_DebugChannel::DoCancel - bad arguments");

		return;

		}

	DDebugAgent* debugAgent = TheDProcessTracker.FindAgentForProcessAndId(info.iProcessName, info.iAgentId);

	if (debugAgent == NULL)

		{

		// Bad agent means there is no tracking agent

		LOG_MSG2("Cannot locate debug agent with pid 0x%x", info.iAgentId);

		return;

		}

	// Agent completes/pends the request as appropriate.

	debugAgent->CancelGetEvent();

	}

//

// DRM_DebugChannel::DoRequest

//

void DRM_DebugChannel::DoRequest(TInt aReqNo, TRequestStatus* aStatus, TAny* a1, TAny* a2)

	{

	LOG_MSG4("DRM_DebugChannel::DoRequest(), iClientThread=0x%08x, tid=0x%08x, TRequestStatus=0x%08x", 

		iClientThread, I64LOW(iClientThread->iId), aStatus);

	switch(aReqNo)

		{

		case RRM_DebugDriver::ERequestGetEvent:

			{

			TEventMetaData eventMetaData;

			TInt err = Kern::ThreadRawRead(iClientThread, a2, (TUint8 *)&eventMetaData, sizeof(TEventMetaData) );

			if (err != KErrNone)

				{

				LOG_MSG("Error: could not read argument data from the DSS (TEventMetaData)");

				// We could not read information from the user, so the a2 argument is probably wrong

				Kern::RequestComplete(iClientThread, aStatus, KErrArgument);

				return;

				}

			DDebugAgent* debugAgent = TheDProcessTracker.FindAgentForProcessAndId(eventMetaData.iTargetProcessName, eventMetaData.iDebugAgentProcessId);

			if (debugAgent == NULL)

				{

				// Bad agent means there is no tracking agent

				LOG_MSG2("Cannot locate debug agent with pid 0x%x", eventMetaData.iDebugAgentProcessId);

				Kern::RequestComplete(iClientThread, aStatus, KErrNotFound);

				return;

				}

			// Agent completes/pends the request as appropriate.

			debugAgent->GetEvent(iAsyncGetValueRequest, iClientThread);

			break;

			}

		default:

			{

			// Should not get here!

			LOG_MSG2("DRM_DebugChannel::DoRequest was passed unsupported request aReqNo=%d", aReqNo );

			Kern::RequestComplete(iClientThread, aStatus, KErrNotSupported);

			}

		}

	}

//

// DRM_DebugChannel::DoControl

//

TInt DRM_DebugChannel::DoControl(TInt aFunction, TAny* a1, TAny* a2)

	{

	LOG_MSG("DRM_DebugChannel::DoControl()");

	LOG_MSG2("DoControl Function %d", aFunction);

	TInt err = KErrNone;

	DThread* threadObj = NULL;

	// Open a thread handle for the operations that need one

	switch (aFunction)

		{

		case RRM_DebugDriver::EControlSuspendThread:

		case RRM_DebugDriver::EControlResumeThread:

		case RRM_DebugDriver::EControlStepRange:

		case RRM_DebugDriver::EControlReadMemory:

		case RRM_DebugDriver::EControlWriteMemory:

		case RRM_DebugDriver::EControlReadRegistersLegacy:

		case RRM_DebugDriver::EControlWriteRegistersLegacy:

		case RRM_DebugDriver::EControlReadRegisters:

		case RRM_DebugDriver::EControlWriteRegisters:

			{

			NKern::ThreadEnterCS();

			threadObj = DebugUtils::OpenThreadHandle((TUint32)a1);

			if (!threadObj)

				{

				NKern::ThreadLeaveCS();

				return KErrBadHandle;

				}

			break;

			}

		default:

			break;

		}

	switch(aFunction)

		{

		/* Security first */

		case RRM_DebugDriver::EControlIsDebuggable:

			{

			err = IsDebuggable((TUint32)a1);

			break;

			}

		case RRM_DebugDriver::EControlSetBreak:

			{

			err = SetBreak((TSetBreakInfo*)a1);

			break;

			}

		case RRM_DebugDriver::EControlClearBreak:

			{

			err = iBreakManager->DoClearBreak((TInt32)a1);

			break;

			}

		case RRM_DebugDriver::EControlModifyBreak:

			{

			err = iBreakManager->DoModifyBreak((TModifyBreakInfo*)a1);

			break;

			}

		case RRM_DebugDriver::EControlModifyProcessBreak:

			{

			err = iBreakManager->DoModifyProcessBreak((TModifyProcessBreakInfo*)a1);

			break;

			}

		case RRM_DebugDriver::EControlBreakInfo:

			{

			err = iBreakManager->DoBreakInfo((TGetBreakInfo*)a1);

			break;

			}

		case RRM_DebugDriver::EControlSuspendThread:

			{

			err = DoSuspendThread(threadObj);