FCL/sf/os/osrndtools: comparison memspy/Driver/Kernel/Source/MemSpyDriverInspectedProcess.cpp

equal deleted inserted replaced

-:e26895079d7c
+:7fdc9a71d314
 	}
 TInt DMemSpyInspectedProcess::Open( DProcess* aProcess )
 {
+	__ASSERT_CRITICAL;
 TRACE( Kern::Printf("DMemSpyInspectedProcess::Open() - START - this: 0x%08x, aProcess: 0x%08x (%O)", this, aProcess, aProcess ));
 TInt error = KErrNone;
 //
 iProcess = aProcess;
 TInt DMemSpyInspectedProcess::NotifyOnChange( DThread* aThread, TRequestStatus* aRequestStatus, TMemSpyDriverProcessInspectionInfo* aInfo )
 {
-	Kern::MutexWait( *iLock );
+	Lock();
 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 ) );
 //
 // 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 );
 		err = KErrNone;
 }
 	//
 TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChange() - END - this: 0x%08x, err: %d", this, err ) );
-	Kern::MutexSignal( *iLock );
+	Unlock();
 return err;
 }
 TInt DMemSpyInspectedProcess::NotifyOnChangeCancel()
 {
-	Kern::MutexWait( *iLock );
+	Lock();
 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 ) );
 iChangeObserverRS = NULL;
 iChangeObserverInfo = NULL;
 }
 	//
 TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChangeCancel() - END - this: 0x%08x", this ) );
-	Kern::MutexSignal( *iLock );
+	Unlock();
 return KErrNone;
 }
 TBool DMemSpyInspectedProcess::NotifyOnChangeQueued() const
 {
 TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChangeQueued() - START - this: 0x%08x", this ) );
 //
-	Kern::MutexWait( *iLock );
+	Lock();
 const TBool queued = ( iChangeObserverRS != NULL );
-	Kern::MutexSignal( *iLock );
+	Unlock();
 //
 TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChangeQueued() - END - this: 0x%08x, queued: %d", this, queued ) );
 return queued;
 }
 void DMemSpyInspectedProcess::EMHandleProcessUpdated( DProcess& aProcess )
 {
 const TUint procId = iDevice.OSAdaption().DProcess().GetId( aProcess );
 if  ( procId == iProcessId )
 {
-	    Kern::MutexWait( *iLock );
+	    Lock();
 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 */ );
 {
 // Inform observer about new results.
 CompleteClientsRequest( KErrNone, &iInfoCurrent );
 }
-NKern::ThreadLeaveCS();
 TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleProcessUpdated() - END - this: 0x%08x", this ) );
-Kern::MutexSignal( *iLock );
+Unlock();
 }
 }
 void DMemSpyInspectedProcess::EMHandleProcessRemoved( DProcess& aProcess )
 DMemSpyDriverOSAdaptionDProcess& dProcessAdaption = iDevice.OSAdaption().DProcess();
 const TUint pid = dProcessAdaption.GetId( aProcess );
 if  ( pid == iProcessId )
 {
-	    Kern::MutexWait( *iLock );
+	    Lock();
 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.
 }
 // 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 );
+Unlock();
 }
 }
 void DMemSpyInspectedProcess::EMHandleThreadAdd( DThread& aThread )
 }
 void DMemSpyInspectedProcess::EMHandleThreadChanged( DThread& /*aThread*/ )
 {
-	Kern::MutexWait( *iLock );
+	Lock();
 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 );
+Unlock();
 }
 void DMemSpyInspectedProcess::EMHandleChunkAdd( DChunk& aChunk )
 {
-	Kern::MutexWait( *iLock );
+	Lock();
 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..." ) );
 CompleteClientsRequest( KErrNone, &iInfoCurrent );
 }
 }
 }
-NKern::ThreadLeaveCS();
 TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkAdd() - END - this: 0x%08x", this ) );
-Kern::MutexSignal( *iLock );
+Unlock();
 }
 void DMemSpyInspectedProcess::EMHandleChunkUpdated( DChunk& aChunk )
 {
-	Kern::MutexWait( *iLock );
+	Lock();
 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 )
 {
 // Inform observer about new results.
 CompleteClientsRequest( KErrNone, &iInfoCurrent );
 }
 }
-NKern::ThreadLeaveCS();
 TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkUpdated() - END - this: 0x%08x", this ) );
-Kern::MutexSignal( *iLock );
+Unlock();
 }
 void DMemSpyInspectedProcess::EMHandleChunkDeleted( DChunk& aChunk )
 {
-	Kern::MutexWait( *iLock );
+	Lock();
 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 )
 {
 // Inform observer about new results.
 CompleteClientsRequest( KErrNone, &iInfoCurrent );
 }
 }
-NKern::ThreadLeaveCS();
 TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkDeleted() - END - this: 0x%08x", this ) );
-Kern::MutexSignal( *iLock );
+Unlock();
 }
 void DMemSpyInspectedProcess::PrintChunkInfo( DChunk& aChunk ) const
 {
 // 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 )
 {
+			NKern::ThreadEnterCS();
 TInt err = firstThread->Open();
 TRACE( Kern::Printf("DMemSpyInspectedProcess::IsHeapChunk() - firstThread open result: %d", err ) );
 if  ( err == KErrNone )
 {
 }
 TRACE( Kern::Printf("DMemSpyInspectedProcess::IsHeapChunk() - closing first thread..." ) );
 	Kern::SafeClose( (DObject*&) firstThread, NULL );
 }
+			NKern::ThreadLeaveCS();
 }
 }
 //
 if  ( !isHeap && aName == KMemSpyLitDollarHeap )
 {
 }
 void DMemSpyInspectedProcess::FindChunks( DProcess& aProcess )
 {
+	__ASSERT_CRITICAL;
 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 );
+		MemSpyObjectIx_HandleLookupLock();
 const TInt count = processHandles->Count();
+		MemSpyObjectIx_HandleLookupUnlock();
 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();
+MemSpyObjectIx_HandleLookupLock();
+			if (i >= processHandles->Count()) break; // Count may have changed in the meantime
 	    DObject* object = (*processHandles)[ i ];
-NKern::UnlockSystem();
+			if (object && object->Open() != KErrNone) object = NULL;
+			MemSpyObjectIx_HandleLookupUnlock();
 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?
 AddTrackedChunk( chunk, type );
 TRACE( Kern::Printf("DMemSpyInspectedProcess::FindChunks() - added chunk..." ));
 }
 }
 }
+			if (object) object->Close(NULL);
 	    }
-MemSpyObjectIx_Signal( processHandles );
 }
 TRACE( Kern::Printf("DMemSpyInspectedProcess::FindChunks() - END - this: 0x%08x", this ) );
 }
 NKern::ThreadLeaveCS();
 TRACE( Kern::Printf("DMemSpyInspectedProcess::ResetPendingChanges() - END - this: 0x%08x", this ) );
 }
+void DMemSpyInspectedProcess::Lock() const
+	{
+	NKern::ThreadEnterCS();
+	Kern::MutexWait(*iLock);
+	}
+void DMemSpyInspectedProcess::Unlock() const
+	{
+	Kern::MutexSignal(*iLock);
+	NKern::ThreadLeaveCS();
+	}

branch	RCL_3
changeset 49	7fdc9a71d314
parent 44	52e343bb8f80
child 59	8ad140f3dd41