Mercurial Mercurial > oss > MCL > sf > os > kernelhwsrv / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
kernel/eka/drivers/debug/rmdebug/rm_debug_eventhandler.cpp
branchRCL_3
changeset 21 e7d2d738d3c2
parent 0 a41df078684a
equal deleted inserted replaced
20:597aaf25e343 21:e7d2d738d3c2 
    42 		iEventHandlers[i] = &DRM_DebugChannel::HandleUnsupportedEvent;
 
    42 		iEventHandlers[i] = &DRM_DebugChannel::HandleUnsupportedEvent;
 
    43 		}
 
    43 		}
 
    44 	iEventHandlers[EEventUserTrace] = &DRM_DebugChannel::HandleUserTrace;
 
    44 	iEventHandlers[EEventUserTrace] = &DRM_DebugChannel::HandleUserTrace;
 
    45 	iEventHandlers[EEventRemoveLibrary] = &DRM_DebugChannel::RemoveLibrary;
 
    45 	iEventHandlers[EEventRemoveLibrary] = &DRM_DebugChannel::RemoveLibrary;
 
    46 	iEventHandlers[EEventAddLibrary] = &DRM_DebugChannel::AddLibrary;
 
    46 	iEventHandlers[EEventAddLibrary] = &DRM_DebugChannel::AddLibrary;
 
    47 	iEventHandlers[EEventRemoveProcess] = &DRM_DebugChannel::RemoveProcess;
 
       
    48 	iEventHandlers[EEventStartThread] = &DRM_DebugChannel::StartThread;
 
    47 	iEventHandlers[EEventStartThread] = &DRM_DebugChannel::StartThread;
 
    49 	iEventHandlers[EEventSwExc] = &DRM_DebugChannel::HandleSwException;
 
    48 	iEventHandlers[EEventSwExc] = &DRM_DebugChannel::HandleSwException;
 
    50 	iEventHandlers[EEventHwExc] = &DRM_DebugChannel::HandleHwException;
 
    49 	iEventHandlers[EEventHwExc] = &DRM_DebugChannel::HandleHwException;
 
    51 	iEventHandlers[EEventKillThread] = &DRM_DebugChannel::HandleEventKillThread;
 
    50 	iEventHandlers[EEventKillThread] = &DRM_DebugChannel::HandleEventKillThread;
 
    52 	iEventHandlers[EEventAddProcess] = &DRM_DebugChannel::HandleAddProcessEvent;
 
    51 	iEventHandlers[EEventAddProcess] = &DRM_DebugChannel::HandleAddProcessEvent;
 
    53 	iEventHandlers[EEventRemoveProcess] = &DRM_DebugChannel::HandleRemoveProcessEvent;
 
    52 	iEventHandlers[EEventRemoveProcess] = &DRM_DebugChannel::HandleRemoveProcessEvent;
 
    54 }
 
    53 }
 
    55 
    54 
    56 TInt DRM_DebugEventHandler::Create(DLogicalDevice* aDevice, DLogicalChannel* aChannel, DThread* aClient)
 
    55 TInt DRM_DebugEventHandler::Create(DLogicalDevice* aDevice, DLogicalChannel* aChannel, DThread* aClient)
 
    57 {
 
    56 {
 
    58 	LOG_MSG("DRM_DebugEventHandler::Create()");
 
    57 	LOG_MSG3("DRM_DebugEventHandler::Create(), aClientthread=0x%08x id=%d", aClient, aClient->iId);
 
    59 
    58 
    60 	TInt err;
 
    59 	TInt err;
 
    61 	err = aDevice->Open();
 
    60 	err = aDevice->Open();
 
    62 	if (err != KErrNone)
 
    61 	if (err != KErrNone)
 
    63 		return err;
 
    62 		return err;
 
    69 	if (err != KErrNone)
 
    68 	if (err != KErrNone)
 
    70 		return err;
 
    69 		return err;
 
    71 	iClientThread = aClient;
 
    70 	iClientThread = aClient;
 
    72 
    71 
    73 	// Use a semaphore to protect our data structures from concurrent access.
 
    72 	// Use a semaphore to protect our data structures from concurrent access.
 
    74 	err = Kern::SemaphoreCreate(iLock, _L("RM_DebugEventHandlerLock"), 1 /* Initial count */);
 
    73 	err = Kern::SemaphoreCreate(iProtectionLock, _L("RM_DebugEventHandlerLock"), 1 /* Initial count */);
 
    75 	if (err != KErrNone)
 
    74 	if (err != KErrNone)
 
    76 		return err;
 
    75 		return err;
 
    77 
    76 
    78 
    77 
    79 	return Add();
 
    78 	return Add();
 
    82 
    81 
    83 DRM_DebugEventHandler::~DRM_DebugEventHandler()
 
    82 DRM_DebugEventHandler::~DRM_DebugEventHandler()
 
    84 {
 
    83 {
 
    85 	LOG_MSG("DRM_DebugEventHandler::~DRM_DebugEventHandler()");
 
    84 	LOG_MSG("DRM_DebugEventHandler::~DRM_DebugEventHandler()");
 
    86 
    85 
    87 	if (iLock)
 
    86 	if (iProtectionLock)
 
    88 		iLock->Close(NULL);
 
    87 		iProtectionLock->Close(NULL);
 
    89 	
    88 	
    90 	if (iDevice)
 
    89 	if (iDevice)
 
    91 		iDevice->Close(NULL);	
    90 		iDevice->Close(NULL);	
    92 	
    91 	
    93 	if (iClientThread)
 
    92 	if (iClientThread)
 
   123 
   122 
   124 
   123 
   125 
   124 
   126 TUint DRM_DebugEventHandler::HandleEvent(TKernelEvent aType, TAny* a1, TAny* a2)
 
   125 TUint DRM_DebugEventHandler::HandleEvent(TKernelEvent aType, TAny* a1, TAny* a2)
 
   127 	{
 
   126 	{
 
   128 	if((!iTracking) || (aType > (TUint32)EEventLimit))
 
   127 	
       
   128 	/*
 
       
   129 	 * Check if we are tracking things at all OR 
       
   130 	 * this event is beyond the limit of known events OR 
       
   131 	 * this event is from the debug thread itself (don't want to debug ourselves) OR
 
       
   132 	 * this event has a handler (there is no point in proceeding without a handler)
 
       
   133 	 */
 
       
   134 	if( (!iTracking) || 
       
   135 			(aType > (TUint32)EEventLimit) ||
 
       
   136 			(iClientThread == &Kern::CurrentThread()) ||
 
       
   137 	    (iEventHandlers[aType] == &DRM_DebugChannel::HandleUnsupportedEvent) )
 
   129 		{
 
   138 		{
 
   130 		return ERunNext;
 
   139 		return ERunNext;
 
   131 		}
 
   140 		}
 
       
   141 	
   132 	return HandleSpecificEvent(aType,a1,a2) ? EExcHandled : ERunNext;
 
   142 	return HandleSpecificEvent(aType,a1,a2) ? EExcHandled : ERunNext;
 
       
   143 
   133 	}
 
   144 	}
 
   134 
   145 
   135 TBool DRM_DebugEventHandler::HandleSpecificEvent(TKernelEvent aType, TAny* a1, TAny* a2)
 
   146 TBool DRM_DebugEventHandler::HandleSpecificEvent(TKernelEvent aType, TAny* a1, TAny* a2)
 
   136 	{
 
   147 	{
 
   137 	TBool ret = EFalse;
 
   148 	TBool ret = EFalse;
 
   138 
   149 
   139 	NKern::ThreadEnterCS();
 
   150 	NKern::ThreadEnterCS();
 
   140 	Kern::SemaphoreWait(*iLock);
 
   151 	LockDataAccess();
 
   141 	
   152 
       
   153 
   142 	if (iChannel)
 
   154 	if (iChannel)
 
   143 		{
 
   155 		{
 
   144 		ret = (iChannel->*(iEventHandlers[aType]))(a1, a2);
 
   156 		ret = (iChannel->*(iEventHandlers[aType]))(a1, a2);
 
   145 		}
 
   157 		}
 
   146 
   158 	ReleaseDataAccess();
 
   147 	Kern::SemaphoreSignal(*iLock);
 
       
   148 	NKern::ThreadLeaveCS();
 
   159 	NKern::ThreadLeaveCS();
 
   149 
   160 
   150 	switch(aType)
 
   161 	switch(aType)
 
   151 		{
 
   162 		{
 
   152 		case EEventHwExc:
 
   163 		case EEventHwExc:
MCL/sf/os/kernelhwsrv