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

equal deleted inserted replaced

-:b58b1294947a
+:1ea875759131
 // We are enumerating an entire container - not a thread-specific request
 const TObjectType type = ObjectTypeFromMemSpyContainerType( params.iContainer );
 DObjectCon* container = Kern::Containers()[type];
 container->Wait();
-NKern::LockSystem();
 const TInt count = container->Count();
 for(TInt i=0; i<count; i++)
 {
 DObject* object = (*container)[ i ];
 {
 AddTempHandle( object );
 }
 }
-NKern::UnlockSystem();
 container->Signal();
 	NKern::ThreadLeaveCS();
 }
 else
 {
 // Are we dealing with threads or processes?
 {
 	            NKern::ThreadEnterCS();
 // Iterate through each handle in the thread/process and add it to the temp handles container if
 // the handle is of the correct type.
-MemSpyObjectIx_Wait( handles );
+				MemSpyObjectIx_HandleLookupLock();
-	            TInt handleCount = handles->Count();
+				const TInt handleCount = handles->Count();
+				MemSpyObjectIx_HandleLookupUnlock();
 TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetContainerHandles - %d handles in index...", handleCount ));
 for( TInt handleIndex=0; handleIndex<handleCount; handleIndex++ )
 	            {
 	            // Get a handle from the container...
-NKern::LockSystem();
+					MemSpyObjectIx_HandleLookupLock();
-	            DObject* objectToSearchFor = (*handles)[ handleIndex ];
+					if (handleIndex >= handles->Count()) break; // Count may have changed in the meantime
-NKern::UnlockSystem();
+				DObject* objectToSearchFor = (*handles)[ handleIndex ];
+					if (objectToSearchFor && objectToSearchFor->Open() != KErrNone) objectToSearchFor = NULL;
+					MemSpyObjectIx_HandleLookupUnlock();
-if  ( objectToSearchFor != NULL )
+if (objectToSearchFor && OSAdaption().DThread().GetObjectType(*objectToSearchFor) == ObjectTypeFromMemSpyContainerType(params.iContainer))
 {
-// Check to see if this object is of the specified type. We can use quick mode
+// Found a match in the specified container. Write the object's handle (aka the object address)
-// because we know the object is valid since it's registered as a handle of the
+// back to the client address space
-// thread/process.
+AddTempHandle( objectToSearchFor );
-DObject* matchResult = CheckIfObjectIsInContainer( params.iContainer, objectToSearchFor, ETrue );
-if  ( matchResult )
-{
-// Found a match in the specified container. Write the object's handle (aka the object address)
-// back to the client address space
-AddTempHandle( matchResult );
-}
 }
+					if (objectToSearchFor) objectToSearchFor->Close(NULL);
 	            }
-MemSpyObjectIx_Signal( handles );
 NKern::ThreadLeaveCS();
 }
 // Done with this now.
 CloseTempObject();
 	NKern::ThreadEnterCS();
 // First, locate the specific DObject in question. Cast the handle, but don't use the object...
 DObject* handleAsObject = (DObject*) params.iHandle;
-handleAsObject = CheckIfObjectIsInContainer( params.iType, handleAsObject );
+handleAsObject = CheckedOpen(params.iType, handleAsObject);
 if  ( handleAsObject != NULL )
 {
 // We found the right object. First get generic info.
 handleAsObject->FullName( params.iName );
 handleAsObject->Name( params.iNameDetail );
-NKern::LockSystem();
+// Using threadAddaption to fetch generic info.
-r = handleAsObject->Open();
+// Implementations of following get functions are actually in DMemSpyDriverOSAdaptionDObject
-NKern::UnlockSystem();
+// so it does not matter what adaption to use for generic info.
-//
+DMemSpyDriverOSAdaptionDThread& threadAddaption = OSAdaption().DThread();
-if  ( r == KErrNone )
+params.iAccessCount = threadAddaption.GetAccessCount( *handleAsObject );
-{
+params.iUniqueID = threadAddaption.GetUniqueID( *handleAsObject );
-// Using threadAddaption to fetch generic info.
+params.iProtection = threadAddaption.GetProtection( *handleAsObject );
-// Implementations of following get functions are actually in DMemSpyDriverOSAdaptionDObject
+params.iAddressOfKernelOwner = threadAddaption.GetAddressOfKernelOwner( *handleAsObject );
-// so it does not matter what adaption to use for generic info.
-DMemSpyDriverOSAdaptionDThread& threadAddaption = OSAdaption().DThread();
-params.iAccessCount = threadAddaption.GetAccessCount( *handleAsObject );
-params.iUniqueID = threadAddaption.GetUniqueID( *handleAsObject );
-params.iProtection = threadAddaption.GetProtection( *handleAsObject );
-params.iAddressOfKernelOwner = threadAddaption.GetAddressOfKernelOwner( *handleAsObject );
-//
-handleAsObject->Close( NULL );
-}
 // Get type-specific info.
 if  ( params.iType == EMemSpyDriverContainerTypeThread )
 {
 	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeThread" ));
 DThread* object = (DThread*) handleAsObject;
-	        NKern::LockSystem();
+DMemSpyDriverOSAdaptionDThread& threadAdaption = OSAdaption().DThread();
-r = object->Open();
+//
-	    NKern::UnlockSystem();
+params.iId = threadAdaption.GetId( *object );
-//
+params.iPriority = threadAdaption.GetPriority( *object );
-if  ( r == KErrNone )
+params.iAddressOfOwningProcess = threadAdaption.GetAddressOfOwningProcess( *object );
+threadAdaption.GetNameOfOwningProcess( *object, params.iNameOfOwner );
+}
+else if ( params.iType == EMemSpyDriverContainerTypeProcess )
+{
+	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeProcess" ));
+DProcess* object = (DProcess*) handleAsObject;
+DMemSpyDriverOSAdaptionDProcess& processAdaption = OSAdaption().DProcess();
+//
+params.iId = processAdaption.GetId( *object );
+//
+params.iPriority = processAdaption.GetPriority( *object );
+params.iAddressOfOwningProcess = processAdaption.GetAddressOfOwningProcess( *object );
+params.iCreatorId = processAdaption.GetCreatorId( *object );
+params.iSecurityZone = processAdaption.GetSecurityZone( *object );
+params.iAttributes = processAdaption.GetAttributes( *object );
+params.iAddressOfDataBssStackChunk = processAdaption.GetAddressOfDataBssStackChunk( *object );
+}
+else if ( params.iType == EMemSpyDriverContainerTypeChunk )
+{
+	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeChunk" ));
+DChunk* object = (DChunk*) handleAsObject;
+DMemSpyDriverOSAdaptionDChunk& ca = OSAdaption().DChunk();
+//
+params.iSize = ca.GetSize( *object );
+params.iId = ca.GetOwningProcessId( *object );
+params.iAddressOfOwningProcess = ca.GetAddressOfOwningProcess( *object );
+params.iMaxSize = ca.GetMaxSize( *object );
+params.iBottom = ca.GetBottom( *object );
+params.iTop = ca.GetTop( *object );
+params.iAttributes = ca.GetAttributes( *object );
+params.iStartPos = ca.GetStartPos( *object );
+params.iControllingOwner = ca.GetControllingOwnerId( *object );
+params.iRestrictions = ca.GetRestrictions( *object );
+params.iMapAttr = ca.GetMapAttr( *object );
+params.iChunkType = ca.GetType( *object );
+ca.GetNameOfOwningProcess( *object, params.iNameOfOwner );
+}
+else if ( params.iType == EMemSpyDriverContainerTypeLibrary )
+{
+	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeLibrary" ));
+	        Kern::AccessCode();
+//
+DLibrary* object = (DLibrary*) handleAsObject;
+DMemSpyDriverOSAdaptionDCodeSeg& csa = OSAdaption().DCodeSeg();
+DCodeSeg* codeSeg = csa.GetCodeSeg( *object );
+params.iAddressOfCodeSeg = (TUint8*)codeSeg;
+params.iMapCount = csa.GetMapCount( *object );
+params.iState = csa.GetState( *object );
+//
+if  ( codeSeg )
 {
-DMemSpyDriverOSAdaptionDThread& threadAdaption = OSAdaption().DThread();
+params.iSize = csa.GetSize( *codeSeg );
-//
-params.iId = threadAdaption.GetId( *object );
-params.iPriority = threadAdaption.GetPriority( *object );
-params.iAddressOfOwningProcess = threadAdaption.GetAddressOfOwningProcess( *object );
-threadAdaption.GetNameOfOwningProcess( *object, params.iNameOfOwner );
-//
-object->Close( NULL );
 }
-}
+else
-else if ( params.iType == EMemSpyDriverContainerTypeProcess )
-{
-	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeProcess" ));
-DProcess* object = (DProcess*) handleAsObject;
-	        NKern::LockSystem();
-r = object->Open();
-	    NKern::UnlockSystem();
-//
-if  ( r == KErrNone )
 {
-DMemSpyDriverOSAdaptionDProcess& processAdaption = OSAdaption().DProcess();
+r = KErrNotFound;
-//
-params.iId = processAdaption.GetId( *object );
-//
-params.iPriority = processAdaption.GetPriority( *object );
-params.iAddressOfOwningProcess = processAdaption.GetAddressOfOwningProcess( *object );
-params.iCreatorId = processAdaption.GetCreatorId( *object );
-params.iSecurityZone = processAdaption.GetSecurityZone( *object );
-params.iAttributes = processAdaption.GetAttributes( *object );
-params.iAddressOfDataBssStackChunk = processAdaption.GetAddressOfDataBssStackChunk( *object );
-//
-object->Close( NULL );
 }
-}
-else if ( params.iType == EMemSpyDriverContainerTypeChunk )
-{
-	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeChunk" ));
-DChunk* object = (DChunk*) handleAsObject;
-	        NKern::LockSystem();
-r = object->Open();
-	    NKern::UnlockSystem();
-//
-if  ( r == KErrNone )
-{
-DMemSpyDriverOSAdaptionDChunk& ca = OSAdaption().DChunk();
-//
-params.iSize = ca.GetSize( *object );
-params.iId = ca.GetOwningProcessId( *object );
-params.iAddressOfOwningProcess = ca.GetAddressOfOwningProcess( *object );
-params.iMaxSize = ca.GetMaxSize( *object );
-params.iBottom = ca.GetBottom( *object );
-params.iTop = ca.GetTop( *object );
-params.iAttributes = ca.GetAttributes( *object );
-params.iStartPos = ca.GetStartPos( *object );
-params.iControllingOwner = ca.GetControllingOwnerId( *object );
-params.iRestrictions = ca.GetRestrictions( *object );
-params.iMapAttr = ca.GetMapAttr( *object );
-params.iChunkType = ca.GetType( *object );
-ca.GetNameOfOwningProcess( *object, params.iNameOfOwner );
-//
-object->Close( NULL );
-}
-}
-else if ( params.iType == EMemSpyDriverContainerTypeLibrary )
-{
-	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeLibrary" ));
-	        Kern::AccessCode();
-//
-DLibrary* object = (DLibrary*) handleAsObject;
-	        NKern::LockSystem();
-r = object->Open();
-	    NKern::UnlockSystem();
-//
-if  ( r == KErrNone )
-{
-DMemSpyDriverOSAdaptionDCodeSeg& csa = OSAdaption().DCodeSeg();
-DCodeSeg* codeSeg = csa.GetCodeSeg( *object );
-params.iAddressOfCodeSeg = (TUint8*)codeSeg;
-params.iMapCount = csa.GetMapCount( *object );
-params.iState = csa.GetState( *object );
-//
-if  ( codeSeg )
-{
-params.iSize = csa.GetSize( *codeSeg );
-}
-else
-{
-r = KErrNotFound;
-}
-//
-object->Close( NULL );
-}
 //
 	        Kern::EndAccessCode();
 }
 else if ( params.iType == EMemSpyDriverContainerTypeSemaphore )
 {
 	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeSemaphore" ));
 DSemaphore* object = (DSemaphore*) handleAsObject;
-	        NKern::LockSystem();
+DMemSpyDriverOSAdaptionDSemaphore& sa = OSAdaption().DSemaphore();
-r = object->Open();
+params.iCount = sa.GetCount( *object );
-	    NKern::UnlockSystem();
+params.iResetting = sa.GetResetting( *object );
-//
-if  ( r == KErrNone )
-{
-DMemSpyDriverOSAdaptionDSemaphore& sa = OSAdaption().DSemaphore();
-params.iCount = sa.GetCount( *object );
-params.iResetting = sa.GetResetting( *object );
-//
-object->Close( NULL );
-}
 }
 else if ( params.iType == EMemSpyDriverContainerTypeMutex )
 {
 	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeMutex" ));
 DMutex* object = (DMutex*) handleAsObject;
-	        NKern::LockSystem();
+DMemSpyDriverOSAdaptionDMutex& ma = OSAdaption().DMutex();
-r = object->Open();
+//
-	    NKern::UnlockSystem();
+params.iCount = ma.GetHoldCount( *object );
-//
+params.iWaitCount = ma.GetWaitCount( *object );
-if  ( r == KErrNone )
+params.iResetting = ma.GetResetting( *object );
-{
+params.iOrder = ma.GetOrder( *object );
-DMemSpyDriverOSAdaptionDMutex& ma = OSAdaption().DMutex();
-//
-params.iCount = ma.GetHoldCount( *object );
-params.iWaitCount = ma.GetWaitCount( *object );
-params.iResetting = ma.GetResetting( *object );
-params.iOrder = ma.GetOrder( *object );
-//
-object->Close( NULL );
-}
 }
 else if ( params.iType == EMemSpyDriverContainerTypeTimer )
 {
 	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeTimer" ));
 // Get timer properties
 DTimer* object = (DTimer*) handleAsObject;
-	        NKern::LockSystem();
+DMemSpyDriverOSAdaptionDTimer& ta = OSAdaption().DTimer();
-r = object->Open();
+//
-	    NKern::UnlockSystem();
+params.iTimerType = MapToMemSpyTimerType( ta.GetType( *object ) );
-//
+params.iTimerState = MapToMemSpyTimerState( ta.GetState( *object ) );
-if  ( r == KErrNone )
+}
+else if ( params.iType == EMemSpyDriverContainerTypeServer )
+{
+	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeServer" ));
+DServer* object = (DServer*) handleAsObject;
+DMemSpyDriverOSAdaptionDServer& sa = OSAdaption().DServer();
+//
+params.iCount = sa.GetSessionCount( *object );
+params.iId = sa.GetOwningThreadId( *object );
+params.iSessionType = sa.GetSessionType( *object );
+params.iAddressOfOwningThread = sa.GetAddressOfOwningThread( *object );
+sa.GetNameOfOwningThread( *object, params.iNameOfOwner );
+}
+else if ( params.iType == EMemSpyDriverContainerTypeSession )
+{
+	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeSession" ));
+DSession* object = (DSession*) handleAsObject;
+DMemSpyDriverOSAdaptionDServer& serverAdaption = OSAdaption().DServer();
+DMemSpyDriverOSAdaptionDSession& sessionAdaption = OSAdaption().DSession();
+params.iName.Zero();
+TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - getting session type..." ));
+params.iSessionType = sessionAdaption.GetSessionType( *object );
+params.iAddressOfServer = sessionAdaption.GetAddressOfServer( *object );
+params.iTotalAccessCount = sessionAdaption.GetTotalAccessCount( *object );
+params.iSvrSessionType = sessionAdaption.GetSessionType( *object );
+params.iMsgCount = sessionAdaption.GetMsgCount( *object );
+params.iMsgLimit = sessionAdaption.GetMsgLimit( *object );
+// Its more useful in this instance, if the name object
+// points to the server which the session is connected to
+// (rather than displaying a process-local name).
+DServer* server = (DServer*)CheckedOpen(EMemSpyDriverContainerTypeServer, sessionAdaption.GetServer( *object ));
+	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - getting full name, server: 0x%08x", server ));
+//
+if  ( server )
 {
-DMemSpyDriverOSAdaptionDTimer& ta = OSAdaption().DTimer();
+server->FullName( params.iName );
-//
-params.iTimerType = MapToMemSpyTimerType( ta.GetType( *object ) );
+// Continue as normal for other items
-params.iTimerState = MapToMemSpyTimerState( ta.GetState( *object ) );
+	            TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - server: 0x%08x, server->iOwningThread: 0x%08x", server, server->iOwningThread ));
-//
+DThread* owningThread = serverAdaption.GetOwningThread( *server );
-object->Close( NULL );
+if  ( owningThread )
+{
+	                TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - getting server thread id..." ));
+params.iId = serverAdaption.GetOwningThreadId( *server );
+}
+server->Close(NULL);
 }
 }
-else if ( params.iType == EMemSpyDriverContainerTypeServer )
-{
-	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeServer" ));
-DServer* object = (DServer*) handleAsObject;
-	        NKern::LockSystem();
-r = object->Open();
-	    NKern::UnlockSystem();
-//
-if  ( r == KErrNone )
-{
-DMemSpyDriverOSAdaptionDServer& sa = OSAdaption().DServer();
-//
-params.iCount = sa.GetSessionCount( *object );
-params.iId = sa.GetOwningThreadId( *object );
-params.iSessionType = sa.GetSessionType( *object );
-params.iAddressOfOwningThread = sa.GetAddressOfOwningThread( *object );
-sa.GetNameOfOwningThread( *object, params.iNameOfOwner );
-//
-object->Close( NULL );
-}
-}
-else if ( params.iType == EMemSpyDriverContainerTypeSession )
-{
-	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeSession" ));
-DSession* object = (DSession*) handleAsObject;
-	        NKern::LockSystem();
-r = object->Open();
-	    NKern::UnlockSystem();
-//
-	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - open error: %d", r ));
-if  ( r == KErrNone )
-{
-DMemSpyDriverOSAdaptionDServer& serverAdaption = OSAdaption().DServer();
-DMemSpyDriverOSAdaptionDSession& sessionAdaption = OSAdaption().DSession();
-params.iName.Zero();
-TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - getting session type..." ));
-params.iSessionType = sessionAdaption.GetSessionType( *object );
-params.iAddressOfServer = sessionAdaption.GetAddressOfServer( *object );
-params.iTotalAccessCount = sessionAdaption.GetTotalAccessCount( *object );
-params.iSvrSessionType = sessionAdaption.GetSessionType( *object );
-params.iMsgCount = sessionAdaption.GetMsgCount( *object );
-params.iMsgLimit = sessionAdaption.GetMsgLimit( *object );
-// Its more useful in this instance, if the name object
-// points to the server which the session is connected to
-// (rather than displaying a process-local name).
-DServer* server = sessionAdaption.GetServer( *object );
-	            TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - getting full name, server: 0x%08x", server ));
-//
-if  ( server )
-{
-	                NKern::LockSystem();
-r = server->Open();
-	            NKern::UnlockSystem();
-if  ( r == KErrNone )
-{
-server->FullName( params.iName );
-// Continue as normal for other items
-	                    TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - server: 0x%08x, server->iOwningThread: 0x%08x", server, server->iOwningThread ));
-DThread* owningThread = serverAdaption.GetOwningThread( *server );
-if  ( owningThread )
-{
-	                        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - getting server thread id..." ));
-params.iId = serverAdaption.GetOwningThreadId( *server );
-}
-server->Close( NULL );
-}
-}
-TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - closing session object..." ));
-object->Close( NULL );
-}
-}
 else if ( params.iType == EMemSpyDriverContainerTypeLogicalDevice )
 {
 	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeLogicalDevice" ));
 DLogicalDevice* object = (DLogicalDevice*) handleAsObject;
-	        NKern::LockSystem();
+DMemSpyDriverOSAdaptionDLogicalDevice& lda = OSAdaption().DLogicalDevice();
-r = object->Open();
+params.iOpenChannels = lda.GetOpenChannels( *object );
-	    NKern::UnlockSystem();
+params.iVersion = lda.GetVersion( *object );
-//
+params.iParseMask = lda.GetParseMask( *object );
-if  ( r == KErrNone )
+params.iUnitsMask = lda.GetUnitsMask( *object );
-{
-DMemSpyDriverOSAdaptionDLogicalDevice& lda = OSAdaption().DLogicalDevice();
-params.iOpenChannels = lda.GetOpenChannels( *object );
-params.iVersion = lda.GetVersion( *object );
-params.iParseMask = lda.GetParseMask( *object );
-params.iUnitsMask = lda.GetUnitsMask( *object );
-//
-object->Close( NULL );
-}
 }
 else if ( params.iType == EMemSpyDriverContainerTypePhysicalDevice )
 {
 	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypePhysicalDevice" ));
 	        DPhysicalDevice* object = (DPhysicalDevice*) handleAsObject;
-NKern::LockSystem();
+DMemSpyDriverOSAdaptionDPhysicalDevice& pda = OSAdaption().DPhysicalDevice();
-r = object->Open();
+params.iVersion = pda.GetVersion( *object );
-NKern::UnlockSystem();
+params.iUnitsMask = pda.GetUnitsMask( *object );
-//
+params.iAddressOfCodeSeg = pda.GetAddressOfCodeSeg( *object );
-if  ( r == KErrNone )
-{
-DMemSpyDriverOSAdaptionDPhysicalDevice& pda = OSAdaption().DPhysicalDevice();
-params.iVersion = pda.GetVersion( *object );
-params.iUnitsMask = pda.GetUnitsMask( *object );
-params.iAddressOfCodeSeg = pda.GetAddressOfCodeSeg( *object );
-//
-object->Close( NULL );
-}
 }
 else if ( params.iType == EMemSpyDriverContainerTypeLogicalChannel )
 {
 	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeLogicalChannel" ));
 }
 else if ( params.iType == EMemSpyDriverContainerTypeChangeNotifier )
 {
 	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeChangeNotifier" ));
 	        DChangeNotifier* object = (DChangeNotifier*) handleAsObject;
-NKern::LockSystem();
+DMemSpyDriverOSAdaptionDChangeNotifier& cna = OSAdaption().DChangeNotifier();
-r = object->Open();
+params.iChanges = cna.GetChanges( *object );
-NKern::UnlockSystem();
+params.iAddressOfOwningThread = cna.GetAddressOfOwningThread( *object );
-//
+cna.GetNameOfOwningThread( *object, params.iNameOfOwner );
-if  ( r == KErrNone )
-{
-DMemSpyDriverOSAdaptionDChangeNotifier& cna = OSAdaption().DChangeNotifier();
-params.iChanges = cna.GetChanges( *object );
-params.iAddressOfOwningThread = cna.GetAddressOfOwningThread( *object );
-cna.GetNameOfOwningThread( *object, params.iNameOfOwner );
-//
-object->Close( NULL );
-}
 }
 else if ( params.iType == EMemSpyDriverContainerTypeUndertaker )
 {
 	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeUndertaker" ));
 DUndertaker* object = (DUndertaker*) handleAsObject;
-NKern::LockSystem();
+DMemSpyDriverOSAdaptionDUndertaker& uta = OSAdaption().DUndertaker();
-r = object->Open();
+params.iAddressOfOwningThread = uta.GetAddressOfOwningThread( *object );
-NKern::UnlockSystem();
+uta.GetNameOfOwningThread( *object, params.iNameOfOwner );
-//
-if  ( r == KErrNone )
-{
-DMemSpyDriverOSAdaptionDUndertaker& uta = OSAdaption().DUndertaker();
-params.iAddressOfOwningThread = uta.GetAddressOfOwningThread( *object );
-uta.GetNameOfOwningThread( *object, params.iNameOfOwner );
-//
-object->Close( NULL );
-}
 }
 else if ( params.iType == EMemSpyDriverContainerTypeMsgQueue )
 {
 	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeMsgQueue" ));
 }
 else if ( params.iType == EMemSpyDriverContainerTypeCondVar )
 {
 	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeCondVar" ));
 DCondVar* object = (DCondVar*) handleAsObject;
-NKern::LockSystem();
+DMemSpyDriverOSAdaptionDCondVar& cva = OSAdaption().DCondVar();
-r = object->Open();
+params.iResetting = cva.GetResetting( *object );
-NKern::UnlockSystem();
+params.iAddressOfOwningThread = cva.GetAddressOfMutex( *object );
-//
+cva.GetNameOfMutex( *object, params.iNameOfOwner );
-if  ( r == KErrNone )
+params.iWaitCount = cva.GetWaitCount( *object );
-{
-DMemSpyDriverOSAdaptionDCondVar& cva = OSAdaption().DCondVar();
-params.iResetting = cva.GetResetting( *object );
-params.iAddressOfOwningThread = cva.GetAddressOfMutex( *object );
-cva.GetNameOfMutex( *object, params.iNameOfOwner );
-params.iWaitCount = cva.GetWaitCount( *object );
-//
-object->Close( NULL );
-}
 }
 else
 {
 	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - KErrNotSupported" ));
 r = KErrNotSupported;
 }
+		handleAsObject->Close(NULL);
 }
 else
 {
 TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo - couldn not find object => KErrNotFound"));
 r = KErrNotFound;
 TInt r = KErrNotFound;
 	NKern::ThreadEnterCS();
 // First, locate the specific DObject in question. Cast the handle, but don't use the object...
-// NB: This claims the system lock
+DObject* object = CheckedOpen(EMemSpyDriverContainerTypePropertyRef, aHandle);
-DObject* object = CheckIfObjectIsInContainer( EMemSpyDriverContainerTypePropertyRef, aHandle );
 TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetPAndSInfo() - handle search returned: 0x%08x", object ));
 if  ( object != NULL )
 {
-NKern::LockSystem();
+NKern::LockSystem(); // Keep this, the DPropertyRef APIs use it -TomS
 DMemSpyDriverOSAdaptionDPropertyRef& pra = OSAdaption().DPropertyRef();
 const TBool isReady = pra.GetIsReady( *object );
 TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetPAndSInfo() - isReady: %d", isReady ));
 {
 r = KErrNotReady;
 }
 NKern::UnlockSystem();
+		object->Close(NULL);
 }
 NKern::ThreadLeaveCS();
 TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetPAndSInfo() - END - r: %d", r));
 const TInt maxCount = params.iMaxCount;
 NKern::ThreadEnterCS();
 DObject* condVarHandle = (DObject*) params.iCondVarHandle;
-condVarHandle = CheckIfObjectIsInContainer( EMemSpyDriverContainerTypeCondVar, condVarHandle );
+condVarHandle = CheckedOpen(EMemSpyDriverContainerTypeCondVar, condVarHandle);
 if  ( condVarHandle == NULL )
 {
 Kern::Printf("DMemSpyDriverLogChanMisc::GetCondVarSuspThrs() - END - condVar not found");
 NKern::ThreadLeaveCS();
 return KErrNotFound;
 }
 ResetTempHandles();
-DCondVar* condVar = (DCondVar*) params.iCondVarHandle;;
+DCondVar* condVar = (DCondVar*) condVarHandle;
-NKern::LockSystem();
+NKern::LockSystem(); // Keep this, needed for iterating suspended queue -TomS
 // Iterate through suspended threads, writing back thread pointer (handle)
 // to client
 SDblQue& suspQueue = condVarAdaption.GetSuspendedQ( *condVar );
 SDblQueLink* anchor = &suspQueue.iA;
 {
 r = finalWrite;
 }
 }
+	condVarHandle->Close(NULL);
 NKern::ThreadLeaveCS();
 TRACE( Kern::Printf("DMemSpyDriverLogChanMisc::GetCondVarSuspThrs() - END - r: %d", r));
 return r;
 }
 DMemSpyDriverOSAdaptionDThread& threadAdaption = OSAdaption().DThread();
 NKern::ThreadEnterCS();
 DObject* threadHandle = (DObject*) aThreadHandle;
