1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 #include "MemSpyDriverLogChanHeapData.h"

    19 

    20 // System includes

    21 #include <u32hal.h>

    22 #include <e32rom.h>

    23 #include <memspy/driver/memspydriverobjectsshared.h>

    24 #include <memspy/driver/memspydriverconstants.h>

    25 

    26 // Shared includes

    27 #include "MemSpyDriverOpCodes.h"

    28 #include "MemSpyDriverObjectsInternal.h"

    29 

    30 // User includes

    31 #include "MemSpyDriverHeap.h"

    32 #include "MemSpyDriverUtils.h"

    33 #include "MemSpyDriverDevice.h"

    34 #include "MemSpyDriverOSAdaption.h"

    35 #include "MemSpyDriverHeapWalker.h"

    36 #include "MemSpyDriverUserEventMonitor.h"

    37 #include "MemSpyDriverSuspensionManager.h"

    38 

    39 

    40 

    41 

    42 DMemSpyDriverLogChanHeapData::DMemSpyDriverLogChanHeapData( DMemSpyDriverDevice& aDevice, DThread& aThread )

    43 :	DMemSpyDriverLogChanHeapBase( aDevice, aThread ), iKernelHeap( aDevice.OSAdaption() )

    44     {

    45     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::DMemSpyDriverLogChanHeapData() - this: 0x%08x", this ));

    46     }

    47 

    48 

    49 DMemSpyDriverLogChanHeapData::~DMemSpyDriverLogChanHeapData()

    50 	{

    51 	TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::~DMemSpyDriverLogChanHeapData() - START - this: 0x%08x", this ));

    52 

    53 	TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::~DMemSpyDriverLogChanHeapData() - END - this: 0x%08x", this ));

    54 	}

    55 

    56 

    57 

    58 

    59 

    60 

    61 

    62 TInt DMemSpyDriverLogChanHeapData::Request( TInt aFunction, TAny* a1, TAny* a2 )

    63 	{

    64 	TInt r = DMemSpyDriverLogChanHeapBase::Request( aFunction, a1, a2 );

    65     if  ( r == KErrNone )

    66         {

    67 	    switch( aFunction )

    68 		    {

    69         case EMemSpyDriverOpCodeHeapDataGetUser:

    70             r = GetHeapDataUser( (TMemSpyDriverInternalHeapDataParams*) a1 );

    71             break;

    72         case EMemSpyDriverOpCodeHeapDataGetKernelInit:

    73             r = GetHeapDataKernelInit( (TMemSpyHeapInfo*) a1, (TDes8*) a2 );

    74             break;

    75         case EMemSpyDriverOpCodeHeapDataGetKernelFetch:

    76             r = GetHeapDataKernelFetch( (TDes8*) a1 );

    77             break;

    78 

    79         default:

    80             r = KErrNotSupported;

    81 		    break;

    82 		    }

    83         }

    84     //

    85     return r;

    86 	}

    87 

    88 

    89 TBool DMemSpyDriverLogChanHeapData::IsHandler( TInt aFunction ) const

    90     {

    91     return ( aFunction > EMemSpyDriverOpCodeHeapDataBase && aFunction < EMemSpyDriverOpCodeHeapDataEnd );

    92     }

    93 

    94 

    95 

    96 

    97 

    98 

    99 

   100 

   101 

   102 

   103 

   104 

   105 

   106 

   107 TInt DMemSpyDriverLogChanHeapData::GetHeapDataUser( TMemSpyDriverInternalHeapDataParams* aParams )

   108     {

   109     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser() - START"));

   110 

   111 	TMemSpyDriverInternalHeapDataParams params;

   112     TInt r = Kern::ThreadRawRead( &ClientThread(), aParams, &params, sizeof(TMemSpyDriverInternalHeapDataParams) );

   113     //

   114     if  ( r == KErrNone )

   115         {

   116 	    TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - thread id: %d, remaining: %8d, vtable: 0x%08x", params.iTid, params.iRemaining, params.iRHeapVTable));

   117 

   118         // Work out if we need to read the user or kernel heap data. 

   119         //

   120         // NB: The two 'get heap data' functions return either an error ( < KErrNone ) or then

   121         // return the length of the descriptor data that was written to the client's address

   122         // space.

   123         //

   124         r = GetHeapDataUser( params );

   125 

   126         // Write back to user space if everything went okay. Remember that the 

   127         // return value above will be the length of data that was written to the

   128         // client if there was no error.

   129         if  ( r >= KErrNone )

   130             {

   131             const TInt clientDescriptorLength = r;

   132 

   133             // Make sure we update client's remaining data

   134             r = Kern::ThreadRawWrite( &ClientThread(), aParams, &params, sizeof(TMemSpyDriverInternalHeapDataParams) );

   135             

   136             // ... and if that went okay, then we return the length of the descriptor data

   137             // back to the client.

   138             if  ( r == KErrNone )

   139                 {

   140                 r = clientDescriptorLength;

   141                 }

   142             }

   143         }

   144     else

   145         {

   146     	TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - params read error: %d", r));

   147         }

   148 

   149     // Done

   150     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser() - END - ret: %d", r));

   151     return r;

   152     }

   153 

   154 

   155 TInt DMemSpyDriverLogChanHeapData::GetHeapDataKernelInit( TMemSpyHeapInfo* aInfo, TDes8* aFreeCells )

   156     {

   157     // First phase is to 

   158     //

   159     // a) Open kernel heap

   160     // b) Make a copy of the heap data

   161     // c) Walk copy in order to extract statistics (meta data, i.e. TMemSpyHeapInfo)

   162     //

   163     // The driver leaves kernel context with the copy of the kernel heap still associated with MemSpy's process.

   164     // The second driver call will copy the chunk data to user side and release the kernel side chunk.

   165     const TBool isInit = iKernelHeap.ChunkIsInitialised();

   166     TRACE_KH( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataKernelInit() - START - isInit: %d", isInit ));

   167     __ASSERT_ALWAYS( !isInit, MemSpyDriverUtils::PanicThread( ClientThread(), EPanicKernelHeapDataInitError ) );

   168 

   169     iKernelHeap.Reset();

   170     NKern::ThreadEnterCS();

   171 

   172     // We must identify if we have a debug kernel allocator

   173     const TBool debugAllocator = IsDebugKernel();

   174     TRACE_KH( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataKernelInit() - debugAllocator: %d", debugAllocator ) );

   175 

   176     TFullName heapChunkName;

   177     TInt r = OpenKernelHeap( iKernelHeap, &heapChunkName );

   178     TRACE_KH( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataKernelInit() - open err: %d", r));

   179 

   180     if  ( r == KErrNone )

   181         {

   182         r = GetHeapInfoKernel( iKernelHeap, debugAllocator, heapChunkName, aInfo, aFreeCells );

   183         TRACE_KH( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoKernel() - base class get heap info: %d", r) );

   184 

   185         // If everything was okay, we can now return back to user-side, indicating the amount of heap data

   186         // that they must prepare to read (in the next operation).

   187         if  ( r == KErrNone )

   188             {

   189             // Indicate how big a buffer the user-side must prepare.

   190             r = OSAdaption().DChunk().GetSize( iKernelHeap.Chunk() );

   191             TRACE_KH( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoKernel() - user side buffer needs to be: %d", r) );

   192             }

   193         else if ( iKernelHeap.ChunkIsInitialised() )

   194             {

   195             // Error scenario - must close heap

   196             iKernelHeap.DisassociateWithKernelChunk();

   197             }

   198         }

   199 

   200     NKern::ThreadLeaveCS();

   201 

   202     TRACE_KH( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataKernelInit() - END - ret: %d", r));

   203     return r;

   204     }

   205 

   206 

   207 TInt DMemSpyDriverLogChanHeapData::GetHeapDataKernelFetch( TDes8* aSink )

   208     {

   209     TRACE_KH( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataKernelFetch() - START"));

   210 

   211     NKern::ThreadEnterCS();

   212 

   213     // We should already have an initialised copy of the kernel heap

   214     const TBool isInit = iKernelHeap.ChunkIsInitialised();

   215     TRACE_KH( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataKernelFetch() - isInit: %d", isInit ));

   216     __ASSERT_ALWAYS( isInit, MemSpyDriverUtils::PanicThread( ClientThread(), EPanicKernelHeapDataFetchError ) );

   217 

   218     // Get user side (MemSpy) descriptor length info

   219     TInt destLen;

   220     TInt destMax;

   221     TUint8* destPtr = NULL;

   222     TInt r = Kern::ThreadGetDesInfo( &ClientThread(), aSink, destLen, destMax, destPtr, ETrue );

   223     TRACE_KH( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataKernelFetch - user side descriptor: 0x%08x (0x%08x), len: %8d, maxLen: %8d, r: %d", aSink, destPtr, destLen, destMax, r ));

   224 

   225     if  ( r == KErrNone )

   226         {

   227         // Calculate start of real heap data (skipping over embedded RHeap object)

   228         const TUint8* startOfHeapOffset = iKernelHeap.Base();

   229         TRACE_KH( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataKernelFetch - startOfHeapOffset:    0x%08x", startOfHeapOffset));

   230         const TUint heapSize = iKernelHeap.Size();

   231         TRACE_KH( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataKernelFetch - heapSize:               %8d", heapSize));

   232 

   233         if ( destMax >= heapSize )

   234             {

   235             }

   236         else

   237             {

   238             // Not enough space

   239             r = KErrOverflow;

   240             TRACE_KH( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataKernelFetch - not enough space in client descriptor" ));

   241             }

   242 

   243         // The remaining number of bytes should allow us to calculate the position

   244         // to read from.

   245         const TInt amountToRead = Min( heapSize, destMax );

   246         const TAny* readAddress = startOfHeapOffset;

   247         TRACE_KH( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataKernelFetch - amountToRead:         %d", amountToRead));

   248         TRACE_KH( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataKernelFetch - readAddress:          0x%08x", readAddress));

   249         const TPtrC8 pKernelHeapData( (const TUint8*) readAddress, amountToRead );

   250 

   251         // Copy kernel heap data to MemSpy

   252         TRACE_KH( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataKernelFetch - about to do write to user-space..."));

   253         r = Kern::ThreadDesWrite( &ClientThread(), aSink, pKernelHeapData, 0, KChunkShiftBy0 | KTruncateToMaxLength, &ClientThread() );

   254         TRACE_KH( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataKernelFetch - write result: %d", r));

   255         }

   256 

   257     // Free heap resource

   258     iKernelHeap.DisassociateWithKernelChunk();

   259 

   260     NKern::ThreadLeaveCS();

   261 

   262 	TRACE_KH( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataKernelFetch() - END - ret: %d", r));

   263     return r;

   264     }

   265 

   266 

   267 

   268 

   269 

   270 

   271 

   272 

   273 

   274 

   275 

   276 

   277 

   278 

   279 

   280 

   281 

   282 

   283 

   284 TInt DMemSpyDriverLogChanHeapData::GetHeapDataUser( TMemSpyDriverInternalHeapDataParams& aParams )

   285     {

   286     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser() - START") );

   287 

   288 	TInt r = OpenTempObject( aParams.iTid, EThread );

   289 	if  ( r != KErrNone )

   290 		{

   291     	Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser() - END - thread not found");

   292 		return r;

   293 		}

   294     else 

   295         {

   296         const DMemSpyDriverLogChanHeapBase::TDrmMatchType drmMatchType = IsDrmThread( TempObjectAsThread() );

   297 

   298         if  ( drmMatchType != DMemSpyDriverLogChanHeapBase::EMatchTypeNone )

   299             {

   300             // Check whether it's a DRM thread...

   301             DThread* thread = (DThread*) TempObject();

   302     	    Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser() - END - Not allowing dump of DRM heap - matchType: %d, thread: %O", drmMatchType, thread );

   303             CloseTempObject();

   304 		    return KErrAccessDenied;

   305             }

   306         }

   307     

   308     // Check that the process' thread's are suspended

   309     DThread* thread = (DThread*) TempObject();

   310     if  ( SuspensionManager().IsSuspended( *thread ) )

   311         {

   312         // Find the chunk with the correct handle

   313 	    TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - thread: %O", thread) );

   314         RMemSpyDriverRHeapUser heap( OSAdaption() );

   315         const TBool allocatorIsReallyRHeap = GetUserHeapHandle( *thread, heap, aParams.iRHeapVTable );

   316         if  ( allocatorIsReallyRHeap )

   317             {

   318             const TInt chunkHandle = heap.iChunkHandle;

   319 	        TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - chunkHandle: 0x%08x, thread: %O", chunkHandle, thread) );

   320 

   321   	        NKern::ThreadEnterCS();

   322  	        NKern::LockSystem();

   323             DChunk* chunk = (DChunk*) Kern::ObjectFromHandle( thread, chunkHandle, EChunk );

   324             NKern::UnlockSystem();

   325 	        TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - chunk: 0x%08x", chunk ) );

   326   	        NKern::ThreadLeaveCS();

   327 

   328             if  ( chunk != NULL )

   329                 {

   330                 TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - chunkBase: 0x%08x, size: %8d, maxLen: %8d, chunk: %O", chunk->iBase, chunk->iSize, chunk->iMaxSize, chunk) );

   331 

   332                 // If the client specified a checksum value, then we must walk the heap just to make sure

   333                 // it hasn't changed. Expensive operation, but good for paranoia purposes...

   334                 if  ( aParams.iChecksum != 0 )

   335                     {

   336                     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - checksum validation requested - expecting: 0x%08x", aParams.iChecksum ) );

   337 

   338                     RMemSpyDriverRHeapUser rHeap( OSAdaption() );

   339                     DChunk* userHeapChunk = NULL;

   340                     r = OpenUserHeap( *thread, aParams.iRHeapVTable, rHeap, userHeapChunk );

   341                     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - opening client heap returned: %d", r) );

   342                     if  ( r == KErrNone )

   343                         {

   344                         TMemSpyHeapWalkerNullObserver observer; 

   345                         RMemSpyDriverHeapWalker heapWalker( rHeap, aParams.iDebugAllocator );

   346                         heapWalker.SetObserver( &observer );

   347                         

   348                         TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - starting traversal..." ));

   349 #if ( defined( TRACE_TYPE_USERHEAP ) && defined( TRACE_TYPE_HEAPWALK ) )

   350                         heapWalker.SetPrintDebug();

   351 #endif

   352                         r = heapWalker.Traverse();

   353                         const TUint32 calculatedChecksum = heapWalker.Stats().iFreeCellCRC;

   354                         TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - finished traversal - err: %d, checksum: 0x%08x", r, calculatedChecksum ));

   355 

   356                         // Release resources

   357                         rHeap.DisassociateWithKernelChunk();

   358 

   359                         TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - comparing CALCULATED: 0x%08x vs EXPECTED: 0x%08x", calculatedChecksum, aParams.iChecksum ));

   360                         if  ( calculatedChecksum != aParams.iChecksum )

   361                             {

   362                             Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - comparing CALCULATED: 0x%08x vs EXPECTED: 0x%08x for thread %O", calculatedChecksum, aParams.iChecksum, thread );

   363                             r = KErrCorrupt;

   364                             }

   365                         }

   366                     else

   367                         {

   368                         // Couldn't verify checksum in this situation...

   369                         }

   370                     }

   371 

   372                 // Get user side (MemSpy) descriptor length info

   373                 if  ( r == KErrNone )

   374                     {

   375                     TInt destLen;

   376                     TInt destMax;

   377                     TUint8* destPtr = NULL;

   378                     r = Kern::ThreadGetDesInfo( &ClientThread(), aParams.iDes, destLen, destMax, destPtr, ETrue );

   379                     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - user side descriptor: 0x%08x (0x%08x), len: %8d, maxLen: %8d, r: %d", aParams.iDes, destPtr, destLen, destMax, r ));

   380 

   381                     if  ( r == KErrNone )

   382                         {

   383                         // Calculate start of real heap data (skipping over embedded RHeap object)

   384                         const TUint8* startOfHeapOffset = heap.iBase;

   385         	            TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - startOfHeapOffset:    0x%08x", startOfHeapOffset) );

   386             

   387                         // Deal with initial case

   388                         const TUint heapSize = heap.Size();

   389         	            TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - heapSize:               %8d", heapSize) );

   390                         if  ( aParams.iRemaining < 0 )

   391                             {

   392                             // Initial case, remaining initialised to -1

   393                             aParams.iRemaining = heapSize;

   394                             }

   395 

   396                         // The remaining number of bytes should allow us to calculate the position

   397                         // to read from.

   398                         const TInt amountToRead = Min( aParams.iRemaining, destMax );

   399         	            TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - amountToRead:           %8d", amountToRead) );

   400                         const TInt readOffset = ( heapSize - aParams.iRemaining );

   401         	            TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - readOffset:             %8d", readOffset) );

   402                         const TAny* readAddress = startOfHeapOffset + readOffset;

   403         	            TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - readAddress:          0x%08x", readAddress) );

   404             

   405                         // Do the read from the heap we are spying on into MemSpy's address space

   406                         r = Kern::ThreadRawRead( thread, readAddress, destPtr, amountToRead );

   407         	            TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - read result: %d", r) );

   408                         //

   409                         if  (r == KErrNone)

   410                             {

   411                             // Client takes care of updating descriptor length.

   412                             r = amountToRead;

   413                             }

   414                         else if ( r == KErrBadDescriptor )

   415                             {

   416                             MemSpyDriverUtils::PanicThread( ClientThread(), EPanicBadDescriptor );

   417                             }

   418             

   419                         // Update remaining bytes

   420                         aParams.iRemaining -= amountToRead;

   421                         aParams.iReadAddress = (TUint) readAddress;

   422                         }

   423                     }

   424                 }

   425             else

   426                 {

   427     	        Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - chunk not found! thread: %O", thread );

   428                 r = KErrNotFound;

   429                 }

   430             }

   431         else

   432             {

   433     	    Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - couldnt find heap - vtable mis-match? thread: %O", thread );

   434             r = KErrNotSupported;

   435             }

   436         }

   437     else

   438         {

   439         Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser - parent process not suspended => KErrAccessDenied - thread: %O", thread );

   440         r = KErrAccessDenied;

   441         }

   442 

   443 	CloseTempObject();

   444 

   445 	TRACE( Kern::Printf("DMemSpyDriverLogChanHeapData::GetHeapDataUser() - END - ret: %d", r) );

   446     return r;

   447     }

   448 

   449 

   450