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

equal deleted inserted replaced

-:7fdc9a71d314
+:8ad140f3dd41
 // 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();
-				const TInt handleCount = handles->Count();
+	            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...
-					MemSpyObjectIx_HandleLookupLock();
+NKern::LockSystem();
-					if (handleIndex >= handles->Count()) break; // Count may have changed in the meantime
+	            DObject* objectToSearchFor = (*handles)[ handleIndex ];
-				DObject* objectToSearchFor = (*handles)[ handleIndex ];
+NKern::UnlockSystem();
-					if (objectToSearchFor && objectToSearchFor->Open() != KErrNone) objectToSearchFor = NULL;
-					MemSpyObjectIx_HandleLookupUnlock();
-if (objectToSearchFor && OSAdaption().DThread().GetObjectType(*objectToSearchFor) == ObjectTypeFromMemSpyContainerType(params.iContainer))
+if  ( objectToSearchFor != NULL )
 {
-// Found a match in the specified container. Write the object's handle (aka the object address)
+// Check to see if this object is of the specified type. We can use quick mode
-// back to the client address space
+// because we know the object is valid since it's registered as a handle of the
-AddTempHandle( objectToSearchFor );
+// thread/process.
+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 = CheckedOpen(params.iType, handleAsObject);
+handleAsObject = CheckIfObjectIsInContainer( params.iType, handleAsObject );
 if  ( handleAsObject != NULL )
 {
 // We found the right object. First get generic info.
 handleAsObject->FullName( params.iName );
 handleAsObject->Name( params.iNameDetail );
-// Using threadAddaption to fetch generic info.
+NKern::LockSystem();
-// Implementations of following get functions are actually in DMemSpyDriverOSAdaptionDObject
+r = handleAsObject->Open();
-// so it does not matter what adaption to use for generic info.
+NKern::UnlockSystem();
-DMemSpyDriverOSAdaptionDThread& threadAddaption = OSAdaption().DThread();
+//
-params.iAccessCount = threadAddaption.GetAccessCount( *handleAsObject );
+if  ( r == KErrNone )
-params.iUniqueID = threadAddaption.GetUniqueID( *handleAsObject );
+{
-params.iProtection = threadAddaption.GetProtection( *handleAsObject );
+// Using threadAddaption to fetch generic info.
-params.iAddressOfKernelOwner = threadAddaption.GetAddressOfKernelOwner( *handleAsObject );
+// Implementations of following get functions are actually in DMemSpyDriverOSAdaptionDObject
+// 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;
-DMemSpyDriverOSAdaptionDThread& threadAdaption = OSAdaption().DThread();
+	        NKern::LockSystem();
-//
+r = object->Open();
-params.iId = threadAdaption.GetId( *object );
+	    NKern::UnlockSystem();
-params.iPriority = threadAdaption.GetPriority( *object );
+//
-params.iAddressOfOwningProcess = threadAdaption.GetAddressOfOwningProcess( *object );
+if  ( r == KErrNone )
-threadAdaption.GetNameOfOwningProcess( *object, params.iNameOfOwner );
+{
+DMemSpyDriverOSAdaptionDThread& threadAdaption = OSAdaption().DThread();
+//
+params.iId = threadAdaption.GetId( *object );
+params.iPriority = threadAdaption.GetPriority( *object );
+params.iAddressOfOwningProcess = threadAdaption.GetAddressOfOwningProcess( *object );
+threadAdaption.GetNameOfOwningProcess( *object, params.iNameOfOwner );
+//
+object->Close( NULL );
+}
 }
 else if ( params.iType == EMemSpyDriverContainerTypeProcess )
 {
 	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeProcess" ));
 DProcess* object = (DProcess*) handleAsObject;
-DMemSpyDriverOSAdaptionDProcess& processAdaption = OSAdaption().DProcess();
+	        NKern::LockSystem();
-//
+r = object->Open();
-params.iId = processAdaption.GetId( *object );
+	    NKern::UnlockSystem();
 //
-params.iPriority = processAdaption.GetPriority( *object );
+if  ( r == KErrNone )
-params.iAddressOfOwningProcess = processAdaption.GetAddressOfOwningProcess( *object );
+{
-params.iCreatorId = processAdaption.GetCreatorId( *object );
+DMemSpyDriverOSAdaptionDProcess& processAdaption = OSAdaption().DProcess();
-params.iSecurityZone = processAdaption.GetSecurityZone( *object );
+//
-params.iAttributes = processAdaption.GetAttributes( *object );
+params.iId = processAdaption.GetId( *object );
-params.iAddressOfDataBssStackChunk = processAdaption.GetAddressOfDataBssStackChunk( *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;
-DMemSpyDriverOSAdaptionDChunk& ca = OSAdaption().DChunk();
+	        NKern::LockSystem();
-//
+r = object->Open();
-params.iSize = ca.GetSize( *object );
+	    NKern::UnlockSystem();
-params.iId = ca.GetOwningProcessId( *object );
+//
-params.iAddressOfOwningProcess = ca.GetAddressOfOwningProcess( *object );
+if  ( r == KErrNone )
-params.iMaxSize = ca.GetMaxSize( *object );
+{
-params.iBottom = ca.GetBottom( *object );
+DMemSpyDriverOSAdaptionDChunk& ca = OSAdaption().DChunk();
-params.iTop = ca.GetTop( *object );
+//
-params.iAttributes = ca.GetAttributes( *object );
+params.iSize = ca.GetSize( *object );
-params.iStartPos = ca.GetStartPos( *object );
+params.iId = ca.GetOwningProcessId( *object );
-params.iControllingOwner = ca.GetControllingOwnerId( *object );
+params.iAddressOfOwningProcess = ca.GetAddressOfOwningProcess( *object );
-params.iRestrictions = ca.GetRestrictions( *object );
+params.iMaxSize = ca.GetMaxSize( *object );
-params.iMapAttr = ca.GetMapAttr( *object );
+params.iBottom = ca.GetBottom( *object );
-params.iChunkType = ca.GetType( *object );
+params.iTop = ca.GetTop( *object );
-ca.GetNameOfOwningProcess( *object, params.iNameOfOwner );
+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;
-DMemSpyDriverOSAdaptionDCodeSeg& csa = OSAdaption().DCodeSeg();
+	        NKern::LockSystem();
-DCodeSeg* codeSeg = csa.GetCodeSeg( *object );
+r = object->Open();
-params.iAddressOfCodeSeg = (TUint8*)codeSeg;
+	    NKern::UnlockSystem();
-params.iMapCount = csa.GetMapCount( *object );
+//
-params.iState = csa.GetState( *object );
+if  ( r == KErrNone )
-//
+{
-if  ( codeSeg )
+DMemSpyDriverOSAdaptionDCodeSeg& csa = OSAdaption().DCodeSeg();
-{
+DCodeSeg* codeSeg = csa.GetCodeSeg( *object );
-params.iSize = csa.GetSize( *codeSeg );
+params.iAddressOfCodeSeg = (TUint8*)codeSeg;
-}
+params.iMapCount = csa.GetMapCount( *object );
-else
+params.iState = csa.GetState( *object );
-{
+//
-r = KErrNotFound;
+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;
-DMemSpyDriverOSAdaptionDSemaphore& sa = OSAdaption().DSemaphore();
+	        NKern::LockSystem();
-params.iCount = sa.GetCount( *object );
+r = object->Open();
-params.iResetting = sa.GetResetting( *object );
+	    NKern::UnlockSystem();
+//
+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;
-DMemSpyDriverOSAdaptionDMutex& ma = OSAdaption().DMutex();
+	        NKern::LockSystem();
-//
+r = object->Open();
-params.iCount = ma.GetHoldCount( *object );
+	    NKern::UnlockSystem();
-params.iWaitCount = ma.GetWaitCount( *object );
+//
-params.iResetting = ma.GetResetting( *object );
+if  ( r == KErrNone )
-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;
-DMemSpyDriverOSAdaptionDTimer& ta = OSAdaption().DTimer();
+	        NKern::LockSystem();
-//
+r = object->Open();
-params.iTimerType = MapToMemSpyTimerType( ta.GetType( *object ) );
+	    NKern::UnlockSystem();
-params.iTimerState = MapToMemSpyTimerState( ta.GetState( *object ) );
+//
+if  ( r == KErrNone )
+{
+DMemSpyDriverOSAdaptionDTimer& ta = OSAdaption().DTimer();
+//
+params.iTimerType = MapToMemSpyTimerType( ta.GetType( *object ) );
+params.iTimerState = MapToMemSpyTimerState( ta.GetState( *object ) );
+//
+object->Close( NULL );
+}
 }
 else if ( params.iType == EMemSpyDriverContainerTypeServer )
 {
 	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - EMemSpyDriverContainerTypeServer" ));
 DServer* object = (DServer*) handleAsObject;
-DMemSpyDriverOSAdaptionDServer& sa = OSAdaption().DServer();
+	        NKern::LockSystem();
-//
+r = object->Open();
-params.iCount = sa.GetSessionCount( *object );
+	    NKern::UnlockSystem();
-params.iId = sa.GetOwningThreadId( *object );
+//
-params.iSessionType = sa.GetSessionType( *object );
+if  ( r == KErrNone )
-params.iAddressOfOwningThread = sa.GetAddressOfOwningThread( *object );
+{
-sa.GetNameOfOwningThread( *object, params.iNameOfOwner );
+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;
-DMemSpyDriverOSAdaptionDServer& serverAdaption = OSAdaption().DServer();
+	        NKern::LockSystem();
-DMemSpyDriverOSAdaptionDSession& sessionAdaption = OSAdaption().DSession();
+r = object->Open();
+	    NKern::UnlockSystem();
-params.iName.Zero();
+//
+	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - open error: %d", r ));
-TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - getting session type..." ));
+if  ( r == KErrNone )
-params.iSessionType = sessionAdaption.GetSessionType( *object );
+{
-params.iAddressOfServer = sessionAdaption.GetAddressOfServer( *object );
+DMemSpyDriverOSAdaptionDServer& serverAdaption = OSAdaption().DServer();
-params.iTotalAccessCount = sessionAdaption.GetTotalAccessCount( *object );
+DMemSpyDriverOSAdaptionDSession& sessionAdaption = OSAdaption().DSession();
-params.iSvrSessionType = sessionAdaption.GetSessionType( *object );
-params.iMsgCount = sessionAdaption.GetMsgCount( *object );
+params.iName.Zero();
-params.iMsgLimit = sessionAdaption.GetMsgLimit( *object );
+TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - getting session type..." ));
-// Its more useful in this instance, if the name object
+params.iSessionType = sessionAdaption.GetSessionType( *object );
-// points to the server which the session is connected to
+params.iAddressOfServer = sessionAdaption.GetAddressOfServer( *object );
-// (rather than displaying a process-local name).
+params.iTotalAccessCount = sessionAdaption.GetTotalAccessCount( *object );
-DServer* server = (DServer*)CheckedOpen(EMemSpyDriverContainerTypeServer, sessionAdaption.GetServer( *object ));
+params.iSvrSessionType = sessionAdaption.GetSessionType( *object );
-	        TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - getting full name, server: 0x%08x", server ));
+params.iMsgCount = sessionAdaption.GetMsgCount( *object );
-//
+params.iMsgLimit = sessionAdaption.GetMsgLimit( *object );
-if  ( server )
-{
+// Its more useful in this instance, if the name object
-server->FullName( params.iName );
+// points to the server which the session is connected to
+// (rather than displaying a process-local name).
-// Continue as normal for other items
+DServer* server = sessionAdaption.GetServer( *object );
-	            TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - server: 0x%08x, server->iOwningThread: 0x%08x", server, server->iOwningThread ));
+	            TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - getting full name, server: 0x%08x", server ));
-DThread* owningThread = serverAdaption.GetOwningThread( *server );
+//
-if  ( owningThread )
+if  ( server )
 {
-	                TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetGenericHandleInfo() - getting server thread id..." ));
+	                NKern::LockSystem();
-params.iId = serverAdaption.GetOwningThreadId( *server );
+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 );
+}
 }
-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;
-DMemSpyDriverOSAdaptionDLogicalDevice& lda = OSAdaption().DLogicalDevice();
+	        NKern::LockSystem();
-params.iOpenChannels = lda.GetOpenChannels( *object );
+r = object->Open();
-params.iVersion = lda.GetVersion( *object );
+	    NKern::UnlockSystem();
-params.iParseMask = lda.GetParseMask( *object );
+//
-params.iUnitsMask = lda.GetUnitsMask( *object );
+if  ( r == KErrNone )
+{
+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;
-DMemSpyDriverOSAdaptionDPhysicalDevice& pda = OSAdaption().DPhysicalDevice();
+NKern::LockSystem();
-params.iVersion = pda.GetVersion( *object );
+r = object->Open();
-params.iUnitsMask = pda.GetUnitsMask( *object );
+NKern::UnlockSystem();
-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;
-DMemSpyDriverOSAdaptionDChangeNotifier& cna = OSAdaption().DChangeNotifier();
+NKern::LockSystem();
-params.iChanges = cna.GetChanges( *object );
+r = object->Open();
-params.iAddressOfOwningThread = cna.GetAddressOfOwningThread( *object );
+NKern::UnlockSystem();
-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;
-DMemSpyDriverOSAdaptionDUndertaker& uta = OSAdaption().DUndertaker();
+NKern::LockSystem();
-params.iAddressOfOwningThread = uta.GetAddressOfOwningThread( *object );
+r = object->Open();
-uta.GetNameOfOwningThread( *object, params.iNameOfOwner );
+NKern::UnlockSystem();
+//
+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;
-DMemSpyDriverOSAdaptionDCondVar& cva = OSAdaption().DCondVar();
+NKern::LockSystem();
-params.iResetting = cva.GetResetting( *object );
+r = object->Open();
-params.iAddressOfOwningThread = cva.GetAddressOfMutex( *object );
+NKern::UnlockSystem();
-cva.GetNameOfMutex( *object, params.iNameOfOwner );
+//
-params.iWaitCount = cva.GetWaitCount( *object );
+if  ( r == KErrNone )
+{
+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...
-DObject* object = CheckedOpen(EMemSpyDriverContainerTypePropertyRef, aHandle);
+// NB: This claims the system lock
+DObject* object = CheckIfObjectIsInContainer( EMemSpyDriverContainerTypePropertyRef, aHandle );
 TRACE( Kern::Printf("DMemSpyDriverLogChanContainers::GetPAndSInfo() - handle search returned: 0x%08x", object ));
 if  ( object != NULL )
 {
-NKern::LockSystem(); // Keep this, the DPropertyRef APIs use it -TomS
+NKern::LockSystem();
 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 = CheckedOpen(EMemSpyDriverContainerTypeCondVar, condVarHandle);
+condVarHandle = CheckIfObjectIsInContainer( EMemSpyDriverContainerTypeCondVar, condVarHandle );
 if  ( condVarHandle == NULL )
 {
 Kern::Printf("DMemSpyDriverLogChanMisc::GetCondVarSuspThrs() - END - condVar not found");
 NKern::ThreadLeaveCS();
 return KErrNotFound;
 }
 ResetTempHandles();
-DCondVar* condVar = (DCondVar*) condVarHandle;
+DCondVar* condVar = (DCondVar*) params.iCondVarHandle;;
-NKern::LockSystem(); // Keep this, needed for iterating suspended queue -TomS
+NKern::LockSystem();
 // 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 = CheckedOpen(EMemSpyDriverContainerTypeThread, threadHandle);
+threadHandle = CheckIfObjectIsInContainer( 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 )
 {
-TBool found = handles->Find( aHandleToLookFor );
+MemSpyObjectIx_Wait( handles );
-	        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 )
 {
-TBool found = handles->Find( aHandleToLookFor );
+MemSpyObjectIx_Wait( handles );
-	        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	RCL_3
changeset 59	8ad140f3dd41
parent 49	7fdc9a71d314