FCL/sf/os/osrndtools: comparison analyzetool/dynamicmemoryhook/src/analyzetoolmainallocator.cpp

equal deleted inserted replaced

-:e26895079d7c
+:7fdc9a71d314
 #include "atlog.h"
 #include "analyzetooleventhandler.h"
 #include "analyzetoolmemoryallocator.h"
 #include "analyzetoolpanics.pan"
 #include "analyzetoolfastlog.h"
+#include "analyzetoolfilelog.h"
 #include <e32svr.h>
+#ifndef __WINSCW__
+#include <e32rom.h>
+#endif
+#include <sysutil.h>
 // CONSTANTS
 // 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
 // might leave.
 // -----------------------------------------------------------------------------
 //
 RAnalyzeToolMainAllocator::RAnalyzeToolMainAllocator( TBool aNotFirst,
-const TFileName aFileName, TUint32 aLogOption, TUint32 aIsDebug,
+const TFileName& aFileName, const TPath& aFilePath, TUint32 aLogOption, TUint32 aIsDebug,
-TUint32 aAllocCallStackSize, TUint32 aFreeCallStackSize ) :
+TUint32 aAllocCallStackSize, TUint32 aFreeCallStackSize,
+const TDesC8& aAtoolVersion, const TDesC8& aApiVersion ) :
 RAnalyzeToolMemoryAllocator( aNotFirst ),
 iAnalyzeToolOpen( EFalse ),
 iDeviceDriverLoaded( EFalse ),
 iCodeblocks( KATMaxCallstackLength ),
 iThreadArray( KATMaxCallstackLength ),
 {
 LOGSTR1( "ATMH RAnalyzeToolMainAllocator::RAnalyzeToolMainAllocator()" );
 // 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();
 __ASSERT_ALWAYS( KErrNone == error, AssertPanic( ECantCreateMutex ) );
 else
 LOGSTR2( "ATMH AnalyzeTool GetMemoryModel error: %i", error );
 }
 // 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 ) );
 }
 // -----------------------------------------------------------------------------
 // There was no other users -> unload the device driver
 TInt error = User::FreeLogicalDevice( KAnalyzeToolLddName );
 LOGSTR2( "ATMH Unloading ldd error: %i", error );
 }
 }
+for( TInt i=0; i<iThreadArray.Count(); i++)
+	{
+// log thread removed
+		if ( iLogOption == EATLogToTraceFast )
+			{
+			ATFastLogThreadEnded( RProcess().Id().operator TUint(), RThread().Id().operator TUint() );
+			}
+		else if ( iLogOption == EATLogToFile )
+			{
+		    iLogFile.ATFileLogThreadEnded( RThread().Id().operator TUint() );
+			}
+	}
 // Close the thread array
 iThreadArray.Close();
-if ( iStorageServerOpen || iLogOption == EATLogToTraceFast )
+if ( iLogOption == EATLogToTraceFast )
 {
-if ( iLogOption == EATLogToTraceFast )
+LOGSTR1( "ATMH ATFastLogProcessEnded()" );
-{
+ATFastLogProcessEnded( iProcessId, handleLeakCount );
-LOGSTR1( "ATMH ATFastLogProcessEnded()" );
+}
-ATFastLogProcessEnded( iProcessId, handleLeakCount );
+else if ( iLogOption == EATLogToFile )
-}
+	{
-else
+iLogFile.ATFileLogProcessEnded( handleLeakCount );
-{
+	}
-iStorageServerOpen = EFalse;
-// Inform that process has ended and close the handle
-LOGSTR1( "ATMH iStorageServer.LogProcessEnded()" );
-iStorageServer.LogProcessEnded( iProcessId, handleLeakCount );
-// Close the handle
-iStorageServer.Close();
-}
-}
 // Close the mutex
 iMutex.Close();
 }
 // -----------------------------------------------------------------------------
 {
 LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Alloc()" );
 // Acquire the mutex
 iMutex.Wait();
+// get thread ID
+TUint threadId = RThread().Id();
 // Alloc memory from the original allocator
 TAny* p = iAllocator->Alloc( aSize );
 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 );
