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 	Kern::MutexWait(*iLock);

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

   175 

   176 	if  ( iTracking )

   177 		{

   178 		switch( aType )

   179 			{

   180         //////////////////////////////////

   181         // THREAD HANDLING

   182         //////////////////////////////////

   183 		case EEventAddThread:

   184 			{

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

   186 			EventThreadAdd( (DThread*) a1 );

   187 			break;

   188 			}

   189 		case EEventRemoveThread:

   190 			{

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

   192 			EventThreadRemoved( (DThread*) a1 );

   193 			break;

   194 			}

   195 		case EEventKillThread:

   196 			{

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

   198 			EventThreadKilled( (DThread*) a1 );

   199 			break;

   200 			}

   201 

   202         //////////////////////////////////

   203         // PROCESS HANDLING

   204         //////////////////////////////////

   205 	    case EEventAddProcess:

   206 			{

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

   208 			EventProcessAdd( (DProcess*) a1 );

   209 			break;

   210 			}

   211 	    case EEventUpdateProcess:

   212 			{

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

   214 			EventProcessUpdate( (DProcess*) a1 );

   215 			break;

   216 			}

   217 	    case EEventRemoveProcess:

   218 			{

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

   220 			EventProcessRemoved( (DProcess*) a1 );

   221 			break;

   222 			}

   223 			

   224         //////////////////////////////////

   225         // CHUNK HANDLING

   226         //////////////////////////////////

   227 	    case EEventNewChunk:

   228 			{

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

   230 			EventChunkAdd( (DChunk*) a1 );

   231 			break;

   232 			}

   233 	    case EEventUpdateChunk:

   234 			{

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

   236 			EventChunkUpdate( (DChunk*) a1 );

   237 			break;

   238 			}

   239 		case EEventDeleteChunk:

   240 			{

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

   242 			EventChunkDelete( (DChunk*) a1 );

   243 			break;

   244 			}

   245 

   246         default:

   247 			break;

   248 			}

   249 		}

   250 

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

   252 	Kern::MutexSignal( *iLock );

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

   254 

   255 	// Allow other handlers to see this event

   256 	return DKernelEventHandler::ERunNext;

   257 	}

   258 

   259 

   260 void DMemSpyEventMonitor::EventProcessAdd( DProcess* aProcess )

   261     {

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

   263     //

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

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

   266 		{

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

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

   269         //

   270         if ( typeMask & EMemSpyEventProcessAdd )

   271 			{

   272             observer->EMHandleProcessAdd( *aProcess );

   273 			}

   274         }

   275     }

   276 

   277 

   278 void DMemSpyEventMonitor::EventProcessUpdate( DProcess* aProcess )

   279     {

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

   281     //

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

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

   284 		{

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

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

   287         //

   288         if ( typeMask & EMemSpyEventProcessUpdate )

   289 			{

   290             observer->EMHandleProcessUpdated( *aProcess );

   291 			}

   292         }

   293     }

   294 

   295 

   296 void DMemSpyEventMonitor::EventProcessRemoved( DProcess* aProcess )

   297     {

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

   299     //

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

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

   302 		{

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

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

   305         //

   306         if ( typeMask & EMemSpyEventProcessRemove )

   307 			{

   308             observer->EMHandleProcessRemoved( *aProcess );

   309 			}

   310         }

   311     }

   312 

   313 

   314 void DMemSpyEventMonitor::EventThreadAdd( DThread* aThread )

   315     {

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

   317     //

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

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

   320 		{

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

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

   323         //

   324         if ( typeMask & EMemSpyEventThreadAdd )

   325 			{

   326             observer->EMHandleThreadAdd( *aThread );

   327 			}

   328         }

   329     }

   330 

   331 

   332 void DMemSpyEventMonitor::EventThreadRemoved( DThread* aThread )

   333     {

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

   335     //

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

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

   338 		{

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

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

   341         //

   342         if ( typeMask & EMemSpyEventThreadRemove )

   343 			{

   344             observer->EMHandleThreadRemoved( *aThread );

   345 			}

   346         }

   347     }

   348 

   349 

   350 void DMemSpyEventMonitor::EventThreadKilled( DThread* aThread )

   351     {

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

   353     //

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

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

   356 		{

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

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

   359         //

   360         if ( typeMask & EMemSpyEventThreadKill )

   361 			{

   362             observer->EMHandleThreadKilled( *aThread );

   363 			}

   364         }

   365     }

   366 

   367 

   368 void DMemSpyEventMonitor::EventChunkAdd( DChunk* aChunk )

   369     {

   370     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 ));

   371     //

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

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

   374 		{

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

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

   377         //

   378         if ( typeMask & EMemSpyEventChunkAdd )

   379 			{

   380             observer->EMHandleChunkAdd( *aChunk );

   381 			}

   382         }

   383     }

   384 

   385 

   386 void DMemSpyEventMonitor::EventChunkUpdate( DChunk* aChunk )

   387     {

   388     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 ));

   389     //

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

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

   392 		{

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

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

   395         //

   396         if ( typeMask & EMemSpyEventChunkUpdate )

   397 			{

   398             observer->EMHandleChunkUpdated( *aChunk );

   399 			}

   400         }

   401     }

   402 

   403 

   404 void DMemSpyEventMonitor::EventChunkDelete( DChunk* aChunk )

   405     {

   406     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 ));

   407     //

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

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

   410 		{

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

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

   413         //

   414         if ( typeMask & EMemSpyEventChunkDelete )

   415 			{

   416             observer->EMHandleChunkDeleted( *aChunk );

   417 			}

   418         }

   419     }

   420 

   421 

   422 

   423 

   424 

   425 

   426 

   427 

   428 

   429 

   430 TBool DMemSpyEventMonitor::IsObserving( MMemSpyEventMonitorObserver& aObserver )

   431     {

   432     TBool ret = EFalse;

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

   434 	

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

   436 		{

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

   438 

   439 		if  ( observer == &aObserver )

   440 			{

   441 			ret = ETrue;

   442             break;

   443 			}

   444 		}

   445 

   446 	return ret;

   447     }

   448