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

equal deleted inserted replaced

-:7fdc9a71d314
+:8ad140f3dd41
 TInt DMemSpyDriverLogChanHeapWalk::WalkHeapInit( TMemSpyDriverInternalWalkHeapParamsInit* aParams )
 {
 	TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapInit() - START"));
-__ASSERT_ALWAYS( !iHeapWalkInitialised && iWalkHeap.Helper() == NULL, MemSpyDriverUtils::PanicThread( ClientThread(), EPanicHeapWalkPending ) );
+__ASSERT_ALWAYS( !iHeapWalkInitialised && iWalkHeap.ChunkIsInitialised() == EFalse, MemSpyDriverUtils::PanicThread( ClientThread(), EPanicHeapWalkPending ) );
 TInt r = Kern::ThreadRawRead( &ClientThread(), aParams, &iHeapWalkInitialParameters, sizeof(TMemSpyDriverInternalWalkHeapParamsInit) );
 if  ( r == KErrNone )
 {
 	    TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapInit - thread id: %d, vtable: 0x%08x, debugAllocator: %d", iHeapWalkInitialParameters.iTid, iHeapWalkInitialParameters.iRHeapVTable, iHeapWalkInitialParameters.iDebugAllocator));
 if  ( SuspensionManager().IsSuspended( *thread ) )
 {
 TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapInit - thread: %O", thread));
 // Open client's heap
-r = iWalkHeap.OpenUserHeap(*thread, iHeapWalkInitialParameters.iDebugAllocator);
+DChunk* userHeapChunk = NULL;
+r = OpenUserHeap( *thread, iHeapWalkInitialParameters.iRHeapVTable, iWalkHeap, userHeapChunk );
 TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapInit - opening client heap returned: %d", r) );
 if  ( r == KErrNone )
 {
 // Indicates that we've initiated a walk - so we can tell whether to close
 iHeapWalkInitialised = ETrue;
 iWalkHeapCellIndex = 0;
 // Walk the client's heap
 TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapInit - calling heap walker constructor..."));
-RMemSpyDriverHeapWalker heapWalker(iWalkHeap);
+RMemSpyDriverHeapWalker heapWalker( iWalkHeap, iHeapWalkInitialParameters.iDebugAllocator );
 TMemSpyDriverLogChanHeapWalkObserver observer( *this );
 heapWalker.SetObserver( &observer );
 TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapInit - starting traversal..."));
 // If the initialise process didn't complete successfully, then we must be sure
 // to release the associated heap chunk
 if  ( r < KErrNone )
 {
 TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapInit - error scenario - releasing kernel heap chunk copy" ));
-iWalkHeap.Close();
+iWalkHeap.DisassociateWithKernelChunk();
 }
 }
 else
 {
 TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapInit - parent process not suspended => KErrAccessDenied"));
 TInt DMemSpyDriverLogChanHeapWalk::WalkHeapNextCell( TUint aTid, TMemSpyDriverInternalWalkHeapParamsCell* aParams )
 {
 const TInt walkedHeapCellCount = iWalkHeapCells.Count();
 	TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapNextCell() - START - current cell count: %d", walkedHeapCellCount));
-__ASSERT_ALWAYS( iHeapWalkInitialised && iWalkHeap.Helper(), MemSpyDriverUtils::PanicThread( ClientThread(), EPanicHeapWalkNotInitialised ) );
+__ASSERT_ALWAYS( iHeapWalkInitialised && iWalkHeap.ChunkIsInitialised(), MemSpyDriverUtils::PanicThread( ClientThread(), EPanicHeapWalkNotInitialised ) );
 // Open the original thread
 	TInt r = OpenTempObject( aTid, EThread );
 	if  ( r == KErrNone )
 		{
 if  ( iHeapWalkInitialised )
 {
 TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapClose - heap walk was still open..."));
 	NKern::ThreadEnterCS();
-		iWalkHeap.Close();
+if  ( iWalkHeap.ChunkIsInitialised() )
+{
+TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapClose - removing chunk (%O) from process", &iWalkHeap.Chunk() ) );
+iWalkHeap.DisassociateWithKernelChunk();
+iWalkHeap.Reset();
+}
 // Discard handled cells
 iWalkHeapCells.Reset();
 iHeapWalkInitialised = EFalse;
 }
 TInt DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData(TMemSpyDriverInternalWalkHeapCellDataReadParams* aParams)
 {
-__ASSERT_ALWAYS( iHeapWalkInitialised && iWalkHeap.Helper(), MemSpyDriverUtils::PanicThread( ClientThread(), EPanicHeapWalkNotInitialised ) );
+__ASSERT_ALWAYS( iHeapWalkInitialised && iWalkHeap.ChunkIsInitialised(), MemSpyDriverUtils::PanicThread( ClientThread(), EPanicHeapWalkNotInitialised ) );
 //
-	TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData() - START - thread id: %d, vtable: 0x%08x", iHeapWalkInitialParameters.iTid, iHeapWalkInitialParameters.iRHeapVTable));
+const TBool debugEUser = iHeapWalkInitialParameters.iDebugAllocator;
+	TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData() - START - thread id: %d, vtable: 0x%08x, debugAllocator: %d", iHeapWalkInitialParameters.iTid, iHeapWalkInitialParameters.iRHeapVTable, debugEUser));
 //
 	TMemSpyDriverInternalWalkHeapCellDataReadParams params;
 TInt r = Kern::ThreadRawRead( &ClientThread(), aParams, &params, sizeof(TMemSpyDriverInternalWalkHeapCellDataReadParams) );
 if  ( r != KErrNone )
 {
 // Check the threads in the process are suspended
 if  ( SuspensionManager().IsSuspended( *thread ) )
 {
 // Check we can find the cell in the cell list...
 const TMemSpyDriverInternalWalkHeapParamsCell* cell = CellInfoForSpecificAddress( params.iCellAddress );
+if  ( cell == NULL )
+{
+// Maybe the client tried the base address of the cell data.
+// try to take the header into account and retry.
+TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - didnt find matching cell for address: 0x%08x... trying address minus allocatedCellHeaderSize", params.iCellAddress ));
+const TUint32 cellHeaderSize = (TUint32) RMemSpyDriverRHeapBase::AllocatedCellHeaderSize( debugEUser );
+TUint32 addr = (TUint32) params.iCellAddress;
+addr -= cellHeaderSize;
+params.iCellAddress = (TAny*) addr;
+TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - new address: 0x%08x", params.iCellAddress ));
+// Last try
+cell = CellInfoForSpecificAddress( params.iCellAddress );
+}
 TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - cell: 0x%08x for address: 0x%08x", cell, params.iCellAddress ));
 if  ( cell )
 {
-const TInt cellLen = cell->iLength;
+const TBool isValidCell = iWalkHeap.CheckCell( cell->iCellAddress, cell->iLength );
-TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - cellLen: %d", cellLen ));
+TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - isValidCell: %d", isValidCell ));
-if  ( params.iReadLen <= cellLen )
+if  ( isValidCell )
 {
+// Check the length request is valid
-// Get user side descriptor length info
+const TInt cellLen = cell->iLength;
-	        TInt destLen = 0;
+TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - cellLen: %d", cellLen ));
-	        TInt destMax = 0;
-TUint8* destPtr = NULL;
+if  ( params.iReadLen <= cellLen )
-r = Kern::ThreadGetDesInfo( &ClientThread(), params.iDes, destLen, destMax, destPtr, ETrue );
-	        TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - user side descriptor: 0x%08x (0x%08x), len: %8d, maxLen: %8d, r: %d", params.iDes, destPtr, destLen, destMax, r ));
-// Work out the start offset for the data...
-if  ( r == KErrNone && destMax >= params.iReadLen )
 {
-const TAny* srcPos = ((TUint8*) cell->iCellAddress);
+const TInt cellHeaderSize = RMemSpyDriverRHeapBase::CellHeaderSize( *cell, debugEUser );
-	            TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - srcPos: 0x%08x", srcPos ));
+	            TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - cellHeaderSize: %8d", cellHeaderSize ));
-// Read some data
+// Get user side descriptor length info
-r = Kern::ThreadRawRead( thread, srcPos, destPtr, params.iReadLen );
+	            TInt destLen = 0;
-	                TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - read from thread returned: %d", r));
+	            TInt destMax = 0;
+TUint8* destPtr = NULL;
-if  ( r == KErrNone )
+r = Kern::ThreadGetDesInfo( &ClientThread(), params.iDes, destLen, destMax, destPtr, ETrue );
+	            TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - user side descriptor: 0x%08x (0x%08x), len: %8d, maxLen: %8d, r: %d", params.iDes, destPtr, destLen, destMax, r ));
+// Work out the start offset for the data...
+if  ( r == KErrNone && destMax >= params.iReadLen )
 {
-// Client will update descriptor length in this situation.
+const TAny* srcPos = ((TUint8*) cell->iCellAddress) + cellHeaderSize;
-r = params.iReadLen;
+	                TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - srcPos: 0x%08x", srcPos ));
+// Read some data
+r = Kern::ThreadRawRead( thread, srcPos, destPtr, params.iReadLen );
+	                    TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - read from thread returned: %d", r));
+if  ( r == KErrNone )
+{
+// Client will update descriptor length in this situation.
+r = params.iReadLen;
+}
+else if ( r == KErrBadDescriptor )
+{
+MemSpyDriverUtils::PanicThread( ClientThread(), EPanicBadDescriptor );
+}
+}
+else
+{
+if  ( r != KErrBadDescriptor )
+{
+r = KErrArgument;
+	                Kern::Printf( "DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - error - user-descriptor isnt big enough for requested data" );
+}
+else
+{
+	                Kern::Printf( "DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - error - bad or non-writable user-side descriptor" );
+}
 }
 }
 else
 {
-if  ( r != KErrBadDescriptor )
+r = KErrArgument;
-{
+	            Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - error - read length is bigger than cell length");
-r = KErrArgument;
-	            Kern::Printf( "DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - error - user-descriptor isnt big enough for requested data" );
-}
-else
-{
-	            Kern::Printf( "DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - error - bad or non-writable user-side descriptor" );
-}
 }
 }
 else
 {
 r = KErrArgument;
-	        Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - error - read length is bigger than cell length");
+Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - invalid cell address: 0x%08x", cell);
 }
 }
 else
 {
 r = KErrArgument;
 else
 {
 	Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData - thread not found");
 		}
 //
-TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData() - END result=%d", r));
+TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapReadCellData() - END"));
 return r;
 }
 TInt DMemSpyDriverLogChanHeapWalk::WalkHeapGetCellInfo( TAny* aCellAddress, TMemSpyDriverInternalWalkHeapParamsCell* aParams )
 {
-__ASSERT_ALWAYS( iHeapWalkInitialised && iWalkHeap.Helper(), MemSpyDriverUtils::PanicThread( ClientThread(), EPanicHeapWalkNotInitialised ) );
+__ASSERT_ALWAYS( iHeapWalkInitialised && iWalkHeap.ChunkIsInitialised(), MemSpyDriverUtils::PanicThread( ClientThread(), EPanicHeapWalkNotInitialised ) );
 //
-TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapGetCellInfo() - START - thread id: %d, vtable: 0x%08x", iHeapWalkInitialParameters.iTid, iHeapWalkInitialParameters.iRHeapVTable));
+const TBool debugEUser = iHeapWalkInitialParameters.iDebugAllocator;
+TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapGetCellInfo() - START - thread id: %d, vtable: 0x%08x, debugAllocator: %d", iHeapWalkInitialParameters.iTid, iHeapWalkInitialParameters.iRHeapVTable, debugEUser));
 TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapGetCellInfo - cell: 0x%08x", aCellAddress));
 // Open the original thread
 	TInt r = OpenTempObject( iHeapWalkInitialParameters.iTid, EThread );
 	if (r != KErrNone)
 // Check we can find the cell in the cell list...
 const TMemSpyDriverInternalWalkHeapParamsCell* cell = CellInfoForSpecificAddress( aCellAddress );
 if  ( cell == NULL )
 {
 TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapGetCellInfo - no exact match for address: 0x%08x...", aCellAddress));
+// Maybe the client tried the base address of the cell data.
+// try to take the header into account and retry.
+const TUint32 cellHeaderSize = (TUint32) RMemSpyDriverRHeapBase::AllocatedCellHeaderSize( debugEUser );
+TUint32 addr = (TUint32) aCellAddress;
+addr -= cellHeaderSize;
+TAny* cellByRawStartingAddress = (TAny*) addr;
+TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapGetCellInfo - trying to search by start of cell address: 0x%08x (cellHeaderSize: %d)", cellByRawStartingAddress, cellHeaderSize));
+cell = CellInfoForSpecificAddress( cellByRawStartingAddress );
 // If the cell still wasn't found, then let's look for any heap cell that contains
 // the client-specified address (i.e. find the heap cell that contains the specified
 // address).
 if  ( cell == NULL )
 }
 }
 if  ( cell )
 {
-// Have enough info to write back to client now
+const TBool isValidCell = iWalkHeap.CheckCell( cell->iCellAddress, cell->iLength );
-TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapGetCellInfo - returning... cellType: %1d, addr: 0x%08x, len: %8d, nestingLev: %8d, allocNum: %8d", cell->iCellType, cell->iCellAddress, cell->iLength, cell->iNestingLevel, cell->iAllocNumber ));
+if  ( isValidCell )
-r = Kern::ThreadRawWrite( &ClientThread(), aParams, cell, sizeof(TMemSpyDriverInternalWalkHeapParamsCell) );
+{
+// Have enough info to write back to client now
+TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapGetCellInfo - returning... cellType: %1d, addr: 0x%08x, len: %8d, nestingLev: %8d, allocNum: %8d", cell->iCellType, cell->iCellAddress, cell->iLength, cell->iNestingLevel, cell->iAllocNumber ));
+r = Kern::ThreadRawWrite( &ClientThread(), aParams, cell, sizeof(TMemSpyDriverInternalWalkHeapParamsCell) );
+}
+else
+{
+r = KErrArgument;
+Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapGetCellInfo - invalid cell address: 0x%08x", cell);
+}
 }
 else
 {
 r = KErrArgument;
 Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapGetCellInfo - no cell at user supplied address!");
 }
 CloseTempObject();
 //
-TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapGetCellInfo() - END result=%d", r));
+TRACE( Kern::Printf("DMemSpyDriverLogChanHeapWalk::WalkHeapGetCellInfo() - END"));
 return r;
 }
-TBool DMemSpyDriverLogChanHeapWalk::WalkerHandleHeapCell(TMemSpyDriverCellType aCellType, TAny* aCellAddress, TInt aLength, TInt aNestingLevel, TInt aAllocNumber )
+TBool DMemSpyDriverLogChanHeapWalk::WalkerHandleHeapCell( TInt aCellType, TAny* aCellAddress, TInt aLength, TInt aNestingLevel, TInt aAllocNumber )
 {
 TInt error = KErrNone;
 //
 if  ( iHeapWalkInitialised )
 {

branch	RCL_3
changeset 59	8ad140f3dd41
parent 49	7fdc9a71d314