1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 #include "MemSpyDriverEventMonitor.h"

    19 

    20 // System includes

    21 #include <kern_priv.h>

    22 #include <nk_trace.h>

    23 

    24 // User includes

    25 #include "MemSpyDriverUtils.h"

    26 #include "MemSpyDriverDevice.h"

    27 

    28 #ifdef __MARM__

    29 #include "kdebug.h"

    30 #endif //__MARM__

    31 

    32 _LIT( KMemSpyEventMonitorMutexName, "MemSpyEventMonitor");

    33 

    34 

    35 DMemSpyEventMonitor::DMemSpyEventMonitor()

    36 :	DKernelEventHandler( EventHandler, this )

    37 	{

    38 	}

    39 

    40 

    41 DMemSpyEventMonitor::~DMemSpyEventMonitor()

    42 	{

    43     TRACE_EM( Kern::Printf("DMemSpyEventMonitor::~DMemSpyEventMonitor() - START" ));

    44 

    45 	if  ( iLock )

    46 		{

    47         TRACE_EM( Kern::Printf("DMemSpyEventMonitor::~DMemSpyEventMonitor() - closing iLock mutex" ));

    48 		iLock->Close(NULL);

    49 		}

    50 

    51 	if  ( iDevice )

    52 		{

    53         TRACE_EM( Kern::Printf("DMemSpyEventMonitor::~DMemSpyEventMonitor() - closing iDevice" ));

    54 		iDevice->Close(NULL);

    55 		}

    56 

    57     TRACE_EM( Kern::Printf("DMemSpyEventMonitor::~DMemSpyEventMonitor() - END" ));

    58 	}

    59 

    60 

    61 TInt DMemSpyEventMonitor::Create( DMemSpyDriverDevice* aDevice )

    62 	{

    63     TRACE_EM( Kern::Printf("DMemSpyEventMonitor::Create() - START - aDevice: 0x%08x", aDevice ));

    64     TInt err = aDevice->Open();

    65     TRACE_EM( Kern::Printf("DMemSpyEventMonitor::Create() - device open err: %d", err ));

    66     //

    67     if (err == KErrNone )

    68 	    {

    69         iDevice = aDevice;

    70         //

    71         err = Kern::MutexCreate( iLock, KMemSpyEventMonitorMutexName, KMutexOrdNone );

    72         TRACE_EM( Kern::Printf("DMemSpyEventMonitor::Create() - mutex create error: %d", err ));

    73         //

    74         if (!err)

    75 	        {

    76 	        err = Add();

    77 	        }

    78         }

    79     //	

    80     TRACE_EM( Kern::Printf("DMemSpyEventMonitor::Create() - END - err: %d", err ));

    81 	return err;

    82 	}

    83 

    84 

    85 TInt DMemSpyEventMonitor::Start()

    86 	{

    87     TRACE_EM( Kern::Printf("DMemSpyEventMonitor::Start() - START"));

    88 

    89 	NKern::ThreadEnterCS();

    90 	Kern::MutexWait( *iLock );

    91 

    92     iTracking = ETrue;

    93 

    94 	Kern::MutexSignal( *iLock );

    95 	NKern::ThreadLeaveCS();

    96 

    97     TRACE_EM( Kern::Printf("DMemSpyEventMonitor::Start() - END") );

    98 	return KErrNone;

    99 	}

   100 

   101 

   102 TInt DMemSpyEventMonitor::Stop()

   103 	{

   104     TRACE_EM( Kern::Printf("DMemSpyEventMonitor::Stop() - START") );

   105 

   106     NKern::ThreadEnterCS();

   107 	Kern::MutexWait( *iLock );

   108 

   109 	iTracking = EFalse;

   110 

   111 	Kern::MutexSignal( *iLock );

   112 	NKern::ThreadLeaveCS();

   113 

   114     TRACE_EM( Kern::Printf("DMemSpyEventMonitor::Stop() - END") );

   115     return KErrNone;

   116     }

   117     

   118     

   119 TInt DMemSpyEventMonitor::RequestEvents( MMemSpyEventMonitorObserver& aObserver )

   120     {

   121     NKern::ThreadEnterCS();

   122 	Kern::MutexWait( *iLock );

   123 

   124     TInt error = KErrAlreadyExists;

   125     //

   126     if  ( IsObserving( aObserver ) == EFalse )

   127         {

   128         iObservers.Add( &aObserver.__iEMLink );

   129         error = KErrNone;

   130         }

   131     //

   132 	Kern::MutexSignal( *iLock );

   133 	NKern::ThreadLeaveCS();

   134     //

   135     TRACE_EM( Kern::Printf("DMemSpyEventMonitor::RequestEvents() - END - error: %d", error) );

   136     return error;

   137     }

   138 

   139 

   140 TInt DMemSpyEventMonitor::RequestEventsCancel( MMemSpyEventMonitorObserver& aObserver )

   141     {

   142     TRACE_EM( Kern::Printf("DMemSpyEventMonitor::RequestEventsCancel() - START - aObserver: 0x%08x", &aObserver) );

   143     NKern::ThreadEnterCS();

   144 	Kern::MutexWait( *iLock );

   145 

   146     const TBool isObserving = IsObserving( aObserver );

   147     if  ( isObserving )

   148         {

   149         TRACE_EM( Kern::Printf("DMemSpyEventMonitor::RequestEventsCancel() - dequing observer...") );

   150         aObserver.__iEMLink.Deque();

   151         TRACE_EM( Kern::Printf("DMemSpyEventMonitor::RequestEventsCancel() - observer dequeued") );

   152         }

   153 

   154 	Kern::MutexSignal( *iLock );

   155 	NKern::ThreadLeaveCS();

   156     //

   157     TRACE_EM( Kern::Printf("DMemSpyEventMonitor::RequestEventsCancel() - END") );

   158     return KErrNone;

   159     }

   160 

   161 

   162 TUint DMemSpyEventMonitor::EventHandler( TKernelEvent aType, TAny* a1, TAny* a2, TAny* aSelf )

   163 	{

   164     DMemSpyEventMonitor* self = (DMemSpyEventMonitor*) aSelf;

   165 	const TUint ret = self->HandleEvent( aType, a1, a2 );

   166     return ret;

   167 	}

   168 

   169 

   170 TUint DMemSpyEventMonitor::HandleEvent( TKernelEvent aType, TAny* a1, TAny* /*a2*/ )

   171 	{ 

   172 	// TRACE_EM( Kern::Printf("DMemSpyEventMonitor::HandleEvent() - PRE WAIT"));

   173 	NKern::ThreadEnterCS();

   174 	Kern::MutexWait(*iLock);

   175 	// TRACE_EM( Kern::Printf("DMemSpyEventMonitor::HandleEvent() - POST WAIT"));

   176 

   177 	if  ( iTracking )

   178 		{

   179 		switch( aType )

   180 			{

   181         //////////////////////////////////

   182         // THREAD HANDLING

   183         //////////////////////////////////

   184 		case EEventAddThread:

   185 			{

   186 			// TRACE_EM( Kern::Printf("DMemSpyEventMonitor::HandleEvent() - EEventAddThread"));

   187 			EventThreadAdd( (DThread*) a1 );

   188 			break;

   189 			}

   190 		case EEventRemoveThread:

   191 			{

   192 			// TRACE_EM( Kern::Printf("DMemSpyEventMonitor::HandleEvent() - EEventRemoveThread"));

   193 			EventThreadRemoved( (DThread*) a1 );

   194 			break;

   195 			}

   196 		case EEventKillThread:

   197 			{

   198 			// TRACE_EM( Kern::Printf("DMemSpyEventMonitor::HandleEvent() - EEventKillThread"));

   199 			EventThreadKilled( (DThread*) a1 );

   200 			break;

   201 			}

   202 

   203         //////////////////////////////////

   204         // PROCESS HANDLING

   205         //////////////////////////////////

   206 	    case EEventAddProcess:

   207 			{

   208 			// TRACE_EM( Kern::Printf("DMemSpyEventMonitor::HandleEvent() - EEventAddProcess"));

   209 			EventProcessAdd( (DProcess*) a1 );

   210 			break;

   211 			}

   212 	    case EEventUpdateProcess:

   213 			{

   214 			// TRACE_EM( Kern::Printf("DMemSpyEventMonitor::HandleEvent() - EEventUpdateProcess"));

   215 			EventProcessUpdate( (DProcess*) a1 );

   216 			break;

   217 			}

   218 	    case EEventRemoveProcess:

   219 			{

   220 			// TRACE_EM( Kern::Printf("DMemSpyEventMonitor::HandleEvent() - EEventRemoveProcess"));

   221 			EventProcessRemoved( (DProcess*) a1 );

   222 			break;

   223 			}

   224 			

   225         //////////////////////////////////

   226         // CHUNK HANDLING

   227         //////////////////////////////////

   228 	    case EEventNewChunk:

   229 			{

   230 			// TRACE_EM( Kern::Printf("DMemSpyEventMonitor::HandleEvent() - EEventNewChunk"));

   231 			EventChunkAdd( (DChunk*) a1 );

   232 			break;

   233 			}

   234 	    case EEventUpdateChunk:

   235 			{

   236 			// TRACE_EM( Kern::Printf("DMemSpyEventMonitor::HandleEvent() - EEventUpdateChunk"));

   237 			EventChunkUpdate( (DChunk*) a1 );

   238 			break;

   239 			}

   240 		case EEventDeleteChunk:

   241 			{

   242 			// TRACE_EM( Kern::Printf("DMemSpyEventMonitor::HandleEvent() - EEventDeleteChunk"));

   243 			EventChunkDelete( (DChunk*) a1 );

   244 			break;

   245 			}

   246 

   247         default:

   248 			break;

   249 			}

   250 		}

   251 

   252 	// TRACE_EM( Kern::Printf("DMemSpyEventMonitor::HandleEvent() - PRE SIGNAL "));

   253 	Kern::MutexSignal( *iLock );

   254 	NKern::ThreadLeaveCS();

   255 	// TRACE_EM( Kern::Printf("DMemSpyEventMonitor::HandleEvent() - POST SIGNAL "));

   256 

   257 	// Allow other handlers to see this event

   258 	return DKernelEventHandler::ERunNext;

   259 	}

   260 

   261 

   262 void DMemSpyEventMonitor::EventProcessAdd( DProcess* aProcess )

   263     {

   264 	TRACE_EM( Kern::Printf("DMemSpyEventMonitor::EventProcessAdd() - aProcess: 0x%08x [%d] (%O)", aProcess, aProcess->iId, aProcess ));

   265     //

   266     const SDblQueLink* const anchor = &iObservers.iA;

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

   268 		{

   269 		MMemSpyEventMonitorObserver* const observer = _LOFF(link, MMemSpyEventMonitorObserver, __iEMLink);

   270         const TInt typeMask = observer->EMTypeMask();

   271         //

   272         if ( typeMask & EMemSpyEventProcessAdd )

   273 			{

   274             observer->EMHandleProcessAdd( *aProcess );

   275 			}

   276         }

   277     }

   278 

   279 

   280 void DMemSpyEventMonitor::EventProcessUpdate( DProcess* aProcess )

   281     {

   282 	TRACE_EM( Kern::Printf("DMemSpyEventMonitor::EventProcessUpdate() - aProcess: 0x%08x [%d] (%O)", aProcess, aProcess->iId, aProcess ));

   283     //

   284 	const SDblQueLink* const anchor = &iObservers.iA;

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

   286 		{

   287 		MMemSpyEventMonitorObserver* const observer = _LOFF(link, MMemSpyEventMonitorObserver, __iEMLink);

   288         const TInt typeMask = observer->EMTypeMask();

   289         //

   290         if ( typeMask & EMemSpyEventProcessUpdate )

   291 			{

   292             observer->EMHandleProcessUpdated( *aProcess );

   293 			}

   294         }

   295     }

   296 

   297 

   298 void DMemSpyEventMonitor::EventProcessRemoved( DProcess* aProcess )

   299     {

   300 	TRACE_EM( Kern::Printf("DMemSpyEventMonitor::EventProcessRemoved() - aProcess: 0x%08x [%d] (%O)", aProcess, aProcess->iId, aProcess ));

   301     //

   302 	const SDblQueLink* const anchor = &iObservers.iA;

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

   304 		{

   305 		MMemSpyEventMonitorObserver* const observer = _LOFF(link, MMemSpyEventMonitorObserver, __iEMLink);

   306         const TInt typeMask = observer->EMTypeMask();

   307         //

   308         if ( typeMask & EMemSpyEventProcessRemove )

   309 			{

   310             observer->EMHandleProcessRemoved( *aProcess );

   311 			}

   312         }

   313     }

   314 

   315 

   316 void DMemSpyEventMonitor::EventThreadAdd( DThread* aThread )

   317     {

   318 	TRACE_EM( Kern::Printf("DMemSpyEventMonitor::EventThreadAdd() - aThread: 0x%08x [%4d] (%O)", aThread, aThread->iId, aThread ));

   319     //

   320 	const SDblQueLink* const anchor = &iObservers.iA;

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

   322 		{

   323 		MMemSpyEventMonitorObserver* const observer = _LOFF(link, MMemSpyEventMonitorObserver, __iEMLink);

   324         const TInt typeMask = observer->EMTypeMask();

   325         //

   326         if ( typeMask & EMemSpyEventThreadAdd )

   327 			{

   328             observer->EMHandleThreadAdd( *aThread );

   329 			}

   330         }

   331     }

   332 

   333 

   334 void DMemSpyEventMonitor::EventThreadRemoved( DThread* aThread )

   335     {

   336 	TRACE_EM( Kern::Printf("DMemSpyEventMonitor::EventThreadRemoved() - aThread: 0x%08x [%4d] (%O)", aThread, aThread->iId, aThread ));

   337     //

   338 	const SDblQueLink* const anchor = &iObservers.iA;

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

   340 		{

   341 		MMemSpyEventMonitorObserver* const observer = _LOFF(link, MMemSpyEventMonitorObserver, __iEMLink);

   342         const TInt typeMask = observer->EMTypeMask();

   343         //

   344         if ( typeMask & EMemSpyEventThreadRemove )

   345 			{

   346             observer->EMHandleThreadRemoved( *aThread );

   347 			}

   348         }

   349     }

   350 

   351 

   352 void DMemSpyEventMonitor::EventThreadKilled( DThread* aThread )

   353     {

   354 	TRACE_EM( Kern::Printf("DMemSpyEventMonitor::EventThreadKilled() - aThread: 0x%08x [%4d] (%O)", aThread, aThread->iId, aThread ));

   355     //

   356 	const SDblQueLink* const anchor = &iObservers.iA;

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

   358 		{

   359 		MMemSpyEventMonitorObserver* const observer = _LOFF(link, MMemSpyEventMonitorObserver, __iEMLink);

   360         const TInt typeMask = observer->EMTypeMask();

   361         //

   362         if ( typeMask & EMemSpyEventThreadKill )

   363 			{

   364             observer->EMHandleThreadKilled( *aThread );

   365 			}

   366         }

   367     }

   368 

   369 

   370 void DMemSpyEventMonitor::EventChunkAdd( DChunk* aChunk )

   371     {

   372     TRACE_EM( Kern::Printf("DMemSpyEventMonitor::EventChunkAdd() - aChunk: 0x%08x [%10d] {OP: %4d, CO: %4d} (%O)", aChunk, aChunk->Size(), ( aChunk->iOwningProcess ? aChunk->iOwningProcess->iId : 0 ), aChunk->iControllingOwner, aChunk ));

   373     //

   374 	const SDblQueLink* const anchor = &iObservers.iA;

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

   376 		{

   377 		MMemSpyEventMonitorObserver* const observer = _LOFF(link, MMemSpyEventMonitorObserver, __iEMLink);

   378         const TInt typeMask = observer->EMTypeMask();

   379         //

   380         if ( typeMask & EMemSpyEventChunkAdd )

   381 			{

   382             observer->EMHandleChunkAdd( *aChunk );

   383 			}

   384         }

   385     }

   386 

   387 

   388 void DMemSpyEventMonitor::EventChunkUpdate( DChunk* aChunk )

   389     {

   390     TRACE_EM( Kern::Printf("DMemSpyEventMonitor::EventChunkUpdate() - aChunk: 0x%08x [%10d] {OP: %4d, CO: %4d} (%O)", aChunk, aChunk->Size(), ( aChunk->iOwningProcess ? aChunk->iOwningProcess->iId : 0 ), aChunk->iControllingOwner, aChunk ));

   391     //

   392 	const SDblQueLink* const anchor = &iObservers.iA;

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

   394 		{

   395 		MMemSpyEventMonitorObserver* const observer = _LOFF(link, MMemSpyEventMonitorObserver, __iEMLink);

   396         const TInt typeMask = observer->EMTypeMask();

   397         //

   398         if ( typeMask & EMemSpyEventChunkUpdate )

   399 			{

   400             observer->EMHandleChunkUpdated( *aChunk );

   401 			}

   402         }

   403     }

   404 

   405 

   406 void DMemSpyEventMonitor::EventChunkDelete( DChunk* aChunk )

   407     {

   408     TRACE_EM( Kern::Printf("DMemSpyEventMonitor::EventChunkDelete() - aChunk: 0x%08x [%10d] {OP: %4d, CO: %4d} (%O)", aChunk, aChunk->Size(), ( aChunk->iOwningProcess ? aChunk->iOwningProcess->iId : 0 ), aChunk->iControllingOwner, aChunk ));

   409     //

   410 	const SDblQueLink* const anchor = &iObservers.iA;

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

   412 		{

   413 		MMemSpyEventMonitorObserver* const observer = _LOFF(link, MMemSpyEventMonitorObserver, __iEMLink);

   414         const TInt typeMask = observer->EMTypeMask();

   415         //

   416         if ( typeMask & EMemSpyEventChunkDelete )

   417 			{

   418             observer->EMHandleChunkDeleted( *aChunk );

   419 			}

   420         }

   421     }

   422 

   423 

   424 

   425 

   426 

   427 

   428 

   429 

   430 

   431 

   432 TBool DMemSpyEventMonitor::IsObserving( MMemSpyEventMonitorObserver& aObserver )

   433     {

   434     TBool ret = EFalse;

   435 	const SDblQueLink* const anchor = &iObservers.iA;

   436 	

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

   438 		{

   439 		MMemSpyEventMonitorObserver* const observer = _LOFF(link, MMemSpyEventMonitorObserver, __iEMLink);

   440 

   441 		if  ( observer == &aObserver )

   442 			{

   443 			ret = ETrue;

   444             break;

   445 			}

   446 		}

   447 

   448 	return ret;

   449     }

   450