Mercurial Mercurial > oss > FCL > sf > os > osrndtools / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
memspy/Driver/Kernel/Source/SubChannels/MemSpyDriverLogChanHeapInfo.cpp
branchGCC_SURGE
changeset 35 1ea875759131
parent 34 7259cf1302ad
child 44 52e343bb8f80
equal deleted inserted replaced
29:b58b1294947a 35:1ea875759131 
    44 
    44 
    45 
    45 
    46 DMemSpyDriverLogChanHeapInfo::~DMemSpyDriverLogChanHeapInfo()
 
    46 DMemSpyDriverLogChanHeapInfo::~DMemSpyDriverLogChanHeapInfo()
 
    47 	{
 
    47 	{
 
    48 	TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::~DMemSpyDriverLogChanHeapInfo() - START - this: 0x%08x", this ));
 
    48 	TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::~DMemSpyDriverLogChanHeapInfo() - START - this: 0x%08x", this ));
 
       
    49 	ReleaseCellList();
 
    49 	TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::~DMemSpyDriverLogChanHeapInfo() - END - this: 0x%08x", this ));
 
    50 	TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::~DMemSpyDriverLogChanHeapInfo() - END - this: 0x%08x", this ));
 
    50 	}
 
    51 	}
 
    51 
       
    52 
       
    53 
       
    54 
       
    55 
       
    56 
       
    57 
       
    58 
    52 
    59 TInt DMemSpyDriverLogChanHeapInfo::Request( TInt aFunction, TAny* a1, TAny* a2 )
 
    53 TInt DMemSpyDriverLogChanHeapInfo::Request( TInt aFunction, TAny* a1, TAny* a2 )
 
    60 	{
 
    54 	{
 
    61 	TInt r = DMemSpyDriverLogChanHeapBase::Request( aFunction, a1, a2 );
 
    55 	TInt r = DMemSpyDriverLogChanHeapBase::Request( aFunction, a1, a2 );
 
    62     if  ( r == KErrNone )
 
    56     if  ( r == KErrNone )
 
    63         {
 
    57         {
 
    64         if  ( aFunction != EMemSpyDriverOpCodeHeapInfoFetchFreeCells )
 
    58         if  ( aFunction != EMemSpyDriverOpCodeHeapInfoFetchCellList )
 
    65             {
 
    59             {
 
    66             ReleaseFreeCells();
 
    60             ReleaseCellList();
 
    67             }
 
    61             }
 
    68         //
 
    62         //
 
    69         switch( aFunction )
 
    63         switch( aFunction )
 
    70 		    {
 
    64 		    {
 
    71         case EMemSpyDriverOpCodeHeapInfoGetUser:
 
    65         case EMemSpyDriverOpCodeHeapInfoGetUser:
 
    73             break;
 
    67             break;
 
    74 	    case EMemSpyDriverOpCodeHeapInfoGetKernel:
 
    68 	    case EMemSpyDriverOpCodeHeapInfoGetKernel:
 
    75             r = GetHeapInfoKernel( (TMemSpyDriverInternalHeapRequestParameters*) a1, (TDes8*) a2 );
 
    69             r = GetHeapInfoKernel( (TMemSpyDriverInternalHeapRequestParameters*) a1, (TDes8*) a2 );
 
    76             break;
 
    70             break;
 
    77         case EMemSpyDriverOpCodeHeapInfoGetIsDebugKernel:
 
    71         case EMemSpyDriverOpCodeHeapInfoGetIsDebugKernel:
 
    78             r = GetIsDebugKernel( (TBool*) a1 );
 
    72             r = GetIsDebugKernel(a1);
 
    79             break;
 
    73             break;
 
    80         case EMemSpyDriverOpCodeHeapInfoFetchFreeCells:
 
    74         case EMemSpyDriverOpCodeHeapInfoFetchCellList:
 
    81             r = FetchFreeCells( (TDes8*) a1 );
 
    75             r = FetchCellList( (TDes8*) a1 );
 
    82             break;
 
    76             break;
 
    83 
    77 
    84         default:
 
    78         default:
 
    85             r = KErrNotSupported;
 
    79             r = KErrNotSupported;
 
    86 		    break;
 
    80 		    break;
 
   130             {
 
   124             {
 
   131             // Check that the process' thread's are suspended
 
   125             // Check that the process' thread's are suspended
 
   132             DThread* thread = (DThread*) TempObject();
 
   126             DThread* thread = (DThread*) TempObject();
 
   133             if  ( SuspensionManager().IsSuspended( *thread ) )
 
   127             if  ( SuspensionManager().IsSuspended( *thread ) )
 
   134                 {
 
   128                 {
 
   135                 TFullName chunkName;
 
       
   136 
       
   137                 // Open client's heap
 
   129                 // Open client's heap
 
   138                 RMemSpyDriverRHeapUser rHeap( OSAdaption() );
 
   130                 RMemSpyDriverRHeapUser rHeap( OSAdaption() );
 
   139                 DChunk* userHeapChunk = NULL;
 
   131 				r = rHeap.OpenUserHeap(*thread, iHeapInfoParams.iDebugAllocator);
 
   140                 r = OpenUserHeap( *thread, iHeapInfoParams.iRHeapVTable, rHeap, userHeapChunk, &chunkName );
 
       
   141                 TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoUser - opening client heap returned: %d", r) );
 
   132                 TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoUser - opening client heap returned: %d", r) );
 
   142 
   133 
   143                 if  ( r == KErrNone )
 
   134                 if  ( r == KErrNone )
 
   144                     {
 
   135                     {
 
   145                     // This object holds all of the info we will accumulate for the client.
 
   136                     // This object holds all of the info we will accumulate for the client.
 
   146                     TMemSpyHeapInfo masterHeapInfo;
 
   137                     TMemSpyHeapInfo masterHeapInfo;
 
   147                     masterHeapInfo.SetType( TMemSpyHeapInfo::ETypeRHeap );
 
   138                     masterHeapInfo.SetType(rHeap.GetTypeFromHelper());
 
   148                     masterHeapInfo.SetTid( iHeapInfoParams.iTid );
 
   139                     masterHeapInfo.SetTid( iHeapInfoParams.iTid );
 
   149                     masterHeapInfo.SetPid( OSAdaption().DThread().GetOwningProcessId( *thread ) );
 
   140                     masterHeapInfo.SetPid( OSAdaption().DThread().GetOwningProcessId( *thread ) );
 
   150 
   141 
   151                     // This is the RHeap-specific object that contains all RHeap info
 
   142                     // This is the RHeap-specific object that contains all RHeap info
 
   152                     TMemSpyHeapInfoRHeap& rHeapInfo = masterHeapInfo.AsRHeap();
 
   143                     TMemSpyHeapInfoRHeap& rHeapInfo = masterHeapInfo.AsRHeap();
 
   153 
   144 
   154                     // This is the object data for the RHeap instance
 
       
   155                     TMemSpyHeapObjectDataRHeap& rHeapObjectData = rHeapInfo.ObjectData();
 
       
   156                     rHeap.CopyObjectDataTo( rHeapObjectData );
 
       
   157 
   145 
   158                     // We must walk the client's heap in order to build statistics
 
   146                     // We must walk the client's heap in order to build statistics
 
   159                     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoUser - calling heap walker constructor..."));
 
   147                     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoUser - calling heap walker constructor..."));
 
   160                     TMemSpyHeapWalkerNullObserver observer; 
   148 					RMemSpyDriverHeapWalker heapWalker(rHeap);
 
   161                     RMemSpyDriverHeapWalker heapWalker( rHeap, iHeapInfoParams.iDebugAllocator );
 
   149                     if  (iHeapInfoParams.iBuildFreeCellList || iHeapInfoParams.iBuildAllocCellList)
 
   162                     if  ( iHeapInfoParams.iBuildFreeCellList )
 
       
   163                         {
 
   150                         {
 
   164                         heapWalker.SetObserver( this );
 
   151                         heapWalker.SetObserver( this );
 
   165                         TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoUser - collecting free cells"));
 
   152                         TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoUser - collecting cells"));
 
   166                         }
 
   153                         }
 
   167                     else
 
   154                     else
 
   168                         {
 
   155                         {
 
   169                         heapWalker.SetObserver( &observer );
 
   156                         TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoUser - not collecting cells"));
 
   170                         TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoUser - not collecting free cells"));
 
       
   171                         }
 
   157                         }
 
   172 
   158 
   173                     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoUser - starting traversal..." ));
 
   159                     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoUser - starting traversal openerr: %d...", r));
 
   174 
   160 
   175 #if ( defined( TRACE_TYPE_USERHEAP ) && defined( TRACE_TYPE_HEAPWALK ) )
 
   161 #if ( defined( TRACE_TYPE_USERHEAP ) && defined( TRACE_TYPE_HEAPWALK ) )
 
   176                     heapWalker.SetPrintDebug();
 
   162                     heapWalker.SetPrintDebug();
 
   177 #endif
 
   163 #endif
 
   178                     r = heapWalker.Traverse();
 
   164                     if (r == KErrNone) r = heapWalker.Traverse();
 
   179                     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoUser - finished traversal - err: %d", r ));
 
   165                     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoUser - finished traversal - err: %d", r ));
 
   180 
   166 
   181                     TMemSpyHeapStatisticsRHeap& rHeapStats = rHeapInfo.Statistics();
 
   167                     TMemSpyHeapStatisticsRHeap& rHeapStats = rHeapInfo.Statistics();
 
   182                     heapWalker.CopyStatsTo( rHeapStats );
 
   168                     heapWalker.CopyStatsTo( rHeapStats );
 
   183 
   169 
   184                     // Get remaining meta data that isn't stored elsewhere
 
   170                     // Get remaining meta data that isn't stored elsewhere
 
   185                     TMemSpyHeapMetaDataRHeap& rHeapMetaData = rHeapInfo.MetaData();
 
   171                     TMemSpyHeapMetaDataRHeap& rHeapMetaData = rHeapInfo.MetaData();
 
   186                     rHeapMetaData.SetChunkName( chunkName );
 
   172 					DChunk& userHeapChunk = rHeap.Chunk();
 
   187                     rHeapMetaData.SetChunkSize( (TUint) OSAdaption().DChunk().GetSize( *userHeapChunk ) );
 
   173 					TFullName chunkName;
 
   188                     rHeapMetaData.SetChunkHandle( userHeapChunk );
 
   174 					userHeapChunk.FullName(chunkName);
 
   189                     rHeapMetaData.SetChunkBaseAddress( OSAdaption().DChunk().GetBase( *userHeapChunk ) );
 
   175 					rHeapMetaData.SetChunkName( chunkName );
 
   190                     rHeapMetaData.SetDebugAllocator( iHeapInfoParams.iDebugAllocator );
 
   176 		            rHeapMetaData.SetChunkSize( (TUint) OSAdaption().DChunk().GetSize( userHeapChunk ) );
 
   191                     rHeapMetaData.SetHeaderSizeFree( RMemSpyDriverRHeapBase::FreeCellHeaderSize() );
 
   177 					rHeapMetaData.SetChunkHandle( &userHeapChunk );
 
   192                     rHeapMetaData.SetHeaderSizeAllocated( RMemSpyDriverRHeapBase::AllocatedCellHeaderSize( iHeapInfoParams.iDebugAllocator ) );
 
   178 					rHeapMetaData.SetChunkBaseAddress( OSAdaption().DChunk().GetBase( userHeapChunk ) );
 
       
   179                     rHeapMetaData.SetDebugAllocator(rHeap.Helper()->AllocatorIsUdeb());
 
   193                     rHeapMetaData.SetUserThread( ETrue );
 
   180                     rHeapMetaData.SetUserThread( ETrue );
 
   194 
   181 					rHeapMetaData.iHeapSize = rHeap.Helper()->CommittedSize();
 
   195                     // Get any heap-specific info
 
   182 					rHeapMetaData.iAllocatorAddress = (TAny*)rHeap.Helper()->AllocatorAddress();
 
   196                     rHeap.GetHeapSpecificInfo( masterHeapInfo );
 
   183 					rHeapMetaData.iMinHeapSize = rHeap.Helper()->MinCommittedSize();
 
       
   184 					rHeapMetaData.iMaxHeapSize = rHeap.Helper()->MaxCommittedSize();
 
   197 
   185 
   198                     PrintHeapInfo( masterHeapInfo );
 
   186                     PrintHeapInfo( masterHeapInfo );
 
   199 
   187 
   200                     // Write free cells if requested
 
   188                     // Write free cells if requested
 
   201                     if  ( r == KErrNone && iHeapInfoParams.iBuildFreeCellList )
 
   189                     if  ( r == KErrNone && (iHeapInfoParams.iBuildFreeCellList || iHeapInfoParams.iBuildAllocCellList))
 
   202                         {
 
   190                         {
 
   203                         r = PrepareFreeCellTransferBuffer();
 
   191                         r = PrepareCellListTransferBuffer();
 
   204                         }
 
   192                         }
 
   205 
   193 
   206                     // Update info ready for writing back to the user-side
 
   194                     // Update info ready for writing back to the user-side
 
   207                     if  ( r >= KErrNone )
 
   195                     if  ( r >= KErrNone )
 
   208                         {
 
   196                         {
 
   215                             r = error;
 
   203                             r = error;
 
   216                             }
 
   204                             }
 
   217                         }
 
   205                         }
 
   218 
   206 
   219                     // Release resources
 
   207                     // Release resources
 
   220                     rHeap.DisassociateWithKernelChunk();
 
   208 					rHeap.Close();
 
   221                     }
 
   209                     }
 
   222                 }
 
   210                 }
 
   223             else
 
   211             else
 
   224                 {
 
   212                 {
 
   225                 r = KErrAccessDenied;
 
   213                 r = KErrAccessDenied;
 
   247     TMemSpyDriverInternalHeapRequestParameters params;
 
   235     TMemSpyDriverInternalHeapRequestParameters params;
 
   248     TInt r = Kern::ThreadRawRead( &ClientThread(), aParams, &params, sizeof(TMemSpyDriverInternalHeapRequestParameters) );
 
   236     TInt r = Kern::ThreadRawRead( &ClientThread(), aParams, &params, sizeof(TMemSpyDriverInternalHeapRequestParameters) );
 
   249     if  ( r == KErrNone )
 
   237     if  ( r == KErrNone )
 
   250         {
 
   238         {
 
   251         // Open kernel heap
 
   239         // Open kernel heap
 
   252         TFullName heapChunkName;
 
       
   253         RMemSpyDriverRHeapKernelInPlace rHeap;
 
   240         RMemSpyDriverRHeapKernelInPlace rHeap;
 
   254         r = OpenKernelHeap( rHeap, &heapChunkName );
 
   241         r = rHeap.OpenKernelHeap();
 
   255         TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoKernel() - open err: %d", r ) );
 
   242         TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoKernel() - open err: %d", r ) );
 
   256 
   243 
   257         if  ( r == KErrNone )
 
   244         if  ( r == KErrNone )
 
   258             {
 
   245             {
 
   259             // We must identify if we have a debug kernel allocator
 
   246             r = DMemSpyDriverLogChanHeapBase::GetHeapInfoKernel(rHeap, params.iMasterInfo, aTransferBuffer);
 
   260             const TBool debugAllocator = IsDebugKernel( rHeap );
 
       
   261             TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoKernel() - debugAllocator: %d", debugAllocator ) );
 
       
   262 
       
   263             r = DMemSpyDriverLogChanHeapBase::GetHeapInfoKernel( rHeap, debugAllocator, heapChunkName, params.iMasterInfo, aTransferBuffer );
 
       
   264             TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoKernel() - base class get heap info: %d", r) );
 
   247             TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetHeapInfoKernel() - base class get heap info: %d", r) );
 
   265             }
 
   248             }
 
   266         }
 
   249         }
 
   267     else
 
   250     else
 
   268         {
 
   251         {
 
   276 
   259 
   277 
   260 
   278 
   261 
   279 
   262 
   280 
   263 
   281 TInt DMemSpyDriverLogChanHeapInfo::GetIsDebugKernel( TBool* aIsDebugKernel )
 
   264 TInt DMemSpyDriverLogChanHeapInfo::GetIsDebugKernel(TAny* aResult)
 
   282     {
 
   265     {
 
   283     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetIsDebugKernel() - START") );
 
   266     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetIsDebugKernel() - START") );
 
   284     
   267     
   285     TInt r = KErrNone;
 
   268     TInt r = KErrNone;
 
   286     TBool debugKernel = EFalse;
 
   269     TBool debugKernel = EFalse;
 
   287 
   270 
   288     NKern::ThreadEnterCS();
 
   271     NKern::ThreadEnterCS();
 
   289     
   272     
   290     RMemSpyDriverRHeapKernelInPlace rHeap;
 
   273     RMemSpyDriverRHeapKernelInPlace rHeap;
 
   291     r = OpenKernelHeap( rHeap );
 
   274     r = rHeap.OpenKernelHeap();
 
   292     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetIsDebugKernel() - open kernel heap returned: %d", r) );
 
   275     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetIsDebugKernel() - open kernel heap returned: %d", r) );
 
   293 
   276 
   294     if  ( r == KErrNone )
 
   277     if  ( r == KErrNone )
 
   295         {
 
   278         {
 
   296         debugKernel = IsDebugKernel( rHeap );
 
   279         debugKernel = rHeap.Helper()->AllocatorIsUdeb();
 
   297 
   280 
   298         // Tidy up
 
   281         // Tidy up
 
   299         rHeap.DisassociateWithKernelChunk();
 
   282         rHeap.Close();
 
   300         }
 
   283         }
 
   301 
   284 
   302     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetIsDebugKernel() - debugKernel: %d", debugKernel) );
 
   285     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetIsDebugKernel() - debugKernel: %d", debugKernel) );
 
   303 
   286 
   304     // Write back to user-land
 
   287     // Write back to user-land
 
   305     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetIsDebugKernel() - writing to user-side...") );
 
   288     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetIsDebugKernel() - writing to user-side...") );
 
   306     r = Kern::ThreadRawWrite( &ClientThread(), aIsDebugKernel, &debugKernel, sizeof(TBool) );
 
   289     r = Kern::ThreadRawWrite( &ClientThread(), aResult, &debugKernel, sizeof(TBool) );
 
   307 
   290 
   308     NKern::ThreadLeaveCS();
 
   291     NKern::ThreadLeaveCS();
 
   309 
   292 
   310  	TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetIsDebugKernel() - END - ret: %d", r) );
 
   293  	TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::GetIsDebugKernel() - END - ret: %d", r) );
 
   311     return r;
 
   294     return r;
 
   312     }
 
   295     }
 
   313 
   296 
   314 
   297 TInt DMemSpyDriverLogChanHeapInfo::PrepareCellListTransferBuffer()
 
   315 
   298     {
 
   316 
   299     // Transfer free cells immediately from xfer stream
 
   317 
   300     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::PrepareCellListTransferBuffer() - START - iHeapStream: 0x%08x", iHeapStream ));
 
   318 
   301     __ASSERT_ALWAYS( !iHeapStream, MemSpyDriverUtils::PanicThread( ClientThread(), EPanicHeapFreeCellStreamNotClosed ) );
 
   319 
   302     //
 
   320 
   303     TInt r = KErrNoMemory;
 
   321 
   304     //
 
   322 
   305     NKern::ThreadEnterCS();
 
   323 
   306     //
 
   324 
   307     iHeapStream = new RMemSpyMemStreamWriter();
 
   325 
   308     if  ( iHeapStream )
 
   326 
   309         {
 
   327 
   310         const TInt requiredMemory = CalculateCellListBufferSize();
 
   328 
   311         r = OpenXferStream( *iHeapStream, requiredMemory );
 
   329 
   312         TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::PrepareCellListTransferBuffer() - requested %d bytes for free cell list, r: %d", requiredMemory, r ));
 
   330 
   313 
   331 
   314         if  ( r == KErrNone )
 
   332 
   315             {
 
   333 
   316             const TInt count = iCellList.Count();
 
   334 
   317             TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::PrepareCellListTransferBuffer() - cell count: %d", count ));
 
   335 
   318             //
 
   336 
   319             iHeapStream->WriteInt32( count );
 
   337 
   320             for( TInt i=0; i<count; i++ )
 
   338 
   321                 {
 
   339 
   322                 const TMemSpyDriverCell& cell = iCellList[ i ];
 
   340 
   323                 TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::PrepareCellListTransferBuffer() - storing entry: %d", i ));
 
   341 
   324                 //
 
   342 
   325                 iHeapStream->WriteInt32( cell.iType );
 
   343 
   326                 iHeapStream->WriteUint32( reinterpret_cast<TUint32>( cell.iAddress ) );
 
   344 
   327                 iHeapStream->WriteInt32( cell.iLength );
 
   345 
   328                 }
 
   346 
   329 
   347 
   330             // Finished with the array now
 
   348 
   331             iCellList.Reset();
 
   349 
   332 
       
   333             // We return the amount of client-side memory that needs to be allocated to hold the buffer
 
       
   334             r = requiredMemory;
 
       
   335             }
 
       
   336         }
 
       
   337     //
 
       
   338     NKern::ThreadLeaveCS();
 
       
   339                
       
   340     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::PrepareCellListTransferBuffer() - END - r: %d", r));
 
       
   341 	return r;
 
       
   342     }
 
       
   343 
       
   344 
       
   345 TInt DMemSpyDriverLogChanHeapInfo::FetchCellList( TDes8* aBufferSink )
 
       
   346     {
 
       
   347     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::FetchCellList() - START - iHeapStream: 0x%08x", iHeapStream ));
 
       
   348     __ASSERT_ALWAYS( iHeapStream, MemSpyDriverUtils::PanicThread( ClientThread(), EPanicHeapFreeCellStreamNotOpen ) );
 
       
   349 
       
   350     TInt r = KErrNone;
 
       
   351 
       
   352     // Write buffer to client
 
       
   353     NKern::ThreadEnterCS();
 
       
   354     r = iHeapStream->WriteAndClose( aBufferSink );
 
       
   355 
       
   356     // Tidy up
 
       
   357     ReleaseCellList();
 
       
   358 
       
   359     NKern::ThreadLeaveCS();
 
       
   360     //
 
       
   361     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::FetchCellList() - END - r: %d", r));
 
       
   362 	return r;
 
       
   363     }
 
       
   364 
       
   365 
       
   366 
       
   367 TInt DMemSpyDriverLogChanHeapInfo::CalculateCellListBufferSize() const
 
       
   368     {
 
       
   369     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::CalculateCellListBufferSize() - START" ));
 
       
   370 
       
   371     const TInt count = iCellList.Count();
 
       
   372     const TInt entrySize = sizeof( TInt32 ) + sizeof( TInt32 ) + sizeof( TUint32 );
 
       
   373     const TInt r = ( count * entrySize ) + sizeof( TInt ); // Extra TInt to hold count
 
       
   374                 
       
   375     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::CalculateCellListBufferSize() - END - r: %d, count: %d, entrySize: %d", r, count, entrySize ));
 
       
   376 	return r;
 
       
   377     }
 
       
   378 
       
   379 
       
   380 
       
   381 void DMemSpyDriverLogChanHeapInfo::ReleaseCellList()
 
       
   382     {
 
       
   383 	TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::ReleaseCellList() - START - this: 0x%08x", this ));
 
       
   384 
       
   385     NKern::ThreadEnterCS();
 
       
   386     iCellList.Reset();
 
       
   387     delete iHeapStream;
 
       
   388     iHeapStream = NULL;
 
       
   389     NKern::ThreadLeaveCS();
 
       
   390 
       
   391     TRACE( Kern::Printf("DMemSpyDriverLogChanHeapInfo::ReleaseCellList() - END - this: 0x%08x", this ));
 
       
   392     }
 
       
   393 
       
   394 TBool DMemSpyDriverLogChanHeapInfo::HandleHeapCell(TMemSpyDriverCellType aCellType, TAny* aCellAddress, TInt aLength, TInt /*aNestingLevel*/, TInt /*aAllocNumber*/)
 
       
   395     {
 
       
   396 	TInt err = KErrNone;
 
       
   397     if (((aCellType & EMemSpyDriverFreeCellMask) && iHeapInfoParams.iBuildFreeCellList) || ((aCellType & EMemSpyDriverAllocatedCellMask) && iHeapInfoParams.iBuildAllocCellList))
 
       
   398 		{
 
       
   399 		TMemSpyDriverCell cell;
 
       
   400 		cell.iType = aCellType;
 
       
   401 		cell.iAddress = aCellAddress;
 
       
   402 		cell.iLength = aLength;
 
       
   403 
       
   404 		NKern::ThreadEnterCS();
 
       
   405 		err = iCellList.Append(cell);
 
       
   406 		NKern::ThreadLeaveCS();
 
       
   407 		}
 
       
   408 	return err == KErrNone;
 
       
   409 	}
 
       
   410 
       
   411 void DMemSpyDriverLogChanHeapInfo::HandleHeapWalkInit()
 
       
   412 	{
 
       
   413 	}
FCL/sf/os/osrndtools