-{
-TInt error( KErrNone );
+	// Check if eventhandler is started already
+	if ( !iEventHandler->IsStarted() )
-// Check if eventhandler is started already
+		{
-if ( !iEventHandler->IsStarted() )
+		// Install the eventhandler if needed
-{
+		InstallEventHandler();
-// Install the eventhandler if needed
+		}
-InstallEventHandler();
-}
+	// Reset the callstack
+	iCallStack.Reset();
-// Reset the callstack
-iCallStack.Reset();
+	// If we don't want any call stack to be saved skip the next part
+	if( iAllocMaxCallStack > 0 )
-// 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 );
-// Find the current thread callstack start address
+		TBool found( FindCurrentThreadStack( stackstart ) );
-TUint32 stackstart( 0 );
+		LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found );
-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.
-// Returns the value of the stack pointer at the
+		TUint32 _sp;
-// current point in your program.
+		__asm
-TUint32 _sp;
+			{
-__asm
+			mov [_sp], esp
-{
+			}
-mov [_sp], esp
-}
+		// Get process loaded code segments count
+		TInt blocksCount( iCodeblocks.Count() );
-// Get process loaded code segments count
+		TUint arrayCounter = 0;
-TInt blocksCount( iCodeblocks.Count() );
-TUint arrayCounter = 0;
+		// Iterate through callstack to find wanted callstack addresses
+		// - Start: current stack address
-// Iterate through callstack to find wanted callstack addresses
+		// - Stop: stack start address(Run-address of user stack)
-// - Start: current stack address
+		// - Add: address length(The word size in the current system is 32 bits, which is 4 bytes)
-// - Stop: stack start address(Run-address of user stack)
+		for ( TUint32 i = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348
-// - 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 );
-{
-TUint32 addr = (TUint32) *( (TUint32*) i );
+			// Checks is the given address in loaded code memory area.
+			if ( !IsAddressLoadedCode( addr ) )
-// Checks is the given address in loaded code memory area.
+				continue;
-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++ )
-// 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 ) )
-// 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
-// To avoid recursive call to ReAlloc specifying granularity
+					iCallStack[arrayCounter] = ( addr );
-// Add address to the callstack
+					arrayCounter++;
-iCallStack[arrayCounter] = ( addr );
+					break;
-arrayCounter++;
+					}
-break;
+				}
-}
-}
+			// Checks if the wanted callstack items are gathered
+			if ( arrayCounter == KATMaxCallstackLength ||
-// Checks if the wanted callstack items are gathered
+				 arrayCounter == iAllocMaxCallStack )
-if ( arrayCounter == KATMaxCallstackLength ||
+				{
-arrayCounter == iAllocMaxCallStack )
+				LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter );
-{
+				break;
-LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter );
+				}
-break;
+			}
-}
+		}
-}
-}
+	// Log the memory allocation information
+	if ( iLogOption == EATLogToTraceFast )
-// Log the memory allocation information
+		{
-if ( iLogOption == EATLogToTraceFast )
+		// Using fast mode.
-{
+		ATFastLogMemoryAllocated( iProcessId, (TUint32) p , iCallStack, aSize, threadId );
-// Using fast mode.
+		}
-ATFastLogMemoryAllocated( iProcessId, (TUint32) p , iCallStack, aSize );
+	else if ( iLogOption == EATLogToFile )
-}
+		{
-else
+		iLogFile.ATFileLogMemoryAllocated( (TUint32) p , iCallStack, aSize, threadId );
-{
+		}
-// 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;
-}
-}
-}
-}
-}
 // Release the mutex
 iMutex.Signal();
 return p;
 }
 {
 LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Alloc()"  );
 // acquire the mutex
 iMutex.Wait();
+// get thread ID
+TUint threadId = RThread().Id();
 // Alloc memory from the original allocator
 TAny* p = iAllocator->Alloc( aSize );
 LOGSTR3( "ATMH RAnalyzeToolMainAllocator::Alloc() - aSize: %i, address: %x",
 aSize,  (TUint32) p );
-TInt error( KErrNone );
+	// Check if eventhandler is active already
-if ( iStorageServerOpen || iLogOption == EATLogToTraceFast )
+	// IsActive might return false value if a tested software has created many
-{
+	// threads which install own CActiveScheduler.
-// Check if eventhandler is active already
+	if ( !iEventHandler->IsStarted() )
-// IsActive might return false value if a tested software has created many
+		{
-// threads which install own CActiveScheduler.
+		// Install the eventhandler if needed
-if ( !iEventHandler->IsStarted() )
+		InstallEventHandler();
-{
+		}
-// Install the eventhandler if needed
-InstallEventHandler();
+	// Reset the callstack
-}
+	iCallStack.Reset();
-// Reset the callstack
+	// If we don't want any call stack to be saved skip the next part
-iCallStack.Reset();
+	if( iAllocMaxCallStack > 0 )
+		{
-// If we don't want any call stack to be saved skip the next part
+		// Find the current thread callstack start address
-if( iAllocMaxCallStack > 0 )
+		TUint32 stackstart( 0 );
-{
+		TBool found( FindCurrentThreadStack( stackstart ) );
-// Find the current thread callstack start address
+		LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found );
-TUint32 stackstart( 0 );
-TBool found( FindCurrentThreadStack( stackstart ) );
+		// Get process loaded code segments count
-LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found );
+		TInt blocksCount( iCodeblocks.Count() );
+		TUint arrayCounter = 0;
-// Get process loaded code segments count
-TInt blocksCount( iCodeblocks.Count() );
+		// Iterate through callstack to find wanted callstack addresses
-TUint arrayCounter = 0;
+		// - Start: current stack address(__current_sp(): Returns the value of the
+		//      stack pointer at the current point in your program.)
-// Iterate through callstack to find wanted callstack addresses
+		// - Stop: stack start address(Run-address of user stack)
-// - Start: current stack address(__current_sp(): Returns the value of the
+		// - Add: address length(The word size in the current system is 32 bits, which is 4 bytes)
-//      stack pointer at the current point in your program.)
+		for ( TUint32 i = __current_sp(); i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348
-// - 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)
+			TUint32 addr = (TUint32) *( (TUint32*) i );
-for ( TUint32 i = __current_sp(); i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348
-{
+			// Checks is the given address in loaded code memory area.
-TUint32 addr = (TUint32) *( (TUint32*) i );
+			if ( !IsAddressLoadedCode( addr ) )
+				continue;
-// Checks is the given address in loaded code memory area.
-if ( !IsAddressLoadedCode( addr ) )
+			// Iterate through array of code blocks to check if address is in code segment area
-continue;
+			for ( TInt j = 0; j < blocksCount; j++ )
+				{
-// Iterate through array of code blocks to check if address is in code segment area
+				// Checks if the given address is in this memory block area
-for ( TInt j = 0; j < blocksCount; j++ )
+				if ( iCodeblocks[j].CheckAddress( addr ) )
-{
+					{
-// Checks if the given address is in this memory block area
+					// To avoid recursive call to ReAlloc specifying granularity
-if ( iCodeblocks[j].CheckAddress( addr ) )
+					// Add address to the callstack
-{
+					iCallStack[arrayCounter] = ( addr );
-// To avoid recursive call to ReAlloc specifying granularity
+					arrayCounter++;
-// Add address to the callstack
+					break;
-iCallStack[arrayCounter] = ( addr );
+					}
-arrayCounter++;
+				}
-break;
-}
+			// Checks if the wanted callstack items are gathered
-}
+			if ( arrayCounter == KATMaxCallstackLength ||
+				 arrayCounter == iAllocMaxCallStack )
-// Checks if the wanted callstack items are gathered
+				{
-if ( arrayCounter == KATMaxCallstackLength ||
+				LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter );
-arrayCounter == iAllocMaxCallStack )
+				break;
-{
+				}
-LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter );
+			}
-break;
+		}
-}
+	// Log the memory allocation information
-}
+	if ( iLogOption == EATLogToTraceFast )
-}
+		{
-// Log the memory allocation information
+		// Using fast mode.
-if ( iLogOption == EATLogToTraceFast )
+		ATFastLogMemoryAllocated( iProcessId, (TUint32) p, iCallStack, aSize, threadId );
-{
+		}
-// Using fast mode.
+	else if ( iLogOption == EATLogToFile )
-ATFastLogMemoryAllocated( iProcessId, (TUint32) p, iCallStack, aSize );
+		{
-}
+		iLogFile.ATFileLogMemoryAllocated( (TUint32) p , iCallStack, aSize, threadId );
-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;
-}
-}
-}
-}
-}
 // Release the mutex
 iMutex.Signal();
 // Return the allocatated memory
 LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Free()" );
 // Acquire the mutex
 iMutex.Wait();