-threadHandle = CheckIfObjectIsInContainer( EMemSpyDriverContainerTypeThread, threadHandle );
+threadHandle = CheckedOpen(EMemSpyDriverContainerTypeThread, threadHandle);
 if  ( threadHandle == NULL )
 {
 Kern::Printf("DMemSpyDriverLogChanMisc::GetCondVarSuspThrInfo() - END - thread not found");
 NKern::ThreadLeaveCS();
 return KErrNotFound;
 if  ( r == KErrNone )
 {
 r = Kern::ThreadRawWrite( &ClientThread(), aParams, &params, sizeof(TMemSpyDriverCondVarSuspendedThreadInfo) );
 }
+	threadHandle->Close(NULL);
 NKern::ThreadLeaveCS();
 TRACE( Kern::Printf("DMemSpyDriverLogChanMisc::GetCondVarSuspThrInfo() - END - r: %d", r));
 return r;
 }
 MemSpyObjectIx* handles = threadAdaption.GetHandles( *thread );
 TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::SearchThreadsFor - handles: 0x%08x", handles ));
 if  ( handles != NULL )
 {
-MemSpyObjectIx_Wait( handles );
+TBool found = handles->Find( aHandleToLookFor );
-//
+	        if (found)
-TInt searchResult = handles->At( aHandleToLookFor );
-	        if  ( searchResult != KErrNotFound )
 		        {
 TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::SearchThreadsFor - found handle match in [%O]", thread ));
 aStream.WriteUint32( (TUint32) thread );
 ++matches;
 		        }
-//
-MemSpyObjectIx_Signal( handles );
 }
 }
 // Finished with thread/process container.
 container->Signal();
 MemSpyObjectIx* handles = processAdaption.GetHandles( *process );
 TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::SearchProcessFor - handles: 0x%08x", handles ));
 if  ( handles != NULL )
 {
-MemSpyObjectIx_Wait( handles );
+TBool found = handles->Find( aHandleToLookFor );
-//
+	        if  ( found )
-TInt searchResult = handles->At( aHandleToLookFor );
-	        if  ( searchResult != KErrNotFound )
 		        {
 TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::SearchProcessFor - found handle match in [%O]", process ));
 aStream.WriteUint32( (TUint32) process );
 ++matches;
 		        }
-//
-MemSpyObjectIx_Signal( handles );
 }
 }
 // Finished with thread/process container.
 container->Signal();

branch	GCC_SURGE
changeset 35	1ea875759131
parent 34	7259cf1302ad
child 44	52e343bb8f80