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

equal deleted inserted replaced

-:ca8a1b6995f6
+:52e343bb8f80
 	}
 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 )
 {
-	Lock();
+	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 ) );
 //
 // 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 ) );
-	Unlock();
+	Kern::MutexSignal( *iLock );
 return err;
 }
 TInt DMemSpyInspectedProcess::NotifyOnChangeCancel()
 {
-	Lock();
+	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 ) );
 iChangeObserverRS = NULL;
 iChangeObserverInfo = NULL;
 }
 	//
 TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChangeCancel() - END - this: 0x%08x", this ) );
-	Unlock();
+	Kern::MutexSignal( *iLock );
 return KErrNone;
 }
 TBool DMemSpyInspectedProcess::NotifyOnChangeQueued() const
 {
 TRACE( Kern::Printf("DMemSpyInspectedProcess::NotifyOnChangeQueued() - START - this: 0x%08x", this ) );
 //
-	Lock();
+	Kern::MutexWait( *iLock );
 const TBool queued = ( iChangeObserverRS != NULL );
-	Unlock();
+	Kern::MutexSignal( *iLock );
 //
 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 )
 {
-	    Lock();
+	    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 */ );
 {
 // Inform observer about new results.
 CompleteClientsRequest( KErrNone, &iInfoCurrent );
 }
+NKern::ThreadLeaveCS();
 TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleProcessUpdated() - END - this: 0x%08x", this ) );
-Unlock();
+Kern::MutexSignal( *iLock );
 }
 }
 void DMemSpyInspectedProcess::EMHandleProcessRemoved( DProcess& aProcess )
 DMemSpyDriverOSAdaptionDProcess& dProcessAdaption = iDevice.OSAdaption().DProcess();
 const TUint pid = dProcessAdaption.GetId( aProcess );
 if  ( pid == iProcessId )
 {
-	    Lock();
+	    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.
 }
 // Stop listening to events since we've drained everything now...
 iAmDead = ETrue;
+NKern::ThreadLeaveCS();
 TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleProcessRemoved() - END - this: 0x%08x", this ) );
-Unlock();
+Kern::MutexSignal( *iLock );
 }
 }
 void DMemSpyInspectedProcess::EMHandleThreadAdd( DThread& aThread )
 }
 void DMemSpyInspectedProcess::EMHandleThreadChanged( DThread& /*aThread*/ )
 {
-	Lock();
+	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 ) );
-Unlock();
+Kern::MutexSignal( *iLock );
 }
 void DMemSpyInspectedProcess::EMHandleChunkAdd( DChunk& aChunk )
 {
-	Lock();
+	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..." ) );
 CompleteClientsRequest( KErrNone, &iInfoCurrent );
 }
 }
 }
+NKern::ThreadLeaveCS();
 TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkAdd() - END - this: 0x%08x", this ) );
-Unlock();
+Kern::MutexSignal( *iLock );
 }
 void DMemSpyInspectedProcess::EMHandleChunkUpdated( DChunk& aChunk )
 {
-	Lock();
+	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 )
 {
 // Inform observer about new results.
 CompleteClientsRequest( KErrNone, &iInfoCurrent );
 }
 }
+NKern::ThreadLeaveCS();
 TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkUpdated() - END - this: 0x%08x", this ) );
-Unlock();
+Kern::MutexSignal( *iLock );
 }
 void DMemSpyInspectedProcess::EMHandleChunkDeleted( DChunk& aChunk )
 {
-	Lock();
+	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 )
 {
 // Inform observer about new results.
 CompleteClientsRequest( KErrNone, &iInfoCurrent );
 }
 }
+NKern::ThreadLeaveCS();
 TRACE( Kern::Printf("DMemSpyInspectedProcess::EMHandleChunkDeleted() - END - this: 0x%08x", this ) );
-Unlock();
+Kern::MutexSignal( *iLock );
 }
 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...
-MemSpyObjectIx_HandleLookupLock();
+NKern::LockSystem();
-			if (i >= processHandles->Count()) break; // Count may have changed in the meantime
 	    DObject* object = (*processHandles)[ i ];
-			if (object && object->Open() != KErrNone) object = NULL;
+NKern::UnlockSystem();
-			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 21	52e343bb8f80
parent 20	ca8a1b6995f6