-if ( iStorageServerOpen || iLogOption == EATLogToTraceFast )
+// get thread ID
-{
+TUint threadId = RThread().Id();
-// Reset the callstack
-iFreeCallStack.Reset();
+	// 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
+	// Check if trace logging mode
-if ( (iLogOption == EATUseDefault || iLogOption == EATLogToTrace || iLogOption == EATLogToTraceFast )
+	// Also if we don't want any call stack to be stored skip the next part
-&& iFreeMaxCallStack > 0 )
+	if ( iFreeMaxCallStack > 0 )
-{
+		{
-// Find the current thread callstack start address
+		// Find the current thread callstack start address
-TUint32 stackstart( 0 );
+		TUint32 stackstart( 0 );
-TBool found( FindCurrentThreadStack( stackstart ) );
+		TBool found( FindCurrentThreadStack( stackstart ) );
-LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found );
+		LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found );
-TUint32 _sp;
+		TUint32 _sp;
-// Returns the value of the stack pointer at the
+		// Returns the value of the stack pointer at the
-// current point in your program.
+		// current point in your program.
-#ifdef __WINS__
+		#ifdef __WINS__
-__asm
+			__asm
-{
+				{
-mov [_sp], esp
+				mov [_sp], esp
-}
+				}
-#else
+		#else
-_sp = __current_sp();
+			_sp = __current_sp();
-#endif
+		#endif
-// Get process loaded code segments count
+		// Get process loaded code segments count
-TInt blocksCount( iCodeblocks.Count() );
+		TInt blocksCount( iCodeblocks.Count() );
-TUint arrayCounter = 0;
+		TUint arrayCounter = 0;
-// Iterate through callstack to find wanted callstack addresses
+		// Iterate through callstack to find wanted callstack addresses
-// - Start: current stack address
+		// - Start: current stack address
-// - Stop: stack start address(Run-address of user stack)
+		// - 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)
+		// - 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
+		for ( TUint32 i = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348
-{
+			{
-TUint32 addr = (TUint32) *( (TUint32*) i );
+			TUint32 addr = (TUint32) *( (TUint32*) i );
-// Checks is the given address in loaded code memory area.
+			// Checks is the given address in loaded code memory area.
-if ( ! IsAddressLoadedCode( addr ) )
+			if ( ! IsAddressLoadedCode( addr ) )
-continue;
+				continue;
-// Iterate through array of code blocks to check if address is in code segment area
+			// Iterate through array of code blocks to check if address is in code segment area
-for ( TInt j = 0; j < blocksCount; j++ )
+			for ( TInt j = 0; j < blocksCount; j++ )
-{
+				{
-// Checks if the given address is in this memory block area
+				// Checks if the given address is in this memory block area
-if ( iCodeblocks[j].CheckAddress( addr ) )
+				if ( iCodeblocks[j].CheckAddress( addr ) )
-{
+					{
-// To avoid recursive call to ReAlloc specifying granularity
+					// To avoid recursive call to ReAlloc specifying granularity
-// Add address to the callstack
+					// Add address to the callstack
-iFreeCallStack[arrayCounter] = addr;
+					iFreeCallStack[arrayCounter] = addr;
-arrayCounter++;
+					arrayCounter++;
-break;
+					break;
-}
+					}
-}
+				}
-// Checks if the wanted callstack items are gathered
+			// Checks if the wanted callstack items are gathered
-if ( arrayCounter == KATMaxFreeCallstackLength ||
+			if ( arrayCounter == KATMaxFreeCallstackLength ||
-arrayCounter == iFreeMaxCallStack )
+				 arrayCounter == iFreeMaxCallStack )
-{
+				{
-break;
+				break;
-}
+				}
-}
+			}
-LOGSTR2( "ATMH > iFreeCallStack count ( %i )", arrayCounter );
+		LOGSTR2( "ATMH > iFreeCallStack count ( %i )", arrayCounter );
-}
+		}
-// Log the memory free information.
+	// Log the memory free information.
-if ( iLogOption == EATLogToTraceFast )
+	if ( iLogOption == EATLogToTraceFast )
-{
+		{
-// Using fast mode.
+		// Using fast mode.
-ATFastLogMemoryFreed( iProcessId, (TUint32) aPtr, iFreeCallStack );
+		ATFastLogMemoryFreed( iProcessId, (TUint32) aPtr, iFreeCallStack, threadId );
-}
+		}
-else
+else if ( iLogOption == EATLogToFile )
-{
+	{
-// Using storage server.
+iLogFile.ATFileLogMemoryFreed( (TUint32) aPtr, iFreeCallStack, threadId );
-TInt err( iStorageServer.LogMemoryFreed( (TUint32) aPtr, iFreeCallStack ) );
+	}
-if ( err != KErrNone )
-{
-LOGSTR2( "ATMH > LogMemoryFreed err( %i )", err );
-}
-}
-}
 // Free the memory using original allocator
 iAllocator->Free( aPtr );
 LOGSTR2( "ATMH RAnalyzeToolMainAllocator::Free() - aPtr: %x", (TUint32)aPtr );
 {
 LOGSTR2( "ATMH Thread stack address: %x", params().iStackAddress );
 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() );
