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

equal deleted inserted replaced

-:7fdc9a71d314
+:8ad140f3dd41
 #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, const TPath& aFilePath, TUint32 aLogOption, TUint32 aIsDebug,
+const TFileName aFileName, 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, aFilePath, aLogOption, aIsDebug, aAtoolVersion, aApiVersion );
+LogProcessInformation( aFileName, aLogOption, aIsDebug );
-// 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 ( iLogOption == EATLogToTraceFast )
+if ( iStorageServerOpen || iLogOption == EATLogToTraceFast )
 {
-LOGSTR1( "ATMH ATFastLogProcessEnded()" );
+if ( iLogOption == EATLogToTraceFast )
-ATFastLogProcessEnded( iProcessId, handleLeakCount );
+{
-}
+LOGSTR1( "ATMH ATFastLogProcessEnded()" );
-else if ( iLogOption == EATLogToFile )
+ATFastLogProcessEnded( iProcessId, handleLeakCount );
-	{
+}
-iLogFile.ATFileLogProcessEnded( handleLeakCount );
+else
-	}
+{
+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.
-	TInt error( KErrNone );
+if ( iStorageServerOpen || iLogOption == EATLogToTraceFast )
+{
-	// Check if eventhandler is started already
+TInt error( KErrNone );
-	if ( !iEventHandler->IsStarted() )
-		{
+// Check if eventhandler is started already
-		// 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 ) );
-		// Returns the value of the stack pointer at the
+LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found );
-		// current point in your program.
-		TUint32 _sp;
+// Returns the value of the stack pointer at the
-		__asm
+// current point in your program.
-			{
+TUint32 _sp;
-			mov [_sp], esp
+__asm
-			}
+{
+mov [_sp], esp
-		// Get process loaded code segments count
+}
-		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
-		// - Stop: stack start address(Run-address of user stack)
+// Iterate through callstack to find wanted callstack addresses
-		// - Add: address length(The word size in the current system is 32 bits, which is 4 bytes)
+// - Start: current stack address
-		for ( TUint32 i = _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 = _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 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
-	// IsActive might return false value if a tested software has created many
+if ( iStorageServerOpen || iLogOption == EATLogToTraceFast )
-	// threads which install own CActiveScheduler.
+{
-	if ( !iEventHandler->IsStarted() )
+// Check if eventhandler is active already
-		{
+// IsActive might return false value if a tested software has created many
-		// Install the eventhandler if needed
+// threads which install own CActiveScheduler.
-		InstallEventHandler();
+if ( !iEventHandler->IsStarted() )
-		}
+{
+// Install the eventhandler if needed
-	// Reset the callstack
+InstallEventHandler();
-	iCallStack.Reset();
+}
-	// If we don't want any call stack to be saved skip the next part
+// Reset the callstack
-	if( iAllocMaxCallStack > 0 )
+iCallStack.Reset();
-		{
-		// Find the current thread callstack start address
+// If we don't want any call stack to be saved skip the next part
-		TUint32 stackstart( 0 );
+if( iAllocMaxCallStack > 0 )
-		TBool found( FindCurrentThreadStack( stackstart ) );
+{
-		LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found );
+// Find the current thread callstack start address
+TUint32 stackstart( 0 );
-		// Get process loaded code segments count
+TBool found( FindCurrentThreadStack( stackstart ) );
-		TInt blocksCount( iCodeblocks.Count() );
+LOGSTR3( "ATMH > stackstart: %x , found = %i", stackstart, found );
-		TUint arrayCounter = 0;
+// 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
+TUint arrayCounter = 0;
-		//      stack pointer at the current point in your program.)
-		// - Stop: stack start address(Run-address of user stack)
+// Iterate through callstack to find wanted callstack addresses
-		// - Add: address length(The word size in the current system is 32 bits, which is 4 bytes)
+// - Start: current stack address(__current_sp(): Returns the value of the
-		for ( TUint32 i = __current_sp(); i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348
+//      stack pointer at the current point in your program.)
-			{
+// - Stop: stack start address(Run-address of user stack)
-			TUint32 addr = (TUint32) *( (TUint32*) i );
+// - 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
-			// Checks is the given address in loaded code memory area.
+{
-			if ( !IsAddressLoadedCode( addr ) )
+TUint32 addr = (TUint32) *( (TUint32*) i );
-				continue;
+// Checks is the given address in loaded code memory area.
-			// Iterate through array of code blocks to check if address is in code segment area
+if ( !IsAddressLoadedCode( addr ) )
-			for ( TInt j = 0; j < blocksCount; j++ )
+continue;
-				{
-				// Checks if the given address is in this memory block area
+// Iterate through array of code blocks to check if address is in code segment area
-				if ( iCodeblocks[j].CheckAddress( addr ) )
+for ( TInt j = 0; j < blocksCount; j++ )
-					{
+{
-					// To avoid recursive call to ReAlloc specifying granularity
+// Checks if the given address is in this memory block area
-					// Add address to the callstack
+if ( iCodeblocks[j].CheckAddress( addr ) )
-					iCallStack[arrayCounter] = ( addr );
+{
-					arrayCounter++;
+// To avoid recursive call to ReAlloc specifying granularity
-					break;
+// Add address to the callstack
-					}
+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
-				LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter );
+if ( arrayCounter == KATMaxCallstackLength ||
-				break;
+arrayCounter == iAllocMaxCallStack )
-				}
+{
-			}
+LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter );
-		}
+break;
-	// Log the memory allocation information
+}
-	if ( iLogOption == EATLogToTraceFast )
+}
-		{
+}
-		// Using fast mode.
+// Log the memory allocation information
-		ATFastLogMemoryAllocated( iProcessId, (TUint32) p, iCallStack, aSize, threadId );
+if ( iLogOption == EATLogToTraceFast )
-		}
+{
-	else if ( iLogOption == EATLogToFile )
+// Using fast mode.
-		{
+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();
-// get thread ID
+if ( iStorageServerOpen || iLogOption == EATLogToTraceFast )
-TUint threadId = RThread().Id();
+{
+// Reset the callstack
-	// Reset the callstack
+iFreeCallStack.Reset();
-	iFreeCallStack.Reset();
+// Check if trace logging mode
-	// Check if trace logging mode
+// Also if we don't want any call stack to be stored skip the next part
-	// Also if we don't want any call stack to be stored skip the next part
+if ( (iLogOption == EATUseDefault || iLogOption == EATLogToTrace || iLogOption == EATLogToTraceFast )
-	if ( iFreeMaxCallStack > 0 )
+&& 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, threadId );
+ATFastLogMemoryFreed( iProcessId, (TUint32) aPtr, iFreeCallStack );
-		}
+}
-else if ( iLogOption == EATLogToFile )
+else
-	{
+{
-iLogFile.ATFileLogMemoryFreed( (TUint32) aPtr, iFreeCallStack, threadId );
+// Using storage server.
-	}
+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.
-	TInt error( KErrNone );
+if ( iStorageServerOpen || iLogOption == EATLogToTraceFast )
-	TUint arrayCounter = 0;
+{
+TInt error( KErrNone );
-	// Reset the callstack
+TUint arrayCounter = 0;
-	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 ) );
-		// Returns the value of the stack pointer at the
+LOGSTR3( "ATMH > stackstart: %x , find = %i", stackstart, found );
-		// current point in your program.
-		TUint32 _sp( 0 );
+// Returns the value of the stack pointer at the
-		__asm
+// current point in your program.
-			{
+TUint32 _sp( 0 );
-			mov [_sp], esp
+__asm
-			}
+{
+mov [_sp], esp
-		// Get process loaded code segments count
+}
-		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
-		// - Stop: stack start address(Run-address of user stack)
+// Iterate through callstack to find wanted callstack addresses
-		// - Add: address length(The word size in the current system is 32 bits, which is 4 bytes)
+// - Start: current stack address
-		for ( TUint32 i = _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 = _sp; i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348
-			// Checks is the given address in loaded code memory area.
+{
-			if ( ! IsAddressLoadedCode( addr ) )
+TUint32 addr = (TUint32) *( (TUint32*) i );
-				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;
-		}
+}
+}
+}
-	// Log the memory reallocation information
-	if ( iLogOption == EATLogToTraceFast )
+// No need to report free if the aPtr was NULL
-		{
+if ( aPtr != NULL )
-		// Using fast logging mode.
+{
-		ATFastLogMemoryReallocated( iProcessId, (TUint32) aPtr, (TUint32) ptr, iReCallStack, aSize, threadId );
+// Reset the free callstack
-		}
+iFreeCallStack.Reset();
-	else if ( iLogOption == EATLogToFile )
-		{
+// Check that logging mode is trace/trace fast so we use free call stack
-		iLogFile.ATFileLogMemoryReallocated( (TUint32) aPtr, (TUint32) ptr, iReCallStack, aSize, threadId );
+// 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();
 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 );
-		// Reset the callstack
+// Don't collect or log data if storage server not open or logging mode is not fast.
-		iReCallStack.Reset();
+if ( iStorageServerOpen || iLogOption == EATLogToTraceFast )
+{
-		// If we don't want any call stack to be saved skip the next part
+// Reset the callstack
-		if( iAllocMaxCallStack > 0 )
+iReCallStack.Reset();
-			{
-			// Find the current thread callstack start address
+// If we don't want any call stack to be saved skip the next part
-			TUint32 stackstart( 0 );
+if( iAllocMaxCallStack > 0 )
-			TBool found( FindCurrentThreadStack( stackstart ) );
+{
-			LOGSTR3( "ATMH > stackstart: %x , find = %i", stackstart, found );
+// Find the current thread callstack start address
+TUint32 stackstart( 0 );
-			// Get process loaded code segments count
+TBool found( FindCurrentThreadStack( stackstart ) );
-			TInt blocksCount( iCodeblocks.Count() );
+LOGSTR3( "ATMH > stackstart: %x , find = %i", stackstart, found );
-			// Iterate through callstack to find wanted callstack addresses
+// Get process loaded code segments count
-			// - Start: current stack address(__current_sp(): Returns the value of the
+TInt blocksCount( iCodeblocks.Count() );
-			//      stack pointer at the current point in your program.)
-			// - Stop: stack start address(Run-address of user stack)
+// Iterate through callstack to find wanted callstack addresses
-			// - Add: address length(The word size in the current system is 32 bits, which is 4 bytes)
+// - Start: current stack address(__current_sp(): Returns the value of the
-			for ( TUint32 i = __current_sp(); i < stackstart; i = i + KAddressLength )//lint !e1055 !e526 !e628 !e348
+//      stack pointer at the current point in your program.)
-				{
+// - Stop: stack start address(Run-address of user stack)
-				TUint32 addr = (TUint32) *( (TUint32*) i );
+// - 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
-				// Checks is the given address in loaded code memory area.
+{
-				if ( !IsAddressLoadedCode( addr ) )
+TUint32 addr = (TUint32) *( (TUint32*) i );
-					continue;
+// Checks is the given address in loaded code memory area.
-				// Iterate through array of code blocks to check if address is in code segment area
+if ( !IsAddressLoadedCode( addr ) )
-				for ( TInt j = 0; j < blocksCount; j++ )
+continue;
-					{
-					// Checks if the given address is in this memory block area
+// Iterate through array of code blocks to check if address is in code segment area
-					if ( iCodeblocks[j].CheckAddress( addr ) )
+for ( TInt j = 0; j < blocksCount; j++ )
-						{
+{
-						// To avoid recursive call to ReAlloc specifying granularity
+// Checks if the given address is in this memory block area
-						// Add address to the callstack
+if ( iCodeblocks[j].CheckAddress( addr ) )
-						iReCallStack[arrayCounter] = ( addr );
+{
-						arrayCounter++;
+// To avoid recursive call to ReAlloc specifying granularity
-						break;
+// Add address to the callstack
-						}
+iReCallStack[arrayCounter] = ( addr );
-					}
+arrayCounter++;
-				// Checks if the wanted callstack items are gathered
+break;
-				if ( arrayCounter == KATMaxCallstackLength ||
+}
-					 arrayCounter == iAllocMaxCallStack )
+}
-					{
+// Checks if the wanted callstack items are gathered
-					LOGSTR2( "ATMH > Wanted CallStack items ready( %i )", arrayCounter );
+if ( arrayCounter == KATMaxCallstackLength ||
-					break;
+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 );
+// No need to report free if the aPtr was NULL
-			}
+if ( aPtr != NULL )
-		else if ( iLogOption == EATLogToFile )
+{
-			{
+// Reset the free callstack
-			iLogFile.ATFileLogMemoryReallocated( (TUint32) aPtr, (TUint32) ptr, iReCallStack, aSize, threadId );
+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;
+}
+}
+}
+}
+}
 }
 // 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, const TPath& aFilePath,
+void RAnalyzeToolMainAllocator::LogProcessInformation( const TFileName aFileName,
-TUint32 aLogOption, TUint32 aIsDebug, const TDesC8& aAtoolVersion, const TDesC8& aApiVersion )
+TUint32 aLogOption, TUint32 aIsDebug )
 {
 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 ) );
-// Using fast logging mode.
+// Log process information
-if ( iLogOption == EATLogToTraceFast )
+if ( iStorageServerOpen || iLogOption == EATLogToTraceFast )
 {
-LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - ATFastLogProcessStarted() #1" );
+if ( iLogOption == EATLogToTraceFast )
-// Log process information
+{
-ATFastLogProcessStarted( params().iProcessName, iProcessId, aIsDebug, aAtoolVersion, aApiVersion );
+// Using fast logging mode.
-// log thread added
+LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - ATFastLogProcessStarted() #1" );
-ATFastLogThreadStarted( iProcessId, RThread().Id().operator TUint() );
+ATFastLogProcessStarted( params().iProcessName, iProcessId, aIsDebug );
 }
-else if ( iLogOption == EATLogToFile )
+else
 {
-// Open a file server session and a file.
+// Using storage server.
-error = iLogFile.OpenFsAndFile( aFileName, aFilePath, params().iProcessName );
+LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - iStorageServerOpen #1" );
+error = iStorageServer.LogProcessStarted(
-// Return without logging, if an error occured
+aFileName,
-if ( error != KErrNone )
+params().iProcessName,
-{
+iProcessId,
-// TODO
+aLogOption,
-}
+aIsDebug );
+}
-//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
 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 if ( iLogOption == EATLogToFile )
+}
-						{
+else
-iLogFile.ATFileLogDllLoaded(
+{
-								codeinfo().iFullName,
+// Using storage server.
-codeinfo().iRunAddress,
+LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - iStorageServerOpen #2" );
-codeinfo().iRunAddress + codeinfo().iSize );
+error = iStorageServer.LogDllLoaded(
-						}
+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 if ( iLogOption == EATLogToFile )
+}
-	{
+else
-	iLogFile.ATFileLogDllLoaded(
+{
-			info().iLibraryName,
+// Using storage server.
-			info().iRunAddress,
+LOGSTR1( "ATMH RAnalyzeToolMainAllocator::LogProcessInformation() - iStorageServerOpen #3" );
-			info().iRunAddress + info().iSize );
+error = iStorageServer.LogDllLoaded(
-	}
+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 59	8ad140f3dd41
parent 49	7fdc9a71d314