/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Definitions for the class CustomUser.
*
*/
#include <f32file.h>
#include <utf.h>
#include "customuser.h"
#include "analyzetoolmainallocator.h"
#include "analyzetoolallocator.h"
#include "atlog.h"
#include "analyzetoolmemoryallocator.h"
#include "analyzetoolpanics.pan"
#include "atstorageservercommon.h"
#include "atdriveinfo.h"
#include <analyzetool/analyzetooltraceconstants.h>
#ifdef USE_CLEANER_DLL
// Global variable to detect dll attach & detach in process.
// Note! This is initialized after SetupThreadHeap so its not usable there.
// This is used to store the main thread id and track when the process ends
// to load the cleaner dll with call back feature to cleanup allocator at the
// last possible phase.
#include <analyzetool/analyzetoolcleaner.h>
// CONSTANTS
const TInt KAToolCleanerOrdinal = 1;
class TAnalyzeToolGlobalTracker : public TAnalyzeToolCleanerBase
{
public:
/* Main thread id */
TThreadId iMainId;
/* Inform if panic occured */
TBool iPanic;
// -----------------------------------------------------------------------------
// TAnalyzeToolGlobalTracker::TAnalyzeToolGlobalTracker()
// C++ default constructor
// -----------------------------------------------------------------------------
//
TAnalyzeToolGlobalTracker()
{
LOGSTR1( "ATMH TAnalyzeToolGlobalTracker::TAnalyzeToolGlobalTracker()" );
iPanic = EFalse; // no panic occured
iMainId = RThread().Id(); // set main thread id
LOGSTR2( "ATMH TAnalyzeToolGlobalTracker() > Main id set: %d",
iMainId.operator TUint() );
}
// -----------------------------------------------------------------------------
// TAnalyzeToolGlobalTracker::~TAnalyzeToolGlobalTracker()
// Destructor.
// -----------------------------------------------------------------------------
//
~TAnalyzeToolGlobalTracker()
{
LOGSTR1( "ATMH TAnalyzeToolGlobalTracker::~TAnalyzeToolGlobalTracker()" );
// We dont load dll if panic has happened (uninstallation has been done).
if ( iPanic )
{
LOGSTR1( "ATMH ~TAnalyzeToolGlobalTracker > Panic set not loading cleaner dll." );
return;
}
LOGSTR1( "ATMH ~TAnalyzeToolGlobalTracker > about to load cleaner dll" );
// Load cleaner library and set a call back to our cleanup
RLibrary lib;
TInt error( lib.Load( KATCleanerDllName ) );
if ( error == KErrNone )
{
// Set address to point to ourself
TLibraryFunction func = lib.Lookup( KAToolCleanerOrdinal ); // Ordinal 1 of the dll
ATCLEANERTABLE* cleaner = (ATCLEANERTABLE*) func(); // Use function to get address
cleaner->At( 0 ) = (TUint32) this; // Set address
LOGSTR1( "ATMH ~TAnalyzeToolGlobalTracker() > cleaner dll loaded and call back set" );
}
else
{
// Error loading cleanup dll
LOGSTR2( "ATMH ~TAnalyzeToolGlobalTracker() > cleaner dll load error(%i) uninstalling allocator now!",
error );
Cleanup();
}
}
// -----------------------------------------------------------------------------
// TAnalyzeToolGlobalTracker::Cleanup()
//
// -----------------------------------------------------------------------------
//
void Cleanup()
{
LOGSTR1( "ATMH TAnalyzeToolGlobalTracker::Cleanup() - allocator uninstall" );
// Uninstall allocator
( (RAnalyzeToolMemoryAllocator&) User::Allocator() ).Uninstall();
}
};
// Global variable definition.
TAnalyzeToolGlobalTracker gGlobalTracker;
#endif
// CONSTANTS
// When needed, update the version number directly inside _LIT macro.
// Constant for the atool API(staticlib) version.
_LIT( KAtoolApiVersion, "1.7.5" );
// Version number buffer length
const TInt KAtoolVersionNumberLength = 10;
// Wrong version error code
const TInt KAtoolVersionError = -1999;
// Version number separator
_LIT( KVersionSeparator, ";" );
// Incorrect version error strings
_LIT( KIncorrectText, "ERROR_OCCURED INCORRECT_ATOOL_VERSION [API v.%S][ATOOL v.%S]" );
_LIT( KIncorrectTextTrace, "PCSS " );
// -----------------------------------------------------------------------------
// CustomUser::Panic()
// Overloaded User::Panic() function
// -----------------------------------------------------------------------------
//
EXPORT_C void CustomUser::Panic( const TDesC& aCategory, TInt aReason )
{
LOGSTR3( "ATMH CustomUser::Panic() %S %i", &aCategory, aReason );
#ifdef USE_CLEANER_DLL
// Set global tracker that panic has happened.
gGlobalTracker.iPanic = ETrue;
#endif
// Uninstall thread's RAllocator
( (RAnalyzeToolMemoryAllocator&) User::Allocator() ).Uninstall();
// Call the "real" User::Panic()
User::Panic( aCategory, aReason );
}
// -----------------------------------------------------------------------------
// CustomUser::Exit()
// Overloaded User::Exit() function
// -----------------------------------------------------------------------------
//
EXPORT_C void CustomUser::Exit( TInt aReason )
{
LOGSTR3( "ATMH CustomUser::Exit() %i %i", aReason, RThread().Id().Id() );
if ( aReason != KAtoolVersionError )
{
#ifdef USE_CLEANER_DLL
// Only uninstall allocator if its not the process main/first thread.
LOGSTR3( "ATMH CustomUser::Exit() - Thread id: %d - Main Id: %d",
RThread().Id().operator TUint(), gGlobalTracker.iMainId.operator TUint() );
if ( RThread().Id() != gGlobalTracker.iMainId )
{
LOGSTR2("ATMH CustomUser::Exit() - Calling allocator uninstall in thread: %d" , RThread().Id().operator TUint() );
( (RAnalyzeToolMemoryAllocator&) User::Allocator() ).Uninstall();
}
#else
// Uninstall thread's RAllocator
( (RAnalyzeToolMemoryAllocator&) User::Allocator() ).Uninstall();
LOGSTR1( "ATMH CustomUser::Exit() - about to User::Exit" );
#endif
}
// Call the "real" User::Exit()
User::Exit( aReason );
}
// -----------------------------------------------------------------------------
// CustomUser::SetCritical()
// Overloaded User::SetCritical() function which returns
// KErrNone, if successful; KErrArgument, if EAllThreadsCritical is
// passed - this is a state associated with a process, and you use
// User::SetProcessCritical() to set it.
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CustomUser::SetCritical( User::TCritical aCritical )
{
LOGSTR1( "ATMH CustomUser::SetCritical()" );
// Check the given User::TCritical type
if ( aCritical == User::EAllThreadsCritical )
{
return KErrArgument;
}
else
{
return KErrNone;
}
}
// -----------------------------------------------------------------------------
// CustomUser::SetProcessCritical()
// Overloaded User::SetProcessCritical() function
// KErrNone, if successful; KErrArgument, if either EProcessCritical or
// EProcessPermanent is passed - these are states associated with a
// thread, and you use User::SetCritical() to set them.
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CustomUser::SetProcessCritical( User::TCritical aCritical )
{
LOGSTR1( "ATMH CustomUser::SetProcessCritical()" );
// Check the given User::TCritical type
if ( aCritical == User::EProcessCritical ||
User::EProcessPermanent == aCritical )
{
return KErrArgument;
}
else
{
return KErrNone;
}
}
// -----------------------------------------------------------------------------
// CustomUser::SetupThreadHeap()
// Overloaded UserHeap::SetupThreadHeap function
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CustomUser::SetupThreadHeap( TBool aNotFirst,
SStdEpocThreadCreateInfo& aInfo, const TFileName& aFileName,
TUint32 aLogOption, TUint32 aIsDebug, const TATVersion& aVersion,
TUint32 aAllocCallStackSize, TUint32 aFreeCallStackSize,
TRefByValue<const TDesC> aFmt, ... )
{
LOGSTR1( "ATMH CustomUser::SetupThreadHeap()" );
LOGSTR2( "ATMH > Thread id(%d)", RThread().Id().operator TUint() );
// Add handling of the argument list here.
TInt ret( KErrNone );
// Check version number
TBuf<KAtoolVersionNumberLength> atoolVer;
if ( CheckVersion( aVersion, atoolVer ) != KErrNone )
{
LOGSTR1( "ATMH > Wrong API version > Inform user and Exit." );
ReportIncorrectVersion( aLogOption, aFileName, atoolVer );
return KAtoolVersionError;
}
// Check is this shared heap
if ( aInfo.iAllocator == NULL )
{
LOGSTR1( "ATMH creating a new heap" );
// RAllocator is NULL so heap is not shared, creating a new heap
ret = UserHeap::SetupThreadHeap( aNotFirst, aInfo );
__ASSERT_ALWAYS( KErrNone == ret, AssertPanic( EFailedToCreateHeap ) );
#if ( SYMBIAN_VERSION_SUPPORT >= SYMBIAN_3 )
#ifndef __WINS__
// Set dummy Tls value
TAny* dummyPtr( NULL );
TInt setErr( UserSvr::DllSetTls( KDummyHandle, dummyPtr ) );
LOGSTR2( "ATMH > Set Tls err(%i)", setErr );
#endif
#endif
// Install the RAllocator
aInfo.iAllocator = &InstallAllocator( aNotFirst, aFileName, aLogOption, aIsDebug,
aAllocCallStackSize, aFreeCallStackSize );
}
else
{
LOGSTR1( "ATMH sharing the heap" );
// The heap is shared. Acquire pointer to the original heap
RAnalyzeToolMemoryAllocator* allocator =
(RAnalyzeToolMemoryAllocator*) aInfo.iAllocator;
// Share the heap
allocator->ShareHeap();
// Switch thread heap
User::SwitchAllocator( allocator );
}
return ret;
}
// -----------------------------------------------------------------------------
// CustomUser::InstallAllocator
// Installs the RAllocator
// -----------------------------------------------------------------------------
//
//lint -e{429} suppress "Custodial pointer 'allocator' has not been freed or returned"
EXPORT_C RAllocator& CustomUser::InstallAllocator( TBool aNotFirst,
const TFileName& aFileName, TUint32 aLogOption, TUint32 aIsDebug,
TUint32 aAllocCallStackSize, TUint32 aFreeCallStackSize )
{
LOGSTR1( "ATMH CustomUser::InstallAllocator()" );
// Open handle to the device driver
RAnalyzeTool analyzetool;
TInt error = analyzetool.Open();
// Check if the device driver has already loaded
if ( KErrNone == error )
{
LOGSTR1( "ATMH CustomUser::InstallAllocator() - analyzetool.Open() returned KErrNone" );
// The device driver has already loaded
// Get pointer to the main thread allocator
TMainThreadParamsBuf params;
params().iProcessId = RProcess().Id().operator TUint();
error = analyzetool.MainThreadAlloctor( params );
__ASSERT_ALWAYS( KErrNone == error, AssertPanic( ECantOpenHandle ) );
// Close handle to the device driver
analyzetool.Close();
// Is this the first thread of the program
if ( params().iAlone )
{
LOGSTR1( "ATMH CustomUser::InstallAllocator() - first thread of the program" );
// Only one thread in the program. Must be main thread
RAnalyzeToolMainAllocator* allocator =
new RAnalyzeToolMainAllocator( aNotFirst, aFileName, aLogOption,
aIsDebug, aAllocCallStackSize, aFreeCallStackSize );
__ASSERT_ALWAYS( allocator != NULL, AssertPanic( ENoMemory ) );
// Change threads allocator
User::SwitchAllocator( allocator );
// Return reference to the RAllocator
return *allocator;
}
// This is not the first thread. A new thread with a new heap created
else
{
LOGSTR1( "ATMH CustomUser::InstallAllocator() - create a new allocator for the new thread" );
// Create new RAllocator with handles from the main thread
RAnalyzeToolAllocator* allocator = new RAnalyzeToolAllocator(
aNotFirst,
((RAnalyzeToolMainAllocator*)params().iAllocator)->StorageServer(),
((RAnalyzeToolMainAllocator*)params().iAllocator)->Codeblocks(),
((RAnalyzeToolMainAllocator*)params().iAllocator)->Mutex(),
((RAnalyzeToolMainAllocator*)params().iAllocator)->ProcessId(),
((RAnalyzeToolMainAllocator*)params().iAllocator)->AnalyzeTool(),
((RAnalyzeToolMainAllocator*)params().iAllocator)->StorageServerOpen(),
((RAnalyzeToolMainAllocator*)params().iAllocator)->LogOption(),
((RAnalyzeToolMainAllocator*)params().iAllocator)->AllocMaxCallStack(),
((RAnalyzeToolMainAllocator*)params().iAllocator)->FreeMaxCallStack() );
__ASSERT_ALWAYS( allocator != NULL, AssertPanic( ENoMemory ) );
// Change threads allocator
User::SwitchAllocator( allocator );
// Return reference to the RAllocator
return *allocator;
}
}
// The device driver does not exists so this must be the first thread
else
{
LOGSTR1( "ATMH CustomUser::InstallAllocator() - analyzetool.Open() returned error, creating DD" );
RAnalyzeToolMainAllocator* allocator =
new RAnalyzeToolMainAllocator( aNotFirst, aFileName, aLogOption, aIsDebug,
aAllocCallStackSize, aFreeCallStackSize );
__ASSERT_ALWAYS( allocator != NULL, AssertPanic( ENoMemory ) );
// Change threads allocator
User::SwitchAllocator( allocator );
// Return reference to the RAllocator
return *allocator;
}
}
// -----------------------------------------------------------------------------
// CustomUser::CheckVersion
// Check atool version
// -----------------------------------------------------------------------------
//
TInt CustomUser::CheckVersion( const TATVersion& aVersion, TDes& aToolVersion )
{
LOGSTR2( "ATMH CustomUser::CheckVersion(), aVersion( %S )", &aVersion );
TFileName version;
version.Copy( aVersion );
TBuf<KAtoolVersionNumberLength> apiVer;
// Find separator place
TInt findplace( version.Find( KVersionSeparator() ) );
// Parse API version first [x.x.x;x.x.x]
if ( findplace >= 0 && findplace <= apiVer.MaxLength() )
{
apiVer.Copy( version.Mid( 0, findplace ) );
version.Delete( 0, findplace + KVersionSeparator().Length() );
}
if ( version.Length() <= aToolVersion.MaxLength() )
{
aToolVersion.Copy( version );
if ( aToolVersion.Compare( KAtoolApiVersion ) == KErrNone &&
apiVer.Length() == 0 )
{
// Support 1.5.0 version (Version info: [1.5.0])
apiVer.Copy( version );
}
}
LOGSTR3( "ATMH > API version( %S ), ATOOL version( %S )",
&apiVer, &aToolVersion );
// Check version numbers
if ( apiVer.Compare( KAtoolApiVersion ) == KErrNone )
{
return KErrNone;
}
return KErrCancel;
}
// -----------------------------------------------------------------------------
// CustomUser::ReportIncorrectVersion
// Function for showing incorrect version information
// -----------------------------------------------------------------------------
//
void CustomUser::ReportIncorrectVersion( const TUint32 aLogOption,
const TFileName& aFileName, const TDes& aToolVersion )
{
LOGSTR2( "ATMH CustomUser::ReportIncorrectVersion(), aFileName( %S )",
&aFileName );
switch ( aLogOption )
{
case EATLogToFile:
{
LOGSTR1( "ATMH ReportIncorrectVersion > EATLogToFile" );
// A handle to a file server session.
RFs fs;
// Creates and opens a file,
// and performs all operations on a single open file.
RFile file;
// Create full path buffer
TBuf<KMaxFileName> logFileBuf;
// Connects a client to the file server.
TInt err( fs.Connect() );
if ( !err )
{
err = TATDriveInfo::CreatePath( logFileBuf, aFileName, fs );
// Replace file if exists
if ( err && err != KErrAlreadyExists )
{
LOGSTR2( "ATMH > TATDriveInfo::CreatePath() err( %i )", err );
return;
}
// Replace file if exists (drive C)
err = file.Replace( fs, logFileBuf, EFileWrite );
// Write to file
if ( !err )
{
err = file.Write( KDataFileVersion );
// Error msg buffer
TBuf8<KMaxFileName> msg;
// Write the error code to the buffer
logFileBuf.Format( KIncorrectText, &KAtoolApiVersion, &aToolVersion );
CnvUtfConverter::ConvertFromUnicodeToUtf8( msg, logFileBuf );
err = file.Write( msg );
}
// Closes the file.
file.Close();
}
LOGSTR2( "ATMH > File err( %i )", err );
// Closes the handle.
fs.Close();
}
break;
case EATUseDefault:
case EATLogToTrace:
{
LOGSTR1( "ATMH > ReportIncorrectVersion > EATLogToTrace" );
// Error msg buffer
TBuf<KMaxFileName> msg;
msg.Copy( KIncorrectTextTrace );
msg.Append( KIncorrectText );
TBuf<KMaxFileName> traceMsg;
// Write the error code to the buffer
traceMsg.Format( msg, &KAtoolApiVersion, &aToolVersion );
RDebug::Print( traceMsg );
}
break;
default:
{
LOGSTR1( "ATMH > ReportIncorrectVersion > default" );
}
break;
}
}
// End of File