+	}
 }
 }
 // Release the mutex
 iMutex.Signal();
 // Check if this is current thread
 if ( iThreadArray[ i ].Match() )
 {
 // 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;
 }
 }
 LOGSTR1( "ATMH RAnalyzeToolMainAllocator::Close() - about to mutex signal" );
 {
 LOGSTR1( "ATMH RAnalyzeToolMainAllocator::ReAlloc()" );
 // 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 );
 // NULL addresses are not in a process under test
 LOGSTR3( "ATMH RAnalyzeToolMainAllocator::ReAlloc() - aPtr: %x, ptr: %x",
 (TUint32)aPtr, (TUint32)ptr );
 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;
-TInt error( KErrNone );
-TUint arrayCounter = 0;
+	// Reset the callstack
+	iReCallStack.Reset();
-// Reset the callstack
-iReCallStack.Reset();
+	// If we don't want any call stack to be saved skip the next part
+	if( iAllocMaxCallStack > 0 )
-// 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 );
-// Find the current thread callstack start address
+		TBool found( FindCurrentThreadStack( stackstart ) );
-TUint32 stackstart( 0 );
+		LOGSTR3( "ATMH > stackstart: %x , find = %i", stackstart, found );
-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.
-// Returns the value of the stack pointer at the
+		TUint32 _sp( 0 );
-// current point in your program.
+		__asm
-TUint32 _sp( 0 );
+			{
-__asm
+			mov [_sp], esp
-{
+			}
-mov [_sp], esp
-}
+		// Get process loaded code segments count
+		TInt blocksCount( iCodeblocks.Count() );
-// Get process loaded code segments count
-TInt blocksCount( iCodeblocks.Count() );
+		// Iterate through callstack to find wanted callstack addresses
+		// - Start: current stack address
-// Iterate through callstack to find wanted callstack addresses
+		// - Stop: stack start address(Run-address of user stack)
-// - Start: current stack address
+		// - Add: address length(The word size in the current system is 32 bits, which is 4 bytes)
-// - Stop: stack start address(Run-address of user stack)
+		for ( TUint32 i = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348
-// - 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.
-TUint32 addr = (TUint32) *( (TUint32*) i );
+			if ( ! IsAddressLoadedCode( addr ) )
-// Checks is the given address in loaded code memory area.
+				continue;
-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++ )
-// 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 ) )
-// 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
-// To avoid recursive call to ReAlloc specifying granularity
+					iReCallStack[arrayCounter] = addr;
-// Add address to the callstack
+					arrayCounter++;
-iReCallStack[arrayCounter] = addr;
+					break;
-arrayCounter++;
+					}
-break;
+				}
-}
+			// Checks if the wanted callstack items are gathered
-}
+			if ( arrayCounter == KATMaxCallstackLength ||
-// Checks if the wanted callstack items are gathered
+				 arrayCounter == iAllocMaxCallStack )
-if ( arrayCounter == KATMaxCallstackLength ||
+				{
-arrayCounter == iAllocMaxCallStack )
+				LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter );
-{
+				break;
-LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter );
+				}
-break;
+			}
-}
+		}
-}
-}
+	// Log the memory reallocation information
-// No need to report free if the aPtr was NULL
+	if ( iLogOption == EATLogToTraceFast )
-if ( aPtr != NULL )
+		{
-{
+		// Using fast logging mode.
-// Reset the free callstack
+		ATFastLogMemoryReallocated( iProcessId, (TUint32) aPtr, (TUint32) ptr, iReCallStack, aSize, threadId );
-iFreeCallStack.Reset();
+		}
+	else if ( iLogOption == EATLogToFile )
-// Check that logging mode is trace/trace fast so we use free call stack
+		{
-// and call stack size bigger than zero
+		iLogFile.ATFileLogMemoryReallocated( (TUint32) aPtr, (TUint32) ptr, iReCallStack, aSize, threadId );
-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;
-}
-}
-}
-}
-}
 }
 // Release the mutex
 iMutex.Signal();
 LOGSTR1( "ATMH RAnalyzeToolMainAllocator::ReAlloc()" );
 // 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
 if ( ptr && !( aMode & ENeverMove ) )
 {
 LOGSTR3( "ATMH RAnalyzeToolMainAllocator::ReAlloc() - aPtr: %x, ptr: %x",
 (TUint32)aPtr, (TUint32)ptr );
 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.
+		// Reset the callstack
-if ( iStorageServerOpen || iLogOption == EATLogToTraceFast )
+		iReCallStack.Reset();
-{
-// Reset the callstack
+		// If we don't want any call stack to be saved skip the next part
-iReCallStack.Reset();
+		if( iAllocMaxCallStack > 0 )
+			{
-// If we don't want any call stack to be saved skip the next part
+			// Find the current thread callstack start address
-if( iAllocMaxCallStack > 0 )
+			TUint32 stackstart( 0 );
-{
+			TBool found( FindCurrentThreadStack( stackstart ) );
-// Find the current thread callstack start address
+			LOGSTR3( "ATMH > stackstart: %x , find = %i", stackstart, found );
-TUint32 stackstart( 0 );
-TBool found( FindCurrentThreadStack( stackstart ) );
+			// Get process loaded code segments count
-LOGSTR3( "ATMH > stackstart: %x , find = %i", stackstart, found );
+			TInt blocksCount( iCodeblocks.Count() );
-// Get process loaded code segments count
+			// Iterate through callstack to find wanted callstack addresses
-TInt blocksCount( iCodeblocks.Count() );
+			// - Start: current stack address(__current_sp(): Returns the value of the
+			//      stack pointer at the current point in your program.)
-// Iterate through callstack to find wanted callstack addresses
+			// - Stop: stack start address(Run-address of user stack)
-// - Start: current stack address(__current_sp(): Returns the value of the
+			// - Add: address length(The word size in the current system is 32 bits, which is 4 bytes)
-//      stack pointer at the current point in your program.)
+			for ( TUint32 i = __current_sp(); i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348
-// - 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)
+				TUint32 addr = (TUint32) *( (TUint32*) i );
-for ( TUint32 i = __current_sp(); i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348
-{
+				// Checks is the given address in loaded code memory area.
-TUint32 addr = (TUint32) *( (TUint32*) i );
+				if ( !IsAddressLoadedCode( addr ) )
+					continue;
-// Checks is the given address in loaded code memory area.
-if ( !IsAddressLoadedCode( addr ) )
+				// Iterate through array of code blocks to check if address is in code segment area
-continue;
+				for ( TInt j = 0; j < blocksCount; j++ )
+					{
-// Iterate through array of code blocks to check if address is in code segment area
+					// Checks if the given address is in this memory block area
-for ( TInt j = 0; j < blocksCount; j++ )
+					if ( iCodeblocks[j].CheckAddress( addr ) )
-{
+						{
-// Checks if the given address is in this memory block area
+						// To avoid recursive call to ReAlloc specifying granularity
-if ( iCodeblocks[j].CheckAddress( addr ) )
+						// Add address to the callstack
-{
+						iReCallStack[arrayCounter] = ( addr );
-// To avoid recursive call to ReAlloc specifying granularity
+						arrayCounter++;
-// Add address to the callstack
+						break;
-iReCallStack[arrayCounter] = ( addr );
+						}
-arrayCounter++;
+					}
-break;
+				// Checks if the wanted callstack items are gathered
-}
+				if ( arrayCounter == KATMaxCallstackLength ||
-}
+					 arrayCounter == iAllocMaxCallStack )
-// Checks if the wanted callstack items are gathered
+					{
-if ( arrayCounter == KATMaxCallstackLength ||
+					LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter );
-arrayCounter == iAllocMaxCallStack )
+					break;
-{
+					}
-LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter );
+				}
-break;
+			}
-}
-}
+		if ( iLogOption == EATLogToTraceFast )
-}
+			{
+			// Using fast logging mode.
-// No need to report free if the aPtr was NULL
+			ATFastLogMemoryReallocated( iProcessId, (TUint32) aPtr, (TUint32) ptr, iReCallStack, aSize, threadId );
-if ( aPtr != NULL )
+			}
-{
+		else if ( iLogOption == EATLogToFile )
-// Reset the free callstack
+			{
-iFreeCallStack.Reset();
+			iLogFile.ATFileLogMemoryReallocated( (TUint32) aPtr, (TUint32) ptr, iReCallStack, aSize, threadId );
+			}
-// 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;
-}
-}
-}
-}
-}
 }
 // Release the mutex
 iMutex.Signal();
 // Check if this is current thread
 if ( iThreadArray[ i ].Match( aThreadId ) )
 {
 // 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;
 }
 }
 // -----------------------------------------------------------------------------
 // RAnalyzeToolMainAllocator::LogProcessInformation()
 // Retrieve and log the process initial information
 // -----------------------------------------------------------------------------
 //
