--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/memspy/Driver/Kernel/Source/MemSpyDriverInspectedProcess.cpp Tue Feb 02 01:57:15 2010 +0200
@@ -0,0 +1,1264 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "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:
+*
+*/
+
+#include "MemSpyDriverInspectedProcess.h"
+
+// System includes
+#include <kern_priv.h>
+#include <nk_trace.h>
+#include <u32hal.h>
+
+#ifdef __MARM__
+#include "kdebug.h"
+#endif //__MARM__
+
+// User includes
+#include "MemSpyDriverUtils.h"
+#include "MemSpyDriverDevice.h"
+#include "MemSpyDriverOSAdaption.h"
+#include "MemSpyDriverInspectedProcessManager.h"
+
+// Constants
+_LIT8( KMemSpyLitDollarHeap, "$HEAP" );
+_LIT8( KMemSpyLitDollarDllData, "DLL$DATA" );
+_LIT8( KMemSpyLitDollarDat, "$DAT" );
+_LIT( KMemSpyInspectedProcessMutexName, "MemSpyInspectedProcess_0x" );
+
+
+DMemSpyInspectedProcess::DMemSpyInspectedProcess( DMemSpyDriverDevice& aDevice )
+: iDevice( aDevice )
+ {
+ }
+
+
+DMemSpyInspectedProcess::~DMemSpyInspectedProcess()
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::~DMemSpyInspectedProcess() - START - this: 0x%08x, %O", this, iProcess ));
+ EventMonitor().RequestEventsCancel( *this );
+
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::~DMemSpyInspectedProcess() - calling NotifyOnChangeCancel..." ) );
+ NotifyOnChangeCancel();
+
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::~DMemSpyInspectedProcess() - calling ResetTrackedList..." ) );
+ ResetTrackedList();
+
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::~DMemSpyInspectedProcess() - calling ResetPendingChanges..." ) );
+ ResetPendingChanges();
+
+ if ( iLock )
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::~DMemSpyInspectedProcess() - closing mutex..." ) );
+ iLock->Close(NULL);
+ }
+
+ if ( iProcess )
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::~DMemSpyInspectedProcess() - closing process..." ) );
+ Kern::SafeClose( (DObject*&) iProcess, NULL );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::~DMemSpyInspectedProcess() - closed process!" ) );
+ }
+
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::~DMemSpyInspectedProcess() - END - this: 0x%08x", this ) );
+ }
+
+
+TInt DMemSpyInspectedProcess::Open( DProcess* aProcess )
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::Open() - START - this: 0x%08x, aProcess: 0x%08x (%O)", this, aProcess, aProcess ));
+
+ TInt error = KErrNone;
+ //
+ iProcess = aProcess;
+ error = iProcess->Open();
+ //
+ if ( error == KErrNone )
+ {
+ iProcessId = iDevice.OSAdaption().DProcess().GetId( *aProcess );
+
+ // Create mutex
+ TName name( KMemSpyInspectedProcessMutexName );
+ name.AppendNumFixedWidth( (TUint) this, EHex, 8 );
+ error = Kern::MutexCreate( iLock, name, KMutexOrdNone );
+ //
+ if ( error == KErrNone )
+ {
+ // Get size of all stacks (user & supervsior) for process. Also
+ // updates iUserThreadStackSize with the current size of just
+ // the user-side thread stacks.
+ iInfoCurrent.iMemoryStack = StackSize( *aProcess );
+
+ // Request events
+ EventMonitor().RequestEvents( *this );
+
+ // Find initial chunks that are mapped into process
+ FindChunks( *aProcess );
+
+ // Indicate that we have data waiting for client. This will
+ // cause the client's RS to be completed as soon as it
+ // registers with us...
+ UpdateStatistics();
+ CompleteClientsRequest( KErrNone, &iInfoCurrent );
+ }
+ }
+ //
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::Open() - END - this: 0x%08x, error: %d", this, error ));
+ return error;
+ }
+
+
+
+
+
+
+
+
+TInt DMemSpyInspectedProcess::NotifyOnChange( DThread* aThread, TRequestStatus* aRequestStatus, TMemSpyDriverProcessInspectionInfo* aInfo )
+ {
+ Kern::MutexWait( *iLock );
+
+ TInt err = KErrInUse;
+ const TBool notificationQueued = NotifyOnChangeQueued();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChange() - START - this: 0x%08x, iAmDead: %d, aRequestStatus: 0x%08x, notificationQueued: %d, iChangeObserverThread: 0x%08x (%O)", this, iAmDead, aRequestStatus, notificationQueued, iChangeObserverThread, iChangeObserverThread ) );
+ //
+ if ( notificationQueued == EFalse )
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChange() - Saving client RS..." ) );
+ iChangeObserverThread = aThread;
+ iChangeObserverRS = aRequestStatus;
+ iChangeObserverInfo = aInfo;
+
+ // Whilst we still have items in the buffer, we let the client drain them fully.
+ // However, if the process is now marked as dead and the buffer is exhausted,
+ // we indicate this via KErrDied completion which will cause the client to
+ // stop requesting any more changes.
+ if ( !iPendingChanges.IsEmpty() )
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChange() - Have buffered changes - SENDING TO CLIENT IMMEDIATELY..." ) );
+
+ // We have something in the pending buffer so we can
+ // give it back to the client immediately.
+ TMemSpyTrackedChunkChangeInfo* cachedChange = _LOFF( iPendingChanges.First(), TMemSpyTrackedChunkChangeInfo, iLink );
+ cachedChange->iLink.Deque();
+
+ // Notify about change
+ CompleteClientsRequest( KErrNone, &cachedChange->iInfo );
+
+ // Discard cached entry
+ NKern::ThreadEnterCS();
+ delete cachedChange;
+ NKern::ThreadLeaveCS();
+ }
+ else if ( iAmDead )
+ {
+ // We must stop listening outside of an event monitor callback...
+ EventMonitor().RequestEventsCancel( *this );
+ CompleteClientsRequest( KErrDied );
+ }
+ //
+ err = KErrNone;
+ }
+ //
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChange() - END - this: 0x%08x, err: %d", this, err ) );
+
+ Kern::MutexSignal( *iLock );
+ return err;
+ }
+
+
+TInt DMemSpyInspectedProcess::NotifyOnChangeCancel()
+ {
+ Kern::MutexWait( *iLock );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChangeCancel() - START - this: 0x%08x, queued: %d, iChangeObserverThread: 0x%08x, iChangeObserverRS: 0x%08x", this, NotifyOnChangeQueued(), iChangeObserverThread, iChangeObserverRS ) );
+ //
+ if ( NotifyOnChangeQueued() )
+ {
+ TRACE( Kern::Printf( "DMemSpyInspectedProcess::NotifyOnChangeCancel() - this: 0x%08x, iChangeObserverRS: 0x%08x, iProcessId: %d (0x%04x)", this, iChangeObserverRS, iProcessId, iProcessId ) );
+ Kern::RequestComplete( iChangeObserverThread, iChangeObserverRS, KErrCancel );
+ iChangeObserverThread = NULL;
+ iChangeObserverRS = NULL;
+ iChangeObserverInfo = NULL;
+ }
+ //
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChangeCancel() - END - this: 0x%08x", this ) );
+ Kern::MutexSignal( *iLock );
+
+ return KErrNone;
+ }
+
+
+TBool DMemSpyInspectedProcess::NotifyOnChangeQueued() const
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChangeQueued() - START - this: 0x%08x", this ) );
+ //
+ Kern::MutexWait( *iLock );
+ const TBool queued = ( iChangeObserverRS != NULL );
+ Kern::MutexSignal( *iLock );
+ //
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChangeQueued() - END - this: 0x%08x, queued: %d", this, queued ) );
+ return queued;
+ }
+
+
+
+
+
+
+
+
+
+void DMemSpyInspectedProcess::CompleteClientsRequest( TInt aCompletionCode, TMemSpyDriverProcessInspectionInfo* aInfo )
+ {
+ const TBool notificationQueued = NotifyOnChangeQueued();
+ TRACE( Kern::Printf( "DMemSpyInspectedProcess::CompleteClientsRequest() - START - this: 0x%08x, iChangeObserverThread: 0x%08x, iChangeObserverRS: 0x%08x, iChangeObserverInfo: 0x%08x, notificationQueued: %d", this, iChangeObserverThread, iChangeObserverRS, iChangeObserverInfo, notificationQueued ) );
+ TRACE( Kern::Printf( "DMemSpyInspectedProcess::CompleteClientsRequest() - iAmDead: %d, buffer is empty: %d, aCompletionCode: %d, iProcessId: %d (0x%04x), aInfo: 0x%08x, iChangeDeliveryCounter: %d", iAmDead, iPendingChanges.IsEmpty(), aCompletionCode, iProcessId, iProcessId, aInfo, iChangeDeliveryCounter ) );
+
+ if ( notificationQueued )
+ {
+ ++iChangeDeliveryCounter;
+ TInt completionCode = aCompletionCode;
+
+ // Write them to client...
+ if ( aInfo != NULL )
+ {
+ const TInt writeErr = Kern::ThreadRawWrite( iChangeObserverThread, iChangeObserverInfo, aInfo, sizeof(TMemSpyDriverProcessInspectionInfo) );
+ if ( writeErr != KErrNone )
+ {
+ completionCode = writeErr;
+ }
+ }
+
+ // Complete client's async request
+ DThread* changeThread = iChangeObserverThread;
+ TRequestStatus* changeRS = iChangeObserverRS;
+
+ // Zero these out first to avoid race condition
+ iChangeObserverThread = NULL;
+ iChangeObserverRS = NULL;
+ iChangeObserverInfo = NULL;
+
+ // ...and then tell client.
+ TRACE( Kern::Printf( "DMemSpyInspectedProcess::CompleteClientsRequest() - SENDING CHANGE [%4d] TO CLIENT [err: %d]", iChangeDeliveryCounter, completionCode ) );
+ Kern::RequestComplete( changeThread, changeRS, completionCode );
+ }
+ else if ( aInfo )
+ {
+ // Buffer the change for next time around...
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::CompleteClientsRequest() - BUFFERING change event whilst client is AWOL...", this ) );
+ NKern::ThreadEnterCS();
+
+ TMemSpyTrackedChunkChangeInfo* changeInfo = new TMemSpyTrackedChunkChangeInfo();
+ if ( changeInfo )
+ {
+ changeInfo->iInfo = *aInfo;
+ iPendingChanges.Add( &changeInfo->iLink );
+ }
+ //
+ NKern::ThreadLeaveCS();
+ }
+
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::CompleteClientsRequest() - END - this: 0x%08x", this ) );
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+void DMemSpyInspectedProcess::ResetTrackedList()
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::ResetTrackedList() - START - this: 0x%08x", this ) );
+ NKern::ThreadEnterCS();
+ //
+ SDblQueLink* link = iTrackedChunks.GetFirst();
+ while( link )
+ {
+ TMemSpyTrackedChunk* object = _LOFF( link, TMemSpyTrackedChunk, iLink );
+ delete object;
+ link = iTrackedChunks.GetFirst();
+ }
+ //
+ NKern::ThreadLeaveCS();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::ResetTrackedList() - END - this: 0x%08x", this ) );
+ }
+
+
+void DMemSpyInspectedProcess::SetTrackedListUnused()
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::SetTrackedListUnused() - START - this: 0x%08x", this ) );
+ SDblQueLink* anchor = &iTrackedChunks.iA;
+ for (SDblQueLink* link = iTrackedChunks.First(); link != anchor; link = link->iNext)
+ {
+ TMemSpyTrackedChunk* trackedChunk = _LOFF( link, TMemSpyTrackedChunk, iLink );
+ trackedChunk->SetUnused( ETrue );
+ }
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::SetTrackedListUnused() - END - this: 0x%08x", this ) );
+ }
+
+
+void DMemSpyInspectedProcess::SetTrackedListUnusedStatusByType( TMemSpyTrackedChunk::TType aType, TBool aUnusedStatus )
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::SetTrackedListUnusedStatusByType() - START - this: 0x%08x", this ) );
+ SDblQueLink* anchor = &iTrackedChunks.iA;
+ for (SDblQueLink* link = iTrackedChunks.First(); link != anchor; link = link->iNext)
+ {
+ TMemSpyTrackedChunk* trackedChunk = _LOFF( link, TMemSpyTrackedChunk, iLink );
+ if ( trackedChunk->Type() == aType )
+ {
+ trackedChunk->SetUnused( aUnusedStatus );
+ }
+ }
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::SetTrackedListUnusedStatusByType() - END - this: 0x%08x", this ) );
+ }
+
+
+void DMemSpyInspectedProcess::DiscardUnusedTrackListItems()
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::DiscardUnusedTrackListItems() - START - this: 0x%08x", this ) );
+ NKern::ThreadEnterCS();
+ const SDblQueLink* const anchor = &iTrackedChunks.iA;
+ //
+ SDblQueLink* link = iTrackedChunks.First();
+ while( link && link != anchor )
+ {
+ TMemSpyTrackedChunk* trackedChunk = _LOFF( link, TMemSpyTrackedChunk, iLink );
+ const TBool unused = trackedChunk->iUnused;
+ //
+ link = link->iNext;
+ //
+ if ( unused )
+ {
+ trackedChunk->iLink.Deque();
+ delete trackedChunk;
+ }
+ else
+ {
+ trackedChunk->SetUnused( EFalse );
+ }
+ }
+ //
+ NKern::ThreadLeaveCS();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::DiscardUnusedTrackListItems() - END - this: 0x%08x", this ) );
+ }
+
+
+void DMemSpyInspectedProcess::AddTrackedChunk( DChunk* aChunk, TMemSpyTrackedChunk::TType aType )
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::AddTrackedChunk() - START - this: 0x%08x, aChunk: 0x%08x (%O)", this, aChunk, aChunk ) );
+ NKern::ThreadEnterCS();
+ //
+ TMemSpyTrackedChunk* wrapper = new TMemSpyTrackedChunk( aChunk, aType );
+ if ( wrapper )
+ {
+ DMemSpyDriverOSAdaptionDChunk& chunkAdaption = iDevice.OSAdaption().DChunk();
+ const TInt cSize = chunkAdaption.GetSize( *aChunk );
+ wrapper->SetSize( cSize );
+ iTrackedChunks.Add( &wrapper->iLink );
+ }
+ //
+ NKern::ThreadLeaveCS();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::AddTrackedChunk() - END - this: 0x%08x", this ) );
+ }
+
+
+TMemSpyTrackedChunk* DMemSpyInspectedProcess::TrackedChunkByHandle( TAny* aHandle )
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::TrackedChunkByHandle() - START - this: 0x%08x", this ) );
+ TMemSpyTrackedChunk* ret = NULL;
+ //
+ const SDblQueLink* const anchor = &iTrackedChunks.iA;
+ for (SDblQueLink* link = iTrackedChunks.First(); link != anchor; link = link->iNext)
+ {
+ TMemSpyTrackedChunk* const trackedChunk = _LOFF( link, TMemSpyTrackedChunk, iLink );
+
+ if ( trackedChunk && trackedChunk->Handle() == aHandle )
+ {
+ ret = trackedChunk;
+ break;
+ }
+ }
+ //
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::TrackedChunkByHandle() - END - this: 0x%08x, entry: 0x%08x (%O)", this, ret, ret ? ret->iChunk : NULL ) );
+ return ret;
+ }
+
+
+
+
+
+
+
+
+
+
+
+DMemSpyInspectedProcessManager& DMemSpyInspectedProcess::PManager()
+ {
+ return iDevice.ProcessInspectionManager();
+ }
+
+
+DMemSpyEventMonitor& DMemSpyInspectedProcess::EventMonitor()
+ {
+ return iDevice.EventMonitor();
+ }
+
+
+
+
+
+
+
+TUint DMemSpyInspectedProcess::EMTypeMask() const
+ {
+ TUint ret = EMemSpyEventThreadAdd | EMemSpyEventThreadRemove | EMemSpyEventThreadKill |
+ EMemSpyEventProcessUpdate | EMemSpyEventProcessRemove |
+ EMemSpyEventChunkAdd | EMemSpyEventChunkUpdate | EMemSpyEventChunkDelete;
+
+ if ( iAmDead )
+ {
+ // Not interested anymore...
+ ret = 0;
+ }
+
+ return ret;
+ }
+
+
+void DMemSpyInspectedProcess::EMHandleProcessUpdated( DProcess& aProcess )
+ {
+ const TUint procId = iDevice.OSAdaption().DProcess().GetId( aProcess );
+ if ( procId == iProcessId )
+ {
+ Kern::MutexWait( *iLock );
+
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleProcessUpdated() - START - this: 0x%08x, iProcess: 0x%08x (%O)", this, iProcess, iProcess ) );
+ NKern::ThreadEnterCS();
+
+ // Mark all tracked chunks as dirty whilst we work out
+ // what is and isn't mapped into the process
+ SetTrackedListUnused();
+ SetTrackedListUnusedStatusByType( TMemSpyTrackedChunk::ETypeChunkGlobalData, EFalse /* global data chunks are still in use */ );
+
+ // Locate any suitable chunks, tagging existing entries as
+ // 'in use' so that we can easily spot ones which are no longer
+ // mapped into the process.
+ FindChunks( *iProcess );
+
+ // Throw away and tracked chunks which aren't mapped into the
+ // process anymore.
+ DiscardUnusedTrackListItems();
+
+ // Calculate latest statistics...
+ const TBool changeDetected = UpdateStatistics();
+ if ( changeDetected )
+ {
+ // Inform observer about new results.
+ CompleteClientsRequest( KErrNone, &iInfoCurrent );
+ }
+
+ NKern::ThreadLeaveCS();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleProcessUpdated() - END - this: 0x%08x", this ) );
+
+ Kern::MutexSignal( *iLock );
+ }
+ }
+
+
+void DMemSpyInspectedProcess::EMHandleProcessRemoved( DProcess& aProcess )
+ {
+ DMemSpyDriverOSAdaptionDProcess& dProcessAdaption = iDevice.OSAdaption().DProcess();
+ const TUint pid = dProcessAdaption.GetId( aProcess );
+
+ if ( pid == iProcessId )
+ {
+ Kern::MutexWait( *iLock );
+
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleProcessRemoved() - START - this: 0x%08x", this ) );
+ NKern::ThreadEnterCS();
+
+ // We will implement a multi phased approach to the process being removed.
+ //
+ // The first notification we will send will show that the process heap and
+ // local chunks have been removed, leaving shared chunk sizes intact.
+ //
+ // We will then send another change, this time setting everything to zero...
+ SetTrackedListUnused();
+ SetTrackedListUnusedStatusByType( TMemSpyTrackedChunk::ETypeChunkShared, EFalse /* shared chunks are still in use */ );
+ SetTrackedListUnusedStatusByType( TMemSpyTrackedChunk::ETypeChunkGlobalData, EFalse /* global data chunks are still in use */ );
+ DiscardUnusedTrackListItems();
+ const TBool changeDetected1 = UpdateStatistics();
+ if ( changeDetected1 )
+ {
+ // Inform observer about new results.
+ CompleteClientsRequest( KErrNone, &iInfoCurrent );
+ }
+
+ // Now repeat the exercise, this time removing everything.
+ ResetTrackedList();
+
+ // ... including stack
+ iInfoCurrent.iMemoryStack = 0;
+
+ const TBool changeDetected2 = UpdateStatistics();
+ if ( changeDetected2 )
+ {
+ // Inform observer about new results.
+ CompleteClientsRequest( KErrNone, &iInfoCurrent );
+ }
+
+ // Stop listening to events since we've drained everything now...
+ iAmDead = ETrue;
+
+ NKern::ThreadLeaveCS();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleProcessRemoved() - END - this: 0x%08x", this ) );
+
+ Kern::MutexSignal( *iLock );
+ }
+ }
+
+
+void DMemSpyInspectedProcess::EMHandleThreadAdd( DThread& aThread )
+ {
+ DMemSpyDriverOSAdaptionDThread& dThreadAdaption = iDevice.OSAdaption().DThread();
+ DMemSpyDriverOSAdaptionDProcess& dProcessAdaption = iDevice.OSAdaption().DProcess();
+ //
+ DProcess* owningProcess = dThreadAdaption.GetOwningProcess( aThread );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleThreadAdd() - this: 0x%08x, aThread: 0x%08x, owningProcess: 0x%08x", this, &aThread, owningProcess ) );
+ if ( owningProcess )
+ {
+ const TUint owningProcessId = dProcessAdaption.GetId( *owningProcess );
+ const TUint myId = dProcessAdaption.GetId( *iProcess );
+ //
+ if ( myId == owningProcessId )
+ {
+ EMHandleThreadChanged( aThread );
+ }
+ }
+ }
+
+
+void DMemSpyInspectedProcess::EMHandleThreadRemoved( DThread& aThread )
+ {
+ DMemSpyDriverOSAdaptionDThread& dThreadAdaption = iDevice.OSAdaption().DThread();
+ DMemSpyDriverOSAdaptionDProcess& dProcessAdaption = iDevice.OSAdaption().DProcess();
+ //
+ DProcess* owningProcess = dThreadAdaption.GetOwningProcess( aThread );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleThreadRemoved() - this: 0x%08x, aThread: 0x%08x, owningProcess: 0x%08x", this, &aThread, owningProcess ) );
+ if ( owningProcess )
+ {
+ const TUint owningProcessId = dProcessAdaption.GetId( *owningProcess );
+ const TUint myId = dProcessAdaption.GetId( *iProcess );
+ //
+ if ( myId == owningProcessId )
+ {
+ EMHandleThreadChanged( aThread );
+ }
+ }
+ }
+
+
+void DMemSpyInspectedProcess::EMHandleThreadKilled( DThread& aThread )
+ {
+ //
+ DMemSpyDriverOSAdaptionDThread& dThreadAdaption = iDevice.OSAdaption().DThread();
+ DMemSpyDriverOSAdaptionDProcess& dProcessAdaption = iDevice.OSAdaption().DProcess();
+ //
+ DProcess* owningProcess = dThreadAdaption.GetOwningProcess( aThread );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleThreadKilled() - this: 0x%08x, aThread: 0x%08x, owningProcess: 0x%08x", this, &aThread, owningProcess ) );
+ if ( owningProcess )
+ {
+ const TUint owningProcessId = dProcessAdaption.GetId( *owningProcess );
+ const TUint myId = dProcessAdaption.GetId( *iProcess );
+ //
+ if ( myId == owningProcessId )
+ {
+ EMHandleThreadChanged( aThread );
+ }
+ }
+ }
+
+
+void DMemSpyInspectedProcess::EMHandleThreadChanged( DThread& /*aThread*/ )
+ {
+ Kern::MutexWait( *iLock );
+
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleThreadChanged() - START - this: 0x%08x", this ) );
+
+ // This is called when a thread is added, changed, or terminated/killed.
+ // We must be careful to only access the members of aThread that still
+ // exist as if it is being destroyed, the object may be in an intermediate
+ // state.
+ NKern::ThreadEnterCS();
+
+ // All we are really interested in is recalculating the stack usage
+ // for the process...
+ iInfoCurrent.iMemoryStack = StackSize( *iProcess );
+
+ // Always inform observer about new results.
+ CompleteClientsRequest( KErrNone, &iInfoCurrent );
+
+ NKern::ThreadLeaveCS();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleThreadChanged() - END - this: 0x%08x", this ) );
+
+ Kern::MutexSignal( *iLock );
+ }
+
+
+void DMemSpyInspectedProcess::EMHandleChunkAdd( DChunk& aChunk )
+ {
+ Kern::MutexWait( *iLock );
+
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkAdd() - START - this: 0x%08x, aChunk: 0x%08x (%O)", this, &aChunk, &aChunk ) );
+ NKern::ThreadEnterCS();
+
+ // Is this chunk related to our process somehow?
+ if ( IsChunkRelevantToOurProcess( aChunk ) )
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkAdd() - processes match, checking chunk type..." ) );
+
+ const TMemSpyTrackedChunk::TType type = ChunkType( &aChunk );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkAdd() - chunkType: %d", type ) );
+
+ if ( type != TMemSpyTrackedChunk::ETypeNotRelevant )
+ {
+ // It's a new entry in our process
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkAdd() - this: 0x%08x, creating new entry for chunk: 0x%08x", this, &aChunk ) );
+
+ AddTrackedChunk( &aChunk, type );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkAdd() - added chunk..." ));
+
+ const TBool changeDetected = UpdateStatistics();
+ if ( changeDetected )
+ {
+ // Inform observer about new results.
+ CompleteClientsRequest( KErrNone, &iInfoCurrent );
+ }
+ }
+ }
+
+ NKern::ThreadLeaveCS();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkAdd() - END - this: 0x%08x", this ) );
+
+ Kern::MutexSignal( *iLock );
+ }
+
+
+void DMemSpyInspectedProcess::EMHandleChunkUpdated( DChunk& aChunk )
+ {
+ Kern::MutexWait( *iLock );
+
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkUpdated() - START - this: 0x%08x, aChunk: 0x%08x [S: %8d] (%O)", this, &aChunk, aChunk.Size(), &aChunk ) );
+ NKern::ThreadEnterCS();
+
+ // Is this chunk mapped into our process?
+ TMemSpyTrackedChunk* trackedEntry = TrackedChunkByHandle( &aChunk );
+ if ( trackedEntry != NULL )
+ {
+ const TInt oldSize = trackedEntry->Size();
+ const TInt newSize = iDevice.OSAdaption().DChunk().GetSize( aChunk );
+
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkUpdated() - was tracked entry [0x%08x, size; %10d, type: %d] vs new size: %d", trackedEntry, oldSize, trackedEntry->Type(), newSize ) );
+
+ // If the existing entry had a size of 0 and the new size is non-zero
+ // then we may have enough data such that we can validate type information.
+ // For example, any secondary heap chunk that is created within the process will
+ // most likely have a Local-NNNNNN style name, and this chunk will be created with
+ // an initial size of zero.
+ //
+ // We can only identify it's type once the chunk has been updated with some data
+ // that supports vTable verification. Hence the type may fluctuate...
+ if ( oldSize == 0 && newSize > 0 )
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkUpdated() - checking type again as chunk size was zero..." ) );
+
+ PrintChunkInfo( aChunk );
+ const TMemSpyTrackedChunk::TType type = ChunkType( &aChunk );
+ if ( type != trackedEntry->Type() )
+ {
+ // Type has changed
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkUpdated() - type has transitioned from: %d to %d", trackedEntry->Type(), type ) );
+ trackedEntry->SetType( type );
+ }
+ }
+
+ // Update our record with new chunk size
+ trackedEntry->SetSize( newSize );
+
+ const TBool changeDetected = UpdateStatistics();
+ if ( changeDetected )
+ {
+ // Inform observer about new results.
+ CompleteClientsRequest( KErrNone, &iInfoCurrent );
+ }
+ }
+
+ NKern::ThreadLeaveCS();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkUpdated() - END - this: 0x%08x", this ) );
+
+ Kern::MutexSignal( *iLock );
+ }
+
+
+void DMemSpyInspectedProcess::EMHandleChunkDeleted( DChunk& aChunk )
+ {
+ Kern::MutexWait( *iLock );
+
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkDeleted() - START - this: 0x%08x", this ) );
+ NKern::ThreadEnterCS();
+
+ // Is this chunk mapped into our process?
+ TMemSpyTrackedChunk* trackedEntry = TrackedChunkByHandle( &aChunk );
+ if ( trackedEntry != NULL )
+ {
+ // Delete entry
+ trackedEntry->iLink.Deque();
+ delete trackedEntry;
+
+ const TBool changeDetected = UpdateStatistics();
+ if ( changeDetected )
+ {
+ // Inform observer about new results.
+ CompleteClientsRequest( KErrNone, &iInfoCurrent );
+ }
+ }
+
+ NKern::ThreadLeaveCS();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkDeleted() - END - this: 0x%08x", this ) );
+
+ Kern::MutexSignal( *iLock );
+ }
+
+
+void DMemSpyInspectedProcess::PrintChunkInfo( DChunk& aChunk ) const
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::PrintChunkInfo() - iProcess*: 0x%08x", iProcess ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::PrintChunkInfo() - iProcess id: 0x%04x", iProcessId ) );
+ MemSpyDriverUtils::PrintChunkInfo( aChunk, iDevice.OSAdaption() );
+ }
+
+
+TBool DMemSpyInspectedProcess::IsChunkRelevantToOurProcess( DChunk& aChunk ) const
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::IsChunkRelevantToOurProcess() - START - this: 0x%08x, iProcess: 0x%08x (%4d), aChunk: 0x%08x (%O)", this, iProcess, iProcessId, &aChunk, &aChunk) );
+
+ TBool relevant = EFalse;
+ DMemSpyDriverOSAdaptionDChunk& chunkAdaption = iDevice.OSAdaption().DChunk();
+ //
+ PrintChunkInfo( aChunk );
+ //
+ DProcess* chunkProc = chunkAdaption.GetOwningProcess( aChunk );
+ if ( chunkProc )
+ {
+ const TUint procId = iDevice.OSAdaption().DProcess().GetId( *chunkProc );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::IsChunkRelevantToOurProcess() - [Owning Process] Comparing chunk pid: 0x%04x with procPid: 0x%04x", this, procId, iProcessId ) );
+ relevant = ( procId == iProcessId );
+ }
+ else if ( chunkAdaption.GetOwner( aChunk ) == iProcess )
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::IsChunkRelevantToOurProcess() - [Owner Match]" ) );
+ relevant = ETrue;
+ }
+ else
+ {
+ const TUint controllingOwnerPid = chunkAdaption.GetControllingOwnerId( aChunk );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::IsChunkRelevantToOurProcess() - [Controlling Owner] Comparing chunk owner: 0x%04x with procPid: 0x%04x", this, controllingOwnerPid, iProcessId ) );
+ relevant = ( controllingOwnerPid == iProcessId );
+ }
+
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::IsChunkRelevantToOurProcess() - END - this: 0x%08x, relevant: %d", this, relevant ) );
+ return relevant;
+ }
+
+
+TMemSpyTrackedChunk::TType DMemSpyInspectedProcess::ChunkType( DObject* aObject ) const
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::ChunkType() - START - this: 0x%08x, iProcess: 0x%08x, aObject: 0x%08x (%O)", this, iProcess, aObject, aObject ) );
+ TMemSpyTrackedChunk::TType ret = TMemSpyTrackedChunk::ETypeNotRelevant;
+
+ // Firstly, check if it's actually held within the chunk container.
+ if ( aObject )
+ {
+ DMemSpyDriverOSAdaptionDChunk& chunkAdaption = iDevice.OSAdaption().DChunk();
+ const TObjectType objectType = chunkAdaption.GetObjectType( *aObject );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::ChunkType() - objectType: %d vs EChunk (%d)", objectType, EChunk ) );
+
+ if ( objectType == EChunk )
+ {
+ DChunk* chunk = (DChunk*) aObject;
+ //
+ if ( IsChunkRelevantToOurProcess( *chunk ) )
+ {
+ TName name;
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::ChunkType() - getting chunk name..." ) );
+ chunk->Name( name );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::ChunkType() - name: %S", &name ) );
+
+ // It is definitely owned by this process. That means that
+ // it could be a heap, or then it's a just some other kind
+ // of data chunk which our process happens to have created.
+ //
+ // The main thread within a process results in the creation
+ // of a heap called $HEAP, but that isn't the case for other
+ // secondary (etc) threads.
+ //
+ // Only way I can think to identify these is via vTables.
+ if ( name == KMemSpyLitDollarDllData )
+ {
+ // This chunk contains Dll Global Data for the process
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::ChunkType() - TMemSpyTrackedChunk::ETypeChunkGlobalData" ) );
+ ret = TMemSpyTrackedChunk::ETypeChunkGlobalData;
+ }
+ else if ( name == KMemSpyLitDollarDat )
+ {
+ // This chunk contains process global data as well as user-side stacks for
+ // the process. However, we calculate the stacks independently, so we must
+ // adjust this later on to remove stack overhead.
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::ChunkType() - TMemSpyTrackedChunk::ETypeChunkProcessGlobalDataAndUserStack" ) );
+ ret = TMemSpyTrackedChunk::ETypeChunkProcessGlobalDataAndUserStack;
+ }
+ else if ( IsHeapChunk( *chunk, name ) )
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::ChunkType() - TMemSpyTrackedChunk::ETypeChunkHeap" ) );
+ ret = TMemSpyTrackedChunk::ETypeChunkHeap;
+ }
+ else
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::ChunkType() - TMemSpyTrackedChunk::ETypeChunkLocal" ) );
+ ret = TMemSpyTrackedChunk::ETypeChunkLocal;
+ }
+ }
+ else
+ {
+ // It's a chunk that is mapped into our process,
+ // but isn't owned by us. Therefore it is shared by some
+ // other process.
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::ChunkType() - TMemSpyTrackedChunk::ETypeChunkShared" ) );
+ ret = TMemSpyTrackedChunk::ETypeChunkShared;
+ }
+ }
+ }
+
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::ChunkType() - END - this: 0x%08x, ret: %d", this, ret ) );
+ return ret;
+ }
+
+
+TBool DMemSpyInspectedProcess::IsHeapChunk( DChunk& aChunk, const TName& aName ) const
+ {
+ const TUint rHeapVTable = iDevice.RHeapVTable();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::IsHeapChunk() - START - this: 0x%08x, aChunk: 0x%08x, RHeapVTable: 0x%08x, iProcess: 0x%08x, aName: %S, (%O)", this, &aChunk, rHeapVTable, iProcess, &aName, &aChunk ) );
+
+ // The first 4 bytes of every chunk correspond to the allocator VTable (For heap chunks).
+ // If it matches RHeap's vtable, we'll treat it as a heap.
+ TBool isHeap = EFalse;
+
+ DMemSpyDriverOSAdaptionDChunk& chunkAdaption = iDevice.OSAdaption().DChunk();
+ TUint8* base = chunkAdaption.GetBase( aChunk );
+ const TInt size = chunkAdaption.GetSize( aChunk );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::IsHeapChunk() - base: 0x%08x, size: %d", base, size ) );
+
+ if ( iProcess && size >= 4 )
+ {
+ // Chunks are mapped into entire process so any thread within the process is enough...
+ DThread* firstThread = iProcess->FirstThread();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::IsHeapChunk() - firstThread: 0x%08x (%O)", firstThread, firstThread ) );
+ if ( firstThread != NULL )
+ {
+ TInt err = firstThread->Open();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::IsHeapChunk() - firstThread open result: %d", err ) );
+
+ if ( err == KErrNone )
+ {
+ TBuf8<4> allocatorVTableBuffer;
+ err = Kern::ThreadRawRead( firstThread, base, (TUint8*) allocatorVTableBuffer.Ptr(), allocatorVTableBuffer.MaxLength() );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::IsHeapChunk - read result of vtable data from requested thread is: %d", err ));
+ //
+ if ( err == KErrNone )
+ {
+ TRACE( MemSpyDriverUtils::DataDump("possible chunk vtable data - %lS", allocatorVTableBuffer.Ptr(), allocatorVTableBuffer.MaxLength(), allocatorVTableBuffer.MaxLength() ) );
+ allocatorVTableBuffer.SetLength( allocatorVTableBuffer.MaxLength() );
+
+ const TUint32 vtable = allocatorVTableBuffer[0] +
+ (allocatorVTableBuffer[1] << 8) +
+ (allocatorVTableBuffer[2] << 16) +
+ (allocatorVTableBuffer[3] << 24);
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::IsHeapChunk - [possible] vTable within chunk is: 0x%08x", vtable) );
+
+ // Check the v-table to work out if it really is an RHeap
+ isHeap = ( vtable == rHeapVTable );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::IsHeapChunk() - isHeap: %d", isHeap ) );
+ }
+
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::IsHeapChunk() - closing first thread..." ) );
+ Kern::SafeClose( (DObject*&) firstThread, NULL );
+ }
+ }
+ }
+ //
+ if ( !isHeap && aName == KMemSpyLitDollarHeap )
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::IsHeapChunk() - is standard Symbian OS initial heap chunk - $HEAP" ) );
+ isHeap = ETrue;
+ }
+ //
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::IsHeapChunk() - END - this: 0x%08x, isHeap: %d", this, isHeap ) );
+ return isHeap;
+ }
+
+
+TUint32 DMemSpyInspectedProcess::TotalStatistics( const TMemSpyDriverProcessInspectionInfo& aStats, TBool aIncludeShared )
+ {
+ TUint32 total = aStats.iMemoryStack +
+ aStats.iMemoryHeap +
+ aStats.iMemoryChunkLocal +
+ aStats.iMemoryGlobalData;
+ //
+ if ( aIncludeShared )
+ {
+ total += aStats.iMemoryChunkShared;
+ }
+ //
+ return total;
+ }
+
+
+TBool DMemSpyInspectedProcess::IsEqual( const TMemSpyDriverProcessInspectionInfo& aLeft, const TMemSpyDriverProcessInspectionInfo& aRight )
+ {
+ const TBool equal = ( aLeft.iMemoryStack == aRight.iMemoryStack &&
+ aLeft.iMemoryHeap == aRight.iMemoryHeap &&
+ aLeft.iMemoryChunkLocal == aRight.iMemoryChunkLocal &&
+ aLeft.iMemoryChunkShared == aRight.iMemoryChunkShared &&
+ aLeft.iMemoryGlobalData == aRight.iMemoryGlobalData
+ );
+ return equal;
+ }
+
+
+void DMemSpyInspectedProcess::ResetStatistics( TMemSpyDriverProcessInspectionInfo& aStats )
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::ResetStatistics() - START - this: 0x%08x", this ) );
+ aStats.iProcessId = iProcessId;
+ aStats.iMemoryHeap = 0;
+ aStats.iMemoryChunkLocal = 0;
+ aStats.iMemoryChunkShared = 0;
+ aStats.iMemoryGlobalData = 0;
+ aStats.iTime = Kern::SystemTime();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::ResetStatistics() - END - this: 0x%08x", this ) );
+ }
+
+
+TBool DMemSpyInspectedProcess::UpdateStatistics()
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - START - this: 0x%08x, iChangeDeliveryCounter: %04d, iProcess: 0x%08x %O", this, iChangeDeliveryCounter, iProcess, iProcess ) );
+
+ // Preserve last stats so we can identify if something really changed...
+ iInfoLast = iInfoCurrent;
+
+ // Reset current stats ready for updating. This doesn't wipe the stack field, since
+ // that only changes when some kind of thread event occurs...
+ ResetStatistics( iInfoCurrent );
+
+ // Go through all tracked chunks and update our stats based upon
+ // their current values...
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() CHUNK ENTRIES:" ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+ const SDblQueLink* const anchor = &iTrackedChunks.iA;
+ for (SDblQueLink* link = iTrackedChunks.First(); link != anchor; link = link->iNext)
+ {
+ TMemSpyTrackedChunk* const trackedChunk = _LOFF( link, TMemSpyTrackedChunk, iLink );
+ //
+ switch( trackedChunk->Type() )
+ {
+ case TMemSpyTrackedChunk::ETypeChunkHeap:
+ iInfoCurrent.iMemoryHeap += trackedChunk->Size();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - [0x%08x] TMemSpyTrackedChunk::ETypeChunkHeap - %12d (0x%08x, %O)", trackedChunk, trackedChunk->Size(), trackedChunk->iChunk, trackedChunk->iChunk ) );
+ break;
+ case TMemSpyTrackedChunk::ETypeChunkLocal:
+ iInfoCurrent.iMemoryChunkLocal += trackedChunk->Size();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - [0x%08x] TMemSpyTrackedChunk::ETypeChunkLocal - %12d (0x%08x, %O)", trackedChunk, trackedChunk->Size(), trackedChunk->iChunk, trackedChunk->iChunk ) );
+ break;
+ case TMemSpyTrackedChunk::ETypeChunkShared:
+ iInfoCurrent.iMemoryChunkShared += trackedChunk->Size();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - [0x%08x] TMemSpyTrackedChunk::ETypeChunkShared - %12d (0x%08x, %O)", trackedChunk, trackedChunk->Size(), trackedChunk->iChunk, trackedChunk->iChunk ) );
+ break;
+ case TMemSpyTrackedChunk::ETypeChunkGlobalData:
+ iInfoCurrent.iMemoryGlobalData += trackedChunk->Size();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - [0x%08x] TMemSpyTrackedChunk::ETypeChunkGlobalData - %12d (0x%08x, %O)", trackedChunk, trackedChunk->Size(), trackedChunk->iChunk, trackedChunk->iChunk ) );
+ break;
+ case TMemSpyTrackedChunk::ETypeChunkProcessGlobalDataAndUserStack:
+ break;
+
+ default:
+ case TMemSpyTrackedChunk::ETypeNotRelevant:
+ break;
+ }
+ }
+
+ const TUint32 totalLastIncShared = TotalStatistics( iInfoLast );
+ const TUint32 totalLastExcShared = TotalStatistics( iInfoLast, EFalse );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() LAST:" ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoLast.iMemoryStack: %12d", iInfoLast.iMemoryStack ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoLast.iMemoryHeap: %12d", iInfoLast.iMemoryHeap ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoLast.iMemoryChunkLocal: %12d", iInfoLast.iMemoryChunkLocal ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoLast.iMemoryChunkShared: %12d", iInfoLast.iMemoryChunkShared ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoLast.iMemoryGlobalData: %12d", iInfoLast.iMemoryGlobalData ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - --------------------------------------------------------------------------" ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoLast total: %12d / %12d", totalLastIncShared, totalLastExcShared ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+
+
+ const TUint32 totalCurrentIncShared = TotalStatistics( iInfoCurrent );
+ const TUint32 totalCurrentExcShared = TotalStatistics( iInfoCurrent, EFalse );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() CURRENT:" ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoCurrent.iMemoryStack: %12d", iInfoCurrent.iMemoryStack ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoCurrent.iMemoryHeap: %12d", iInfoCurrent.iMemoryHeap ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoCurrent.iMemoryChunkLocal: %12d", iInfoCurrent.iMemoryChunkLocal ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoCurrent.iMemoryChunkShared: %12d", iInfoCurrent.iMemoryChunkShared ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoCurrent.iMemoryGlobalData: %12d", iInfoCurrent.iMemoryGlobalData ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - --------------------------------------------------------------------------" ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoCurrent total: %12d / %12d", totalCurrentIncShared, totalCurrentExcShared ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+
+ // Update peaks, i.e. how large each individual element reached
+ const TUint32 totalPeaks = TotalStatistics( iInfoPeaks );
+ iInfoPeaks.iMemoryStack = Max( iInfoPeaks.iMemoryStack, iInfoCurrent.iMemoryStack );
+ iInfoPeaks.iMemoryHeap = Max( iInfoPeaks.iMemoryHeap, iInfoCurrent.iMemoryHeap );
+ iInfoPeaks.iMemoryChunkLocal = Max( iInfoPeaks.iMemoryChunkLocal, iInfoCurrent.iMemoryChunkLocal );
+ iInfoPeaks.iMemoryChunkShared = Max( iInfoPeaks.iMemoryChunkShared, iInfoCurrent.iMemoryChunkShared );
+ iInfoPeaks.iMemoryGlobalData = Max( iInfoPeaks.iMemoryGlobalData, iInfoCurrent.iMemoryGlobalData );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() PEAK:" ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoPeaks.iMemoryStack: %12d", iInfoPeaks.iMemoryStack ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoPeaks.iMemoryHeap: %12d", iInfoPeaks.iMemoryHeap ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoPeaks.iMemoryChunkLocal: %12d", iInfoPeaks.iMemoryChunkLocal ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoPeaks.iMemoryChunkShared: %12d", iInfoPeaks.iMemoryChunkShared ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoPeaks.iMemoryGlobalData: %12d", iInfoPeaks.iMemoryGlobalData ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - -----------------------------------------------------" ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoPeaks total: %12d", totalPeaks ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+
+ // Update HWM, i.e. the largest total so far.
+ const TUint32 totalHWMIncShared = TotalStatistics( iInfoHWMIncShared );
+ const TUint32 totalHWMExcShared = TotalStatistics( iInfoHWMIncShared, EFalse );
+ if ( totalCurrentIncShared > totalHWMIncShared )
+ {
+ iInfoHWMIncShared = iInfoCurrent;
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() HWM INC SHARED:" ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoHWMIncShared.iMemoryStack: %12d", iInfoHWMIncShared.iMemoryStack ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoHWMIncShared.iMemoryHeap: %12d", iInfoHWMIncShared.iMemoryHeap ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoHWMIncShared.iMemoryChunkLocal: %12d", iInfoHWMIncShared.iMemoryChunkLocal ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoHWMIncShared.iMemoryChunkShared: %12d", iInfoHWMIncShared.iMemoryChunkShared ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoHWMIncShared.iMemoryGlobalData: %12d", iInfoHWMIncShared.iMemoryGlobalData ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - -----------------------------------------------------" ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoHWMIncShared total: %12d", totalHWMIncShared ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+ }
+ if ( totalCurrentExcShared > totalHWMExcShared )
+ {
+ iInfoHWMExcShared = iInfoCurrent;
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() HWM EXC SHARED:" ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoHWMExcShared.iMemoryStack: %12d", iInfoHWMExcShared.iMemoryStack ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoHWMExcShared.iMemoryHeap: %12d", iInfoHWMExcShared.iMemoryHeap ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoHWMExcShared.iMemoryChunkLocal: %12d", iInfoHWMExcShared.iMemoryChunkLocal ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoHWMExcShared.iMemoryChunkShared: %12d", iInfoHWMExcShared.iMemoryChunkShared ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoHWMExcShared.iMemoryGlobalData: %12d", iInfoHWMExcShared.iMemoryGlobalData ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - -----------------------------------------------------" ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - iInfoHWMExcShared total: %12d", totalHWMExcShared ) );
+ }
+
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() " ) );
+
+ // Work out if something changed...
+ const TBool statsChanged = !IsEqual( iInfoLast, iInfoCurrent );
+ if ( statsChanged )
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - STATS CHANGED!" ) );
+ }
+
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::UpdateStatistics() - END - this: 0x%08x, statsChanged: %d, iChangeDeliveryCounter: %04d, iProcess: 0x%08x %O", this, statsChanged, iChangeDeliveryCounter, iProcess, iProcess ) );
+ return statsChanged;
+ }
+
+
+void DMemSpyInspectedProcess::FindChunks( DProcess& aProcess )
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::FindChunks() - START - this: 0x%08x", this ) );
+
+ DMemSpyDriverOSAdaptionDChunk& chunkAdaption = iDevice.OSAdaption().DChunk();
+ DMemSpyDriverOSAdaptionDProcess& processAdaption = iDevice.OSAdaption().DProcess();
+
+ // Iterate through each handle in the process
+ if ( processAdaption.IsHandleIndexValid( aProcess ) )
+ {
+ MemSpyObjectIx* processHandles = processAdaption.GetHandles( aProcess );
+ MemSpyObjectIx_Wait( processHandles );
+
+ const TInt count = processHandles->Count();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::FindChunks() - got: %d handles...", count ) );
+
+ for( TInt i=0; i<count; i++ )
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::FindChunks() - checking handle index: %2d", i ) );
+
+ // Get a handle from the process container...
+ NKern::LockSystem();
+ DObject* object = (*processHandles)[ i ];
+ NKern::UnlockSystem();
+
+ const TObjectType objectType = ( object ? chunkAdaption.GetObjectType( *object ) : EObjectTypeAny );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::FindChunks() - object: 0x%08x, type: %2d (%O)", object, objectType, object ) );
+
+ // Is it a chunk that is already mapped into our process?
+ // See if we're already aware of this chunk...
+ if ( object != NULL && objectType == EChunk )
+ {
+ TMemSpyTrackedChunk* existingEntry = TrackedChunkByHandle( object );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::FindChunks() - found a chunk, existing lookup entry: 0x%08x", existingEntry ) );
+
+ if ( existingEntry != NULL )
+ {
+ const TInt cSize = chunkAdaption.GetSize( *existingEntry->iChunk );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::FindChunks() - setting existing entry size to: %d", cSize ) );
+
+ // It must be a chunk then... Update size
+ existingEntry->SetSize( cSize );
+
+ // This item is in use, i.e. it is not unused
+ existingEntry->SetUnused( EFalse );
+ }
+ else
+ {
+ DChunk* chunk = (DChunk*) object;
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::FindChunks() - chunk not known, checking type..." ) );
+
+ // We have no record of this item so far. Is it really a chunk?
+ const TMemSpyTrackedChunk::TType type = ChunkType( object );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::FindChunks() - type is: %d", type ) );
+
+ if ( type != TMemSpyTrackedChunk::ETypeNotRelevant )
+ {
+ // It's a new entry
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::FindChunks() - this: 0x%08x, creating new entry for chunk: 0x%08x", this, chunk ) );
+
+ AddTrackedChunk( chunk, type );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::FindChunks() - added chunk..." ));
+ }
+ }
+ }
+ }
+
+ MemSpyObjectIx_Signal( processHandles );
+ }
+
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::FindChunks() - END - this: 0x%08x", this ) );
+ }
+
+
+TInt DMemSpyInspectedProcess::StackSize( DProcess& aProcess )
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::StackSize() - START - this: 0x%08x", this ) );
+ TInt ret = 0;
+ //
+ DMemSpyDriverOSAdaptionDThread& dThreadAdaption = iDevice.OSAdaption().DThread();
+
+ iUserThreadStackSize = 0;
+ //
+ SDblQueLink* pLink = aProcess.iThreadQ.First();
+ while(pLink != &aProcess.iThreadQ.iA)
+ {
+ DThread* pT = _LOFF( pLink, DThread, iProcessLink );
+ //
+ const TUint32 userStackSize = dThreadAdaption.GetUserStackSize( *pT );
+ const TUint32 suprStackSize = dThreadAdaption.GetSupervisorStackSize( *pT );
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::StackSize() - thread: 0x%08x, userStack: %8d, suprStack: %8d, total: %8d %O", pT, userStackSize, suprStackSize, userStackSize + suprStackSize, pT ));
+ //
+ iUserThreadStackSize += userStackSize;
+ ret += userStackSize + suprStackSize;
+ //
+ pLink = pLink->iNext;
+ }
+ //
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::StackSize() - END - this: 0x%08x, total stack size for process: %8d, iUserThreadStackSize: %8d", this, ret, iUserThreadStackSize ) );
+ return ret;
+ }
+
+
+void DMemSpyInspectedProcess::ResetPendingChanges()
+ {
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::ResetPendingChanges() - START - this: 0x%08x", this ) );
+ NKern::ThreadEnterCS();
+ //
+ SDblQueLink* link = iPendingChanges.GetFirst();
+ while( link )
+ {
+ TMemSpyTrackedChunkChangeInfo* cachedChange = _LOFF( link, TMemSpyTrackedChunkChangeInfo, iLink );
+ delete cachedChange;
+ link = iPendingChanges.GetFirst();
+ }
+ //
+ NKern::ThreadLeaveCS();
+ TRACE( Kern::Printf("DMemSpyInspectedProcess::ResetPendingChanges() - END - this: 0x%08x", this ) );
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+TMemSpyTrackedChunk::TMemSpyTrackedChunk( DChunk* aChunk, TType aType )
+: iChunk( aChunk ), iType( aType ), iSize( 0 ), iUnused( EFalse )
+ {
+ }
+
+
+void TMemSpyTrackedChunk::SetSize( TInt aSize )
+ {
+ iSize = aSize;
+ }
+
+
+void TMemSpyTrackedChunk::SetUnused( TBool aUnused )
+ {
+ iUnused = aUnused;
+ }
+