diff -r e26895079d7c -r 7fdc9a71d314 analyzetool/dynamicmemoryhook/src/analyzetoolmainallocator.cpp --- a/analyzetool/dynamicmemoryhook/src/analyzetoolmainallocator.cpp Wed Sep 15 00:19:18 2010 +0300 +++ b/analyzetool/dynamicmemoryhook/src/analyzetoolmainallocator.cpp Wed Sep 15 13:53:27 2010 +0300 @@ -22,7 +22,12 @@ #include "analyzetoolmemoryallocator.h" #include "analyzetoolpanics.pan" #include "analyzetoolfastlog.h" +#include "analyzetoolfilelog.h" #include +#ifndef __WINSCW__ +#include +#endif +#include // CONSTANTS @@ -30,15 +35,19 @@ // The name of the memoryhook dll _LIT8( KMemoryHook, "AToolMemoryHook.dll" ); -// The name of the storage server dll -_LIT8( KStorageServer, "AToolStorageServerClnt.dll" ); - // Length of the callstack address const TUint32 KAddressLength = 4; // Thread count const TInt KThreadCount = 1; +// separator that replaces \n character in sw version +_LIT( KSeparator, "@" ); +// new line character +_LIT( KNewLine16, "\n" ); +_LIT( KSpace16, " " ); + + // ----------------------------------------------------------------------------- // RAnalyzeToolMainAllocator::RAnalyzeToolMainAllocator() // C++ default constructor can NOT contain any code, that @@ -46,8 +55,9 @@ // ----------------------------------------------------------------------------- // RAnalyzeToolMainAllocator::RAnalyzeToolMainAllocator( TBool aNotFirst, - const TFileName aFileName, TUint32 aLogOption, TUint32 aIsDebug, - TUint32 aAllocCallStackSize, TUint32 aFreeCallStackSize ) : + const TFileName& aFileName, const TPath& aFilePath, TUint32 aLogOption, TUint32 aIsDebug, + TUint32 aAllocCallStackSize, TUint32 aFreeCallStackSize, + const TDesC8& aAtoolVersion, const TDesC8& aApiVersion ) : RAnalyzeToolMemoryAllocator( aNotFirst ), iAnalyzeToolOpen( EFalse ), iDeviceDriverLoaded( EFalse ), @@ -62,32 +72,7 @@ // Basic error variable used in method. TInt error( KErrNone ); - - // Connect to the storage server if logging mode not fast trace. - if ( iLogOption != EATLogToTraceFast ) - { - error = iStorageServer.Connect(); - - LOGSTR2( "ATMH Opening RATStorageServer error %i", error ); - - if ( KErrNone == error ) - { - iStorageServerOpen = ETrue; - } - else - { - iStorageServerOpen = EFalse; - } - - if ( KErrNone == error ) - { - // Make the storage server handle shared between threads - error = iStorageServer.ShareAuto(); - } - - LOGSTR2( "ATMH Sharing RATStorageServer error %i", error ); - } - + // Create mutex for schedule access to shared resources error = iMutex.CreateLocal(); @@ -135,16 +120,19 @@ } // Retrieve the initial process information - LogProcessInformation( aFileName, aLogOption, aIsDebug ); + LogProcessInformation( aFileName, aFilePath, aLogOption, aIsDebug, aAtoolVersion, aApiVersion ); + + // log version of ATApp, ATApi, S60 version and ROM checksum + LogDeviceInfo(); // Create handler for receiving kernel events iEventHandler = new CLibraryEventHandler( iAnalyzeTool, iCodeblocks, - iStorageServer, iProcessId, iMutex, *this, - aLogOption); + aLogOption, + iLogFile ); __ASSERT_ALWAYS( iEventHandler != NULL, AssertPanic( ENoMemory ) ); } @@ -197,28 +185,33 @@ LOGSTR2( "ATMH Unloading ldd error: %i", error ); } } - + for( TInt i=0; iAlloc( aSize ); @@ -294,120 +290,86 @@ LOGSTR3( "ATMH RAnalyzeToolMainAllocator::Alloc() - aSize: %i, address: %x", aSize, (TUint32) p ); - // Don't collect or log data if storage server not open or logging mode fast. - if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) - { - TInt error( KErrNone ); - - // Check if eventhandler is started already - if ( !iEventHandler->IsStarted() ) - { - // Install the eventhandler if needed - InstallEventHandler(); - } - - // Reset the callstack - iCallStack.Reset(); + + TInt error( KErrNone ); + + // Check if eventhandler is started already + if ( !iEventHandler->IsStarted() ) + { + // Install the eventhandler if needed + InstallEventHandler(); + } + + // Reset the callstack + iCallStack.Reset(); - // If we don't want any call stack to be saved skip the next part - if( iAllocMaxCallStack > 0 ) - { - // Find the current thread callstack start address - TUint32 stackstart( 0 ); - TBool found( FindCurrentThreadStack( stackstart ) ); - LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found ); - - // Returns the value of the stack pointer at the - // current point in your program. - TUint32 _sp; - __asm - { - mov [_sp], esp - } - - // Get process loaded code segments count - TInt blocksCount( iCodeblocks.Count() ); - TUint arrayCounter = 0; - - // Iterate through callstack to find wanted callstack addresses - // - Start: current stack address - // - Stop: stack start address(Run-address of user stack) - // - Add: address length(The word size in the current system is 32 bits, which is 4 bytes) - for ( TUint32 i = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 - { - TUint32 addr = (TUint32) *( (TUint32*) i ); - - // Checks is the given address in loaded code memory area. - if ( !IsAddressLoadedCode( addr ) ) - continue; - - // Iterate through array of code blocks to check if address is in code segment area - for ( TInt j = 0; j < blocksCount; j++ ) - { - // Checks if the given address is in this memory block area - if ( iCodeblocks[j].CheckAddress( addr ) ) - { - // To avoid recursive call to ReAlloc specifying granularity - // Add address to the callstack - iCallStack[arrayCounter] = ( addr ); - arrayCounter++; - break; - } - } - - // Checks if the wanted callstack items are gathered - if ( arrayCounter == KATMaxCallstackLength || - arrayCounter == iAllocMaxCallStack ) - { - LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter ); - break; - } - } - } + // If we don't want any call stack to be saved skip the next part + if( iAllocMaxCallStack > 0 ) + { + // Find the current thread callstack start address + TUint32 stackstart( 0 ); + TBool found( FindCurrentThreadStack( stackstart ) ); + LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found ); + + // Returns the value of the stack pointer at the + // current point in your program. + TUint32 _sp; + __asm + { + mov [_sp], esp + } + + // Get process loaded code segments count + TInt blocksCount( iCodeblocks.Count() ); + TUint arrayCounter = 0; + + // Iterate through callstack to find wanted callstack addresses + // - Start: current stack address + // - Stop: stack start address(Run-address of user stack) + // - Add: address length(The word size in the current system is 32 bits, which is 4 bytes) + for ( TUint32 i = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 + { + TUint32 addr = (TUint32) *( (TUint32*) i ); + + // Checks is the given address in loaded code memory area. + if ( !IsAddressLoadedCode( addr ) ) + continue; + + // Iterate through array of code blocks to check if address is in code segment area + for ( TInt j = 0; j < blocksCount; j++ ) + { + // Checks if the given address is in this memory block area + if ( iCodeblocks[j].CheckAddress( addr ) ) + { + // To avoid recursive call to ReAlloc specifying granularity + // Add address to the callstack + iCallStack[arrayCounter] = ( addr ); + arrayCounter++; + break; + } + } + + // Checks if the wanted callstack items are gathered + if ( arrayCounter == KATMaxCallstackLength || + arrayCounter == iAllocMaxCallStack ) + { + LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter ); + break; + } + } + } - // Log the memory allocation information - if ( iLogOption == EATLogToTraceFast ) - { - // Using fast mode. - ATFastLogMemoryAllocated( iProcessId, (TUint32) p , iCallStack, aSize ); - } - else - { - // Using storage server. - error = iStorageServer.LogMemoryAllocated( (TUint32) p, - iCallStack, - aSize ); - if ( KErrNone != error ) - { - switch ( error ) - { - case KErrNoMemory: - { - LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Alloc() - KErrNoMemory case" ); - // Check if eventhandler is active - if ( iEventHandler->IsActive() ) - { - // Cancel iEventHandler because not needed anymore - iEventHandler->Cancel(); - } - if ( iStorageServerOpen ) - { - // Close storage server - iStorageServerOpen = EFalse; - LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Alloc() - close iStorageServer" ); - iStorageServer.Close(); - } - break; - } - default: - { - LOGSTR2( "ATMH LogMemoryAllocated error %i", error ); - break; - } - } - } - } - } + // Log the memory allocation information + if ( iLogOption == EATLogToTraceFast ) + { + // Using fast mode. + ATFastLogMemoryAllocated( iProcessId, (TUint32) p , iCallStack, aSize, threadId ); + } + else if ( iLogOption == EATLogToFile ) + { + iLogFile.ATFileLogMemoryAllocated( (TUint32) p , iCallStack, aSize, threadId ); + } + // Release the mutex iMutex.Signal(); @@ -426,6 +388,9 @@ // acquire the mutex iMutex.Wait(); + + // get thread ID + TUint threadId = RThread().Id(); // Alloc memory from the original allocator TAny* p = iAllocator->Alloc( aSize ); @@ -433,113 +398,77 @@ LOGSTR3( "ATMH RAnalyzeToolMainAllocator::Alloc() - aSize: %i, address: %x", aSize, (TUint32) p ); - TInt error( KErrNone ); - - if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) - { - // Check if eventhandler is active already - // IsActive might return false value if a tested software has created many - // threads which install own CActiveScheduler. - if ( !iEventHandler->IsStarted() ) - { - // Install the eventhandler if needed - InstallEventHandler(); - } - - // Reset the callstack - iCallStack.Reset(); - - // If we don't want any call stack to be saved skip the next part - if( iAllocMaxCallStack > 0 ) - { - // Find the current thread callstack start address - TUint32 stackstart( 0 ); - TBool found( FindCurrentThreadStack( stackstart ) ); - LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found ); - - // Get process loaded code segments count - TInt blocksCount( iCodeblocks.Count() ); - TUint arrayCounter = 0; - - // Iterate through callstack to find wanted callstack addresses - // - Start: current stack address(__current_sp(): Returns the value of the - // stack pointer at the current point in your program.) - // - Stop: stack start address(Run-address of user stack) - // - Add: address length(The word size in the current system is 32 bits, which is 4 bytes) - for ( TUint32 i = __current_sp(); i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 - { - TUint32 addr = (TUint32) *( (TUint32*) i ); - - // Checks is the given address in loaded code memory area. - if ( !IsAddressLoadedCode( addr ) ) - continue; - - // Iterate through array of code blocks to check if address is in code segment area - for ( TInt j = 0; j < blocksCount; j++ ) - { - // Checks if the given address is in this memory block area - if ( iCodeblocks[j].CheckAddress( addr ) ) - { - // To avoid recursive call to ReAlloc specifying granularity - // Add address to the callstack - iCallStack[arrayCounter] = ( addr ); - arrayCounter++; - break; - } - } - - // Checks if the wanted callstack items are gathered - if ( arrayCounter == KATMaxCallstackLength || - arrayCounter == iAllocMaxCallStack ) - { - LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter ); - break; - } - } - } - // Log the memory allocation information - if ( iLogOption == EATLogToTraceFast ) - { - // Using fast mode. - ATFastLogMemoryAllocated( iProcessId, (TUint32) p, iCallStack, aSize ); - } - else - { - // Using storage server. - error = iStorageServer.LogMemoryAllocated( (TUint32) p, - iCallStack, - aSize ); - if ( KErrNone != error ) - { - switch ( error ) - { - case KErrNoMemory: - { - LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Alloc() - KErrNoMemory case" ); - // Check if eventhandler is active - if ( iEventHandler->IsActive() ) - { - // Cancel ieventhandler because not needed anymore - iEventHandler->Cancel(); - } - if ( iStorageServerOpen ) - { - // Close storage server - iStorageServerOpen = EFalse; - LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Alloc() - close iStorageServer" ); - iStorageServer.Close(); - } - break; - } - default: - { - LOGSTR2( "ATMH LogMemoryAllocated error %i", error ); - break; - } - } - } - } - } + + // Check if eventhandler is active already + // IsActive might return false value if a tested software has created many + // threads which install own CActiveScheduler. + if ( !iEventHandler->IsStarted() ) + { + // Install the eventhandler if needed + InstallEventHandler(); + } + + // Reset the callstack + iCallStack.Reset(); + + // If we don't want any call stack to be saved skip the next part + if( iAllocMaxCallStack > 0 ) + { + // Find the current thread callstack start address + TUint32 stackstart( 0 ); + TBool found( FindCurrentThreadStack( stackstart ) ); + LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found ); + + // Get process loaded code segments count + TInt blocksCount( iCodeblocks.Count() ); + TUint arrayCounter = 0; + + // Iterate through callstack to find wanted callstack addresses + // - Start: current stack address(__current_sp(): Returns the value of the + // stack pointer at the current point in your program.) + // - Stop: stack start address(Run-address of user stack) + // - Add: address length(The word size in the current system is 32 bits, which is 4 bytes) + for ( TUint32 i = __current_sp(); i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 + { + TUint32 addr = (TUint32) *( (TUint32*) i ); + + // Checks is the given address in loaded code memory area. + if ( !IsAddressLoadedCode( addr ) ) + continue; + + // Iterate through array of code blocks to check if address is in code segment area + for ( TInt j = 0; j < blocksCount; j++ ) + { + // Checks if the given address is in this memory block area + if ( iCodeblocks[j].CheckAddress( addr ) ) + { + // To avoid recursive call to ReAlloc specifying granularity + // Add address to the callstack + iCallStack[arrayCounter] = ( addr ); + arrayCounter++; + break; + } + } + + // Checks if the wanted callstack items are gathered + if ( arrayCounter == KATMaxCallstackLength || + arrayCounter == iAllocMaxCallStack ) + { + LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter ); + break; + } + } + } + // Log the memory allocation information + if ( iLogOption == EATLogToTraceFast ) + { + // Using fast mode. + ATFastLogMemoryAllocated( iProcessId, (TUint32) p, iCallStack, aSize, threadId ); + } + else if ( iLogOption == EATLogToFile ) + { + iLogFile.ATFileLogMemoryAllocated( (TUint32) p , iCallStack, aSize, threadId ); + } // Release the mutex iMutex.Signal(); @@ -561,87 +490,81 @@ // Acquire the mutex iMutex.Wait(); - if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) - { - // Reset the callstack - iFreeCallStack.Reset(); - - // Check if trace logging mode - // Also if we don't want any call stack to be stored skip the next part - if ( (iLogOption == EATUseDefault || iLogOption == EATLogToTrace || iLogOption == EATLogToTraceFast ) - && iFreeMaxCallStack > 0 ) - { - // Find the current thread callstack start address - TUint32 stackstart( 0 ); - TBool found( FindCurrentThreadStack( stackstart ) ); - LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found ); - TUint32 _sp; - - // Returns the value of the stack pointer at the - // current point in your program. - #ifdef __WINS__ - __asm - { - mov [_sp], esp - } - #else - _sp = __current_sp(); - #endif - - // Get process loaded code segments count - TInt blocksCount( iCodeblocks.Count() ); - TUint arrayCounter = 0; - - // Iterate through callstack to find wanted callstack addresses - // - Start: current stack address - // - Stop: stack start address(Run-address of user stack) - // - Add: address length(The word size in the current system is 32 bits, which is 4 bytes) - for ( TUint32 i = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 - { - TUint32 addr = (TUint32) *( (TUint32*) i ); - // Checks is the given address in loaded code memory area. - if ( ! IsAddressLoadedCode( addr ) ) - continue; - - // Iterate through array of code blocks to check if address is in code segment area - for ( TInt j = 0; j < blocksCount; j++ ) - { - // Checks if the given address is in this memory block area - if ( iCodeblocks[j].CheckAddress( addr ) ) - { - // To avoid recursive call to ReAlloc specifying granularity - // Add address to the callstack - iFreeCallStack[arrayCounter] = addr; - arrayCounter++; - break; - } - } - // Checks if the wanted callstack items are gathered - if ( arrayCounter == KATMaxFreeCallstackLength || - arrayCounter == iFreeMaxCallStack ) - { - break; - } - } - LOGSTR2( "ATMH > iFreeCallStack count ( %i )", arrayCounter ); - } - // Log the memory free information. - if ( iLogOption == EATLogToTraceFast ) - { - // Using fast mode. - ATFastLogMemoryFreed( iProcessId, (TUint32) aPtr, iFreeCallStack ); - } - else - { - // Using storage server. - TInt err( iStorageServer.LogMemoryFreed( (TUint32) aPtr, iFreeCallStack ) ); - if ( err != KErrNone ) - { - LOGSTR2( "ATMH > LogMemoryFreed err( %i )", err ); - } - } - } - + // get thread ID + TUint threadId = RThread().Id(); + + // Reset the callstack + iFreeCallStack.Reset(); + + // Check if trace logging mode + // Also if we don't want any call stack to be stored skip the next part + if ( iFreeMaxCallStack > 0 ) + { + // Find the current thread callstack start address + TUint32 stackstart( 0 ); + TBool found( FindCurrentThreadStack( stackstart ) ); + LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found ); + TUint32 _sp; + + // Returns the value of the stack pointer at the + // current point in your program. + #ifdef __WINS__ + __asm + { + mov [_sp], esp + } + #else + _sp = __current_sp(); + #endif + + // Get process loaded code segments count + TInt blocksCount( iCodeblocks.Count() ); + TUint arrayCounter = 0; + + // Iterate through callstack to find wanted callstack addresses + // - Start: current stack address + // - Stop: stack start address(Run-address of user stack) + // - Add: address length(The word size in the current system is 32 bits, which is 4 bytes) + for ( TUint32 i = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 + { + TUint32 addr = (TUint32) *( (TUint32*) i ); + // Checks is the given address in loaded code memory area. + if ( ! IsAddressLoadedCode( addr ) ) + continue; + + // Iterate through array of code blocks to check if address is in code segment area + for ( TInt j = 0; j < blocksCount; j++ ) + { + // Checks if the given address is in this memory block area + if ( iCodeblocks[j].CheckAddress( addr ) ) + { + // To avoid recursive call to ReAlloc specifying granularity + // Add address to the callstack + iFreeCallStack[arrayCounter] = addr; + arrayCounter++; + break; + } + } + // Checks if the wanted callstack items are gathered + if ( arrayCounter == KATMaxFreeCallstackLength || + arrayCounter == iFreeMaxCallStack ) + { + break; + } + } + LOGSTR2( "ATMH > iFreeCallStack count ( %i )", arrayCounter ); + } + // Log the memory free information. + if ( iLogOption == EATLogToTraceFast ) + { + // Using fast mode. + ATFastLogMemoryFreed( iProcessId, (TUint32) aPtr, iFreeCallStack, threadId ); + } + else if ( iLogOption == EATLogToFile ) + { + iLogFile.ATFileLogMemoryFreed( (TUint32) aPtr, iFreeCallStack, threadId ); + } + // Free the memory using original allocator iAllocator->Free( aPtr ); @@ -682,6 +605,15 @@ LOGSTR2( "ATMH Thread stack size: %x", params().iStackSize ); iThreadArray.Append( TThreadStack( RThread().Id(), params().iStackAddress + params().iStackSize ) ); + if ( iLogOption == EATLogToTraceFast ) + { + // log thread added + ATFastLogThreadStarted( RProcess().Id().operator TUint() , RThread().Id().operator TUint() ); + } + else if ( iLogOption == EATLogToFile ) + { + iLogFile.ATFileLogThreadStarted( RThread().Id().operator TUint() ); + } } } @@ -718,6 +650,15 @@ { // Remove the thread iThreadArray.Remove( i ); + if ( iLogOption == EATLogToTraceFast ) + { + // log thread removed + ATFastLogThreadEnded( RProcess().Id().operator TUint(), RThread().Id().operator TUint() ); + } + else if ( iLogOption == EATLogToFile ) + { + iLogFile.ATFileLogThreadEnded( RThread().Id().operator TUint() ); + } LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Close() - thread removed" ); break; } @@ -740,6 +681,9 @@ // Acquire the mutex iMutex.Wait(); + + // get thread ID + TUint threadId = RThread().Id(); // Realloc the memory using original allocator TAny* ptr = iAllocator->ReAlloc( aPtr, aSize, aMode ); @@ -752,142 +696,78 @@ LOGSTR3( "ATMH RAnalyzeToolMainAllocator::ReAlloc() - aSize: %i, aMode: %i", aSize, aMode ); - // Don't collect or log data if storage server not open or logging mode is not fast. - if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) - { - TInt error( KErrNone ); - TUint arrayCounter = 0; - - // Reset the callstack - iReCallStack.Reset(); - - // If we don't want any call stack to be saved skip the next part - if( iAllocMaxCallStack > 0 ) - { - // Find the current thread callstack start address - TUint32 stackstart( 0 ); - TBool found( FindCurrentThreadStack( stackstart ) ); - LOGSTR3( "ATMH > stackstart: %x , find = %i", stackstart, found ); - - // Returns the value of the stack pointer at the - // current point in your program. - TUint32 _sp( 0 ); - __asm - { - mov [_sp], esp - } - - // Get process loaded code segments count - TInt blocksCount( iCodeblocks.Count() ); - - // Iterate through callstack to find wanted callstack addresses - // - Start: current stack address - // - Stop: stack start address(Run-address of user stack) - // - Add: address length(The word size in the current system is 32 bits, which is 4 bytes) - for ( TUint32 i = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 - { - TUint32 addr = (TUint32) *( (TUint32*) i ); - // Checks is the given address in loaded code memory area. - if ( ! IsAddressLoadedCode( addr ) ) - continue; - - // Iterate through array of code blocks to check if address is in code segment area - for ( TInt j = 0; j < blocksCount; j++ ) - { - // Checks if the given address is in this memory block area - if ( iCodeblocks[j].CheckAddress( addr ) ) - { - // To avoid recursive call to ReAlloc specifying granularity - // Add address to the callstack - iReCallStack[arrayCounter] = addr; - arrayCounter++; - break; - } - } - // Checks if the wanted callstack items are gathered - if ( arrayCounter == KATMaxCallstackLength || - arrayCounter == iAllocMaxCallStack ) - { - LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter ); - break; - } - } - } - - // No need to report free if the aPtr was NULL - if ( aPtr != NULL ) - { - // Reset the free callstack - iFreeCallStack.Reset(); - - // Check that logging mode is trace/trace fast so we use free call stack - // and call stack size bigger than zero - if ( ( iLogOption == EATUseDefault || iLogOption == EATLogToTrace || iLogOption == EATLogToTraceFast ) && iFreeMaxCallStack > 0 ) - { - for ( TInt i = 0; i < arrayCounter; i++ ) - { - if ( i == KATMaxFreeCallstackLength || i == iFreeMaxCallStack ) - { - break; - } - iFreeCallStack[i] = iReCallStack[i]; - } - } - // Try to remove old address from the storage server's - // leak array. If found. it's removed from the array because system frees - // old address directly in the RHeap in ReAlloc case. - if ( iLogOption == EATLogToTraceFast ) - { - ATFastLogMemoryFreed( iProcessId, (TUint32) aPtr, iFreeCallStack ); - } - else - { - iStorageServer.LogMemoryFreed( (TUint32) aPtr, iFreeCallStack ); - } - } - // Log the memory allocation information - if ( iLogOption == EATLogToTraceFast ) - { - // Using fast logging mode. - ATFastLogMemoryAllocated( iProcessId, (TUint32) ptr, iReCallStack, aSize ); - } - else - { - // Using storage server. - error = iStorageServer.LogMemoryAllocated( (TUint32) ptr, - iReCallStack, - aSize ); - if ( KErrNone != error ) - { - switch ( error ) - { - case KErrNoMemory: - { - LOGSTR1( "ATMH RAnalyzeToolMainAllocator::ReAlloc() - KErrNoMemory case" ); - // Check if eventhandler is active - if ( iEventHandler->IsActive() ) - { - // Cancel iEventHandler because not needed anymore - iEventHandler->Cancel(); - } - if ( iStorageServerOpen ) - { - // Close storage server - iStorageServerOpen = EFalse; - LOGSTR1( "ATMH RAnalyzeToolMainAllocator::ReAlloc() - close iStorageServer" ); - iStorageServer.Close(); - } - break; - } - default: - { - LOGSTR2( "ATMH LogMemoryAllocated error %i", error ); - break; - } - } - } - } - } + + TInt error( KErrNone ); + TUint arrayCounter = 0; + + // Reset the callstack + iReCallStack.Reset(); + + // If we don't want any call stack to be saved skip the next part + if( iAllocMaxCallStack > 0 ) + { + // Find the current thread callstack start address + TUint32 stackstart( 0 ); + TBool found( FindCurrentThreadStack( stackstart ) ); + LOGSTR3( "ATMH > stackstart: %x , find = %i", stackstart, found ); + + // Returns the value of the stack pointer at the + // current point in your program. + TUint32 _sp( 0 ); + __asm + { + mov [_sp], esp + } + + // Get process loaded code segments count + TInt blocksCount( iCodeblocks.Count() ); + + // Iterate through callstack to find wanted callstack addresses + // - Start: current stack address + // - Stop: stack start address(Run-address of user stack) + // - Add: address length(The word size in the current system is 32 bits, which is 4 bytes) + for ( TUint32 i = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 + { + TUint32 addr = (TUint32) *( (TUint32*) i ); + // Checks is the given address in loaded code memory area. + if ( ! IsAddressLoadedCode( addr ) ) + continue; + + // Iterate through array of code blocks to check if address is in code segment area + for ( TInt j = 0; j < blocksCount; j++ ) + { + // Checks if the given address is in this memory block area + if ( iCodeblocks[j].CheckAddress( addr ) ) + { + // To avoid recursive call to ReAlloc specifying granularity + // Add address to the callstack + iReCallStack[arrayCounter] = addr; + arrayCounter++; + break; + } + } + // Checks if the wanted callstack items are gathered + if ( arrayCounter == KATMaxCallstackLength || + arrayCounter == iAllocMaxCallStack ) + { + LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter ); + break; + } + } + } + + + // Log the memory reallocation information + if ( iLogOption == EATLogToTraceFast ) + { + // Using fast logging mode. + ATFastLogMemoryReallocated( iProcessId, (TUint32) aPtr, (TUint32) ptr, iReCallStack, aSize, threadId ); + } + else if ( iLogOption == EATLogToFile ) + { + iLogFile.ATFileLogMemoryReallocated( (TUint32) aPtr, (TUint32) ptr, iReCallStack, aSize, threadId ); + } + } // Release the mutex @@ -911,10 +791,12 @@ // Acquire the mutex iMutex.Wait(); + // get thread ID + TUint threadId = RThread().Id(); + // Realloc the memory using original allocator TAny* ptr = iAllocator->ReAlloc( aPtr, aSize, aMode ); - TInt error( KErrNone ); TUint arrayCounter = 0; // NULL addresses are not in a process under test @@ -925,136 +807,65 @@ LOGSTR3( "ATMH RAnalyzeToolMainAllocator::ReAlloc() - aSize: %i, aMode: %i", aSize, aMode ); - // Don't collect or log data if storage server not open or logging mode is not fast. - if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) - { - // Reset the callstack - iReCallStack.Reset(); - - // If we don't want any call stack to be saved skip the next part - if( iAllocMaxCallStack > 0 ) - { - // Find the current thread callstack start address - TUint32 stackstart( 0 ); - TBool found( FindCurrentThreadStack( stackstart ) ); - LOGSTR3( "ATMH > stackstart: %x , find = %i", stackstart, found ); - - // Get process loaded code segments count - TInt blocksCount( iCodeblocks.Count() ); - - // Iterate through callstack to find wanted callstack addresses - // - Start: current stack address(__current_sp(): Returns the value of the - // stack pointer at the current point in your program.) - // - Stop: stack start address(Run-address of user stack) - // - Add: address length(The word size in the current system is 32 bits, which is 4 bytes) - for ( TUint32 i = __current_sp(); i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 - { - TUint32 addr = (TUint32) *( (TUint32*) i ); - - // Checks is the given address in loaded code memory area. - if ( !IsAddressLoadedCode( addr ) ) - continue; - - // Iterate through array of code blocks to check if address is in code segment area - for ( TInt j = 0; j < blocksCount; j++ ) - { - // Checks if the given address is in this memory block area - if ( iCodeblocks[j].CheckAddress( addr ) ) - { - // To avoid recursive call to ReAlloc specifying granularity - // Add address to the callstack - iReCallStack[arrayCounter] = ( addr ); - arrayCounter++; - break; - } - } - // Checks if the wanted callstack items are gathered - if ( arrayCounter == KATMaxCallstackLength || - arrayCounter == iAllocMaxCallStack ) - { - LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter ); - break; - } - } - } - - // No need to report free if the aPtr was NULL - if ( aPtr != NULL ) - { - // Reset the free callstack - iFreeCallStack.Reset(); - - // Check that logging mode is trace/trace fast so we use free call stack - // and call stack size bigger than zero - if ( (iLogOption == EATUseDefault || iLogOption == EATLogToTrace || iLogOption == EATLogToTraceFast ) - && iFreeMaxCallStack > 0 ) - { - for ( TInt i = 0; i < arrayCounter; i++ ) - { - if ( i == KATMaxFreeCallstackLength || i == iFreeMaxCallStack ) - { - break; - } - iFreeCallStack[i] = ( iReCallStack[i] ); - } - } - - // Try to remove old address from the storage server's - // leak array. If found. it's removed from the array because system frees - // old address directly in the RHeap in ReAlloc case. - if ( iLogOption == EATLogToTraceFast ) - { - ATFastLogMemoryFreed( iProcessId, (TUint32) aPtr, iFreeCallStack ); - } - else - { - iStorageServer.LogMemoryFreed( (TUint32) aPtr, iFreeCallStack ); - } - } - - // Log the memory allocation information - if ( iLogOption == EATLogToTraceFast ) - { - // Using fast logging mode. - ATFastLogMemoryAllocated( iProcessId, (TUint32) ptr, iReCallStack, aSize ); - } - else - { - // Using storage server. - error = iStorageServer.LogMemoryAllocated( (TUint32) ptr, - iReCallStack, - aSize ); - if ( KErrNone != error ) - { - switch ( error ) - { - case KErrNoMemory: - { - LOGSTR1( "ATMH RAnalyzeToolMainAllocator::ReAlloc() - KErrNoMemory case" ); - // Check if eventhandler is active - if ( iEventHandler->IsActive() ) - { - // Cancel iEventHandler because not needed anymore - iEventHandler->Cancel(); - } - if ( iStorageServerOpen ) - { - // Close storage server - iStorageServerOpen = EFalse; - LOGSTR1( "ATMH RAnalyzeToolMainAllocator::ReAlloc() - close iStorageServer" ); - iStorageServer.Close(); - } - break; - } - default: - { - LOGSTR2( "ATMH LogMemoryAllocated error %i", error ); - break; - } - } - } - } - } + // Reset the callstack + iReCallStack.Reset(); + + // If we don't want any call stack to be saved skip the next part + if( iAllocMaxCallStack > 0 ) + { + // Find the current thread callstack start address + TUint32 stackstart( 0 ); + TBool found( FindCurrentThreadStack( stackstart ) ); + LOGSTR3( "ATMH > stackstart: %x , find = %i", stackstart, found ); + + // Get process loaded code segments count + TInt blocksCount( iCodeblocks.Count() ); + + // Iterate through callstack to find wanted callstack addresses + // - Start: current stack address(__current_sp(): Returns the value of the + // stack pointer at the current point in your program.) + // - Stop: stack start address(Run-address of user stack) + // - Add: address length(The word size in the current system is 32 bits, which is 4 bytes) + for ( TUint32 i = __current_sp(); i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348 + { + TUint32 addr = (TUint32) *( (TUint32*) i ); + + // Checks is the given address in loaded code memory area. + if ( !IsAddressLoadedCode( addr ) ) + continue; + + // Iterate through array of code blocks to check if address is in code segment area + for ( TInt j = 0; j < blocksCount; j++ ) + { + // Checks if the given address is in this memory block area + if ( iCodeblocks[j].CheckAddress( addr ) ) + { + // To avoid recursive call to ReAlloc specifying granularity + // Add address to the callstack + iReCallStack[arrayCounter] = ( addr ); + arrayCounter++; + break; + } + } + // Checks if the wanted callstack items are gathered + if ( arrayCounter == KATMaxCallstackLength || + arrayCounter == iAllocMaxCallStack ) + { + LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter ); + break; + } + } + } + + if ( iLogOption == EATLogToTraceFast ) + { + // Using fast logging mode. + ATFastLogMemoryReallocated( iProcessId, (TUint32) aPtr, (TUint32) ptr, iReCallStack, aSize, threadId ); + } + else if ( iLogOption == EATLogToFile ) + { + iLogFile.ATFileLogMemoryReallocated( (TUint32) aPtr, (TUint32) ptr, iReCallStack, aSize, threadId ); + } } // Release the mutex @@ -1249,6 +1060,15 @@ { // Remove the thread iThreadArray.Remove( i ); + if ( iLogOption == EATLogToTraceFast ) + { + // log thread removed + ATFastLogThreadEnded( RProcess().Id().operator TUint(), aThreadId ); + } + else if ( iLogOption == EATLogToFile ) + { + iLogFile.ATFileLogThreadEnded( aThreadId ); + } LOGSTR1( "ATMH > thread removed" ); break; } @@ -1285,8 +1105,8 @@ // Retrieve and log the process initial information // ----------------------------------------------------------------------------- // -void RAnalyzeToolMainAllocator::LogProcessInformation( const TFileName aFileName, - TUint32 aLogOption, TUint32 aIsDebug ) +void RAnalyzeToolMainAllocator::LogProcessInformation( const TFileName& aFileName, const TPath& aFilePath, + TUint32 aLogOption, TUint32 aIsDebug, const TDesC8& aAtoolVersion, const TDesC8& aApiVersion ) { LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation()" ); @@ -1309,31 +1129,38 @@ // Append thread to array of the users of this allocator error = iThreadArray.Append( TThreadStack( RThread().Id(), params().iStackAddress + params().iStackSize) ); + __ASSERT_ALWAYS( KErrNone == error, AssertPanic( ECantAppendToTheArray ) ); - - // Log process information - if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) + + // Using fast logging mode. + if ( iLogOption == EATLogToTraceFast ) + { + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - ATFastLogProcessStarted() #1" ); + // Log process information + ATFastLogProcessStarted( params().iProcessName, iProcessId, aIsDebug, aAtoolVersion, aApiVersion ); + // log thread added + ATFastLogThreadStarted( iProcessId, RThread().Id().operator TUint() ); + } + else if ( iLogOption == EATLogToFile ) { - if ( iLogOption == EATLogToTraceFast ) - { - // Using fast logging mode. - LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - ATFastLogProcessStarted() #1" ); - ATFastLogProcessStarted( params().iProcessName, iProcessId, aIsDebug ); - } - else + // Open a file server session and a file. + error = iLogFile.OpenFsAndFile( aFileName, aFilePath, params().iProcessName ); + + // Return without logging, if an error occured + if ( error != KErrNone ) { - // Using storage server. - LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - iStorageServerOpen #1" ); - error = iStorageServer.LogProcessStarted( - aFileName, - params().iProcessName, - iProcessId, - aLogOption, - aIsDebug ); + // TODO } + + //if everything is ok, add file version in the begining of file + iLogFile.ATFileLogVersion(); + //log process start + iLogFile.ATFileLogProcessStarted( params().iProcessName, iProcessId, aIsDebug, aAtoolVersion, aApiVersion ); + // log thread added + iLogFile.ATFileLogThreadStarted( RThread().Id().operator TUint() ); } - + LOGSTR2( "ATMH LogProcessStarted error %i", error ); // Iterate through process codesegments @@ -1349,31 +1176,27 @@ if ( KErrNone == error ) { // Don't log AnalyzeTool libraries - if ( 0 != codeinfo().iFullName.CompareC( KMemoryHook ) && - 0 != codeinfo().iFullName.CompareC( KStorageServer ) ) + if ( 0 != codeinfo().iFullName.CompareC( KMemoryHook ) ) { // Log the loaded codesegment(s) - if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) + + if ( iLogOption == EATLogToTraceFast ) { - if ( iLogOption == EATLogToTraceFast ) - { - // Using fast logging mode. - LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - ATFastLogDllLoaded() #2" ); - ATFastLogDllLoaded( iProcessId, - codeinfo().iFullName, - codeinfo().iRunAddress, - codeinfo().iRunAddress + codeinfo().iSize ); - } - else - { - // Using storage server. - LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - iStorageServerOpen #2" ); - error = iStorageServer.LogDllLoaded( - codeinfo().iFullName, - codeinfo().iRunAddress, - codeinfo().iRunAddress + codeinfo().iSize ); - } + // Using fast logging mode. + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - ATFastLogDllLoaded() #2" ); + ATFastLogDllLoaded( iProcessId, + codeinfo().iFullName, + codeinfo().iRunAddress, + codeinfo().iRunAddress + codeinfo().iSize ); } + else if ( iLogOption == EATLogToFile ) + { + iLogFile.ATFileLogDllLoaded( + codeinfo().iFullName, + codeinfo().iRunAddress, + codeinfo().iRunAddress + codeinfo().iSize ); + } + LOGSTR2( "ATMH LogDllLoaded error %i", error ); @@ -1403,29 +1226,24 @@ if ( KErrNone == error ) { // Log the loaded dynamic codesegment(s) - if ( iStorageServerOpen || iLogOption == EATLogToTraceFast ) + + if ( iLogOption == EATLogToTraceFast ) { - if ( iLogOption == EATLogToTraceFast ) - { - // Using fast logging mode. - LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - - ATFastLogDllLoaded()#3" ); - ATFastLogDllLoaded( iProcessId, - info().iLibraryName, - info().iRunAddress, - info().iRunAddress + info().iSize ); - } - else - { - // Using storage server. - LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - iStorageServerOpen #3" ); - error = iStorageServer.LogDllLoaded( - info().iLibraryName, - info().iRunAddress, - info().iRunAddress + info().iSize ); - } + // Using fast logging mode. + LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - - ATFastLogDllLoaded()#3" ); + ATFastLogDllLoaded( iProcessId, + info().iLibraryName, + info().iRunAddress, + info().iRunAddress + info().iSize ); } - - + else if ( iLogOption == EATLogToFile ) + { + iLogFile.ATFileLogDllLoaded( + info().iLibraryName, + info().iRunAddress, + info().iRunAddress + info().iSize ); + } + LOGSTR2( "ATMH LogDllLoaded error %i", error ); if ( KErrNone == error ) @@ -1441,6 +1259,7 @@ } } + // ----------------------------------------------------------------------------- // RAnalyzeToolMainAllocator::FindCurrentThreadStack() // Find the current thread which is using the heap @@ -1504,6 +1323,59 @@ { iEventHandler->Start(); } + } + +// ----------------------------------------------------------------------------- +// RAnalyzeToolMainAllocator::LogDeviceInfo() +// Logs iversion of ATApp, ATApi, S60 version and ROM checksum +// at the startup of hooked application +// ----------------------------------------------------------------------------- +// +void RAnalyzeToolMainAllocator::LogDeviceInfo() + { + //get s60 version + TBuf bufS60; + if (SysUtil::GetSWVersion(bufS60) == KErrNone) + { + TInt index(0); + //replace newlines in string with '@' + //while ((index = bufS60.Find(KNewLine)) != KSysUtilVersionTextLength && index != KErrNotFound) + while ( (index = bufS60.Find(KNewLine16)) != KErrNotFound) + { + bufS60.Replace(index, 1, KSeparator); + } + while ( (index = bufS60.Find(KSpace16)) != KErrNotFound) + { + bufS60.Replace(index, 1, KSeparator); + } + } + + TBuf bufChecksum; + +#ifndef __WINSCW__ + TRomHeader* romHeader = (TRomHeader*) UserSvr::RomHeaderAddress(); + if (romHeader) + { + bufChecksum.Format(_L("%08x"), romHeader->iCheckSum); + } +#endif + + TBuf8 s60Version; + s60Version.Copy(bufS60); + + TBuf8 romChecksum; + romChecksum.Copy(bufChecksum); + + //only fastlog implementation + if (iLogOption == EATLogToTraceFast) + { + ATFastLogDeviceInfo(s60Version, romChecksum); + } + else if ( iLogOption == EATLogToFile ) + { + iLogFile.ATFileLogDeviceInfo( s60Version, romChecksum ); + } + } // End of File