-void RAnalyzeToolMainAllocator::LogProcessInformation( const TFileName aFileName,
+void RAnalyzeToolMainAllocator::LogProcessInformation( const TFileName& aFileName, const TPath& aFilePath,
-TUint32 aLogOption, TUint32 aIsDebug )
+TUint32 aLogOption, TUint32 aIsDebug, const TDesC8& aAtoolVersion, const TDesC8& aApiVersion )
 {
 LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation()" );
 // Create local variable and retrieve the process information
 TProcessIdentityParamsBuf params;
 LOGSTR2( "ATMH Thread stack size:    %x", params().iStackSize );
 // 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
+// Using fast logging mode.
-if ( iStorageServerOpen || iLogOption == EATLogToTraceFast )
+if ( iLogOption == EATLogToTraceFast )
 {
-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 )
+{
+// 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 fast logging mode.
+// TODO
-LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - ATFastLogProcessStarted() #1" );
-ATFastLogProcessStarted( params().iProcessName, iProcessId, aIsDebug );
 }
-else
-{
+//if everything is ok, add file version in the begining of file
-// Using storage server.
+iLogFile.ATFileLogVersion();
-LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - iStorageServerOpen #1" );
+//log process start
-error = iStorageServer.LogProcessStarted(
+iLogFile.ATFileLogProcessStarted( params().iProcessName, iProcessId, aIsDebug, aAtoolVersion, aApiVersion );
-aFileName,
+// log thread added
-params().iProcessName,
+iLogFile.ATFileLogThreadStarted( RThread().Id().operator TUint() );
-iProcessId,
+}
-aLogOption,
-aIsDebug );
-}
-}
 LOGSTR2( "ATMH LogProcessStarted error %i", error );
 // Iterate through process codesegments
 for( TInt i = 0; i < params().iCodesegCount; i++ )
 {
 LOGSTR2( "ATMH GetCodesegInfo error %i", error );
 if ( KErrNone == error )
 {
 // Don't log AnalyzeTool libraries
-if ( 0 != codeinfo().iFullName.CompareC( KMemoryHook ) &&
+if ( 0 != codeinfo().iFullName.CompareC( KMemoryHook ) )
-0 != codeinfo().iFullName.CompareC( KStorageServer ) )
 {
 // 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" );
-// Using fast logging mode.
+ATFastLogDllLoaded( iProcessId,
-LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - ATFastLogDllLoaded() #2" );
+codeinfo().iFullName,
-ATFastLogDllLoaded( iProcessId,
+codeinfo().iRunAddress,
-codeinfo().iFullName,
+codeinfo().iRunAddress + codeinfo().iSize );
-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 );
-}
 }
+else if ( iLogOption == EATLogToFile )
+						{
+iLogFile.ATFileLogDllLoaded(
+								codeinfo().iFullName,
+codeinfo().iRunAddress,
+codeinfo().iRunAddress + codeinfo().iSize );
+						}
 LOGSTR2( "ATMH LogDllLoaded error %i", error );
 // Check that everything is OK
 if ( KErrNone == error )
 error = iAnalyzeTool.GetLibraryInfo( info );
 LOGSTR2( "ATMH GetLibraryInfo error %i", error );
 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" );
-// Using fast logging mode.
+ATFastLogDllLoaded( iProcessId,
-LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - - ATFastLogDllLoaded()#3" );
+info().iLibraryName,
-ATFastLogDllLoaded( iProcessId,
+info().iRunAddress,
-info().iLibraryName,
+info().iRunAddress + info().iSize );
-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 );
-}
 }
