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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Device driver for kernel side debug assist

    15 //

    16 

    17 #ifdef __WINS__

    18 #error - this driver cannot be built for emulation

    19 #endif

    20 

    21 #include <e32def.h>

    22 #include <e32def_private.h>

    23 #include <e32cmn.h>

    24 #include <e32cmn_private.h>

    25 #include <e32ldr.h>

    26 #include <u32std.h>

    27 #include <kernel/kernel.h>

    28 #include <kernel/kern_priv.h>

    29 #include <nk_trace.h>

    30 #include <arm.h>

    31 #include <kernel/cache.h>

    32 #include <platform.h>

    33 #include <nkern.h>

    34 #include <u32hal.h>

    35 #include <kernel/kdebug.h>

    36 #include <rm_debug_api.h>

    37 

    38 #include "debug_logging.h"

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

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

    41 #include "rm_debug_kerneldriver.h"

    42 #include "d_list_manager.h"

    43 #include "rm_debug_driver.h"

    44 #include "rm_debug_eventhandler.h"

    45 #include "d_debug_functionality.h"

    46 #include "d_process_tracker.h"

    47 #include "debug_utils.h"

    48 #include "d_buffer_manager.h"

    49 

    50 using namespace Debug;

    51 

    52 /////////////////////////////////////////////////////////////////////////

    53 //

    54 // DRM_DebugDriverFactory implementation

    55 //

    56 /////////////////////////////////////////////////////////////////////////

    57 

    58 //

    59 // DRM_DebugDriverFactory constructor

    60 //

    61 DRM_DebugDriverFactory::DRM_DebugDriverFactory()

    62 	{

    63 	iVersion = TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

    64 	}

    65 

    66 //

    67 // DRM_DebugDriverFactory::Create

    68 //

    69 TInt DRM_DebugDriverFactory::Create(DLogicalChannelBase*& aChannel)

    70 	{

    71 	if (iOpenChannels != 0)

    72 		return KErrInUse; // a channel is already open

    73 

    74 	aChannel = new DRM_DebugChannel(this);

    75 

    76 	return aChannel ? KErrNone : KErrNoMemory;

    77 	}

    78 

    79 //

    80 // DRM_DebugDriverFactory::Install

    81 //

    82 TInt DRM_DebugDriverFactory::Install()

    83 	{

    84 	return(SetName(&KRM_DebugDriverName));

    85 	}

    86 

    87 //

    88 // DRM_DebugDriverFactory::Install

    89 //

    90 void DRM_DebugDriverFactory::GetCaps(TDes8& aDes) const

    91 	{

    92 	TCapsRM_DebugDriver b;

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

    94 

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

    96 	}

    97 

    98 /////////////////////////////////////////////////////////////////////////

    99 //

   100 // DRM_DebugChannel implementation

   101 //

   102 /////////////////////////////////////////////////////////////////////////

   103 

   104 //

   105 // DRM_DebugChannel constructor

   106 //

   107 DRM_DebugChannel::DRM_DebugChannel(DLogicalDevice* aLogicalDevice)

   108 	: iExcludedROMAddressStart(ROM_LINEAR_BASE),

   109 	iExcludedROMAddressEnd(0),

   110 	iPageSize(0x1000),

   111 	iBreakManager(0),

   112 	iStepper(0),

   113 	iStepLock(0),

   114 	iDfcQ(NULL),

   115 	iInitialisedCodeModifier(0),

   116 	iAsyncGetValueRequest(NULL)

   117 	{

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

   119 

   120 	iDevice = aLogicalDevice;

   121 

   122 	iClientThread = &Kern::CurrentThread();

   123 	iClientThread->Open();

   124 

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

   126 	            iClientThread, iClientThread->iId );

   127 

   128 

   129 	iPageSize = Kern::RoundToPageSize(1);

   130 	}

   131 

   132 //

   133 // DRM_DebugChannel destructor

   134 //

   135 DRM_DebugChannel::~DRM_DebugChannel()

   136 	{

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

   138 

   139 	if (iAsyncGetValueRequest)

   140 		{

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

   142 		Kern::DestroyClientRequest(iAsyncGetValueRequest);

   143 		}

   144 

   145 	NKern::ThreadEnterCS();

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

   147 	NKern::ThreadLeaveCS();

   148 

   149 	// Close breakpoint manager

   150 	if (iBreakManager)

   151 		{

   152 		NKern::ThreadEnterCS();

   153 		delete iBreakManager;

   154 		NKern::ThreadLeaveCS();

   155 		}

   156 

   157 	// Close stepping manager

   158 	if (iStepper)

   159 		{

   160 		NKern::ThreadEnterCS();

   161 		delete iStepper;

   162 		NKern::ThreadLeaveCS();

   163 		}

   164 

   165 	//close the debug process list

   166 	iDebugProcessList.Close();

   167 

   168 	DestroyDfcQ();

   169 

   170 	//close the code modifier

   171 	if (iInitialisedCodeModifier)

   172 		{

   173 		DebugSupport::CloseCodeModifier();

   174 		}

   175 	}

   176 

   177 void DRM_DebugChannel::DestroyDfcQ()

   178 	{

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

   180 	if (iDfcQ)

   181 		{

   182 		NKern::ThreadEnterCS();

   183 		iDfcQ->Destroy();

   184 		NKern::ThreadLeaveCS();

   185 		}

   186 	}

   187 

   188 //

   189 // DRM_DebugChannel::DoCreate

   190 //

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

   192 	{

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

   194 	TInt err = Kern::CreateClientDataRequest(iAsyncGetValueRequest);

   195 	if(err != KErrNone)

   196 		return err;

   197 

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

   199 		return KErrNotSupported;

   200 

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

   202 	// use of Trk kernel driver.

   203 	if (!DoSecurityCheck())

   204 		{

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

   206 			return KErrPermissionDenied;

   207 		}

   208 

   209 	if (anInfo)

   210 		{

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

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

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

   214 		// about kernel being stopped as kernel is multithreaded.

   215 		// just retaining this for future use.

   216 		TBuf8<32> buf;

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

   218 		if(err != KErrNone)

   219 			return err;

   220 		}

   221 

   222 	// Allocate a D_RMD_Breakpoints class as a breakpoint manager

   223 	NKern::ThreadEnterCS();

   224 	iBreakManager = new D_RMD_Breakpoints(this);

   225 	NKern::ThreadLeaveCS();

   226 	if (iBreakManager == NULL)

   227 		{

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

   229 		return KErrNoMemory;

   230 		}

   231 

   232 	// Initialise the new breakpoint manager object

   233 	iBreakManager->Init();

   234 

   235 	// Allocate a DRMDStepping class as the stepping manager

   236 	NKern::ThreadEnterCS();

   237 	iStepper = new DRMDStepping(this);

   238 	NKern::ThreadLeaveCS();

   239 	if (iStepper == NULL)

   240 		{

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

   242 		return KErrNoMemory;

   243 		}

   244 

   245 	// Initialize the code modifier for managing breakpoints.

   246 	TUint caps; //ignored for now

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

   248 	//if code modifier initializer failed,

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

   250 	if(err != KErrNone)

   251 		{

   252 		return err;

   253 		}

   254 	else

   255 		{

   256 		iInitialisedCodeModifier = ETrue;

   257 		}

   258 

   259 	//create and set the driver's Dfc queue

   260 	err = CreateDfcQ();

   261 	if(err != KErrNone)

   262 		{

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

   264 		}

   265 	SetDfcQ(iDfcQ);

   266 

   267 	iMsgQ.Receive();

   268 

   269 	iEventHandler = new DRM_DebugEventHandler;

   270 	if (!iEventHandler)

   271 		return KErrNoMemory;

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

   273 	if (err != KErrNone)

   274 		return err;

   275 

   276 	//return KErrNone;

   277 	return iEventHandler->Start();

   278 	}

   279 

   280 /**

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

   282  

   283 Protect access via a the event handler lock to 

   284 serialise all calls and protect concurrent access to data structures

   285 

   286 @param aMsg pointer to a TMessageBase object 

   287 

   288 @return error returned by called methods

   289 

   290 @see DRM_DebugEventHandler::HandleSpecificEvent where lock is also used

   291 @see DRM_DebugEventHandler::iProtectionLock

   292 

   293 */

   294 TInt DRM_DebugChannel::SendMsg(TMessageBase* aMsg)

   295 	{

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

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

   298 

   299 	iEventHandler->LockDataAccess();

   300 	

   301 	TThreadMessage& m = *(TThreadMessage*)aMsg;

   302 	TInt id = m.iValue;

   303 	TInt err = KErrNone;

   304 

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

   306 		{

   307 		// DoRequest

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

   309 		err = SendRequest(aMsg);

   310 		if (err != KErrNone)

   311 			Kern::RequestComplete(pStatus,err);

   312 		}

   313 	else

   314 		{

   315 		err = DLogicalChannel::SendMsg(aMsg);

   316 		}

   317 	

   318 	iEventHandler->ReleaseDataAccess();

   319 	return err;

   320 	}

   321 

   322 //

   323 // DRM_DebugChannel::SendRequest

   324 //

   325 TInt DRM_DebugChannel::SendRequest(TMessageBase* aMsg)

   326 	{

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

   328 

   329 	TThreadMessage& m = *(TThreadMessage*)aMsg;

   330 	TInt function = ~m.iValue;

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

   332 	TAny* a1 = m.Ptr1();

   333 

   334 	TInt err = KErrNotSupported;

   335 	switch(function)

   336 		{

   337 		case RRM_DebugDriver::ERequestGetEvent:

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

   339 			break;

   340 		}

   341 	if (err == KErrNone)

   342 		err = DLogicalChannel::SendMsg(aMsg);

   343 	return err;

   344 	}

   345 

   346 //

   347 // DRM_DebugChannel::PreAsyncGetValue

   348 //

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

   350 	{

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

   352 		aValue, aStatus );

   353 	

   354 	iAsyncGetValueRequest->Reset();

   355 	

   356 	TInt err = iAsyncGetValueRequest->SetStatus(aStatus);

   357 	if (err != KErrNone)

   358 		return err;

   359 	

   360 	iAsyncGetValueRequest->SetDestPtr(aValue);

   361 	return KErrNone;

   362 	}

   363 

   364 /**

   365   Create the Dfc queue for receiving messages

   366   */

   367 TInt DRM_DebugChannel::CreateDfcQ()

   368 	{

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

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

   371 	// Fix to stop t_rmdebug2 etc crashing the device.

   372 	// This should be removed once the rm debug driver has been updated for WDP.

   373 	if (r == KErrNone)

   374 		iDfcQ->SetRealtimeState(ERealtimeStateOff);

   375 	return r;

   376 	}

   377 

   378 //

   379 // DRM_DebugChannel::DoCancel

   380 //

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

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

   383 // to a user-side struct defining the cancellation

   384 //

   385 void DRM_DebugChannel::DoCancel(TInt aReqNo)

   386 	{

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

   388 

   389 	TRMD_DebugCancelInfo info;

   390 

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

   392 	if (err != KErrNone)

   393 		{

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

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

   396 		return;

   397 		}

   398 

   399 	// Find the process

   400 	DTargetProcess* pProcess = TheDProcessTracker.FindProcess(info.iProcessName);

   401 	if (pProcess == NULL)

   402 		{

   403 		// We are doomed. We don't know which event to cancel..

   404 		LOG_MSG2("Cannot determine which process is being debugged: %S", &(info.iProcessName));

   405 

   406 		return;

   407 		}

   408 

   409 	// Find the agent

   410 	DDebugAgent* debugAgent = pProcess->Agent(info.iAgentId);

   411 	if (debugAgent == NULL)

   412 		{

   413 		// Bad agent means there is no tracking agent

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

   415 		return;

   416 		}

   417 

   418 	// Agent completes/pends the request as appropriate.

   419 	debugAgent->CancelGetEvent();

   420 

   421 	}

   422 

   423 //

   424 // DRM_DebugChannel::DoRequest

   425 //

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

   427 	{

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

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

   430 

   431 	switch(aReqNo)

   432 		{

   433 		case RRM_DebugDriver::ERequestGetEvent:

   434 			{

   435 			TEventMetaData eventMetaData;

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

   437 			if (err != KErrNone)

   438 				{

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

   440 

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

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

   443 				return;

   444 				}

   445 

   446 			// Find the process

   447 			DTargetProcess* pProcess = TheDProcessTracker.FindProcess(eventMetaData.iTargetProcessName);

   448 			if (pProcess == NULL)

   449 				{

   450 				LOG_MSG("Cannot identify process being debugged");

   451 

   452 				// We could not locate the process, so the user asked for the wrong one.

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

   454 				return;

   455 				}

   456 

   457 			// Find the agent

   458 			DDebugAgent* debugAgent = pProcess->Agent(eventMetaData.iDebugAgentProcessId);

   459 			LOG_MSG5(" For agent pid=%d, DTargetProcess=0x%08x, Agent=0x%08x, iAsyncGetValueRequest0x%08x", 

   460 				I64LOW(eventMetaData.iDebugAgentProcessId), pProcess, debugAgent, iAsyncGetValueRequest );

   461 

   462 			if (debugAgent == NULL)

   463 				{

   464 				// Bad agent means there is no tracking agent

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

   466 				return;

   467 				}

   468 			// Agent completes/pends the request as appropriate.

   469 			debugAgent->GetEvent(iAsyncGetValueRequest, iClientThread);

   470 

   471 			break;

   472 			}

   473 		default:

   474 			{

   475 			// Don't know what to do, should not get here!

   476 			LOG_MSG("DRM_DebugChannel::DoRequest was passed an unsupported request aReqNo");

   477 

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

   479 			}

   480 		}

   481 	}

   482 

   483 //

   484 // DRM_DebugChannel::DoControl

   485 //

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

   487 	{

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

   489 

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

   491 

   492 	TInt err = KErrBadHandle;

   493 	DThread* threadObj = NULL;

   494 

   495 	switch(aFunction)

   496 		{

   497 		/* Security first */

   498 		case RRM_DebugDriver::EControlIsDebuggable:

   499 			{

   500 			err = IsDebuggable((TUint32)a1);

   501 			break;

   502 			}

   503 		case RRM_DebugDriver::EControlSetBreak:

   504 			{

   505 			err = SetBreak((TSetBreakInfo*)a1);

   506 			break;

   507 			}

   508 		case RRM_DebugDriver::EControlClearBreak:

   509 			{

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

   511 			break;

   512 			}

   513 		case RRM_DebugDriver::EControlModifyBreak:

   514 			{

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

   516 			break;

   517 			}

   518 		case RRM_DebugDriver::EControlModifyProcessBreak:

   519 			{

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

   521 			break;

   522 			}

   523 		case RRM_DebugDriver::EControlBreakInfo:

   524 			{

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

   526 			break;

   527 			}

   528 		case RRM_DebugDriver::EControlSuspendThread:

   529 			{

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

   531 			if (threadObj)

   532 			{

   533 				err = DoSuspendThread(threadObj);

   534 			}

   535 			break;

   536 			}

   537 		case RRM_DebugDriver::EControlResumeThread:

   538 			{

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

   540 			if (threadObj)

   541 				{

   542 				err = DoResumeThread(threadObj);

   543 				}

   544 			break;

   545 			}

   546 		case RRM_DebugDriver::EControlStepRange:

   547 			{

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

   549 			if (threadObj)

   550 				{

   551 				err = StepRange(threadObj, (TRM_DebugStepInfo*)a2);

   552 				}

   553 			break;

   554 			}

   555 		case RRM_DebugDriver::EControlReadMemory:

   556 			{

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

   558 			if (threadObj)

   559 				{

   560 				err = ReadMemory(threadObj, (TRM_DebugMemoryInfo*)a2);

   561 				}

   562 			break;

   563 			}

   564 		case RRM_DebugDriver::EControlWriteMemory:

   565 			{

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

   567 			if (threadObj)

   568 				{

   569 				err = WriteMemory(threadObj, (TRM_DebugMemoryInfo*)a2);

   570 				}

   571 			break;

   572 			}

   573 		case RRM_DebugDriver::EControlReadRegistersLegacy:

   574 			{

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

   576 			if (threadObj)

   577 				{

   578 				err = ReadRegistersLegacy(threadObj, (TRM_DebugRegisterInfo*)a2);

   579 				}

   580 			break;

   581 			}

   582 		case RRM_DebugDriver::EControlWriteRegistersLegacy:

   583 			{

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

   585 			if (threadObj)

   586 				{

   587 				err = WriteRegistersLegacy(threadObj, (TRM_DebugRegisterInfo*)a2);

   588 				}

   589 			break;

   590 			}

   591 		case RRM_DebugDriver::EControlReadRegisters:

   592 			{

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

   594 			if (threadObj)

   595 				{

   596 				err = ReadRegisters(threadObj, (TRM_DebugRegisterInformation*)a2);

   597 				}

   598 			break;

   599 			}

   600 		case RRM_DebugDriver::EControlWriteRegisters:

   601 			{

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

   603 			if (threadObj)

   604 				{

   605 				err = WriteRegisters(threadObj, (TRM_DebugRegisterInformation*)a2);

   606 				}

   607 			break;

   608 			}

   609 		case RRM_DebugDriver::EControlGetDebugFunctionalityBufSize:

   610 			{

   611 			LOG_MSG("RRM_DebugDriver::EControlGetDebugFunctionalityBufSize\n");

   612 

   613 			TDebugFunctionality df;

   614 

   615 			TUint size = df.GetDebugFunctionalityBufSize();

   616 

   617 			// Return size to user-side in a safe manner

   618 			err = Kern::ThreadRawWrite(iClientThread, a1, (TUint8*)&size, sizeof(TUint), iClientThread);

   619 			break;

   620 			}

   621 		case RRM_DebugDriver::EControlGetDebugFunctionality:

   622 			{

   623 			LOG_MSG("RRM_DebugDriver::EControlGetDebugFunctionality\n");

   624 

   625 			TDebugFunctionality df;

   626 

   627 			TUint32 dfsize = df.GetDebugFunctionalityBufSize();

   628 

   629 			// Alloc tmp buffer for Debug Functionality data

   630 			NKern::ThreadEnterCS();

   631 			TUint8* dfbuffer = (TUint8*)Kern::AllocZ(dfsize);

   632 			NKern::ThreadLeaveCS();

   633 			if (dfbuffer==NULL)

   634 				{

   635 				LOG_MSG2("Could not allocate memory for %d bytes\n",dfsize);

   636 

   637 				// could not allocate memory

   638 				return KErrNoMemory;

   639 				}

   640 

   641 			// Temporary descriptor to hold DF data

   642 			TPtr8 tmpPtr(dfbuffer,0,dfsize);

   643 

   644 			// Obtain the DF data

   645 			if (df.GetDebugFunctionality(tmpPtr) )

   646 				{

   647 				// Return the DF data to the user-side

   648 				err = Kern::ThreadDesWrite(iClientThread, a1, tmpPtr, 0, KChunkShiftBy0, iClientThread);

   649 				}

   650 			else

   651 				{

   652 				// Failed.

   653 				err = KErrGeneral;

   654 				}

   655 

   656 			// Free tmp buffer

   657 			NKern::ThreadEnterCS();

   658 			Kern::Free(dfbuffer);

   659 			NKern::ThreadLeaveCS();

   660 			break;

   661 			}

   662 		case RRM_DebugDriver::EControlAttachProcess:

   663 			{

   664 			LOG_MSG("RRM_DebugDriver::EControlAttachProcess");

   665 

   666 			err = AttachProcess(a1,a2);

   667 			break;

   668 			}

   669 		case RRM_DebugDriver::EControlDetachProcess:

   670 			{

   671 			LOG_MSG("RRM_DebugDriver::EControlDetachProcess");

   672 

   673 			err = DetachProcess(a1,a2);

   674 			break;

   675 			}

   676 		case RRM_DebugDriver::EControlDetachAgent:

   677 			{

   678 			LOG_MSG("RRM_DebugDriver::EControlDetachAgent");

   679 

   680 			err = DetachAgent(a1,a2);

   681 			break;

   682 			}

   683 		case RRM_DebugDriver::EControlSetEventAction:

   684 			{

   685 			LOG_MSG("RRM_DebugDriver::EControlSetEventAction");

   686 

   687 			err = SetEventAction(a1,a2);

   688 			break;

   689 			}

   690 		case RRM_DebugDriver::EControlGetMemoryOperationMaxBlockSize:

   691 			{

   692 			LOG_MSG("RRM_DebugDriver::EControlGetMemoryOperationMaxBlockSize\n");

   693 

   694 			TUint32 maxSize = TDebugFunctionality::GetMemoryOperationMaxBlockSize();

   695 

   696 			// Return size to user-side in a safe manner

   697 			err = Kern::ThreadRawWrite(iClientThread, a1, (TUint8*)&maxSize, sizeof(TUint32), iClientThread);

   698 			break;

   699 			}

   700 		case RRM_DebugDriver::EControlGetList:

   701 			{

   702 			LOG_MSG("RRM_DebugDriver::EControlGetList\n");

   703 			err = GetList((TListInformation*)a1);

   704 			break;

   705 			}

   706 		case RRM_DebugDriver::EControlStep:

   707 			{

   708 			LOG_MSG("RRM_DebugDriver::EControlStep\n");

   709 

   710 			err = Step((TUint32)a1,(TUint32)a2);

   711 			break;

   712 			}

   713 		case RRM_DebugDriver::EControlKillProcess:

   714 			{

   715 			LOG_MSG("RRM_DebugDriver::EControlKillProcess\n");

   716 

   717 			err = KillProcess((TUint32)a1,(TUint32)a2);

   718 			break;

   719 			}

   720 		default:

   721 			{

   722 			err = KErrGeneral;

   723 			}

   724 		}

   725 

   726 	if (KErrNone != err)

   727 		{

   728 		LOG_MSG2("Error %d from control function", err);

   729 		}

   730 

   731 	if (threadObj)

   732 		{

   733 		// Close the thread handle which has been opened by DebugUtils::OpenThreadHandle

   734 		threadObj->Close(NULL);

   735 		}

   736 

   737 	return err;

   738 	}

   739 

   740 void DRM_DebugChannel::HandleMsg(TMessageBase* aMsg)

   741 	{

   742 	LOG_MSG("DRM_DebugChannel::HandleMsg()");

   743 

   744 	TThreadMessage& m = *(TThreadMessage*)aMsg;

   745 	TInt id = m.iValue;

   746 

   747 	if (id == (TInt)ECloseMsg)

   748 		{

   749 		if (iEventHandler)

   750 			{

   751 			iEventHandler->Stop();

   752 			iEventHandler->Close();

   753 			iEventHandler = NULL;

   754 			}

   755 		m.Complete(KErrNone, EFalse);

   756 		return;

   757 		}

   758 

   759 	if (id == KMaxTInt)

   760 		{

   761 		// DoCancel

   762 		DoCancel(m.Int0());

   763 		m.Complete(KErrNone, ETrue);

   764 		return;

   765 		}

   766 

   767 	if (id < 0)

   768 		{

   769 		// DoRequest

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

   771 		DoRequest(~id, pStatus, m.Ptr1(), m.Ptr2());

   772 		m.Complete(KErrNone, ETrue);

   773 		}

   774 	else

   775 		{

   776 		// DoControl

   777 		TInt err = DoControl(id, m.Ptr0(), m.Ptr1());

   778 		m.Complete(err, ETrue);

   779 		}

   780 	}

   781 

   782 //

   783 // DRM_DebugChannel::RemoveProcess

   784 //

   785 TBool DRM_DebugChannel::RemoveProcess(TAny* a1, TAny* a2)

   786 	{

   787 	LOG_MSG("DRM_DebugChannel::RemoveProcess()");

   788 

   789 	DProcess *aProcess = (DProcess*)a1;

   790 

   791 	// Sanity check

   792 	if (!aProcess)

   793 		{

   794 		// No process was specified!

   795 		LOG_MSG("DRM_DebugChannel::RemoveProcess was called with an invalid process ID");

   796 		return EFalse;

   797 		}

   798 

   799 	// this is called when a process dies.  we want to mark any breakpoints in this

   800 	// process space as obsolete.  the main reason for this is so we don't return

   801 	// an error when the host debugger tries to clear breakpoints for the process

   802 

   803 	TUint32 codeAddress = 0;

   804 	TUint32 codeSize = 0;

   805 

   806 	LOG_EVENT_MSG2("Process being removed, Name %S", aProcess->iName);

   807 

   808 	DCodeSeg* codeSeg = aProcess->iCodeSeg;

   809 

   810 	if (codeSeg)

   811 		{

   812 		TModuleMemoryInfo processMemoryInfo;

   813 		TInt err = codeSeg->GetMemoryInfo(processMemoryInfo, aProcess);

   814 		if (err != KErrNone)

   815 			{

   816 			codeAddress = processMemoryInfo.iCodeBase;

   817 			codeSize = processMemoryInfo.iCodeSize;

   818 			}

   819 		else

   820 			{

   821 			LOG_MSG2("Error in getting memory info: %d", err);

   822 			}

   823 		}

   824 

   825 	if (!codeAddress || !codeSize)

   826 		{

   827 		LOG_EVENT_MSG2("Code segment not available for process %d", aProcess->iId);

   828 		// make sure there is not already a breakpoint at this address

   829 		for (TInt i = 0; i < iDebugProcessList.Count(); i++)

   830 			{

   831 			if (iDebugProcessList[i].iId == aProcess->iId)

   832 				{

   833 				codeAddress = iDebugProcessList[i].iCodeAddress;

   834 				codeSize = iDebugProcessList[i].iCodeSize;

   835 

   836 				//now remove from the list

   837 				iDebugProcessList.Remove(i);

   838 				break;

   839 				}

   840 			}

   841 		}

   842 

   843 	if (!codeAddress || !codeSize)

   844 		{

   845 		return EFalse;

   846 		}

   847 

   848 	iBreakManager->RemoveBreaksForProcess(aProcess->iId, codeAddress, codeSize);

   849 	return EFalse;

   850 	}

   851 

   852 //

   853 // DRM_DebugChannel::StartThread

   854 //

   855 TBool DRM_DebugChannel::StartThread(TAny* a1, TAny* a2)

   856 	{

   857 	LOG_EVENT_MSG("DRM_DebugChannel::StartThread()");

   858 

   859 	DThread *aThread = (DThread*)a1;

   860 	if(!aThread)

   861 		{

   862 		LOG_MSG("Error getting DThread object");

   863 		__NK_ASSERT_DEBUG(aThread);

   864 		return EFalse;

   865 		}

   866 

   867 	//a2 points to the thread creating the new thread.

   868 	//We have no use for it at the moment so just ignore it for now

   869 

   870 	TDriverEventInfo info;

   871 	info.iEventType = EEventsStartThread;

   872 	info.iThreadId = aThread->iId;

   873 	info.iThreadIdValid = ETrue;

   874 	DProcess* owningProcess = aThread->iOwningProcess;

   875 	if(owningProcess)

   876 		{

   877 		info.iProcessId = owningProcess->iId;

   878 		info.iProcessIdValid = ETrue;

   879 		DCodeSeg* p = owningProcess->iCodeSeg;

   880 		if(p && p->iFileName)

   881 			{

   882 			info.iFileName.Copy(*(p->iFileName));

   883 			DTargetProcess* foundProcess = TheDProcessTracker.FindProcess(*(p->iFileName));

   884 			if(foundProcess)

   885 				{

   886 				foundProcess->NotifyEvent(info);

   887 				}

   888 			else

   889 				{

   890 				LOG_EVENT_MSG2("Couldn't find process with name [%S]", p->iFileName);

   891 				}

   892 			}

   893 		else

   894 			{

   895 			if(p)

   896 				{

   897 				LOG_EVENT_MSG("\tCode segment name missing");

   898 				}

   899 			else

   900 				{

   901 				LOG_EVENT_MSG("\tCode segment is NULL");

   902 				}

   903 			}

   904 		}

   905 	return EFalse;

   906 	}

   907 

   908 //

   909 // DRM_DebugChannel::HandleAddProcessEvent

   910 //

   911 TBool DRM_DebugChannel::HandleAddProcessEvent(TAny* a1, TAny* a2)

   912 	{

   913 	LOG_EVENT_MSG("DRM_DebugChannel::AddProcess()");

   914 

   915 	DProcess *aProcess = (DProcess*)a1;

   916 	// a2 points to the thread creating the new process.

   917 	DThread *aThread = (DThread*)a2;

   918 

   919 	if(!aProcess)

   920 		{

   921 		LOG_MSG("Error getting DProcess object");

   922 		__NK_ASSERT_DEBUG(aProcess);

   923 		return EFalse;

   924 		}

   925 

   926 	TDriverEventInfo info;

   927 	info.iEventType = EEventsAddProcess;

   928 	info.iProcessId = aProcess->iId;

   929 

   930 	info.iCreatorThreadId  = aThread ? aThread->iId : 0;

   931 	info.iProcessIdValid = ETrue;

   932 

   933 	// Copy TUids

   934 	info.iUids = aProcess->iUids;

   935 

   936 	info.iUidsValid = ETrue;

   937 

   938 	// copy name of the process

   939 	if (aProcess->iName)

   940 		{

   941 		// copy the name of the process

   942 		info.iFileName.Copy(*aProcess->iName);

   943 

   944 		DTargetProcess* foundProcess = TheDProcessTracker.FindProcess(*(aProcess->iName));

   945 		if(foundProcess)

   946 			{

   947 			foundProcess->NotifyEvent(info);

   948 			}

   949 		else

   950 			{

   951 			// AddProcess event does not have fully-qualified path, it has "filename.exe"

   952 			// So we try a less-precise match

   953 			DTargetProcess* foundProcess = TheDProcessTracker.FuzzyFindProcess(*(aProcess->iName));

   954 			if(foundProcess)

   955 				{

   956 				foundProcess->NotifyEvent(info);

   957 				}

   958 			else

   959 				{

   960 				LOG_EVENT_MSG2("Couldn't find process with name [%S]", aProcess->iName);

   961 				}

   962 			}

   963 		}

   964 	else

   965 		{

   966 		LOG_EVENT_MSG("DRM_DebugChannel::AddProcess - No iName for this process");

   967 		}

   968 

   969 	return EFalse;

   970 	}

   971 

   972 //

   973 // DRM_DebugChannel::HandleRemoveProcessEvent

   974 //

   975 TBool DRM_DebugChannel::HandleRemoveProcessEvent(TAny* a1, TAny* a2)

   976 	{

   977 	LOG_EVENT_MSG("DRM_DebugChannel::RemoveProcess()");

   978 

   979 	DProcess *aProcess = (DProcess*)a1;

   980 	if(!aProcess)

   981 		{

   982 		LOG_MSG("Error getting DProcess object");

   983 		__NK_ASSERT_DEBUG(aProcess);

   984 		return EFalse;

   985 		}

   986 

   987 	// a2 points to the thread creating the new process.

   988 	// We have no use for it at the moment so just ignore it for now

   989 	// Also, it may not be known and therefore NULL

   990 

   991 	TDriverEventInfo info;

   992 	info.iEventType = EEventsRemoveProcess;

   993 	info.iProcessId = aProcess->iId;

   994 	info.iProcessIdValid = ETrue;

   995 

   996 	// copy name of the process

   997 	if (aProcess->iName)

   998 		{

   999 		// copy the name of the process

  1000 		info.iFileName.Copy(*aProcess->iName);

  1001 

  1002 		DTargetProcess* foundProcess = TheDProcessTracker.FindProcess(*(aProcess->iName));

  1003 		if(foundProcess)

  1004 			{

  1005 			foundProcess->NotifyEvent(info);

  1006 			}

  1007 		else

  1008 			{

  1009 			// RemoveProcess event does not have fully-qualified path, it has "filename.exe"

  1010 			// So we try a less-precise match

  1011 			DTargetProcess* foundProcess = TheDProcessTracker.FuzzyFindProcess(*(aProcess->iName));

  1012 			if(foundProcess)

  1013 				{

  1014 				foundProcess->NotifyEvent(info);

  1015 				}

  1016 			else

  1017 				{

  1018 				LOG_EVENT_MSG2("Couldn't find process with name [%S]", aProcess->iName);

  1019 				}

  1020 			}

  1021 

  1022 		}

  1023 	else

  1024 		{

  1025 		LOG_EVENT_MSG("DRM_DebugChannel::AddProcess - No iName for this process");

  1026 		}

  1027 

  1028 	return EFalse;

  1029 	}

  1030 

  1031 //

  1032 // DRM_DebugChannel::AddLibrary

  1033 //

  1034 TBool DRM_DebugChannel::AddLibrary(TAny* a1, TAny* a2)

  1035 	{

  1036 	LOG_EVENT_MSG("DRM_DebugChannel::AddLibrary()");

  1037 

  1038 	DLibrary *aLibrary = (DLibrary*)a1;

  1039 	DThread *aThread = (DThread*)a2;

  1040 

  1041 	// sanity check

  1042 	if (!aLibrary)

  1043 		{

  1044 		LOG_EVENT_MSG("DRM_DebugChannel::AddLibrary called with no library specified");

  1045 		return EFalse;

  1046 		}

  1047 

  1048 	if (!aThread)

  1049 		{

  1050 		LOG_EVENT_MSG("DRM_DebugChannel::AddLibrary called with no thread specified");

  1051 		return EFalse;

  1052 		}

  1053 

  1054 	LOG_EVENT_MSG2(("Lib loaded: %S"), aLibrary->iName);

  1055 

  1056 	if (aThread)

  1057 		{

  1058 		// make sure this is not the debugger thread

  1059 		if ((aThread != iClientThread) && (aThread->iOwningProcess->iId != iClientThread->iOwningProcess->iId))

  1060 			{

  1061 			TDriverEventInfo info;

  1062 

  1063 			info.iEventType = EEventsAddLibrary;

  1064 			info.iProcessId = aThread->iOwningProcess->iId;

  1065 			info.iProcessIdValid = ETrue;

  1066 			info.iThreadId = aThread->iId;

  1067 			info.iThreadIdValid = ETrue;

  1068 

  1069 			//get the code address

  1070 			DCodeSeg* codeSeg = aLibrary->iCodeSeg;

  1071 			if (!codeSeg)

  1072 				{

  1073 				LOG_EVENT_MSG2("Code segment not available for library %S", aLibrary->iName);

  1074 				return EFalse;

  1075 				}

  1076 

  1077 			// Uid3

  1078 			info.iUids = codeSeg->iUids;

  1079 			info.iUidsValid = ETrue;

  1080 

  1081 			TModuleMemoryInfo memoryInfo;

  1082 			TInt err = codeSeg->GetMemoryInfo(memoryInfo, NULL); //NULL for DProcess should be ok;

  1083 			if (err != KErrNone)

  1084 				{

  1085 				LOG_EVENT_MSG2("Error in getting memory info: %d", err);

  1086 				return EFalse;

  1087 				}

  1088 

  1089 			info.iCodeAddress = memoryInfo.iCodeBase;

  1090 			info.iDataAddress = memoryInfo.iInitialisedDataBase;

  1091 

  1092 			info.iFileName.Copy(*(aLibrary->iName)); //just the name, without uid info.

  1093 

  1094 			//queue up or complete the event

  1095 			info.iArg1 = a1;

  1096 			info.iArg2 = a2;

  1097 			NotifyEvent(info);

  1098 			}

  1099 

  1100 		}

  1101 	return EFalse;

  1102 	}

  1103 

  1104 //

  1105 // DRM_DebugChannel::RemoveLibrary

  1106 //

  1107 TBool DRM_DebugChannel::RemoveLibrary(TAny* a1, TAny* a2)

  1108 	{

  1109 	LOG_EVENT_MSG("DRM_DebugChannel::RemoveLibrary()");

  1110 	DLibrary *aLibrary = (DLibrary*)a1;

  1111 

  1112 	// sanity check

  1113 	if (!aLibrary)

  1114 		{

  1115 		LOG_EVENT_MSG("DRM_DebugChannel::RemoveLibrary called with no library specified");

  1116 		return EFalse;

  1117 		}

  1118 

  1119 	LOG_EVENT_MSG2(("Lib unloaded: %S"), aLibrary->iName);

  1120 

  1121 	// this is called when all handles to this library have been closed.  this can happen when a process dies, or when a dll is

  1122 	// unloaded while the process lives on.  in former case, we don't need to notify the host debugger because that process is

  1123 	// dying anyway.  for the latter case, we do need to notify the host so it can unload the symbolics, etc.

  1124 

  1125 	DThread* aThread = &Kern::CurrentThread();

  1126 

  1127 	if ((aThread) &&

  1128 			(aThread != iClientThread) &&

  1129 			(aThread->iOwningProcess->iId != iClientThread->iOwningProcess->iId))

  1130 		{

  1131 		//the library gets unloaded only when the mapcount is 0.

  1132 		if (aLibrary->iMapCount != 0)

  1133 			return EFalse;

  1134