+else if ( iLogOption == EATLogToFile )
+	{
+	iLogFile.ATFileLogDllLoaded(
+			info().iLibraryName,
+			info().iRunAddress,
+			info().iRunAddress + info().iSize );
+	}
 LOGSTR2( "ATMH LogDllLoaded error %i", error );
 if ( KErrNone == error )
 {
 // Append the codesegment to the array
 }
 }
 }
 }
 // -----------------------------------------------------------------------------
 // RAnalyzeToolMainAllocator::FindCurrentThreadStack()
 // Find the current thread which is using the heap
 // -----------------------------------------------------------------------------
 //
 // Active eventhalder is not active, trying to start it
 if ( NULL != CActiveScheduler::Current() )
 {
 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<KSysUtilVersionTextLength> 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<KHexa32Length> bufChecksum;
+#ifndef __WINSCW__
+TRomHeader* romHeader = (TRomHeader*) UserSvr::RomHeaderAddress();
+if (romHeader)
+{
+bufChecksum.Format(_L("%08x"), romHeader->iCheckSum);
+}
+#endif
+TBuf8<KSysUtilVersionTextLength> s60Version;
+s60Version.Copy(bufS60);
+TBuf8<KHexa32Length> romChecksum;
+romChecksum.Copy(bufChecksum);
+//only fastlog implementation
+if (iLogOption == EATLogToTraceFast)
+	{
+ATFastLogDeviceInfo(s60Version, romChecksum);
+}
+else if ( iLogOption == EATLogToFile )
+	{
+iLogFile.ATFileLogDeviceInfo( s60Version, romChecksum );
+	}
 }
 // End of File

branch	RCL_3
changeset 49	7fdc9a71d314
parent 19	da2cedce4920
child 59	8ad140f3dd41